3 * This code was developed as part of Google Summer of Code 2006.
4 * E-AC-3 support was added as part of Google Summer of Code 2007.
6 * Copyright (c) 2006 Kartikey Mahendra BHATT (bhattkm at gmail dot com)
7 * Copyright (c) 2007-2008 Bartlomiej Wolowiec <bartek.wolowiec@gmail.com>
8 * Copyright (c) 2007 Justin Ruggles <justin.ruggles@gmail.com>
10 * This file is part of Libav.
12 * Libav is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU Lesser General Public
14 * License as published by the Free Software Foundation; either
15 * version 2.1 of the License, or (at your option) any later version.
17 * Libav is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * Lesser General Public License for more details.
22 * You should have received a copy of the GNU Lesser General Public
23 * License along with Libav; if not, write to the Free Software
24 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
32 #include "libavutil/crc.h"
34 #include "aac_ac3_parser.h"
35 #include "ac3_parser.h"
37 #include "ac3dec_data.h"
40 /** Large enough for maximum possible frame size when the specification limit is ignored */
41 #define AC3_FRAME_BUFFER_SIZE 32768
44 * table for ungrouping 3 values in 7 bits.
45 * used for exponents and bap=2 mantissas
47 static uint8_t ungroup_3_in_7_bits_tab[128][3];
50 /** tables for ungrouping mantissas */
51 static int b1_mantissas[32][3];
52 static int b2_mantissas[128][3];
53 static int b3_mantissas[8];
54 static int b4_mantissas[128][2];
55 static int b5_mantissas[16];
58 * Quantization table: levels for symmetric. bits for asymmetric.
59 * reference: Table 7.18 Mapping of bap to Quantizer
61 static const uint8_t quantization_tab[16] = {
63 5, 6, 7, 8, 9, 10, 11, 12, 14, 16
66 /** dynamic range table. converts codes to scale factors. */
67 static float dynamic_range_tab[256];
69 /** Adjustments in dB gain */
70 static const float gain_levels[9] = {
74 LEVEL_MINUS_1POINT5DB,
76 LEVEL_MINUS_4POINT5DB,
83 * Table for center mix levels
84 * reference: Section 5.4.2.4 cmixlev
86 static const uint8_t center_levels[4] = { 4, 5, 6, 5 };
89 * Table for surround mix levels
90 * reference: Section 5.4.2.5 surmixlev
92 static const uint8_t surround_levels[4] = { 4, 6, 7, 6 };
95 * Table for default stereo downmixing coefficients
96 * reference: Section 7.8.2 Downmixing Into Two Channels
98 static const uint8_t ac3_default_coeffs[8][5][2] = {
99 { { 2, 7 }, { 7, 2 }, },
101 { { 2, 7 }, { 7, 2 }, },
102 { { 2, 7 }, { 5, 5 }, { 7, 2 }, },
103 { { 2, 7 }, { 7, 2 }, { 6, 6 }, },
104 { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 }, },
105 { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
106 { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
110 * Symmetrical Dequantization
111 * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization
112 * Tables 7.19 to 7.23
115 symmetric_dequant(int code, int levels)
117 return ((code - (levels >> 1)) << 24) / levels;
121 * Initialize tables at runtime.
123 static av_cold void ac3_tables_init(void)
127 /* generate table for ungrouping 3 values in 7 bits
128 reference: Section 7.1.3 Exponent Decoding */
129 for(i=0; i<128; i++) {
130 ungroup_3_in_7_bits_tab[i][0] = i / 25;
131 ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5;
132 ungroup_3_in_7_bits_tab[i][2] = (i % 25) % 5;
135 /* generate grouped mantissa tables
136 reference: Section 7.3.5 Ungrouping of Mantissas */
137 for(i=0; i<32; i++) {
138 /* bap=1 mantissas */
139 b1_mantissas[i][0] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][0], 3);
140 b1_mantissas[i][1] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][1], 3);
141 b1_mantissas[i][2] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][2], 3);
143 for(i=0; i<128; i++) {
144 /* bap=2 mantissas */
145 b2_mantissas[i][0] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][0], 5);
146 b2_mantissas[i][1] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][1], 5);
147 b2_mantissas[i][2] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][2], 5);
149 /* bap=4 mantissas */
150 b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
151 b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
153 /* generate ungrouped mantissa tables
154 reference: Tables 7.21 and 7.23 */
156 /* bap=3 mantissas */
157 b3_mantissas[i] = symmetric_dequant(i, 7);
159 for(i=0; i<15; i++) {
160 /* bap=5 mantissas */
161 b5_mantissas[i] = symmetric_dequant(i, 15);
164 /* generate dynamic range table
165 reference: Section 7.7.1 Dynamic Range Control */
166 for(i=0; i<256; i++) {
167 int v = (i >> 5) - ((i >> 7) << 3) - 5;
168 dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
174 * AVCodec initialization
176 static av_cold int ac3_decode_init(AVCodecContext *avctx)
178 AC3DecodeContext *s = avctx->priv_data;
181 ff_ac3_common_init();
183 ff_mdct_init(&s->imdct_256, 8, 1, 1.0);
184 ff_mdct_init(&s->imdct_512, 9, 1, 1.0);
185 ff_kbd_window_init(s->window, 5.0, 256);
186 dsputil_init(&s->dsp, avctx);
187 ff_ac3dsp_init(&s->ac3dsp, avctx->flags & CODEC_FLAG_BITEXACT);
188 ff_fmt_convert_init(&s->fmt_conv, avctx);
189 av_lfg_init(&s->dith_state, 0);
191 /* set scale value for float to int16 conversion */
192 s->mul_bias = 32767.0f;
194 /* allow downmixing to stereo or mono */
195 if (avctx->channels > 0 && avctx->request_channels > 0 &&
196 avctx->request_channels < avctx->channels &&
197 avctx->request_channels <= 2) {
198 avctx->channels = avctx->request_channels;
202 /* allocate context input buffer */
203 s->input_buffer = av_mallocz(AC3_FRAME_BUFFER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);
204 if (!s->input_buffer)
205 return AVERROR(ENOMEM);
207 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
212 * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
213 * GetBitContext within AC3DecodeContext must point to
214 * the start of the synchronized AC-3 bitstream.
216 static int ac3_parse_header(AC3DecodeContext *s)
218 GetBitContext *gbc = &s->gbc;
221 /* read the rest of the bsi. read twice for dual mono mode. */
222 i = !(s->channel_mode);
224 skip_bits(gbc, 5); // skip dialog normalization
226 skip_bits(gbc, 8); //skip compression
228 skip_bits(gbc, 8); //skip language code
230 skip_bits(gbc, 7); //skip audio production information
233 skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
235 /* skip the timecodes (or extra bitstream information for Alternate Syntax)
236 TODO: read & use the xbsi1 downmix levels */
238 skip_bits(gbc, 14); //skip timecode1 / xbsi1
240 skip_bits(gbc, 14); //skip timecode2 / xbsi2
242 /* skip additional bitstream info */
243 if (get_bits1(gbc)) {
244 i = get_bits(gbc, 6);
254 * Common function to parse AC-3 or E-AC-3 frame header
256 static int parse_frame_header(AC3DecodeContext *s)
261 err = ff_ac3_parse_header(&s->gbc, &hdr);
265 /* get decoding parameters from header info */
266 s->bit_alloc_params.sr_code = hdr.sr_code;
267 s->bitstream_mode = hdr.bitstream_mode;
268 s->channel_mode = hdr.channel_mode;
269 s->channel_layout = hdr.channel_layout;
270 s->lfe_on = hdr.lfe_on;
271 s->bit_alloc_params.sr_shift = hdr.sr_shift;
272 s->sample_rate = hdr.sample_rate;
273 s->bit_rate = hdr.bit_rate;
274 s->channels = hdr.channels;
275 s->fbw_channels = s->channels - s->lfe_on;
276 s->lfe_ch = s->fbw_channels + 1;
277 s->frame_size = hdr.frame_size;
278 s->center_mix_level = hdr.center_mix_level;
279 s->surround_mix_level = hdr.surround_mix_level;
280 s->num_blocks = hdr.num_blocks;
281 s->frame_type = hdr.frame_type;
282 s->substreamid = hdr.substreamid;
285 s->start_freq[s->lfe_ch] = 0;
286 s->end_freq[s->lfe_ch] = 7;
287 s->num_exp_groups[s->lfe_ch] = 2;
288 s->channel_in_cpl[s->lfe_ch] = 0;
291 if (hdr.bitstream_id <= 10) {
293 s->snr_offset_strategy = 2;
294 s->block_switch_syntax = 1;
295 s->dither_flag_syntax = 1;
296 s->bit_allocation_syntax = 1;
297 s->fast_gain_syntax = 0;
298 s->first_cpl_leak = 0;
301 memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
302 return ac3_parse_header(s);
303 } else if (CONFIG_EAC3_DECODER) {
305 return ff_eac3_parse_header(s);
307 av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n");
313 * Set stereo downmixing coefficients based on frame header info.
314 * reference: Section 7.8.2 Downmixing Into Two Channels
316 static void set_downmix_coeffs(AC3DecodeContext *s)
319 float cmix = gain_levels[center_levels[s->center_mix_level]];
320 float smix = gain_levels[surround_levels[s->surround_mix_level]];
323 for(i=0; i<s->fbw_channels; i++) {
324 s->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
325 s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
327 if(s->channel_mode > 1 && s->channel_mode & 1) {
328 s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix;
330 if(s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
331 int nf = s->channel_mode - 2;
332 s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
334 if(s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
335 int nf = s->channel_mode - 4;
336 s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix;
341 for(i=0; i<s->fbw_channels; i++) {
342 norm0 += s->downmix_coeffs[i][0];
343 norm1 += s->downmix_coeffs[i][1];
345 norm0 = 1.0f / norm0;
346 norm1 = 1.0f / norm1;
347 for(i=0; i<s->fbw_channels; i++) {
348 s->downmix_coeffs[i][0] *= norm0;
349 s->downmix_coeffs[i][1] *= norm1;
352 if(s->output_mode == AC3_CHMODE_MONO) {
353 for(i=0; i<s->fbw_channels; i++)
354 s->downmix_coeffs[i][0] = (s->downmix_coeffs[i][0] + s->downmix_coeffs[i][1]) * LEVEL_MINUS_3DB;
359 * Decode the grouped exponents according to exponent strategy.
360 * reference: Section 7.1.3 Exponent Decoding
362 static int decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
363 uint8_t absexp, int8_t *dexps)
365 int i, j, grp, group_size;
370 group_size = exp_strategy + (exp_strategy == EXP_D45);
371 for(grp=0,i=0; grp<ngrps; grp++) {
372 expacc = get_bits(gbc, 7);
373 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
374 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
375 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
378 /* convert to absolute exps and expand groups */
380 for(i=0,j=0; i<ngrps*3; i++) {
381 prevexp += dexp[i] - 2;
384 switch (group_size) {
385 case 4: dexps[j++] = prevexp;
386 dexps[j++] = prevexp;
387 case 2: dexps[j++] = prevexp;
388 case 1: dexps[j++] = prevexp;
395 * Generate transform coefficients for each coupled channel in the coupling
396 * range using the coupling coefficients and coupling coordinates.
397 * reference: Section 7.4.3 Coupling Coordinate Format
399 static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
403 bin = s->start_freq[CPL_CH];
404 for (band = 0; band < s->num_cpl_bands; band++) {
405 int band_start = bin;
406 int band_end = bin + s->cpl_band_sizes[band];
407 for (ch = 1; ch <= s->fbw_channels; ch++) {
408 if (s->channel_in_cpl[ch]) {
409 int cpl_coord = s->cpl_coords[ch][band] << 5;
410 for (bin = band_start; bin < band_end; bin++) {
411 s->fixed_coeffs[ch][bin] = MULH(s->fixed_coeffs[CPL_CH][bin] << 4, cpl_coord);
413 if (ch == 2 && s->phase_flags[band]) {
414 for (bin = band_start; bin < band_end; bin++)
415 s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin];
424 * Grouped mantissas for 3-level 5-level and 11-level quantization
436 * Decode the transform coefficients for a particular channel
437 * reference: Section 7.3 Quantization and Decoding of Mantissas
439 static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
441 int start_freq = s->start_freq[ch_index];
442 int end_freq = s->end_freq[ch_index];
443 uint8_t *baps = s->bap[ch_index];
444 int8_t *exps = s->dexps[ch_index];
445 int *coeffs = s->fixed_coeffs[ch_index];
446 int dither = (ch_index == CPL_CH) || s->dither_flag[ch_index];
447 GetBitContext *gbc = &s->gbc;
450 for(freq = start_freq; freq < end_freq; freq++){
451 int bap = baps[freq];
456 mantissa = (av_lfg_get(&s->dith_state) & 0x7FFFFF) - 0x400000;
463 mantissa = m->b1_mant[m->b1];
466 int bits = get_bits(gbc, 5);
467 mantissa = b1_mantissas[bits][0];
468 m->b1_mant[1] = b1_mantissas[bits][1];
469 m->b1_mant[0] = b1_mantissas[bits][2];
476 mantissa = m->b2_mant[m->b2];
479 int bits = get_bits(gbc, 7);
480 mantissa = b2_mantissas[bits][0];
481 m->b2_mant[1] = b2_mantissas[bits][1];
482 m->b2_mant[0] = b2_mantissas[bits][2];
487 mantissa = b3_mantissas[get_bits(gbc, 3)];
492 mantissa = m->b4_mant;
495 int bits = get_bits(gbc, 7);
496 mantissa = b4_mantissas[bits][0];
497 m->b4_mant = b4_mantissas[bits][1];
502 mantissa = b5_mantissas[get_bits(gbc, 4)];
504 default: /* 6 to 15 */
505 mantissa = get_bits(gbc, quantization_tab[bap]);
506 /* Shift mantissa and sign-extend it. */
507 mantissa = (mantissa << (32-quantization_tab[bap]))>>8;
510 coeffs[freq] = mantissa >> exps[freq];
515 * Remove random dithering from coupling range coefficients with zero-bit
516 * mantissas for coupled channels which do not use dithering.
517 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
519 static void remove_dithering(AC3DecodeContext *s) {
522 for(ch=1; ch<=s->fbw_channels; ch++) {
523 if(!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
524 for(i = s->start_freq[CPL_CH]; i<s->end_freq[CPL_CH]; i++) {
525 if(!s->bap[CPL_CH][i])
526 s->fixed_coeffs[ch][i] = 0;
532 static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,
535 if (!s->channel_uses_aht[ch]) {
536 ac3_decode_transform_coeffs_ch(s, ch, m);
538 /* if AHT is used, mantissas for all blocks are encoded in the first
539 block of the frame. */
541 if (!blk && CONFIG_EAC3_DECODER)
542 ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
543 for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
544 s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
550 * Decode the transform coefficients.
552 static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
558 m.b1 = m.b2 = m.b4 = 0;
560 for (ch = 1; ch <= s->channels; ch++) {
561 /* transform coefficients for full-bandwidth channel */
562 decode_transform_coeffs_ch(s, blk, ch, &m);
563 /* tranform coefficients for coupling channel come right after the
564 coefficients for the first coupled channel*/
565 if (s->channel_in_cpl[ch]) {
567 decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
568 calc_transform_coeffs_cpl(s);
571 end = s->end_freq[CPL_CH];
573 end = s->end_freq[ch];
576 s->fixed_coeffs[ch][end] = 0;
580 /* zero the dithered coefficients for appropriate channels */
585 * Stereo rematrixing.
586 * reference: Section 7.5.4 Rematrixing : Decoding Technique
588 static void do_rematrixing(AC3DecodeContext *s)
593 end = FFMIN(s->end_freq[1], s->end_freq[2]);
595 for(bnd=0; bnd<s->num_rematrixing_bands; bnd++) {
596 if(s->rematrixing_flags[bnd]) {
597 bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd+1]);
598 for(i=ff_ac3_rematrix_band_tab[bnd]; i<bndend; i++) {
599 int tmp0 = s->fixed_coeffs[1][i];
600 s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
601 s->fixed_coeffs[2][i] = tmp0 - s->fixed_coeffs[2][i];
608 * Inverse MDCT Transform.
609 * Convert frequency domain coefficients to time-domain audio samples.
610 * reference: Section 7.9.4 Transformation Equations
612 static inline void do_imdct(AC3DecodeContext *s, int channels)
616 for (ch=1; ch<=channels; ch++) {
617 if (s->block_switch[ch]) {
619 float *x = s->tmp_output+128;
621 x[i] = s->transform_coeffs[ch][2*i];
622 s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
623 s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, 128);
625 x[i] = s->transform_coeffs[ch][2*i+1];
626 s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch-1], x);
628 s->imdct_512.imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
629 s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, 128);
630 memcpy(s->delay[ch-1], s->tmp_output+128, 128*sizeof(float));
636 * Downmix the output to mono or stereo.
638 void ff_ac3_downmix_c(float (*samples)[256], float (*matrix)[2], int out_ch, int in_ch, int len)
643 for(i=0; i<len; i++) {
645 for(j=0; j<in_ch; j++) {
646 v0 += samples[j][i] * matrix[j][0];
647 v1 += samples[j][i] * matrix[j][1];
652 } else if(out_ch == 1) {
653 for(i=0; i<len; i++) {
655 for(j=0; j<in_ch; j++)
656 v0 += samples[j][i] * matrix[j][0];
663 * Upmix delay samples from stereo to original channel layout.
665 static void ac3_upmix_delay(AC3DecodeContext *s)
667 int channel_data_size = sizeof(s->delay[0]);
668 switch(s->channel_mode) {
669 case AC3_CHMODE_DUALMONO:
670 case AC3_CHMODE_STEREO:
671 /* upmix mono to stereo */
672 memcpy(s->delay[1], s->delay[0], channel_data_size);
674 case AC3_CHMODE_2F2R:
675 memset(s->delay[3], 0, channel_data_size);
676 case AC3_CHMODE_2F1R:
677 memset(s->delay[2], 0, channel_data_size);
679 case AC3_CHMODE_3F2R:
680 memset(s->delay[4], 0, channel_data_size);
681 case AC3_CHMODE_3F1R:
682 memset(s->delay[3], 0, channel_data_size);
684 memcpy(s->delay[2], s->delay[1], channel_data_size);
685 memset(s->delay[1], 0, channel_data_size);
691 * Decode band structure for coupling, spectral extension, or enhanced coupling.
692 * The band structure defines how many subbands are in each band. For each
693 * subband in the range, 1 means it is combined with the previous band, and 0
694 * means that it starts a new band.
696 * @param[in] gbc bit reader context
697 * @param[in] blk block number
698 * @param[in] eac3 flag to indicate E-AC-3
699 * @param[in] ecpl flag to indicate enhanced coupling
700 * @param[in] start_subband subband number for start of range
701 * @param[in] end_subband subband number for end of range
702 * @param[in] default_band_struct default band structure table
703 * @param[out] num_bands number of bands (optionally NULL)
704 * @param[out] band_sizes array containing the number of bins in each band (optionally NULL)
706 static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
707 int ecpl, int start_subband, int end_subband,
708 const uint8_t *default_band_struct,
709 int *num_bands, uint8_t *band_sizes)
711 int subbnd, bnd, n_subbands, n_bands=0;
713 uint8_t coded_band_struct[22];
714 const uint8_t *band_struct;
716 n_subbands = end_subband - start_subband;
718 /* decode band structure from bitstream or use default */
719 if (!eac3 || get_bits1(gbc)) {
720 for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
721 coded_band_struct[subbnd] = get_bits1(gbc);
723 band_struct = coded_band_struct;
725 band_struct = &default_band_struct[start_subband+1];
727 /* no change in band structure */
731 /* calculate number of bands and band sizes based on band structure.
732 note that the first 4 subbands in enhanced coupling span only 6 bins
734 if (num_bands || band_sizes ) {
735 n_bands = n_subbands;
736 bnd_sz[0] = ecpl ? 6 : 12;
737 for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
738 int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
739 if (band_struct[subbnd-1]) {
741 bnd_sz[bnd] += subbnd_size;
743 bnd_sz[++bnd] = subbnd_size;
748 /* set optional output params */
750 *num_bands = n_bands;
752 memcpy(band_sizes, bnd_sz, n_bands);
756 * Decode a single audio block from the AC-3 bitstream.
758 static int decode_audio_block(AC3DecodeContext *s, int blk)
760 int fbw_channels = s->fbw_channels;
761 int channel_mode = s->channel_mode;
763 int different_transforms;
766 GetBitContext *gbc = &s->gbc;
767 uint8_t bit_alloc_stages[AC3_MAX_CHANNELS];
769 memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);
771 /* block switch flags */
772 different_transforms = 0;
773 if (s->block_switch_syntax) {
774 for (ch = 1; ch <= fbw_channels; ch++) {
775 s->block_switch[ch] = get_bits1(gbc);
776 if(ch > 1 && s->block_switch[ch] != s->block_switch[1])
777 different_transforms = 1;
781 /* dithering flags */
782 if (s->dither_flag_syntax) {
783 for (ch = 1; ch <= fbw_channels; ch++) {
784 s->dither_flag[ch] = get_bits1(gbc);
789 i = !(s->channel_mode);
792 s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)]-1.0) *
793 s->avctx->drc_scale)+1.0;
794 } else if(blk == 0) {
795 s->dynamic_range[i] = 1.0f;
799 /* spectral extension strategy */
800 if (s->eac3 && (!blk || get_bits1(gbc))) {
801 s->spx_in_use = get_bits1(gbc);
803 int dst_start_freq, dst_end_freq, src_start_freq,
804 start_subband, end_subband;
806 /* determine which channels use spx */
807 if (s->channel_mode == AC3_CHMODE_MONO) {
808 s->channel_uses_spx[1] = 1;
810 for (ch = 1; ch <= fbw_channels; ch++)
811 s->channel_uses_spx[ch] = get_bits1(gbc);
814 /* get the frequency bins of the spx copy region and the spx start
816 dst_start_freq = get_bits(gbc, 2);
817 start_subband = get_bits(gbc, 3) + 2;
818 if (start_subband > 7)
819 start_subband += start_subband - 7;
820 end_subband = get_bits(gbc, 3) + 5;
822 end_subband += end_subband - 7;
823 dst_start_freq = dst_start_freq * 12 + 25;
824 src_start_freq = start_subband * 12 + 25;
825 dst_end_freq = end_subband * 12 + 25;
827 /* check validity of spx ranges */
828 if (start_subband >= end_subband) {
829 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
830 "range (%d >= %d)\n", start_subband, end_subband);
833 if (dst_start_freq >= src_start_freq) {
834 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
835 "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
839 s->spx_dst_start_freq = dst_start_freq;
840 s->spx_src_start_freq = src_start_freq;
841 s->spx_dst_end_freq = dst_end_freq;
843 decode_band_structure(gbc, blk, s->eac3, 0,
844 start_subband, end_subband,
845 ff_eac3_default_spx_band_struct,
849 for (ch = 1; ch <= fbw_channels; ch++) {
850 s->channel_uses_spx[ch] = 0;
851 s->first_spx_coords[ch] = 1;
856 /* spectral extension coordinates */
858 for (ch = 1; ch <= fbw_channels; ch++) {
859 if (s->channel_uses_spx[ch]) {
860 if (s->first_spx_coords[ch] || get_bits1(gbc)) {
862 int bin, master_spx_coord;
864 s->first_spx_coords[ch] = 0;
865 spx_blend = get_bits(gbc, 5) * (1.0f/32);
866 master_spx_coord = get_bits(gbc, 2) * 3;
868 bin = s->spx_src_start_freq;
869 for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
871 int spx_coord_exp, spx_coord_mant;
872 float nratio, sblend, nblend, spx_coord;
874 /* calculate blending factors */
875 bandsize = s->spx_band_sizes[bnd];
876 nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
877 nratio = av_clipf(nratio, 0.0f, 1.0f);
878 nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3) to give unity variance
879 sblend = sqrtf(1.0f - nratio);
882 /* decode spx coordinates */
883 spx_coord_exp = get_bits(gbc, 4);
884 spx_coord_mant = get_bits(gbc, 2);
885 if (spx_coord_exp == 15) spx_coord_mant <<= 1;
886 else spx_coord_mant += 4;
887 spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
888 spx_coord = spx_coord_mant * (1.0f/(1<<23));
890 /* multiply noise and signal blending factors by spx coordinate */
891 s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
892 s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
896 s->first_spx_coords[ch] = 1;
901 /* coupling strategy */
902 if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
903 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
905 s->cpl_in_use[blk] = get_bits1(gbc);
906 if (s->cpl_in_use[blk]) {
907 /* coupling in use */
908 int cpl_start_subband, cpl_end_subband;
910 if (channel_mode < AC3_CHMODE_STEREO) {
911 av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
915 /* check for enhanced coupling */
916 if (s->eac3 && get_bits1(gbc)) {
917 /* TODO: parse enhanced coupling strategy info */
918 av_log_missing_feature(s->avctx, "Enhanced coupling", 1);
922 /* determine which channels are coupled */
923 if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
924 s->channel_in_cpl[1] = 1;
925 s->channel_in_cpl[2] = 1;
927 for (ch = 1; ch <= fbw_channels; ch++)
928 s->channel_in_cpl[ch] = get_bits1(gbc);
931 /* phase flags in use */
932 if (channel_mode == AC3_CHMODE_STEREO)
933 s->phase_flags_in_use = get_bits1(gbc);
935 /* coupling frequency range */
936 cpl_start_subband = get_bits(gbc, 4);
937 cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
938 get_bits(gbc, 4) + 3;
939 if (cpl_start_subband >= cpl_end_subband) {
940 av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
941 cpl_start_subband, cpl_end_subband);
944 s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
945 s->end_freq[CPL_CH] = cpl_end_subband * 12 + 37;
947 decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
949 ff_eac3_default_cpl_band_struct,
950 &s->num_cpl_bands, s->cpl_band_sizes);
952 /* coupling not in use */
953 for (ch = 1; ch <= fbw_channels; ch++) {
954 s->channel_in_cpl[ch] = 0;
955 s->first_cpl_coords[ch] = 1;
957 s->first_cpl_leak = s->eac3;
958 s->phase_flags_in_use = 0;
960 } else if (!s->eac3) {
962 av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must be present in block 0\n");
965 s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
968 cpl_in_use = s->cpl_in_use[blk];
970 /* coupling coordinates */
972 int cpl_coords_exist = 0;
974 for (ch = 1; ch <= fbw_channels; ch++) {
975 if (s->channel_in_cpl[ch]) {
976 if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
977 int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
978 s->first_cpl_coords[ch] = 0;
979 cpl_coords_exist = 1;
980 master_cpl_coord = 3 * get_bits(gbc, 2);
981 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
982 cpl_coord_exp = get_bits(gbc, 4);
983 cpl_coord_mant = get_bits(gbc, 4);
984 if (cpl_coord_exp == 15)
985 s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
987 s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
988 s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
991 av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must be present in block 0\n");
995 /* channel not in coupling */
996 s->first_cpl_coords[ch] = 1;
1000 if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
1001 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1002 s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
1007 /* stereo rematrixing strategy and band structure */
1008 if (channel_mode == AC3_CHMODE_STEREO) {
1009 if ((s->eac3 && !blk) || get_bits1(gbc)) {
1010 s->num_rematrixing_bands = 4;
1011 if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
1012 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
1013 } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
1014 s->num_rematrixing_bands--;
1016 for(bnd=0; bnd<s->num_rematrixing_bands; bnd++)
1017 s->rematrixing_flags[bnd] = get_bits1(gbc);
1019 av_log(s->avctx, AV_LOG_WARNING, "Warning: new rematrixing strategy not present in block 0\n");
1020 s->num_rematrixing_bands = 0;
1024 /* exponent strategies for each channel */
1025 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1027 s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
1028 if(s->exp_strategy[blk][ch] != EXP_REUSE)
1029 bit_alloc_stages[ch] = 3;
1032 /* channel bandwidth */
1033 for (ch = 1; ch <= fbw_channels; ch++) {
1034 s->start_freq[ch] = 0;
1035 if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1037 int prev = s->end_freq[ch];
1038 if (s->channel_in_cpl[ch])
1039 s->end_freq[ch] = s->start_freq[CPL_CH];
1040 else if (s->channel_uses_spx[ch])
1041 s->end_freq[ch] = s->spx_src_start_freq;
1043 int bandwidth_code = get_bits(gbc, 6);
1044 if (bandwidth_code > 60) {
1045 av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1048 s->end_freq[ch] = bandwidth_code * 3 + 73;
1050 group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1051 s->num_exp_groups[ch] = (s->end_freq[ch]+group_size-4) / group_size;
1052 if(blk > 0 && s->end_freq[ch] != prev)
1053 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1056 if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1057 s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
1058 (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1061 /* decode exponents for each channel */
1062 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1063 if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1064 s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1065 if (decode_exponents(gbc, s->exp_strategy[blk][ch],
1066 s->num_exp_groups[ch], s->dexps[ch][0],
1067 &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1068 av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
1071 if(ch != CPL_CH && ch != s->lfe_ch)
1072 skip_bits(gbc, 2); /* skip gainrng */
1076 /* bit allocation information */
1077 if (s->bit_allocation_syntax) {
1078 if (get_bits1(gbc)) {
1079 s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1080 s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1081 s->bit_alloc_params.slow_gain = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
1082 s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
1083 s->bit_alloc_params.floor = ff_ac3_floor_tab[get_bits(gbc, 3)];
1084 for(ch=!cpl_in_use; ch<=s->channels; ch++)
1085 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1087 av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must be present in block 0\n");
1092 /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1093 if(!s->eac3 || !blk){
1094 if(s->snr_offset_strategy && get_bits1(gbc)) {
1097 csnr = (get_bits(gbc, 6) - 15) << 4;
1098 for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1100 if (ch == i || s->snr_offset_strategy == 2)
1101 snr = (csnr + get_bits(gbc, 4)) << 2;
1102 /* run at least last bit allocation stage if snr offset changes */
1103 if(blk && s->snr_offset[ch] != snr) {
1104 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1106 s->snr_offset[ch] = snr;
1108 /* fast gain (normal AC-3 only) */
1110 int prev = s->fast_gain[ch];
1111 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1112 /* run last 2 bit allocation stages if fast gain changes */
1113 if(blk && prev != s->fast_gain[ch])
1114 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1117 } else if (!s->eac3 && !blk) {
1118 av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1123 /* fast gain (E-AC-3 only) */
1124 if (s->fast_gain_syntax && get_bits1(gbc)) {
1125 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1126 int prev = s->fast_gain[ch];
1127 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1128 /* run last 2 bit allocation stages if fast gain changes */
1129 if(blk && prev != s->fast_gain[ch])
1130 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1132 } else if (s->eac3 && !blk) {
1133 for (ch = !cpl_in_use; ch <= s->channels; ch++)
1134 s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1137 /* E-AC-3 to AC-3 converter SNR offset */
1138 if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1139 skip_bits(gbc, 10); // skip converter snr offset
1142 /* coupling leak information */
1144 if (s->first_cpl_leak || get_bits1(gbc)) {
1145 int fl = get_bits(gbc, 3);
1146 int sl = get_bits(gbc, 3);
1147 /* run last 2 bit allocation stages for coupling channel if
1148 coupling leak changes */
1149 if(blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1150 sl != s->bit_alloc_params.cpl_slow_leak)) {
1151 bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1153 s->bit_alloc_params.cpl_fast_leak = fl;
1154 s->bit_alloc_params.cpl_slow_leak = sl;
1155 } else if (!s->eac3 && !blk) {
1156 av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must be present in block 0\n");
1159 s->first_cpl_leak = 0;
1162 /* delta bit allocation information */
1163 if (s->dba_syntax && get_bits1(gbc)) {
1164 /* delta bit allocation exists (strategy) */
1165 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1166 s->dba_mode[ch] = get_bits(gbc, 2);
1167 if (s->dba_mode[ch] == DBA_RESERVED) {
1168 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1171 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1173 /* channel delta offset, len and bit allocation */
1174 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1175 if (s->dba_mode[ch] == DBA_NEW) {
1176 s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;
1177 for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
1178 s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1179 s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1180 s->dba_values[ch][seg] = get_bits(gbc, 3);
1182 /* run last 2 bit allocation stages if new dba values */
1183 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1186 } else if(blk == 0) {
1187 for(ch=0; ch<=s->channels; ch++) {
1188 s->dba_mode[ch] = DBA_NONE;
1192 /* Bit allocation */
1193 for(ch=!cpl_in_use; ch<=s->channels; ch++) {
1194 if(bit_alloc_stages[ch] > 2) {
1195 /* Exponent mapping into PSD and PSD integration */
1196 ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
1197 s->start_freq[ch], s->end_freq[ch],
1198 s->psd[ch], s->band_psd[ch]);
1200 if(bit_alloc_stages[ch] > 1) {
1201 /* Compute excitation function, Compute masking curve, and
1202 Apply delta bit allocation */
1203 if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1204 s->start_freq[ch], s->end_freq[ch],
1205 s->fast_gain[ch], (ch == s->lfe_ch),
1206 s->dba_mode[ch], s->dba_nsegs[ch],
1207 s->dba_offsets[ch], s->dba_lengths[ch],
1208 s->dba_values[ch], s->mask[ch])) {
1209 av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1213 if(bit_alloc_stages[ch] > 0) {
1214 /* Compute bit allocation */
1215 const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1216 ff_eac3_hebap_tab : ff_ac3_bap_tab;
1217 s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1218 s->start_freq[ch], s->end_freq[ch],
1220 s->bit_alloc_params.floor,
1221 bap_tab, s->bap[ch]);
1225 /* unused dummy data */
1226 if (s->skip_syntax && get_bits1(gbc)) {
1227 int skipl = get_bits(gbc, 9);
1232 /* unpack the transform coefficients
1233 this also uncouples channels if coupling is in use. */
1234 decode_transform_coeffs(s, blk);
1236 /* TODO: generate enhanced coupling coordinates and uncouple */
1238 /* recover coefficients if rematrixing is in use */
1239 if(s->channel_mode == AC3_CHMODE_STEREO)
1242 /* apply scaling to coefficients (headroom, dynrng) */
1243 for(ch=1; ch<=s->channels; ch++) {
1244 float gain = s->mul_bias / 4194304.0f;
1245 if(s->channel_mode == AC3_CHMODE_DUALMONO) {
1246 gain *= s->dynamic_range[2-ch];
1248 gain *= s->dynamic_range[0];
1250 s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch], s->fixed_coeffs[ch], gain, 256);
1253 /* apply spectral extension to high frequency bins */
1254 if (s->spx_in_use && CONFIG_EAC3_DECODER) {
1255 ff_eac3_apply_spectral_extension(s);
1258 /* downmix and MDCT. order depends on whether block switching is used for
1259 any channel in this block. this is because coefficients for the long
1260 and short transforms cannot be mixed. */
1261 downmix_output = s->channels != s->out_channels &&
1262 !((s->output_mode & AC3_OUTPUT_LFEON) &&
1263 s->fbw_channels == s->out_channels);
1264 if(different_transforms) {
1265 /* the delay samples have already been downmixed, so we upmix the delay
1266 samples in order to reconstruct all channels before downmixing. */
1272 do_imdct(s, s->channels);
1274 if(downmix_output) {
1275 s->dsp.ac3_downmix(s->output, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
1278 if(downmix_output) {
1279 s->dsp.ac3_downmix(s->transform_coeffs+1, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
1282 if(downmix_output && !s->downmixed) {
1284 s->dsp.ac3_downmix(s->delay, s->downmix_coeffs, s->out_channels, s->fbw_channels, 128);
1287 do_imdct(s, s->out_channels);
1294 * Decode a single AC-3 frame.
1296 static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size,
1299 const uint8_t *buf = avpkt->data;
1300 int buf_size = avpkt->size;
1301 AC3DecodeContext *s = avctx->priv_data;
1302 int16_t *out_samples = (int16_t *)data;
1304 const uint8_t *channel_map;
1305 const float *output[AC3_MAX_CHANNELS];
1307 /* copy input buffer to decoder context to avoid reading past the end
1308 of the buffer, which can be caused by a damaged input stream. */
1309 if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
1310 // seems to be byte-swapped AC-3
1311 int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1312 s->dsp.bswap16_buf((uint16_t *)s->input_buffer, (const uint16_t *)buf, cnt);
1314 memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1315 buf = s->input_buffer;
1316 /* initialize the GetBitContext with the start of valid AC-3 Frame */
1317 init_get_bits(&s->gbc, buf, buf_size * 8);
1319 /* parse the syncinfo */
1321 err = parse_frame_header(s);
1325 case AAC_AC3_PARSE_ERROR_SYNC:
1326 av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1328 case AAC_AC3_PARSE_ERROR_BSID:
1329 av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1331 case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
1332 av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1334 case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
1335 av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1337 case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
1338 /* skip frame if CRC is ok. otherwise use error concealment. */
1339 /* TODO: add support for substreams and dependent frames */
1340 if(s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
1341 av_log(avctx, AV_LOG_ERROR, "unsupported frame type : skipping frame\n");
1342 return s->frame_size;
1344 av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1348 av_log(avctx, AV_LOG_ERROR, "invalid header\n");
1352 /* check that reported frame size fits in input buffer */
1353 if (s->frame_size > buf_size) {
1354 av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1355 err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
1356 } else if (avctx->error_recognition >= FF_ER_CAREFUL) {
1357 /* check for crc mismatch */
1358 if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2], s->frame_size-2)) {
1359 av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1360 err = AAC_AC3_PARSE_ERROR_CRC;
1365 /* if frame is ok, set audio parameters */
1367 avctx->sample_rate = s->sample_rate;
1368 avctx->bit_rate = s->bit_rate;
1370 /* channel config */
1371 s->out_channels = s->channels;
1372 s->output_mode = s->channel_mode;
1374 s->output_mode |= AC3_OUTPUT_LFEON;
1375 if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&
1376 avctx->request_channels < s->channels) {
1377 s->out_channels = avctx->request_channels;
1378 s->output_mode = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1379 s->channel_layout = ff_ac3_channel_layout_tab[s->output_mode];
1381 avctx->channels = s->out_channels;
1382 avctx->channel_layout = s->channel_layout;
1384 /* set downmixing coefficients if needed */
1385 if(s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1386 s->fbw_channels == s->out_channels)) {
1387 set_downmix_coeffs(s);
1389 } else if (!s->out_channels) {
1390 s->out_channels = avctx->channels;
1391 if(s->out_channels < s->channels)
1392 s->output_mode = s->out_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1394 /* set audio service type based on bitstream mode for AC-3 */
1395 avctx->audio_service_type = s->bitstream_mode;
1396 if (s->bitstream_mode == 0x7 && s->channels > 1)
1397 avctx->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
1399 /* decode the audio blocks */
1400 channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1401 for (ch = 0; ch < s->out_channels; ch++)
1402 output[ch] = s->output[channel_map[ch]];
1403 for (blk = 0; blk < s->num_blocks; blk++) {
1404 if (!err && decode_audio_block(s, blk)) {
1405 av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1408 s->fmt_conv.float_to_int16_interleave(out_samples, output, 256, s->out_channels);
1409 out_samples += 256 * s->out_channels;
1411 *data_size = s->num_blocks * 256 * avctx->channels * sizeof (int16_t);
1412 return FFMIN(buf_size, s->frame_size);
1416 * Uninitialize the AC-3 decoder.
1418 static av_cold int ac3_decode_end(AVCodecContext *avctx)
1420 AC3DecodeContext *s = avctx->priv_data;
1421 ff_mdct_end(&s->imdct_512);
1422 ff_mdct_end(&s->imdct_256);
1424 av_freep(&s->input_buffer);
1429 AVCodec ff_ac3_decoder = {
1431 .type = AVMEDIA_TYPE_AUDIO,
1433 .priv_data_size = sizeof (AC3DecodeContext),
1434 .init = ac3_decode_init,
1435 .close = ac3_decode_end,
1436 .decode = ac3_decode_frame,
1437 .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
1440 #if CONFIG_EAC3_DECODER
1441 AVCodec ff_eac3_decoder = {
1443 .type = AVMEDIA_TYPE_AUDIO,
1444 .id = CODEC_ID_EAC3,
1445 .priv_data_size = sizeof (AC3DecodeContext),
1446 .init = ac3_decode_init,
1447 .close = ac3_decode_end,
1448 .decode = ac3_decode_frame,
1449 .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),