* This code was developed as part of Google Summer of Code 2006.
* E-AC-3 support was added as part of Google Summer of Code 2007.
*
- * Copyright (c) 2006 Kartikey Mahendra BHATT (bhattkm at gmail dot com).
+ * Copyright (c) 2006 Kartikey Mahendra BHATT (bhattkm at gmail dot com)
* Copyright (c) 2007-2008 Bartlomiej Wolowiec <bartek.wolowiec@gmail.com>
* Copyright (c) 2007 Justin Ruggles <justin.ruggles@gmail.com>
*
#include <string.h>
#include "libavutil/crc.h"
+#include "internal.h"
+#include "aac_ac3_parser.h"
#include "ac3_parser.h"
#include "ac3dec.h"
#include "ac3dec_data.h"
ac3_common_init();
ac3_tables_init();
- ff_mdct_init(&s->imdct_256, 8, 1);
- ff_mdct_init(&s->imdct_512, 9, 1);
+ ff_mdct_init(&s->imdct_256, 8, 1, 1.0);
+ ff_mdct_init(&s->imdct_512, 9, 1, 1.0);
ff_kbd_window_init(s->window, 5.0, 256);
dsputil_init(&s->dsp, avctx);
av_lfg_init(&s->dith_state, 0);
s->downmixed = 1;
/* allocate context input buffer */
- if (avctx->error_resilience >= FF_ER_CAREFUL) {
+ if (avctx->error_recognition >= FF_ER_CAREFUL) {
s->input_buffer = av_mallocz(AC3_FRAME_BUFFER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);
if (!s->input_buffer)
return AVERROR_NOMEM;
/* get decoding parameters from header info */
s->bit_alloc_params.sr_code = hdr.sr_code;
s->channel_mode = hdr.channel_mode;
+ s->channel_layout = hdr.channel_layout;
s->lfe_on = hdr.lfe_on;
s->bit_alloc_params.sr_shift = hdr.sr_shift;
s->sample_rate = hdr.sample_rate;
memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
return ac3_parse_header(s);
} else {
- /*s->eac3 = 1;
- return ff_eac3_parse_header(s);*/
- return AC3_PARSE_ERROR_BSID;
+ s->eac3 = 1;
+ return ff_eac3_parse_header(s);
}
}
* Decode the grouped exponents according to exponent strategy.
* reference: Section 7.1.3 Exponent Decoding
*/
-static void decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
- uint8_t absexp, int8_t *dexps)
+static int decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
+ uint8_t absexp, int8_t *dexps)
{
int i, j, grp, group_size;
int dexp[256];
/* convert to absolute exps and expand groups */
prevexp = absexp;
- for(i=0; i<ngrps*3; i++) {
- prevexp = av_clip(prevexp + dexp[i]-2, 0, 24);
- for(j=0; j<group_size; j++) {
- dexps[(i*group_size)+j] = prevexp;
+ for(i=0,j=0; i<ngrps*3; i++) {
+ prevexp += dexp[i] - 2;
+ if (prevexp > 24U)
+ return -1;
+ switch (group_size) {
+ case 4: dexps[j++] = prevexp;
+ dexps[j++] = prevexp;
+ case 2: dexps[j++] = prevexp;
+ case 1: dexps[j++] = prevexp;
}
}
+ return 0;
}
/**
/* if AHT is used, mantissas for all blocks are encoded in the first
block of the frame. */
int bin;
- /*
if (!blk)
ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
- */
for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
}
}
}
+/**
+ * Decode band structure for coupling, spectral extension, or enhanced coupling.
+ * @param[in] gbc bit reader context
+ * @param[in] blk block number
+ * @param[in] eac3 flag to indicate E-AC-3
+ * @param[in] ecpl flag to indicate enhanced coupling
+ * @param[in] start_subband subband number for start of range
+ * @param[in] end_subband subband number for end of range
+ * @param[in] default_band_struct default band structure table
+ * @param[out] band_struct decoded band structure
+ * @param[out] num_bands number of bands (optionally NULL)
+ * @param[out] band_sizes array containing the number of bins in each band (optionally NULL)
+ */
+static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
+ int ecpl, int start_subband, int end_subband,
+ const uint8_t *default_band_struct,
+ uint8_t *band_struct, int *num_bands,
+ uint8_t *band_sizes)
+{
+ int subbnd, bnd, n_subbands, n_bands=0;
+ uint8_t bnd_sz[22];
+
+ n_subbands = end_subband - start_subband;
+
+ /* decode band structure from bitstream or use default */
+ if (!eac3 || get_bits1(gbc)) {
+ for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
+ band_struct[subbnd] = get_bits1(gbc);
+ }
+ } else if (!blk) {
+ memcpy(band_struct,
+ &default_band_struct[start_subband+1],
+ n_subbands-1);
+ }
+ band_struct[n_subbands-1] = 0;
+
+ /* calculate number of bands and band sizes based on band structure.
+ note that the first 4 subbands in enhanced coupling span only 6 bins
+ instead of 12. */
+ if (num_bands || band_sizes ) {
+ n_bands = n_subbands;
+ bnd_sz[0] = ecpl ? 6 : 12;
+ for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
+ int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
+ if (band_struct[subbnd-1]) {
+ n_bands--;
+ bnd_sz[bnd] += subbnd_size;
+ } else {
+ bnd_sz[++bnd] = subbnd_size;
+ }
+ }
+ }
+
+ /* set optional output params */
+ if (num_bands)
+ *num_bands = n_bands;
+ if (band_sizes)
+ memcpy(band_sizes, bnd_sz, n_bands);
+}
+
/**
* Decode a single audio block from the AC-3 bitstream.
*/
/* spectral extension strategy */
if (s->eac3 && (!blk || get_bits1(gbc))) {
if (get_bits1(gbc)) {
- av_log_missing_feature(s->avctx, "Spectral extension", 1);
+ ff_log_missing_feature(s->avctx, "Spectral extension", 1);
return -1;
}
/* TODO: parse spectral extension strategy info */
s->cpl_in_use[blk] = get_bits1(gbc);
if (s->cpl_in_use[blk]) {
/* coupling in use */
- int cpl_begin_freq, cpl_end_freq;
+ int cpl_start_subband, cpl_end_subband;
if (channel_mode < AC3_CHMODE_STEREO) {
av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
/* check for enhanced coupling */
if (s->eac3 && get_bits1(gbc)) {
/* TODO: parse enhanced coupling strategy info */
- av_log_missing_feature(s->avctx, "Enhanced coupling", 1);
+ ff_log_missing_feature(s->avctx, "Enhanced coupling", 1);
return -1;
}
/* coupling frequency range */
/* TODO: modify coupling end freq if spectral extension is used */
- cpl_begin_freq = get_bits(gbc, 4);
- cpl_end_freq = get_bits(gbc, 4);
- if (3 + cpl_end_freq - cpl_begin_freq < 0) {
- av_log(s->avctx, AV_LOG_ERROR, "3+cplendf = %d < cplbegf = %d\n", 3+cpl_end_freq, cpl_begin_freq);
+ cpl_start_subband = get_bits(gbc, 4);
+ cpl_end_subband = get_bits(gbc, 4) + 3;
+ if (cpl_start_subband >= cpl_end_subband) {
+ av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
+ cpl_start_subband, cpl_end_subband);
return -1;
}
- s->num_cpl_bands = s->num_cpl_subbands = 3 + cpl_end_freq - cpl_begin_freq;
- s->start_freq[CPL_CH] = cpl_begin_freq * 12 + 37;
- s->end_freq[CPL_CH] = cpl_end_freq * 12 + 73;
-
- /* coupling band structure */
- if (!s->eac3 || get_bits1(gbc)) {
- for (bnd = 0; bnd < s->num_cpl_subbands - 1; bnd++) {
- s->cpl_band_struct[bnd] = get_bits1(gbc);
- }
- } else if (!blk) {
- memcpy(s->cpl_band_struct,
- &ff_eac3_default_cpl_band_struct[cpl_begin_freq+1],
- s->num_cpl_subbands-1);
- }
- s->cpl_band_struct[s->num_cpl_subbands-1] = 0;
+ s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
+ s->end_freq[CPL_CH] = cpl_end_subband * 12 + 37;
- /* calculate number of coupling bands based on band structure */
- for (bnd = 0; bnd < s->num_cpl_subbands-1; bnd++) {
- s->num_cpl_bands -= s->cpl_band_struct[bnd];
- }
+ decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
+ cpl_end_subband,
+ ff_eac3_default_cpl_band_struct,
+ s->cpl_band_struct, &s->num_cpl_bands, NULL);
} else {
/* coupling not in use */
for (ch = 1; ch <= fbw_channels; ch++) {
else {
int bandwidth_code = get_bits(gbc, 6);
if (bandwidth_code > 60) {
- av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60", bandwidth_code);
+ av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
return -1;
}
s->end_freq[ch] = bandwidth_code * 3 + 73;
for (ch = !cpl_in_use; ch <= s->channels; ch++) {
if (s->exp_strategy[blk][ch] != EXP_REUSE) {
s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
- decode_exponents(gbc, s->exp_strategy[blk][ch],
- s->num_exp_groups[ch], s->dexps[ch][0],
- &s->dexps[ch][s->start_freq[ch]+!!ch]);
+ if (decode_exponents(gbc, s->exp_strategy[blk][ch],
+ s->num_exp_groups[ch], s->dexps[ch][0],
+ &s->dexps[ch][s->start_freq[ch]+!!ch])) {
+ av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
+ return -1;
+ }
if(ch != CPL_CH && ch != s->lfe_ch)
skip_bits(gbc, 2); /* skip gainrng */
}
/* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
if(!s->eac3 || !blk){
if(s->snr_offset_strategy && get_bits1(gbc)) {
- int snr = 0;
- int csnr;
- csnr = (get_bits(gbc, 6) - 15) << 4;
- for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
- /* snr offset */
- if (ch == i || s->snr_offset_strategy == 2)
- snr = (csnr + get_bits(gbc, 4)) << 2;
- /* run at least last bit allocation stage if snr offset changes */
- if(blk && s->snr_offset[ch] != snr) {
- bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
- }
- s->snr_offset[ch] = snr;
+ int snr = 0;
+ int csnr;
+ csnr = (get_bits(gbc, 6) - 15) << 4;
+ for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
+ /* snr offset */
+ if (ch == i || s->snr_offset_strategy == 2)
+ snr = (csnr + get_bits(gbc, 4)) << 2;
+ /* run at least last bit allocation stage if snr offset changes */
+ if(blk && s->snr_offset[ch] != snr) {
+ bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
+ }
+ s->snr_offset[ch] = snr;
/* fast gain (normal AC-3 only) */
if (!s->eac3) {
int prev = s->fast_gain[ch];
- s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
+ s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
/* run last 2 bit allocation stages if fast gain changes */
if(blk && prev != s->fast_gain[ch])
bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
- }
}
+ }
} else if (!s->eac3 && !blk) {
- av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
- return -1;
+ av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
+ return -1;
}
}
coupling leak changes */
if(blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
sl != s->bit_alloc_params.cpl_slow_leak)) {
- bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
+ bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
}
s->bit_alloc_params.cpl_fast_leak = fl;
s->bit_alloc_params.cpl_slow_leak = sl;
if(bit_alloc_stages[ch] > 1) {
/* Compute excitation function, Compute masking curve, and
Apply delta bit allocation */
- ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
- s->start_freq[ch], s->end_freq[ch],
- s->fast_gain[ch], (ch == s->lfe_ch),
- s->dba_mode[ch], s->dba_nsegs[ch],
- s->dba_offsets[ch], s->dba_lengths[ch],
- s->dba_values[ch], s->mask[ch]);
+ if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
+ s->start_freq[ch], s->end_freq[ch],
+ s->fast_gain[ch], (ch == s->lfe_ch),
+ s->dba_mode[ch], s->dba_nsegs[ch],
+ s->dba_offsets[ch], s->dba_lengths[ch],
+ s->dba_values[ch], s->mask[ch])) {
+ av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
+ return -1;
+ }
}
if(bit_alloc_stages[ch] > 0) {
/* Compute bit allocation */
* Decode a single AC-3 frame.
*/
static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size,
- const uint8_t *buf, int buf_size)
+ AVPacket *avpkt)
{
+ const uint8_t *buf = avpkt->data;
+ int buf_size = avpkt->size;
AC3DecodeContext *s = avctx->priv_data;
int16_t *out_samples = (int16_t *)data;
int blk, ch, err;
+ const uint8_t *channel_map;
+ const float *output[AC3_MAX_CHANNELS];
/* initialize the GetBitContext with the start of valid AC-3 Frame */
if (s->input_buffer) {
/* check that reported frame size fits in input buffer */
if(s->frame_size > buf_size) {
av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
- err = AC3_PARSE_ERROR_FRAME_SIZE;
+ err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
}
/* check for crc mismatch */
- if(err != AC3_PARSE_ERROR_FRAME_SIZE && avctx->error_resilience >= FF_ER_CAREFUL) {
+ if(err != AAC_AC3_PARSE_ERROR_FRAME_SIZE && avctx->error_recognition >= FF_ER_CAREFUL) {
if(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2], s->frame_size-2)) {
av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
- err = AC3_PARSE_ERROR_CRC;
+ err = AAC_AC3_PARSE_ERROR_CRC;
}
}
- if(err && err != AC3_PARSE_ERROR_CRC) {
+ if(err && err != AAC_AC3_PARSE_ERROR_CRC) {
switch(err) {
- case AC3_PARSE_ERROR_SYNC:
+ case AAC_AC3_PARSE_ERROR_SYNC:
av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
return -1;
- case AC3_PARSE_ERROR_BSID:
+ case AAC_AC3_PARSE_ERROR_BSID:
av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
break;
- case AC3_PARSE_ERROR_SAMPLE_RATE:
+ case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
break;
- case AC3_PARSE_ERROR_FRAME_SIZE:
+ case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
break;
- case AC3_PARSE_ERROR_FRAME_TYPE:
+ case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
/* skip frame if CRC is ok. otherwise use error concealment. */
/* TODO: add support for substreams and dependent frames */
if(s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
avctx->request_channels < s->channels) {
s->out_channels = avctx->request_channels;
s->output_mode = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
+ s->channel_layout = ff_ac3_channel_layout_tab[s->output_mode];
}
avctx->channels = s->out_channels;
+ avctx->channel_layout = s->channel_layout;
/* set downmixing coefficients if needed */
if(s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
}
/* decode the audio blocks */
+ channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
+ for (ch = 0; ch < s->out_channels; ch++)
+ output[ch] = s->output[channel_map[ch]];
for (blk = 0; blk < s->num_blocks; blk++) {
- const float *output[s->out_channels];
if (!err && decode_audio_block(s, blk)) {
av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
+ err = 1;
}
- for (ch = 0; ch < s->out_channels; ch++)
- output[ch] = s->output[ch];
s->dsp.float_to_int16_interleave(out_samples, output, 256, s->out_channels);
out_samples += 256 * s->out_channels;
}
.init = ac3_decode_init,
.close = ac3_decode_end,
.decode = ac3_decode_frame,
- .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52 (AC-3, E-AC-3)"),
+ .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
+};
+
+AVCodec eac3_decoder = {
+ .name = "eac3",
+ .type = CODEC_TYPE_AUDIO,
+ .id = CODEC_ID_EAC3,
+ .priv_data_size = sizeof (AC3DecodeContext),
+ .init = ac3_decode_init,
+ .close = ac3_decode_end,
+ .decode = ac3_decode_frame,
+ .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
};
projects / frescor / ffmpeg.git / blobdiff