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 FFmpeg.
12 * FFmpeg 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 * FFmpeg 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 FFmpeg; if not, write to the Free Software
24 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
32 #include "libavutil/channel_layout.h"
33 #include "libavutil/crc.h"
34 #include "libavutil/opt.h"
36 #include "aac_ac3_parser.h"
37 #include "ac3_parser.h"
39 #include "ac3dec_data.h"
43 * table for ungrouping 3 values in 7 bits.
44 * used for exponents and bap=2 mantissas
46 static uint8_t ungroup_3_in_7_bits_tab[128][3];
48 /** tables for ungrouping mantissas */
49 static int b1_mantissas[32][3];
50 static int b2_mantissas[128][3];
51 static int b3_mantissas[8];
52 static int b4_mantissas[128][2];
53 static int b5_mantissas[16];
56 * Quantization table: levels for symmetric. bits for asymmetric.
57 * reference: Table 7.18 Mapping of bap to Quantizer
59 static const uint8_t quantization_tab[16] = {
61 5, 6, 7, 8, 9, 10, 11, 12, 14, 16
64 /** dynamic range table. converts codes to scale factors. */
65 static float dynamic_range_tab[256];
67 /** Adjustments in dB gain */
68 static const float gain_levels[9] = {
72 LEVEL_MINUS_1POINT5DB,
74 LEVEL_MINUS_4POINT5DB,
81 * Table for default stereo downmixing coefficients
82 * reference: Section 7.8.2 Downmixing Into Two Channels
84 static const uint8_t ac3_default_coeffs[8][5][2] = {
85 { { 2, 7 }, { 7, 2 }, },
87 { { 2, 7 }, { 7, 2 }, },
88 { { 2, 7 }, { 5, 5 }, { 7, 2 }, },
89 { { 2, 7 }, { 7, 2 }, { 6, 6 }, },
90 { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 }, },
91 { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
92 { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
96 * Symmetrical Dequantization
97 * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization
101 symmetric_dequant(int code, int levels)
103 return ((code - (levels >> 1)) << 24) / levels;
107 * Initialize tables at runtime.
109 static av_cold void ac3_tables_init(void)
113 /* generate table for ungrouping 3 values in 7 bits
114 reference: Section 7.1.3 Exponent Decoding */
115 for (i = 0; i < 128; i++) {
116 ungroup_3_in_7_bits_tab[i][0] = i / 25;
117 ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5;
118 ungroup_3_in_7_bits_tab[i][2] = (i % 25) % 5;
121 /* generate grouped mantissa tables
122 reference: Section 7.3.5 Ungrouping of Mantissas */
123 for (i = 0; i < 32; i++) {
124 /* bap=1 mantissas */
125 b1_mantissas[i][0] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][0], 3);
126 b1_mantissas[i][1] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][1], 3);
127 b1_mantissas[i][2] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][2], 3);
129 for (i = 0; i < 128; i++) {
130 /* bap=2 mantissas */
131 b2_mantissas[i][0] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][0], 5);
132 b2_mantissas[i][1] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][1], 5);
133 b2_mantissas[i][2] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][2], 5);
135 /* bap=4 mantissas */
136 b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
137 b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
139 /* generate ungrouped mantissa tables
140 reference: Tables 7.21 and 7.23 */
141 for (i = 0; i < 7; i++) {
142 /* bap=3 mantissas */
143 b3_mantissas[i] = symmetric_dequant(i, 7);
145 for (i = 0; i < 15; i++) {
146 /* bap=5 mantissas */
147 b5_mantissas[i] = symmetric_dequant(i, 15);
150 /* generate dynamic range table
151 reference: Section 7.7.1 Dynamic Range Control */
152 for (i = 0; i < 256; i++) {
153 int v = (i >> 5) - ((i >> 7) << 3) - 5;
154 dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
159 * AVCodec initialization
161 static av_cold int ac3_decode_init(AVCodecContext *avctx)
163 AC3DecodeContext *s = avctx->priv_data;
168 ff_ac3_common_init();
170 ff_mdct_init(&s->imdct_256, 8, 1, 1.0);
171 ff_mdct_init(&s->imdct_512, 9, 1, 1.0);
172 ff_kbd_window_init(s->window, 5.0, 256);
173 ff_dsputil_init(&s->dsp, avctx);
174 avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
175 ff_ac3dsp_init(&s->ac3dsp, avctx->flags & CODEC_FLAG_BITEXACT);
176 ff_fmt_convert_init(&s->fmt_conv, avctx);
177 av_lfg_init(&s->dith_state, 0);
179 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
181 /* allow downmixing to stereo or mono */
182 #if FF_API_REQUEST_CHANNELS
183 FF_DISABLE_DEPRECATION_WARNINGS
184 if (avctx->request_channels == 1)
185 avctx->request_channel_layout = AV_CH_LAYOUT_MONO;
186 else if (avctx->request_channels == 2)
187 avctx->request_channel_layout = AV_CH_LAYOUT_STEREO;
188 FF_ENABLE_DEPRECATION_WARNINGS
190 if (avctx->channels > 1 &&
191 avctx->request_channel_layout == AV_CH_LAYOUT_MONO)
193 else if (avctx->channels > 2 &&
194 avctx->request_channel_layout == AV_CH_LAYOUT_STEREO)
198 for (i = 0; i < AC3_MAX_CHANNELS; i++) {
199 s->xcfptr[i] = s->transform_coeffs[i];
200 s->dlyptr[i] = s->delay[i];
207 * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
208 * GetBitContext within AC3DecodeContext must point to
209 * the start of the synchronized AC-3 bitstream.
211 static int ac3_parse_header(AC3DecodeContext *s)
213 GetBitContext *gbc = &s->gbc;
216 /* read the rest of the bsi. read twice for dual mono mode. */
217 i = !s->channel_mode;
219 skip_bits(gbc, 5); // skip dialog normalization
221 skip_bits(gbc, 8); //skip compression
223 skip_bits(gbc, 8); //skip language code
225 skip_bits(gbc, 7); //skip audio production information
228 skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
230 /* skip the timecodes (or extra bitstream information for Alternate Syntax)
231 TODO: read & use the xbsi1 downmix levels */
233 skip_bits(gbc, 14); //skip timecode1 / xbsi1
235 skip_bits(gbc, 14); //skip timecode2 / xbsi2
237 /* skip additional bitstream info */
238 if (get_bits1(gbc)) {
239 i = get_bits(gbc, 6);
249 * Common function to parse AC-3 or E-AC-3 frame header
251 static int parse_frame_header(AC3DecodeContext *s)
256 err = avpriv_ac3_parse_header(&s->gbc, &hdr);
260 /* get decoding parameters from header info */
261 s->bit_alloc_params.sr_code = hdr.sr_code;
262 s->bitstream_mode = hdr.bitstream_mode;
263 s->channel_mode = hdr.channel_mode;
264 s->lfe_on = hdr.lfe_on;
265 s->bit_alloc_params.sr_shift = hdr.sr_shift;
266 s->sample_rate = hdr.sample_rate;
267 s->bit_rate = hdr.bit_rate;
268 s->channels = hdr.channels;
269 s->fbw_channels = s->channels - s->lfe_on;
270 s->lfe_ch = s->fbw_channels + 1;
271 s->frame_size = hdr.frame_size;
272 s->center_mix_level = hdr.center_mix_level;
273 s->surround_mix_level = hdr.surround_mix_level;
274 s->num_blocks = hdr.num_blocks;
275 s->frame_type = hdr.frame_type;
276 s->substreamid = hdr.substreamid;
279 s->start_freq[s->lfe_ch] = 0;
280 s->end_freq[s->lfe_ch] = 7;
281 s->num_exp_groups[s->lfe_ch] = 2;
282 s->channel_in_cpl[s->lfe_ch] = 0;
285 if (hdr.bitstream_id <= 10) {
287 s->snr_offset_strategy = 2;
288 s->block_switch_syntax = 1;
289 s->dither_flag_syntax = 1;
290 s->bit_allocation_syntax = 1;
291 s->fast_gain_syntax = 0;
292 s->first_cpl_leak = 0;
295 memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
296 return ac3_parse_header(s);
297 } else if (CONFIG_EAC3_DECODER) {
299 return ff_eac3_parse_header(s);
301 av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n");
302 return AVERROR(ENOSYS);
307 * Set stereo downmixing coefficients based on frame header info.
308 * reference: Section 7.8.2 Downmixing Into Two Channels
310 static void set_downmix_coeffs(AC3DecodeContext *s)
313 float cmix = gain_levels[s-> center_mix_level];
314 float smix = gain_levels[s->surround_mix_level];
317 for (i = 0; i < s->fbw_channels; i++) {
318 s->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
319 s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
321 if (s->channel_mode > 1 && s->channel_mode & 1) {
322 s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix;
324 if (s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
325 int nf = s->channel_mode - 2;
326 s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
328 if (s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
329 int nf = s->channel_mode - 4;
330 s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix;
335 for (i = 0; i < s->fbw_channels; i++) {
336 norm0 += s->downmix_coeffs[i][0];
337 norm1 += s->downmix_coeffs[i][1];
339 norm0 = 1.0f / norm0;
340 norm1 = 1.0f / norm1;
341 for (i = 0; i < s->fbw_channels; i++) {
342 s->downmix_coeffs[i][0] *= norm0;
343 s->downmix_coeffs[i][1] *= norm1;
346 if (s->output_mode == AC3_CHMODE_MONO) {
347 for (i = 0; i < s->fbw_channels; i++)
348 s->downmix_coeffs[i][0] = (s->downmix_coeffs[i][0] +
349 s->downmix_coeffs[i][1]) * LEVEL_MINUS_3DB;
354 * Decode the grouped exponents according to exponent strategy.
355 * reference: Section 7.1.3 Exponent Decoding
357 static int decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
358 uint8_t absexp, int8_t *dexps)
360 int i, j, grp, group_size;
365 group_size = exp_strategy + (exp_strategy == EXP_D45);
366 for (grp = 0, i = 0; grp < ngrps; grp++) {
367 expacc = get_bits(gbc, 7);
368 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
369 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
370 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
373 /* convert to absolute exps and expand groups */
375 for (i = 0, j = 0; i < ngrps * 3; i++) {
376 prevexp += dexp[i] - 2;
379 switch (group_size) {
380 case 4: dexps[j++] = prevexp;
381 dexps[j++] = prevexp;
382 case 2: dexps[j++] = prevexp;
383 case 1: dexps[j++] = prevexp;
390 * Generate transform coefficients for each coupled channel in the coupling
391 * range using the coupling coefficients and coupling coordinates.
392 * reference: Section 7.4.3 Coupling Coordinate Format
394 static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
398 bin = s->start_freq[CPL_CH];
399 for (band = 0; band < s->num_cpl_bands; band++) {
400 int band_start = bin;
401 int band_end = bin + s->cpl_band_sizes[band];
402 for (ch = 1; ch <= s->fbw_channels; ch++) {
403 if (s->channel_in_cpl[ch]) {
404 int cpl_coord = s->cpl_coords[ch][band] << 5;
405 for (bin = band_start; bin < band_end; bin++) {
406 s->fixed_coeffs[ch][bin] =
407 MULH(s->fixed_coeffs[CPL_CH][bin] << 4, cpl_coord);
409 if (ch == 2 && s->phase_flags[band]) {
410 for (bin = band_start; bin < band_end; bin++)
411 s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin];
420 * Grouped mantissas for 3-level 5-level and 11-level quantization
432 * Decode the transform coefficients for a particular channel
433 * reference: Section 7.3 Quantization and Decoding of Mantissas
435 static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
437 int start_freq = s->start_freq[ch_index];
438 int end_freq = s->end_freq[ch_index];
439 uint8_t *baps = s->bap[ch_index];
440 int8_t *exps = s->dexps[ch_index];
441 int32_t *coeffs = s->fixed_coeffs[ch_index];
442 int dither = (ch_index == CPL_CH) || s->dither_flag[ch_index];
443 GetBitContext *gbc = &s->gbc;
446 for (freq = start_freq; freq < end_freq; freq++) {
447 int bap = baps[freq];
451 /* random noise with approximate range of -0.707 to 0.707 */
453 mantissa = (((av_lfg_get(&s->dith_state)>>8)*181)>>8) - 5931008;
460 mantissa = m->b1_mant[m->b1];
462 int bits = get_bits(gbc, 5);
463 mantissa = b1_mantissas[bits][0];
464 m->b1_mant[1] = b1_mantissas[bits][1];
465 m->b1_mant[0] = b1_mantissas[bits][2];
472 mantissa = m->b2_mant[m->b2];
474 int bits = get_bits(gbc, 7);
475 mantissa = b2_mantissas[bits][0];
476 m->b2_mant[1] = b2_mantissas[bits][1];
477 m->b2_mant[0] = b2_mantissas[bits][2];
482 mantissa = b3_mantissas[get_bits(gbc, 3)];
487 mantissa = m->b4_mant;
489 int bits = get_bits(gbc, 7);
490 mantissa = b4_mantissas[bits][0];
491 m->b4_mant = b4_mantissas[bits][1];
496 mantissa = b5_mantissas[get_bits(gbc, 4)];
498 default: /* 6 to 15 */
499 /* Shift mantissa and sign-extend it. */
501 av_log(s->avctx, AV_LOG_ERROR, "bap %d is invalid in plain AC-3\n", bap);
504 mantissa = get_sbits(gbc, quantization_tab[bap]);
505 mantissa <<= 24 - quantization_tab[bap];
508 coeffs[freq] = mantissa >> exps[freq];
513 * Remove random dithering from coupling range coefficients with zero-bit
514 * mantissas for coupled channels which do not use dithering.
515 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
517 static void remove_dithering(AC3DecodeContext *s) {
520 for (ch = 1; ch <= s->fbw_channels; ch++) {
521 if (!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
522 for (i = s->start_freq[CPL_CH]; i < s->end_freq[CPL_CH]; i++) {
523 if (!s->bap[CPL_CH][i])
524 s->fixed_coeffs[ch][i] = 0;
530 static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,
533 if (!s->channel_uses_aht[ch]) {
534 ac3_decode_transform_coeffs_ch(s, ch, m);
536 /* if AHT is used, mantissas for all blocks are encoded in the first
537 block of the frame. */
539 if (!blk && CONFIG_EAC3_DECODER)
540 ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
541 for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
542 s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
548 * Decode the transform coefficients.
550 static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
556 m.b1 = m.b2 = m.b4 = 0;
558 for (ch = 1; ch <= s->channels; ch++) {
559 /* transform coefficients for full-bandwidth channel */
560 decode_transform_coeffs_ch(s, blk, ch, &m);
561 /* transform coefficients for coupling channel come right after the
562 coefficients for the first coupled channel*/
563 if (s->channel_in_cpl[ch]) {
565 decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
566 calc_transform_coeffs_cpl(s);
569 end = s->end_freq[CPL_CH];
571 end = s->end_freq[ch];
574 s->fixed_coeffs[ch][end] = 0;
578 /* zero the dithered coefficients for appropriate channels */
583 * Stereo rematrixing.
584 * reference: Section 7.5.4 Rematrixing : Decoding Technique
586 static void do_rematrixing(AC3DecodeContext *s)
591 end = FFMIN(s->end_freq[1], s->end_freq[2]);
593 for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) {
594 if (s->rematrixing_flags[bnd]) {
595 bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd + 1]);
596 for (i = ff_ac3_rematrix_band_tab[bnd]; i < bndend; i++) {
597 int tmp0 = s->fixed_coeffs[1][i];
598 s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
599 s->fixed_coeffs[2][i] = tmp0 - s->fixed_coeffs[2][i];
606 * Inverse MDCT Transform.
607 * Convert frequency domain coefficients to time-domain audio samples.
608 * reference: Section 7.9.4 Transformation Equations
610 static inline void do_imdct(AC3DecodeContext *s, int channels)
614 for (ch = 1; ch <= channels; ch++) {
615 if (s->block_switch[ch]) {
617 float *x = s->tmp_output + 128;
618 for (i = 0; i < 128; i++)
619 x[i] = s->transform_coeffs[ch][2 * i];
620 s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
621 s->fdsp.vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
622 s->tmp_output, s->window, 128);
623 for (i = 0; i < 128; i++)
624 x[i] = s->transform_coeffs[ch][2 * i + 1];
625 s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch - 1], x);
627 s->imdct_512.imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
628 s->fdsp.vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
629 s->tmp_output, s->window, 128);
630 memcpy(s->delay[ch - 1], s->tmp_output + 128, 128 * sizeof(float));
636 * Upmix delay samples from stereo to original channel layout.
638 static void ac3_upmix_delay(AC3DecodeContext *s)
640 int channel_data_size = sizeof(s->delay[0]);
641 switch (s->channel_mode) {
642 case AC3_CHMODE_DUALMONO:
643 case AC3_CHMODE_STEREO:
644 /* upmix mono to stereo */
645 memcpy(s->delay[1], s->delay[0], channel_data_size);
647 case AC3_CHMODE_2F2R:
648 memset(s->delay[3], 0, channel_data_size);
649 case AC3_CHMODE_2F1R:
650 memset(s->delay[2], 0, channel_data_size);
652 case AC3_CHMODE_3F2R:
653 memset(s->delay[4], 0, channel_data_size);
654 case AC3_CHMODE_3F1R:
655 memset(s->delay[3], 0, channel_data_size);
657 memcpy(s->delay[2], s->delay[1], channel_data_size);
658 memset(s->delay[1], 0, channel_data_size);
664 * Decode band structure for coupling, spectral extension, or enhanced coupling.
665 * The band structure defines how many subbands are in each band. For each
666 * subband in the range, 1 means it is combined with the previous band, and 0
667 * means that it starts a new band.
669 * @param[in] gbc bit reader context
670 * @param[in] blk block number
671 * @param[in] eac3 flag to indicate E-AC-3
672 * @param[in] ecpl flag to indicate enhanced coupling
673 * @param[in] start_subband subband number for start of range
674 * @param[in] end_subband subband number for end of range
675 * @param[in] default_band_struct default band structure table
676 * @param[out] num_bands number of bands (optionally NULL)
677 * @param[out] band_sizes array containing the number of bins in each band (optionally NULL)
679 static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
680 int ecpl, int start_subband, int end_subband,
681 const uint8_t *default_band_struct,
682 int *num_bands, uint8_t *band_sizes)
684 int subbnd, bnd, n_subbands, n_bands=0;
686 uint8_t coded_band_struct[22];
687 const uint8_t *band_struct;
689 n_subbands = end_subband - start_subband;
691 /* decode band structure from bitstream or use default */
692 if (!eac3 || get_bits1(gbc)) {
693 for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
694 coded_band_struct[subbnd] = get_bits1(gbc);
696 band_struct = coded_band_struct;
698 band_struct = &default_band_struct[start_subband+1];
700 /* no change in band structure */
704 /* calculate number of bands and band sizes based on band structure.
705 note that the first 4 subbands in enhanced coupling span only 6 bins
707 if (num_bands || band_sizes ) {
708 n_bands = n_subbands;
709 bnd_sz[0] = ecpl ? 6 : 12;
710 for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
711 int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
712 if (band_struct[subbnd - 1]) {
714 bnd_sz[bnd] += subbnd_size;
716 bnd_sz[++bnd] = subbnd_size;
721 /* set optional output params */
723 *num_bands = n_bands;
725 memcpy(band_sizes, bnd_sz, n_bands);
729 * Decode a single audio block from the AC-3 bitstream.
731 static int decode_audio_block(AC3DecodeContext *s, int blk)
733 int fbw_channels = s->fbw_channels;
734 int channel_mode = s->channel_mode;
736 int different_transforms;
739 GetBitContext *gbc = &s->gbc;
740 uint8_t bit_alloc_stages[AC3_MAX_CHANNELS] = { 0 };
742 /* block switch flags */
743 different_transforms = 0;
744 if (s->block_switch_syntax) {
745 for (ch = 1; ch <= fbw_channels; ch++) {
746 s->block_switch[ch] = get_bits1(gbc);
747 if (ch > 1 && s->block_switch[ch] != s->block_switch[1])
748 different_transforms = 1;
752 /* dithering flags */
753 if (s->dither_flag_syntax) {
754 for (ch = 1; ch <= fbw_channels; ch++) {
755 s->dither_flag[ch] = get_bits1(gbc);
760 i = !s->channel_mode;
762 if (get_bits1(gbc)) {
763 s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)] - 1.0) *
765 } else if (blk == 0) {
766 s->dynamic_range[i] = 1.0f;
770 /* spectral extension strategy */
771 if (s->eac3 && (!blk || get_bits1(gbc))) {
772 s->spx_in_use = get_bits1(gbc);
774 int dst_start_freq, dst_end_freq, src_start_freq,
775 start_subband, end_subband;
777 /* determine which channels use spx */
778 if (s->channel_mode == AC3_CHMODE_MONO) {
779 s->channel_uses_spx[1] = 1;
781 for (ch = 1; ch <= fbw_channels; ch++)
782 s->channel_uses_spx[ch] = get_bits1(gbc);
785 /* get the frequency bins of the spx copy region and the spx start
787 dst_start_freq = get_bits(gbc, 2);
788 start_subband = get_bits(gbc, 3) + 2;
789 if (start_subband > 7)
790 start_subband += start_subband - 7;
791 end_subband = get_bits(gbc, 3) + 5;
793 end_subband += end_subband - 7;
794 dst_start_freq = dst_start_freq * 12 + 25;
795 src_start_freq = start_subband * 12 + 25;
796 dst_end_freq = end_subband * 12 + 25;
798 /* check validity of spx ranges */
799 if (start_subband >= end_subband) {
800 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
801 "range (%d >= %d)\n", start_subband, end_subband);
802 return AVERROR_INVALIDDATA;
804 if (dst_start_freq >= src_start_freq) {
805 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
806 "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
807 return AVERROR_INVALIDDATA;
810 s->spx_dst_start_freq = dst_start_freq;
811 s->spx_src_start_freq = src_start_freq;
812 s->spx_dst_end_freq = dst_end_freq;
814 decode_band_structure(gbc, blk, s->eac3, 0,
815 start_subband, end_subband,
816 ff_eac3_default_spx_band_struct,
820 for (ch = 1; ch <= fbw_channels; ch++) {
821 s->channel_uses_spx[ch] = 0;
822 s->first_spx_coords[ch] = 1;
827 /* spectral extension coordinates */
829 for (ch = 1; ch <= fbw_channels; ch++) {
830 if (s->channel_uses_spx[ch]) {
831 if (s->first_spx_coords[ch] || get_bits1(gbc)) {
833 int bin, master_spx_coord;
835 s->first_spx_coords[ch] = 0;
836 spx_blend = get_bits(gbc, 5) * (1.0f/32);
837 master_spx_coord = get_bits(gbc, 2) * 3;
839 bin = s->spx_src_start_freq;
840 for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
842 int spx_coord_exp, spx_coord_mant;
843 float nratio, sblend, nblend, spx_coord;
845 /* calculate blending factors */
846 bandsize = s->spx_band_sizes[bnd];
847 nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
848 nratio = av_clipf(nratio, 0.0f, 1.0f);
849 nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
850 // to give unity variance
851 sblend = sqrtf(1.0f - nratio);
854 /* decode spx coordinates */
855 spx_coord_exp = get_bits(gbc, 4);
856 spx_coord_mant = get_bits(gbc, 2);
857 if (spx_coord_exp == 15) spx_coord_mant <<= 1;
858 else spx_coord_mant += 4;
859 spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
860 spx_coord = spx_coord_mant * (1.0f / (1 << 23));
862 /* multiply noise and signal blending factors by spx coordinate */
863 s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
864 s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
868 s->first_spx_coords[ch] = 1;
873 /* coupling strategy */
874 if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
875 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
877 s->cpl_in_use[blk] = get_bits1(gbc);
878 if (s->cpl_in_use[blk]) {
879 /* coupling in use */
880 int cpl_start_subband, cpl_end_subband;
882 if (channel_mode < AC3_CHMODE_STEREO) {
883 av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
884 return AVERROR_INVALIDDATA;
887 /* check for enhanced coupling */
888 if (s->eac3 && get_bits1(gbc)) {
889 /* TODO: parse enhanced coupling strategy info */
890 avpriv_request_sample(s->avctx, "Enhanced coupling");
891 return AVERROR_PATCHWELCOME;
894 /* determine which channels are coupled */
895 if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
896 s->channel_in_cpl[1] = 1;
897 s->channel_in_cpl[2] = 1;
899 for (ch = 1; ch <= fbw_channels; ch++)
900 s->channel_in_cpl[ch] = get_bits1(gbc);
903 /* phase flags in use */
904 if (channel_mode == AC3_CHMODE_STEREO)
905 s->phase_flags_in_use = get_bits1(gbc);
907 /* coupling frequency range */
908 cpl_start_subband = get_bits(gbc, 4);
909 cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
910 get_bits(gbc, 4) + 3;
911 if (cpl_start_subband >= cpl_end_subband) {
912 av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
913 cpl_start_subband, cpl_end_subband);
914 return AVERROR_INVALIDDATA;
916 s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
917 s->end_freq[CPL_CH] = cpl_end_subband * 12 + 37;
919 decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
921 ff_eac3_default_cpl_band_struct,
922 &s->num_cpl_bands, s->cpl_band_sizes);
924 /* coupling not in use */
925 for (ch = 1; ch <= fbw_channels; ch++) {
926 s->channel_in_cpl[ch] = 0;
927 s->first_cpl_coords[ch] = 1;
929 s->first_cpl_leak = s->eac3;
930 s->phase_flags_in_use = 0;
932 } else if (!s->eac3) {
934 av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "
935 "be present in block 0\n");
936 return AVERROR_INVALIDDATA;
938 s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
941 cpl_in_use = s->cpl_in_use[blk];
943 /* coupling coordinates */
945 int cpl_coords_exist = 0;
947 for (ch = 1; ch <= fbw_channels; ch++) {
948 if (s->channel_in_cpl[ch]) {
949 if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
950 int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
951 s->first_cpl_coords[ch] = 0;
952 cpl_coords_exist = 1;
953 master_cpl_coord = 3 * get_bits(gbc, 2);
954 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
955 cpl_coord_exp = get_bits(gbc, 4);
956 cpl_coord_mant = get_bits(gbc, 4);
957 if (cpl_coord_exp == 15)
958 s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
960 s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
961 s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
964 av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
965 "be present in block 0\n");
966 return AVERROR_INVALIDDATA;
969 /* channel not in coupling */
970 s->first_cpl_coords[ch] = 1;
974 if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
975 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
976 s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
981 /* stereo rematrixing strategy and band structure */
982 if (channel_mode == AC3_CHMODE_STEREO) {
983 if ((s->eac3 && !blk) || get_bits1(gbc)) {
984 s->num_rematrixing_bands = 4;
985 if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
986 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
987 } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
988 s->num_rematrixing_bands--;
990 for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
991 s->rematrixing_flags[bnd] = get_bits1(gbc);
993 av_log(s->avctx, AV_LOG_WARNING, "Warning: "
994 "new rematrixing strategy not present in block 0\n");
995 s->num_rematrixing_bands = 0;
999 /* exponent strategies for each channel */
1000 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1002 s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
1003 if (s->exp_strategy[blk][ch] != EXP_REUSE)
1004 bit_alloc_stages[ch] = 3;
1007 /* channel bandwidth */
1008 for (ch = 1; ch <= fbw_channels; ch++) {
1009 s->start_freq[ch] = 0;
1010 if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1012 int prev = s->end_freq[ch];
1013 if (s->channel_in_cpl[ch])
1014 s->end_freq[ch] = s->start_freq[CPL_CH];
1015 else if (s->channel_uses_spx[ch])
1016 s->end_freq[ch] = s->spx_src_start_freq;
1018 int bandwidth_code = get_bits(gbc, 6);
1019 if (bandwidth_code > 60) {
1020 av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1021 return AVERROR_INVALIDDATA;
1023 s->end_freq[ch] = bandwidth_code * 3 + 73;
1025 group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1026 s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
1027 if (blk > 0 && s->end_freq[ch] != prev)
1028 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1031 if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1032 s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
1033 (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1036 /* decode exponents for each channel */
1037 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1038 if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1039 s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1040 if (decode_exponents(gbc, s->exp_strategy[blk][ch],
1041 s->num_exp_groups[ch], s->dexps[ch][0],
1042 &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1043 av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
1044 return AVERROR_INVALIDDATA;
1046 if (ch != CPL_CH && ch != s->lfe_ch)
1047 skip_bits(gbc, 2); /* skip gainrng */
1051 /* bit allocation information */
1052 if (s->bit_allocation_syntax) {
1053 if (get_bits1(gbc)) {
1054 s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1055 s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1056 s->bit_alloc_params.slow_gain = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
1057 s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
1058 s->bit_alloc_params.floor = ff_ac3_floor_tab[get_bits(gbc, 3)];
1059 for (ch = !cpl_in_use; ch <= s->channels; ch++)
1060 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1062 av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must "
1063 "be present in block 0\n");
1064 return AVERROR_INVALIDDATA;
1068 /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1069 if (!s->eac3 || !blk) {
1070 if (s->snr_offset_strategy && get_bits1(gbc)) {
1073 csnr = (get_bits(gbc, 6) - 15) << 4;
1074 for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1076 if (ch == i || s->snr_offset_strategy == 2)
1077 snr = (csnr + get_bits(gbc, 4)) << 2;
1078 /* run at least last bit allocation stage if snr offset changes */
1079 if (blk && s->snr_offset[ch] != snr) {
1080 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1082 s->snr_offset[ch] = snr;
1084 /* fast gain (normal AC-3 only) */
1086 int prev = s->fast_gain[ch];
1087 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1088 /* run last 2 bit allocation stages if fast gain changes */
1089 if (blk && prev != s->fast_gain[ch])
1090 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1093 } else if (!s->eac3 && !blk) {
1094 av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1095 return AVERROR_INVALIDDATA;
1099 /* fast gain (E-AC-3 only) */
1100 if (s->fast_gain_syntax && get_bits1(gbc)) {
1101 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1102 int prev = s->fast_gain[ch];
1103 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1104 /* run last 2 bit allocation stages if fast gain changes */
1105 if (blk && prev != s->fast_gain[ch])
1106 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1108 } else if (s->eac3 && !blk) {
1109 for (ch = !cpl_in_use; ch <= s->channels; ch++)
1110 s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1113 /* E-AC-3 to AC-3 converter SNR offset */
1114 if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1115 skip_bits(gbc, 10); // skip converter snr offset
1118 /* coupling leak information */
1120 if (s->first_cpl_leak || get_bits1(gbc)) {
1121 int fl = get_bits(gbc, 3);
1122 int sl = get_bits(gbc, 3);
1123 /* run last 2 bit allocation stages for coupling channel if
1124 coupling leak changes */
1125 if (blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1126 sl != s->bit_alloc_params.cpl_slow_leak)) {
1127 bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1129 s->bit_alloc_params.cpl_fast_leak = fl;
1130 s->bit_alloc_params.cpl_slow_leak = sl;
1131 } else if (!s->eac3 && !blk) {
1132 av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must "
1133 "be present in block 0\n");
1134 return AVERROR_INVALIDDATA;
1136 s->first_cpl_leak = 0;
1139 /* delta bit allocation information */
1140 if (s->dba_syntax && get_bits1(gbc)) {
1141 /* delta bit allocation exists (strategy) */
1142 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1143 s->dba_mode[ch] = get_bits(gbc, 2);
1144 if (s->dba_mode[ch] == DBA_RESERVED) {
1145 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1146 return AVERROR_INVALIDDATA;
1148 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1150 /* channel delta offset, len and bit allocation */
1151 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1152 if (s->dba_mode[ch] == DBA_NEW) {
1153 s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;
1154 for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
1155 s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1156 s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1157 s->dba_values[ch][seg] = get_bits(gbc, 3);
1159 /* run last 2 bit allocation stages if new dba values */
1160 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1163 } else if (blk == 0) {
1164 for (ch = 0; ch <= s->channels; ch++) {
1165 s->dba_mode[ch] = DBA_NONE;
1169 /* Bit allocation */
1170 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1171 if (bit_alloc_stages[ch] > 2) {
1172 /* Exponent mapping into PSD and PSD integration */
1173 ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
1174 s->start_freq[ch], s->end_freq[ch],
1175 s->psd[ch], s->band_psd[ch]);
1177 if (bit_alloc_stages[ch] > 1) {
1178 /* Compute excitation function, Compute masking curve, and
1179 Apply delta bit allocation */
1180 if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1181 s->start_freq[ch], s->end_freq[ch],
1182 s->fast_gain[ch], (ch == s->lfe_ch),
1183 s->dba_mode[ch], s->dba_nsegs[ch],
1184 s->dba_offsets[ch], s->dba_lengths[ch],
1185 s->dba_values[ch], s->mask[ch])) {
1186 av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1187 return AVERROR_INVALIDDATA;
1190 if (bit_alloc_stages[ch] > 0) {
1191 /* Compute bit allocation */
1192 const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1193 ff_eac3_hebap_tab : ff_ac3_bap_tab;
1194 s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1195 s->start_freq[ch], s->end_freq[ch],
1197 s->bit_alloc_params.floor,
1198 bap_tab, s->bap[ch]);
1202 /* unused dummy data */
1203 if (s->skip_syntax && get_bits1(gbc)) {
1204 int skipl = get_bits(gbc, 9);
1209 /* unpack the transform coefficients
1210 this also uncouples channels if coupling is in use. */
1211 decode_transform_coeffs(s, blk);
1213 /* TODO: generate enhanced coupling coordinates and uncouple */
1215 /* recover coefficients if rematrixing is in use */
1216 if (s->channel_mode == AC3_CHMODE_STEREO)
1219 /* apply scaling to coefficients (headroom, dynrng) */
1220 for (ch = 1; ch <= s->channels; ch++) {
1221 float gain = 1.0 / 4194304.0f;
1222 if (s->channel_mode == AC3_CHMODE_DUALMONO) {
1223 gain *= s->dynamic_range[2 - ch];
1225 gain *= s->dynamic_range[0];
1227 s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch],
1228 s->fixed_coeffs[ch], gain, 256);
1231 /* apply spectral extension to high frequency bins */
1232 if (s->spx_in_use && CONFIG_EAC3_DECODER) {
1233 ff_eac3_apply_spectral_extension(s);
1236 /* downmix and MDCT. order depends on whether block switching is used for
1237 any channel in this block. this is because coefficients for the long
1238 and short transforms cannot be mixed. */
1239 downmix_output = s->channels != s->out_channels &&
1240 !((s->output_mode & AC3_OUTPUT_LFEON) &&
1241 s->fbw_channels == s->out_channels);
1242 if (different_transforms) {
1243 /* the delay samples have already been downmixed, so we upmix the delay
1244 samples in order to reconstruct all channels before downmixing. */
1250 do_imdct(s, s->channels);
1252 if (downmix_output) {
1253 s->ac3dsp.downmix(s->outptr, s->downmix_coeffs,
1254 s->out_channels, s->fbw_channels, 256);
1257 if (downmix_output) {
1258 s->ac3dsp.downmix(s->xcfptr + 1, s->downmix_coeffs,
1259 s->out_channels, s->fbw_channels, 256);
1262 if (downmix_output && !s->downmixed) {
1264 s->ac3dsp.downmix(s->dlyptr, s->downmix_coeffs, s->out_channels,
1265 s->fbw_channels, 128);
1268 do_imdct(s, s->out_channels);
1275 * Decode a single AC-3 frame.
1277 static int ac3_decode_frame(AVCodecContext * avctx, void *data,
1278 int *got_frame_ptr, AVPacket *avpkt)
1280 AVFrame *frame = data;
1281 const uint8_t *buf = avpkt->data;
1282 int buf_size = avpkt->size;
1283 AC3DecodeContext *s = avctx->priv_data;
1284 int blk, ch, err, ret;
1285 const uint8_t *channel_map;
1286 const float *output[AC3_MAX_CHANNELS];
1288 /* copy input buffer to decoder context to avoid reading past the end
1289 of the buffer, which can be caused by a damaged input stream. */
1290 if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
1291 // seems to be byte-swapped AC-3
1292 int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1293 s->dsp.bswap16_buf((uint16_t *)s->input_buffer, (const uint16_t *)buf, cnt);
1295 memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1296 buf = s->input_buffer;
1297 /* initialize the GetBitContext with the start of valid AC-3 Frame */
1298 init_get_bits(&s->gbc, buf, buf_size * 8);
1300 /* parse the syncinfo */
1301 err = parse_frame_header(s);
1305 case AAC_AC3_PARSE_ERROR_SYNC:
1306 av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1307 return AVERROR_INVALIDDATA;
1308 case AAC_AC3_PARSE_ERROR_BSID:
1309 av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1311 case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
1312 av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1314 case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
1315 av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1317 case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
1318 /* skip frame if CRC is ok. otherwise use error concealment. */
1319 /* TODO: add support for substreams and dependent frames */
1320 if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
1321 av_log(avctx, AV_LOG_WARNING, "unsupported frame type : "
1322 "skipping frame\n");
1326 av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1329 case AAC_AC3_PARSE_ERROR_CRC:
1330 case AAC_AC3_PARSE_ERROR_CHANNEL_CFG:
1332 default: // Normal AVERROR do not try to recover.
1337 /* check that reported frame size fits in input buffer */
1338 if (s->frame_size > buf_size) {
1339 av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1340 err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
1341 } else if (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL)) {
1342 /* check for crc mismatch */
1343 if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
1344 s->frame_size - 2)) {
1345 av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1346 if (avctx->err_recognition & AV_EF_EXPLODE)
1347 return AVERROR_INVALIDDATA;
1348 err = AAC_AC3_PARSE_ERROR_CRC;
1353 /* if frame is ok, set audio parameters */
1355 avctx->sample_rate = s->sample_rate;
1356 avctx->bit_rate = s->bit_rate;
1359 /* channel config */
1360 if (!err || (s->channels && s->out_channels != s->channels)) {
1361 s->out_channels = s->channels;
1362 s->output_mode = s->channel_mode;
1364 s->output_mode |= AC3_OUTPUT_LFEON;
1365 if (s->channels > 1 &&
1366 avctx->request_channel_layout == AV_CH_LAYOUT_MONO) {
1367 s->out_channels = 1;
1368 s->output_mode = AC3_CHMODE_MONO;
1369 } else if (s->channels > 2 &&
1370 avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
1371 s->out_channels = 2;
1372 s->output_mode = AC3_CHMODE_STEREO;
1375 s->loro_center_mix_level = gain_levels[s-> center_mix_level];
1376 s->loro_surround_mix_level = gain_levels[s->surround_mix_level];
1377 s->ltrt_center_mix_level = LEVEL_MINUS_3DB;
1378 s->ltrt_surround_mix_level = LEVEL_MINUS_3DB;
1379 /* set downmixing coefficients if needed */
1380 if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1381 s->fbw_channels == s->out_channels)) {
1382 set_downmix_coeffs(s);
1384 } else if (!s->channels) {
1385 av_log(avctx, AV_LOG_ERROR, "unable to determine channel mode\n");
1386 return AVERROR_INVALIDDATA;
1388 avctx->channels = s->out_channels;
1389 avctx->channel_layout = avpriv_ac3_channel_layout_tab[s->output_mode & ~AC3_OUTPUT_LFEON];
1390 if (s->output_mode & AC3_OUTPUT_LFEON)
1391 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1393 /* set audio service type based on bitstream mode for AC-3 */
1394 avctx->audio_service_type = s->bitstream_mode;
1395 if (s->bitstream_mode == 0x7 && s->channels > 1)
1396 avctx->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
1398 /* get output buffer */
1399 frame->nb_samples = s->num_blocks * AC3_BLOCK_SIZE;
1400 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1403 /* decode the audio blocks */
1404 channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1405 for (ch = 0; ch < AC3_MAX_CHANNELS; ch++) {
1406 output[ch] = s->output[ch];
1407 s->outptr[ch] = s->output[ch];
1409 for (ch = 0; ch < s->channels; ch++) {
1410 if (ch < s->out_channels)
1411 s->outptr[channel_map[ch]] = (float *)frame->data[ch];
1413 for (blk = 0; blk < s->num_blocks; blk++) {
1414 if (!err && decode_audio_block(s, blk)) {
1415 av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1419 for (ch = 0; ch < s->out_channels; ch++)
1420 memcpy(((float*)frame->data[ch]) + AC3_BLOCK_SIZE*blk, output[ch], sizeof(**output) * AC3_BLOCK_SIZE);
1421 for (ch = 0; ch < s->out_channels; ch++)
1422 output[ch] = s->outptr[channel_map[ch]];
1423 for (ch = 0; ch < s->out_channels; ch++) {
1424 if (!ch || channel_map[ch])
1425 s->outptr[channel_map[ch]] += AC3_BLOCK_SIZE;
1429 av_frame_set_decode_error_flags(frame, err ? FF_DECODE_ERROR_INVALID_BITSTREAM : 0);
1431 /* keep last block for error concealment in next frame */
1432 for (ch = 0; ch < s->out_channels; ch++)
1433 memcpy(s->output[ch], output[ch], sizeof(**output) * AC3_BLOCK_SIZE);
1437 return FFMIN(buf_size, s->frame_size);
1441 * Uninitialize the AC-3 decoder.
1443 static av_cold int ac3_decode_end(AVCodecContext *avctx)
1445 AC3DecodeContext *s = avctx->priv_data;
1446 ff_mdct_end(&s->imdct_512);
1447 ff_mdct_end(&s->imdct_256);
1452 #define OFFSET(x) offsetof(AC3DecodeContext, x)
1453 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)
1454 static const AVOption options[] = {
1455 { "drc_scale", "percentage of dynamic range compression to apply", OFFSET(drc_scale), AV_OPT_TYPE_FLOAT, {.dbl = 1.0}, 0.0, 1.0, PAR },
1457 {"dmix_mode", "Preferred Stereo Downmix Mode", OFFSET(preferred_stereo_downmix), AV_OPT_TYPE_INT, {.i64 = -1 }, -1, 2, 0, "dmix_mode"},
1458 {"ltrt_cmixlev", "Lt/Rt Center Mix Level", OFFSET(ltrt_center_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
1459 {"ltrt_surmixlev", "Lt/Rt Surround Mix Level", OFFSET(ltrt_surround_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
1460 {"loro_cmixlev", "Lo/Ro Center Mix Level", OFFSET(loro_center_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
1461 {"loro_surmixlev", "Lo/Ro Surround Mix Level", OFFSET(loro_surround_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
1466 static const AVClass ac3_decoder_class = {
1467 .class_name = "AC3 decoder",
1468 .item_name = av_default_item_name,
1470 .version = LIBAVUTIL_VERSION_INT,
1473 AVCodec ff_ac3_decoder = {
1475 .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
1476 .type = AVMEDIA_TYPE_AUDIO,
1477 .id = AV_CODEC_ID_AC3,
1478 .priv_data_size = sizeof (AC3DecodeContext),
1479 .init = ac3_decode_init,
1480 .close = ac3_decode_end,
1481 .decode = ac3_decode_frame,
1482 .capabilities = CODEC_CAP_DR1,
1483 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1484 AV_SAMPLE_FMT_NONE },
1485 .priv_class = &ac3_decoder_class,
1488 #if CONFIG_EAC3_DECODER
1489 static const AVClass eac3_decoder_class = {
1490 .class_name = "E-AC3 decoder",
1491 .item_name = av_default_item_name,
1493 .version = LIBAVUTIL_VERSION_INT,
1496 AVCodec ff_eac3_decoder = {
1498 .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
1499 .type = AVMEDIA_TYPE_AUDIO,
1500 .id = AV_CODEC_ID_EAC3,
1501 .priv_data_size = sizeof (AC3DecodeContext),
1502 .init = ac3_decode_init,
1503 .close = ac3_decode_end,
1504 .decode = ac3_decode_frame,
1505 .capabilities = CODEC_CAP_DR1,
1506 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1507 AV_SAMPLE_FMT_NONE },
1508 .priv_class = &eac3_decoder_class,