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/downmix_info.h"
35 #include "libavutil/opt.h"
37 #include "aac_ac3_parser.h"
38 #include "ac3_parser.h"
40 #include "ac3dec_data.h"
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];
49 /** tables for ungrouping mantissas */
50 static int b1_mantissas[32][3];
51 static int b2_mantissas[128][3];
52 static int b3_mantissas[8];
53 static int b4_mantissas[128][2];
54 static int b5_mantissas[16];
57 * Quantization table: levels for symmetric. bits for asymmetric.
58 * reference: Table 7.18 Mapping of bap to Quantizer
60 static const uint8_t quantization_tab[16] = {
62 5, 6, 7, 8, 9, 10, 11, 12, 14, 16
65 /** dynamic range table. converts codes to scale factors. */
66 static float dynamic_range_tab[256];
68 /** Adjustments in dB gain */
69 static const float gain_levels[9] = {
73 LEVEL_MINUS_1POINT5DB,
75 LEVEL_MINUS_4POINT5DB,
81 /** Adjustments in dB gain (LFE, +10 to -21 dB) */
82 static const float gain_levels_lfe[32] = {
83 3.162275, 2.818382, 2.511886, 2.238719, 1.995261, 1.778278, 1.584893,
84 1.412536, 1.258924, 1.122018, 1.000000, 0.891251, 0.794328, 0.707946,
85 0.630957, 0.562341, 0.501187, 0.446683, 0.398107, 0.354813, 0.316227,
86 0.281838, 0.251188, 0.223872, 0.199526, 0.177828, 0.158489, 0.141253,
87 0.125892, 0.112201, 0.100000, 0.089125
91 * Table for default stereo downmixing coefficients
92 * reference: Section 7.8.2 Downmixing Into Two Channels
94 static const uint8_t ac3_default_coeffs[8][5][2] = {
95 { { 2, 7 }, { 7, 2 }, },
97 { { 2, 7 }, { 7, 2 }, },
98 { { 2, 7 }, { 5, 5 }, { 7, 2 }, },
99 { { 2, 7 }, { 7, 2 }, { 6, 6 }, },
100 { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 }, },
101 { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
102 { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
106 * Symmetrical Dequantization
107 * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization
108 * Tables 7.19 to 7.23
111 symmetric_dequant(int code, int levels)
113 return ((code - (levels >> 1)) << 24) / levels;
117 * Initialize tables at runtime.
119 static av_cold void ac3_tables_init(void)
123 /* generate table for ungrouping 3 values in 7 bits
124 reference: Section 7.1.3 Exponent Decoding */
125 for (i = 0; i < 128; i++) {
126 ungroup_3_in_7_bits_tab[i][0] = i / 25;
127 ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5;
128 ungroup_3_in_7_bits_tab[i][2] = (i % 25) % 5;
131 /* generate grouped mantissa tables
132 reference: Section 7.3.5 Ungrouping of Mantissas */
133 for (i = 0; i < 32; i++) {
134 /* bap=1 mantissas */
135 b1_mantissas[i][0] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][0], 3);
136 b1_mantissas[i][1] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][1], 3);
137 b1_mantissas[i][2] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][2], 3);
139 for (i = 0; i < 128; i++) {
140 /* bap=2 mantissas */
141 b2_mantissas[i][0] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][0], 5);
142 b2_mantissas[i][1] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][1], 5);
143 b2_mantissas[i][2] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][2], 5);
145 /* bap=4 mantissas */
146 b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
147 b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
149 /* generate ungrouped mantissa tables
150 reference: Tables 7.21 and 7.23 */
151 for (i = 0; i < 7; i++) {
152 /* bap=3 mantissas */
153 b3_mantissas[i] = symmetric_dequant(i, 7);
155 for (i = 0; i < 15; i++) {
156 /* bap=5 mantissas */
157 b5_mantissas[i] = symmetric_dequant(i, 15);
160 /* generate dynamic range table
161 reference: Section 7.7.1 Dynamic Range Control */
162 for (i = 0; i < 256; i++) {
163 int v = (i >> 5) - ((i >> 7) << 3) - 5;
164 dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
169 * AVCodec initialization
171 static av_cold int ac3_decode_init(AVCodecContext *avctx)
173 AC3DecodeContext *s = avctx->priv_data;
178 ff_ac3_common_init();
180 ff_mdct_init(&s->imdct_256, 8, 1, 1.0);
181 ff_mdct_init(&s->imdct_512, 9, 1, 1.0);
182 AC3_RENAME(ff_kbd_window_init)(s->window, 5.0, 256);
183 ff_dsputil_init(&s->dsp, avctx);
186 s->fdsp = avpriv_alloc_fixed_dsp(avctx->flags & CODEC_FLAG_BITEXACT);
188 avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
191 ff_ac3dsp_init(&s->ac3dsp, avctx->flags & CODEC_FLAG_BITEXACT);
192 ff_fmt_convert_init(&s->fmt_conv, avctx);
193 av_lfg_init(&s->dith_state, 0);
196 avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
198 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
200 /* allow downmixing to stereo or mono */
201 #if FF_API_REQUEST_CHANNELS
202 FF_DISABLE_DEPRECATION_WARNINGS
203 if (avctx->request_channels == 1)
204 avctx->request_channel_layout = AV_CH_LAYOUT_MONO;
205 else if (avctx->request_channels == 2)
206 avctx->request_channel_layout = AV_CH_LAYOUT_STEREO;
207 FF_ENABLE_DEPRECATION_WARNINGS
209 if (avctx->channels > 1 &&
210 avctx->request_channel_layout == AV_CH_LAYOUT_MONO)
212 else if (avctx->channels > 2 &&
213 avctx->request_channel_layout == AV_CH_LAYOUT_STEREO)
217 for (i = 0; i < AC3_MAX_CHANNELS; i++) {
218 s->xcfptr[i] = s->transform_coeffs[i];
219 s->dlyptr[i] = s->delay[i];
226 * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
227 * GetBitContext within AC3DecodeContext must point to
228 * the start of the synchronized AC-3 bitstream.
230 static int ac3_parse_header(AC3DecodeContext *s)
232 GetBitContext *gbc = &s->gbc;
235 /* read the rest of the bsi. read twice for dual mono mode. */
236 i = !s->channel_mode;
238 skip_bits(gbc, 5); // skip dialog normalization
240 skip_bits(gbc, 8); //skip compression
242 skip_bits(gbc, 8); //skip language code
244 skip_bits(gbc, 7); //skip audio production information
247 skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
249 /* skip the timecodes or parse the Alternate Bit Stream Syntax */
250 if (s->bitstream_id != 6) {
252 skip_bits(gbc, 14); //skip timecode1
254 skip_bits(gbc, 14); //skip timecode2
256 if (get_bits1(gbc)) {
257 s->preferred_downmix = get_bits(gbc, 2);
258 s->center_mix_level_ltrt = get_bits(gbc, 3);
259 s->surround_mix_level_ltrt = av_clip(get_bits(gbc, 3), 3, 7);
260 s->center_mix_level = get_bits(gbc, 3);
261 s->surround_mix_level = av_clip(get_bits(gbc, 3), 3, 7);
263 if (get_bits1(gbc)) {
264 s->dolby_surround_ex_mode = get_bits(gbc, 2);
265 s->dolby_headphone_mode = get_bits(gbc, 2);
266 skip_bits(gbc, 10); // skip adconvtyp (1), xbsi2 (8), encinfo (1)
270 /* skip additional bitstream info */
271 if (get_bits1(gbc)) {
272 i = get_bits(gbc, 6);
282 * Common function to parse AC-3 or E-AC-3 frame header
284 static int parse_frame_header(AC3DecodeContext *s)
286 AC3HeaderInfo hdr, *phdr=&hdr;
289 err = avpriv_ac3_parse_header2(&s->gbc, &phdr);
293 /* get decoding parameters from header info */
294 s->bit_alloc_params.sr_code = hdr.sr_code;
295 s->bitstream_id = hdr.bitstream_id;
296 s->bitstream_mode = hdr.bitstream_mode;
297 s->channel_mode = hdr.channel_mode;
298 s->lfe_on = hdr.lfe_on;
299 s->bit_alloc_params.sr_shift = hdr.sr_shift;
300 s->sample_rate = hdr.sample_rate;
301 s->bit_rate = hdr.bit_rate;
302 s->channels = hdr.channels;
303 s->fbw_channels = s->channels - s->lfe_on;
304 s->lfe_ch = s->fbw_channels + 1;
305 s->frame_size = hdr.frame_size;
306 s->preferred_downmix = AC3_DMIXMOD_NOTINDICATED;
307 s->center_mix_level = hdr.center_mix_level;
308 s->center_mix_level_ltrt = 4; // -3.0dB
309 s->surround_mix_level = hdr.surround_mix_level;
310 s->surround_mix_level_ltrt = 4; // -3.0dB
311 s->lfe_mix_level_exists = 0;
312 s->num_blocks = hdr.num_blocks;
313 s->frame_type = hdr.frame_type;
314 s->substreamid = hdr.substreamid;
315 s->dolby_surround_mode = hdr.dolby_surround_mode;
316 s->dolby_surround_ex_mode = AC3_DSUREXMOD_NOTINDICATED;
317 s->dolby_headphone_mode = AC3_DHEADPHONMOD_NOTINDICATED;
320 s->start_freq[s->lfe_ch] = 0;
321 s->end_freq[s->lfe_ch] = 7;
322 s->num_exp_groups[s->lfe_ch] = 2;
323 s->channel_in_cpl[s->lfe_ch] = 0;
326 if (s->bitstream_id <= 10) {
328 s->snr_offset_strategy = 2;
329 s->block_switch_syntax = 1;
330 s->dither_flag_syntax = 1;
331 s->bit_allocation_syntax = 1;
332 s->fast_gain_syntax = 0;
333 s->first_cpl_leak = 0;
336 memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
337 return ac3_parse_header(s);
338 } else if (CONFIG_EAC3_DECODER) {
340 return ff_eac3_parse_header(s);
342 av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n");
343 return AVERROR(ENOSYS);
348 * Set stereo downmixing coefficients based on frame header info.
349 * reference: Section 7.8.2 Downmixing Into Two Channels
351 static void set_downmix_coeffs(AC3DecodeContext *s)
354 float cmix = gain_levels[s-> center_mix_level];
355 float smix = gain_levels[s->surround_mix_level];
357 float downmix_coeffs[AC3_MAX_CHANNELS][2];
359 for (i = 0; i < s->fbw_channels; i++) {
360 downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
361 downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
363 if (s->channel_mode > 1 && s->channel_mode & 1) {
364 downmix_coeffs[1][0] = downmix_coeffs[1][1] = cmix;
366 if (s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
367 int nf = s->channel_mode - 2;
368 downmix_coeffs[nf][0] = downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
370 if (s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
371 int nf = s->channel_mode - 4;
372 downmix_coeffs[nf][0] = downmix_coeffs[nf+1][1] = smix;
377 for (i = 0; i < s->fbw_channels; i++) {
378 norm0 += downmix_coeffs[i][0];
379 norm1 += downmix_coeffs[i][1];
381 norm0 = 1.0f / norm0;
382 norm1 = 1.0f / norm1;
383 for (i = 0; i < s->fbw_channels; i++) {
384 downmix_coeffs[i][0] *= norm0;
385 downmix_coeffs[i][1] *= norm1;
388 if (s->output_mode == AC3_CHMODE_MONO) {
389 for (i = 0; i < s->fbw_channels; i++)
390 downmix_coeffs[i][0] = (downmix_coeffs[i][0] +
391 downmix_coeffs[i][1]) * LEVEL_MINUS_3DB;
393 for (i = 0; i < s->fbw_channels; i++) {
394 s->downmix_coeffs[i][0] = FIXR12(downmix_coeffs[i][0]);
395 s->downmix_coeffs[i][1] = FIXR12(downmix_coeffs[i][1]);
400 * Decode the grouped exponents according to exponent strategy.
401 * reference: Section 7.1.3 Exponent Decoding
403 static int decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
404 uint8_t absexp, int8_t *dexps)
406 int i, j, grp, group_size;
411 group_size = exp_strategy + (exp_strategy == EXP_D45);
412 for (grp = 0, i = 0; grp < ngrps; grp++) {
413 expacc = get_bits(gbc, 7);
414 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
415 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
416 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
419 /* convert to absolute exps and expand groups */
421 for (i = 0, j = 0; i < ngrps * 3; i++) {
422 prevexp += dexp[i] - 2;
425 switch (group_size) {
426 case 4: dexps[j++] = prevexp;
427 dexps[j++] = prevexp;
428 case 2: dexps[j++] = prevexp;
429 case 1: dexps[j++] = prevexp;
436 * Generate transform coefficients for each coupled channel in the coupling
437 * range using the coupling coefficients and coupling coordinates.
438 * reference: Section 7.4.3 Coupling Coordinate Format
440 static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
444 bin = s->start_freq[CPL_CH];
445 for (band = 0; band < s->num_cpl_bands; band++) {
446 int band_start = bin;
447 int band_end = bin + s->cpl_band_sizes[band];
448 for (ch = 1; ch <= s->fbw_channels; ch++) {
449 if (s->channel_in_cpl[ch]) {
450 int cpl_coord = s->cpl_coords[ch][band] << 5;
451 for (bin = band_start; bin < band_end; bin++) {
452 s->fixed_coeffs[ch][bin] =
453 MULH(s->fixed_coeffs[CPL_CH][bin] << 4, cpl_coord);
455 if (ch == 2 && s->phase_flags[band]) {
456 for (bin = band_start; bin < band_end; bin++)
457 s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin];
466 * Grouped mantissas for 3-level 5-level and 11-level quantization
478 * Decode the transform coefficients for a particular channel
479 * reference: Section 7.3 Quantization and Decoding of Mantissas
481 static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
483 int start_freq = s->start_freq[ch_index];
484 int end_freq = s->end_freq[ch_index];
485 uint8_t *baps = s->bap[ch_index];
486 int8_t *exps = s->dexps[ch_index];
487 int32_t *coeffs = s->fixed_coeffs[ch_index];
488 int dither = (ch_index == CPL_CH) || s->dither_flag[ch_index];
489 GetBitContext *gbc = &s->gbc;
492 for (freq = start_freq; freq < end_freq; freq++) {
493 int bap = baps[freq];
497 /* random noise with approximate range of -0.707 to 0.707 */
499 mantissa = (((av_lfg_get(&s->dith_state)>>8)*181)>>8) - 5931008;
506 mantissa = m->b1_mant[m->b1];
508 int bits = get_bits(gbc, 5);
509 mantissa = b1_mantissas[bits][0];
510 m->b1_mant[1] = b1_mantissas[bits][1];
511 m->b1_mant[0] = b1_mantissas[bits][2];
518 mantissa = m->b2_mant[m->b2];
520 int bits = get_bits(gbc, 7);
521 mantissa = b2_mantissas[bits][0];
522 m->b2_mant[1] = b2_mantissas[bits][1];
523 m->b2_mant[0] = b2_mantissas[bits][2];
528 mantissa = b3_mantissas[get_bits(gbc, 3)];
533 mantissa = m->b4_mant;
535 int bits = get_bits(gbc, 7);
536 mantissa = b4_mantissas[bits][0];
537 m->b4_mant = b4_mantissas[bits][1];
542 mantissa = b5_mantissas[get_bits(gbc, 4)];
544 default: /* 6 to 15 */
545 /* Shift mantissa and sign-extend it. */
547 av_log(s->avctx, AV_LOG_ERROR, "bap %d is invalid in plain AC-3\n", bap);
550 mantissa = get_sbits(gbc, quantization_tab[bap]);
551 mantissa <<= 24 - quantization_tab[bap];
554 coeffs[freq] = mantissa >> exps[freq];
559 * Remove random dithering from coupling range coefficients with zero-bit
560 * mantissas for coupled channels which do not use dithering.
561 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
563 static void remove_dithering(AC3DecodeContext *s) {
566 for (ch = 1; ch <= s->fbw_channels; ch++) {
567 if (!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
568 for (i = s->start_freq[CPL_CH]; i < s->end_freq[CPL_CH]; i++) {
569 if (!s->bap[CPL_CH][i])
570 s->fixed_coeffs[ch][i] = 0;
576 static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,
579 if (!s->channel_uses_aht[ch]) {
580 ac3_decode_transform_coeffs_ch(s, ch, m);
582 /* if AHT is used, mantissas for all blocks are encoded in the first
583 block of the frame. */
585 if (!blk && CONFIG_EAC3_DECODER)
586 ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
587 for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
588 s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
594 * Decode the transform coefficients.
596 static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
602 m.b1 = m.b2 = m.b4 = 0;
604 for (ch = 1; ch <= s->channels; ch++) {
605 /* transform coefficients for full-bandwidth channel */
606 decode_transform_coeffs_ch(s, blk, ch, &m);
607 /* transform coefficients for coupling channel come right after the
608 coefficients for the first coupled channel*/
609 if (s->channel_in_cpl[ch]) {
611 decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
612 calc_transform_coeffs_cpl(s);
615 end = s->end_freq[CPL_CH];
617 end = s->end_freq[ch];
620 s->fixed_coeffs[ch][end] = 0;
624 /* zero the dithered coefficients for appropriate channels */
629 * Stereo rematrixing.
630 * reference: Section 7.5.4 Rematrixing : Decoding Technique
632 static void do_rematrixing(AC3DecodeContext *s)
637 end = FFMIN(s->end_freq[1], s->end_freq[2]);
639 for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) {
640 if (s->rematrixing_flags[bnd]) {
641 bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd + 1]);
642 for (i = ff_ac3_rematrix_band_tab[bnd]; i < bndend; i++) {
643 int tmp0 = s->fixed_coeffs[1][i];
644 s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
645 s->fixed_coeffs[2][i] = tmp0 - s->fixed_coeffs[2][i];
652 * Inverse MDCT Transform.
653 * Convert frequency domain coefficients to time-domain audio samples.
654 * reference: Section 7.9.4 Transformation Equations
656 static inline void do_imdct(AC3DecodeContext *s, int channels)
660 for (ch = 1; ch <= channels; ch++) {
661 if (s->block_switch[ch]) {
663 FFTSample *x = s->tmp_output + 128;
664 for (i = 0; i < 128; i++)
665 x[i] = s->transform_coeffs[ch][2 * i];
666 s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
668 s->fdsp->vector_fmul_window_scaled(s->outptr[ch - 1], s->delay[ch - 1],
669 s->tmp_output, s->window, 128, 8);
671 s->fdsp.vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
672 s->tmp_output, s->window, 128);
674 for (i = 0; i < 128; i++)
675 x[i] = s->transform_coeffs[ch][2 * i + 1];
676 s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch - 1], x);
678 s->imdct_512.imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
680 s->fdsp->vector_fmul_window_scaled(s->outptr[ch - 1], s->delay[ch - 1],
681 s->tmp_output, s->window, 128, 8);
683 s->fdsp.vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
684 s->tmp_output, s->window, 128);
686 memcpy(s->delay[ch - 1], s->tmp_output + 128, 128 * sizeof(FFTSample));
692 * Upmix delay samples from stereo to original channel layout.
694 static void ac3_upmix_delay(AC3DecodeContext *s)
696 int channel_data_size = sizeof(s->delay[0]);
697 switch (s->channel_mode) {
698 case AC3_CHMODE_DUALMONO:
699 case AC3_CHMODE_STEREO:
700 /* upmix mono to stereo */
701 memcpy(s->delay[1], s->delay[0], channel_data_size);
703 case AC3_CHMODE_2F2R:
704 memset(s->delay[3], 0, channel_data_size);
705 case AC3_CHMODE_2F1R:
706 memset(s->delay[2], 0, channel_data_size);
708 case AC3_CHMODE_3F2R:
709 memset(s->delay[4], 0, channel_data_size);
710 case AC3_CHMODE_3F1R:
711 memset(s->delay[3], 0, channel_data_size);
713 memcpy(s->delay[2], s->delay[1], channel_data_size);
714 memset(s->delay[1], 0, channel_data_size);
720 * Decode band structure for coupling, spectral extension, or enhanced coupling.
721 * The band structure defines how many subbands are in each band. For each
722 * subband in the range, 1 means it is combined with the previous band, and 0
723 * means that it starts a new band.
725 * @param[in] gbc bit reader context
726 * @param[in] blk block number
727 * @param[in] eac3 flag to indicate E-AC-3
728 * @param[in] ecpl flag to indicate enhanced coupling
729 * @param[in] start_subband subband number for start of range
730 * @param[in] end_subband subband number for end of range
731 * @param[in] default_band_struct default band structure table
732 * @param[out] num_bands number of bands (optionally NULL)
733 * @param[out] band_sizes array containing the number of bins in each band (optionally NULL)
735 static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
736 int ecpl, int start_subband, int end_subband,
737 const uint8_t *default_band_struct,
738 int *num_bands, uint8_t *band_sizes)
740 int subbnd, bnd, n_subbands, n_bands=0;
742 uint8_t coded_band_struct[22];
743 const uint8_t *band_struct;
745 n_subbands = end_subband - start_subband;
747 /* decode band structure from bitstream or use default */
748 if (!eac3 || get_bits1(gbc)) {
749 for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
750 coded_band_struct[subbnd] = get_bits1(gbc);
752 band_struct = coded_band_struct;
754 band_struct = &default_band_struct[start_subband+1];
756 /* no change in band structure */
760 /* calculate number of bands and band sizes based on band structure.
761 note that the first 4 subbands in enhanced coupling span only 6 bins
763 if (num_bands || band_sizes ) {
764 n_bands = n_subbands;
765 bnd_sz[0] = ecpl ? 6 : 12;
766 for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
767 int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
768 if (band_struct[subbnd - 1]) {
770 bnd_sz[bnd] += subbnd_size;
772 bnd_sz[++bnd] = subbnd_size;
777 /* set optional output params */
779 *num_bands = n_bands;
781 memcpy(band_sizes, bnd_sz, n_bands);
785 * Decode a single audio block from the AC-3 bitstream.
787 static int decode_audio_block(AC3DecodeContext *s, int blk)
789 int fbw_channels = s->fbw_channels;
790 int channel_mode = s->channel_mode;
792 int different_transforms;
795 GetBitContext *gbc = &s->gbc;
796 uint8_t bit_alloc_stages[AC3_MAX_CHANNELS] = { 0 };
798 /* block switch flags */
799 different_transforms = 0;
800 if (s->block_switch_syntax) {
801 for (ch = 1; ch <= fbw_channels; ch++) {
802 s->block_switch[ch] = get_bits1(gbc);
803 if (ch > 1 && s->block_switch[ch] != s->block_switch[1])
804 different_transforms = 1;
808 /* dithering flags */
809 if (s->dither_flag_syntax) {
810 for (ch = 1; ch <= fbw_channels; ch++) {
811 s->dither_flag[ch] = get_bits1(gbc);
816 i = !s->channel_mode;
818 if (get_bits1(gbc)) {
819 /* Allow asymmetric application of DRC when drc_scale > 1.
820 Amplification of quiet sounds is enhanced */
821 INTFLOAT range = AC3_RANGE(get_bits(gbc, 8));
822 if (range > 1.0 || s->drc_scale <= 1.0)
823 s->dynamic_range[i] = AC3_DYNAMIC_RANGE(range);
825 s->dynamic_range[i] = range;
826 } else if (blk == 0) {
827 s->dynamic_range[i] = AC3_DYNAMIC_RANGE1;
831 /* spectral extension strategy */
832 if (s->eac3 && (!blk || get_bits1(gbc))) {
833 s->spx_in_use = get_bits1(gbc);
835 int dst_start_freq, dst_end_freq, src_start_freq,
836 start_subband, end_subband;
838 /* determine which channels use spx */
839 if (s->channel_mode == AC3_CHMODE_MONO) {
840 s->channel_uses_spx[1] = 1;
842 for (ch = 1; ch <= fbw_channels; ch++)
843 s->channel_uses_spx[ch] = get_bits1(gbc);
846 /* get the frequency bins of the spx copy region and the spx start
848 dst_start_freq = get_bits(gbc, 2);
849 start_subband = get_bits(gbc, 3) + 2;
850 if (start_subband > 7)
851 start_subband += start_subband - 7;
852 end_subband = get_bits(gbc, 3) + 5;
854 s->spx_dst_end_freq = end_freq_inv_tab[end_subband];
857 end_subband += end_subband - 7;
858 dst_start_freq = dst_start_freq * 12 + 25;
859 src_start_freq = start_subband * 12 + 25;
860 dst_end_freq = end_subband * 12 + 25;
862 /* check validity of spx ranges */
863 if (start_subband >= end_subband) {
864 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
865 "range (%d >= %d)\n", start_subband, end_subband);
866 return AVERROR_INVALIDDATA;
868 if (dst_start_freq >= src_start_freq) {
869 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
870 "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
871 return AVERROR_INVALIDDATA;
874 s->spx_dst_start_freq = dst_start_freq;
875 s->spx_src_start_freq = src_start_freq;
877 s->spx_dst_end_freq = dst_end_freq;
879 decode_band_structure(gbc, blk, s->eac3, 0,
880 start_subband, end_subband,
881 ff_eac3_default_spx_band_struct,
885 for (ch = 1; ch <= fbw_channels; ch++) {
886 s->channel_uses_spx[ch] = 0;
887 s->first_spx_coords[ch] = 1;
892 /* spectral extension coordinates */
894 for (ch = 1; ch <= fbw_channels; ch++) {
895 if (s->channel_uses_spx[ch]) {
896 if (s->first_spx_coords[ch] || get_bits1(gbc)) {
898 int bin, master_spx_coord;
900 s->first_spx_coords[ch] = 0;
901 spx_blend = AC3_SPX_BLEND(get_bits(gbc, 5));
902 master_spx_coord = get_bits(gbc, 2) * 3;
904 bin = s->spx_src_start_freq;
905 for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
907 int spx_coord_exp, spx_coord_mant;
908 INTFLOAT nratio, sblend, nblend;
911 /* calculate blending factors */
912 bandsize = s->spx_band_sizes[bnd];
913 accu = (int64_t)((bin << 23) + (bandsize << 22)) * s->spx_dst_end_freq;
914 nratio = (int)(accu >> 32);
915 nratio -= spx_blend << 18;
920 } else if (nratio > 0x7fffff) {
924 nblend = fixed_sqrt(nratio, 23);
925 accu = (int64_t)nblend * 1859775393;
926 nblend = (int)((accu + (1<<29)) >> 30);
927 sblend = fixed_sqrt(0x800000 - nratio, 23);
932 /* calculate blending factors */
933 bandsize = s->spx_band_sizes[bnd];
934 nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
935 nratio = av_clipf(nratio, 0.0f, 1.0f);
936 nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
937 // to give unity variance
938 sblend = sqrtf(1.0f - nratio);
942 /* decode spx coordinates */
943 spx_coord_exp = get_bits(gbc, 4);
944 spx_coord_mant = get_bits(gbc, 2);
945 if (spx_coord_exp == 15) spx_coord_mant <<= 1;
946 else spx_coord_mant += 4;
947 spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
949 /* multiply noise and signal blending factors by spx coordinate */
951 accu = (int64_t)nblend * spx_coord_mant;
952 s->spx_noise_blend[ch][bnd] = (int)((accu + (1<<22)) >> 23);
953 accu = (int64_t)sblend * spx_coord_mant;
954 s->spx_signal_blend[ch][bnd] = (int)((accu + (1<<22)) >> 23);
956 spx_coord = spx_coord_mant * (1.0f / (1 << 23));
957 s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
958 s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
963 s->first_spx_coords[ch] = 1;
968 /* coupling strategy */
969 if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
970 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
972 s->cpl_in_use[blk] = get_bits1(gbc);
973 if (s->cpl_in_use[blk]) {
974 /* coupling in use */
975 int cpl_start_subband, cpl_end_subband;
977 if (channel_mode < AC3_CHMODE_STEREO) {
978 av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
979 return AVERROR_INVALIDDATA;
982 /* check for enhanced coupling */
983 if (s->eac3 && get_bits1(gbc)) {
984 /* TODO: parse enhanced coupling strategy info */
985 avpriv_request_sample(s->avctx, "Enhanced coupling");
986 return AVERROR_PATCHWELCOME;
989 /* determine which channels are coupled */
990 if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
991 s->channel_in_cpl[1] = 1;
992 s->channel_in_cpl[2] = 1;
994 for (ch = 1; ch <= fbw_channels; ch++)
995 s->channel_in_cpl[ch] = get_bits1(gbc);
998 /* phase flags in use */
999 if (channel_mode == AC3_CHMODE_STEREO)
1000 s->phase_flags_in_use = get_bits1(gbc);
1002 /* coupling frequency range */
1003 cpl_start_subband = get_bits(gbc, 4);
1004 cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
1005 get_bits(gbc, 4) + 3;
1006 if (cpl_start_subband >= cpl_end_subband) {
1007 av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
1008 cpl_start_subband, cpl_end_subband);
1009 return AVERROR_INVALIDDATA;
1011 s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
1012 s->end_freq[CPL_CH] = cpl_end_subband * 12 + 37;
1014 decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
1016 ff_eac3_default_cpl_band_struct,
1017 &s->num_cpl_bands, s->cpl_band_sizes);
1019 /* coupling not in use */
1020 for (ch = 1; ch <= fbw_channels; ch++) {
1021 s->channel_in_cpl[ch] = 0;
1022 s->first_cpl_coords[ch] = 1;
1024 s->first_cpl_leak = s->eac3;
1025 s->phase_flags_in_use = 0;
1027 } else if (!s->eac3) {
1029 av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "
1030 "be present in block 0\n");
1031 return AVERROR_INVALIDDATA;
1033 s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
1036 cpl_in_use = s->cpl_in_use[blk];
1038 /* coupling coordinates */
1040 int cpl_coords_exist = 0;
1042 for (ch = 1; ch <= fbw_channels; ch++) {
1043 if (s->channel_in_cpl[ch]) {
1044 if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
1045 int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
1046 s->first_cpl_coords[ch] = 0;
1047 cpl_coords_exist = 1;
1048 master_cpl_coord = 3 * get_bits(gbc, 2);
1049 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1050 cpl_coord_exp = get_bits(gbc, 4);
1051 cpl_coord_mant = get_bits(gbc, 4);
1052 if (cpl_coord_exp == 15)
1053 s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
1055 s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
1056 s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
1059 av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
1060 "be present in block 0\n");
1061 return AVERROR_INVALIDDATA;
1064 /* channel not in coupling */
1065 s->first_cpl_coords[ch] = 1;
1069 if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
1070 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1071 s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
1076 /* stereo rematrixing strategy and band structure */
1077 if (channel_mode == AC3_CHMODE_STEREO) {
1078 if ((s->eac3 && !blk) || get_bits1(gbc)) {
1079 s->num_rematrixing_bands = 4;
1080 if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
1081 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
1082 } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
1083 s->num_rematrixing_bands--;
1085 for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
1086 s->rematrixing_flags[bnd] = get_bits1(gbc);
1088 av_log(s->avctx, AV_LOG_WARNING, "Warning: "
1089 "new rematrixing strategy not present in block 0\n");
1090 s->num_rematrixing_bands = 0;
1094 /* exponent strategies for each channel */
1095 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1097 s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
1098 if (s->exp_strategy[blk][ch] != EXP_REUSE)
1099 bit_alloc_stages[ch] = 3;
1102 /* channel bandwidth */
1103 for (ch = 1; ch <= fbw_channels; ch++) {
1104 s->start_freq[ch] = 0;
1105 if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1107 int prev = s->end_freq[ch];
1108 if (s->channel_in_cpl[ch])
1109 s->end_freq[ch] = s->start_freq[CPL_CH];
1110 else if (s->channel_uses_spx[ch])
1111 s->end_freq[ch] = s->spx_src_start_freq;
1113 int bandwidth_code = get_bits(gbc, 6);
1114 if (bandwidth_code > 60) {
1115 av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1116 return AVERROR_INVALIDDATA;
1118 s->end_freq[ch] = bandwidth_code * 3 + 73;
1120 group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1121 s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
1122 if (blk > 0 && s->end_freq[ch] != prev)
1123 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1126 if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1127 s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
1128 (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1131 /* decode exponents for each channel */
1132 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1133 if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1134 s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1135 if (decode_exponents(gbc, s->exp_strategy[blk][ch],
1136 s->num_exp_groups[ch], s->dexps[ch][0],
1137 &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1138 av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
1139 return AVERROR_INVALIDDATA;
1141 if (ch != CPL_CH && ch != s->lfe_ch)
1142 skip_bits(gbc, 2); /* skip gainrng */
1146 /* bit allocation information */
1147 if (s->bit_allocation_syntax) {
1148 if (get_bits1(gbc)) {
1149 s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1150 s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1151 s->bit_alloc_params.slow_gain = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
1152 s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
1153 s->bit_alloc_params.floor = ff_ac3_floor_tab[get_bits(gbc, 3)];
1154 for (ch = !cpl_in_use; ch <= s->channels; ch++)
1155 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1157 av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must "
1158 "be present in block 0\n");
1159 return AVERROR_INVALIDDATA;
1163 /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1164 if (!s->eac3 || !blk) {
1165 if (s->snr_offset_strategy && get_bits1(gbc)) {
1168 csnr = (get_bits(gbc, 6) - 15) << 4;
1169 for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1171 if (ch == i || s->snr_offset_strategy == 2)
1172 snr = (csnr + get_bits(gbc, 4)) << 2;
1173 /* run at least last bit allocation stage if snr offset changes */
1174 if (blk && s->snr_offset[ch] != snr) {
1175 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1177 s->snr_offset[ch] = snr;
1179 /* fast gain (normal AC-3 only) */
1181 int prev = s->fast_gain[ch];
1182 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1183 /* run last 2 bit allocation stages if fast gain changes */
1184 if (blk && prev != s->fast_gain[ch])
1185 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1188 } else if (!s->eac3 && !blk) {
1189 av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1190 return AVERROR_INVALIDDATA;
1194 /* fast gain (E-AC-3 only) */
1195 if (s->fast_gain_syntax && get_bits1(gbc)) {
1196 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1197 int prev = s->fast_gain[ch];
1198 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1199 /* run last 2 bit allocation stages if fast gain changes */
1200 if (blk && prev != s->fast_gain[ch])
1201 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1203 } else if (s->eac3 && !blk) {
1204 for (ch = !cpl_in_use; ch <= s->channels; ch++)
1205 s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1208 /* E-AC-3 to AC-3 converter SNR offset */
1209 if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1210 skip_bits(gbc, 10); // skip converter snr offset
1213 /* coupling leak information */
1215 if (s->first_cpl_leak || get_bits1(gbc)) {
1216 int fl = get_bits(gbc, 3);
1217 int sl = get_bits(gbc, 3);
1218 /* run last 2 bit allocation stages for coupling channel if
1219 coupling leak changes */
1220 if (blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1221 sl != s->bit_alloc_params.cpl_slow_leak)) {
1222 bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1224 s->bit_alloc_params.cpl_fast_leak = fl;
1225 s->bit_alloc_params.cpl_slow_leak = sl;
1226 } else if (!s->eac3 && !blk) {
1227 av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must "
1228 "be present in block 0\n");
1229 return AVERROR_INVALIDDATA;
1231 s->first_cpl_leak = 0;
1234 /* delta bit allocation information */
1235 if (s->dba_syntax && get_bits1(gbc)) {
1236 /* delta bit allocation exists (strategy) */
1237 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1238 s->dba_mode[ch] = get_bits(gbc, 2);
1239 if (s->dba_mode[ch] == DBA_RESERVED) {
1240 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1241 return AVERROR_INVALIDDATA;
1243 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1245 /* channel delta offset, len and bit allocation */
1246 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1247 if (s->dba_mode[ch] == DBA_NEW) {
1248 s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;
1249 for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
1250 s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1251 s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1252 s->dba_values[ch][seg] = get_bits(gbc, 3);
1254 /* run last 2 bit allocation stages if new dba values */
1255 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1258 } else if (blk == 0) {
1259 for (ch = 0; ch <= s->channels; ch++) {
1260 s->dba_mode[ch] = DBA_NONE;
1264 /* Bit allocation */
1265 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1266 if (bit_alloc_stages[ch] > 2) {
1267 /* Exponent mapping into PSD and PSD integration */
1268 ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
1269 s->start_freq[ch], s->end_freq[ch],
1270 s->psd[ch], s->band_psd[ch]);
1272 if (bit_alloc_stages[ch] > 1) {
1273 /* Compute excitation function, Compute masking curve, and
1274 Apply delta bit allocation */
1275 if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1276 s->start_freq[ch], s->end_freq[ch],
1277 s->fast_gain[ch], (ch == s->lfe_ch),
1278 s->dba_mode[ch], s->dba_nsegs[ch],
1279 s->dba_offsets[ch], s->dba_lengths[ch],
1280 s->dba_values[ch], s->mask[ch])) {
1281 av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1282 return AVERROR_INVALIDDATA;
1285 if (bit_alloc_stages[ch] > 0) {
1286 /* Compute bit allocation */
1287 const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1288 ff_eac3_hebap_tab : ff_ac3_bap_tab;
1289 s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1290 s->start_freq[ch], s->end_freq[ch],
1292 s->bit_alloc_params.floor,
1293 bap_tab, s->bap[ch]);
1297 /* unused dummy data */
1298 if (s->skip_syntax && get_bits1(gbc)) {
1299 int skipl = get_bits(gbc, 9);
1304 /* unpack the transform coefficients
1305 this also uncouples channels if coupling is in use. */
1306 decode_transform_coeffs(s, blk);
1308 /* TODO: generate enhanced coupling coordinates and uncouple */
1310 /* recover coefficients if rematrixing is in use */
1311 if (s->channel_mode == AC3_CHMODE_STEREO)
1314 /* apply scaling to coefficients (headroom, dynrng) */
1315 for (ch = 1; ch <= s->channels; ch++) {
1317 if(s->channel_mode == AC3_CHMODE_DUALMONO) {
1318 gain = s->dynamic_range[2-ch];
1320 gain = s->dynamic_range[0];
1323 scale_coefs(s->transform_coeffs[ch], s->fixed_coeffs[ch], gain, 256);
1325 gain *= 1.0 / 4194304.0f;
1326 s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch],
1327 s->fixed_coeffs[ch], gain, 256);
1331 /* apply spectral extension to high frequency bins */
1332 if (s->spx_in_use && CONFIG_EAC3_DECODER) {
1333 ff_eac3_apply_spectral_extension(s);
1336 /* downmix and MDCT. order depends on whether block switching is used for
1337 any channel in this block. this is because coefficients for the long
1338 and short transforms cannot be mixed. */
1339 downmix_output = s->channels != s->out_channels &&
1340 !((s->output_mode & AC3_OUTPUT_LFEON) &&
1341 s->fbw_channels == s->out_channels);
1342 if (different_transforms) {
1343 /* the delay samples have already been downmixed, so we upmix the delay
1344 samples in order to reconstruct all channels before downmixing. */
1350 do_imdct(s, s->channels);
1352 if (downmix_output) {
1354 ac3_downmix_c_fixed16(s->outptr, s->downmix_coeffs,
1355 s->out_channels, s->fbw_channels, 256);
1357 s->ac3dsp.downmix(s->outptr, s->downmix_coeffs,
1358 s->out_channels, s->fbw_channels, 256);
1362 if (downmix_output) {
1363 s->ac3dsp.AC3_RENAME(downmix)(s->xcfptr + 1, s->downmix_coeffs,
1364 s->out_channels, s->fbw_channels, 256);
1367 if (downmix_output && !s->downmixed) {
1369 s->ac3dsp.AC3_RENAME(downmix)(s->dlyptr, s->downmix_coeffs,
1370 s->out_channels, s->fbw_channels, 128);
1373 do_imdct(s, s->out_channels);
1380 * Decode a single AC-3 frame.
1382 static int ac3_decode_frame(AVCodecContext * avctx, void *data,
1383 int *got_frame_ptr, AVPacket *avpkt)
1385 AVFrame *frame = data;
1386 const uint8_t *buf = avpkt->data;
1387 int buf_size = avpkt->size;
1388 AC3DecodeContext *s = avctx->priv_data;
1389 int blk, ch, err, ret;
1390 const uint8_t *channel_map;
1391 const SHORTFLOAT *output[AC3_MAX_CHANNELS];
1392 enum AVMatrixEncoding matrix_encoding;
1393 AVDownmixInfo *downmix_info;
1395 /* copy input buffer to decoder context to avoid reading past the end
1396 of the buffer, which can be caused by a damaged input stream. */
1397 if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
1398 // seems to be byte-swapped AC-3
1399 int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1400 s->dsp.bswap16_buf((uint16_t *)s->input_buffer, (const uint16_t *)buf, cnt);
1402 memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1403 buf = s->input_buffer;
1404 /* initialize the GetBitContext with the start of valid AC-3 Frame */
1405 init_get_bits(&s->gbc, buf, buf_size * 8);
1407 /* parse the syncinfo */
1408 err = parse_frame_header(s);
1412 case AAC_AC3_PARSE_ERROR_SYNC:
1413 av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1414 return AVERROR_INVALIDDATA;
1415 case AAC_AC3_PARSE_ERROR_BSID:
1416 av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1418 case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
1419 av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1421 case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
1422 av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1424 case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
1425 /* skip frame if CRC is ok. otherwise use error concealment. */
1426 /* TODO: add support for substreams and dependent frames */
1427 if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
1428 av_log(avctx, AV_LOG_WARNING, "unsupported frame type : "
1429 "skipping frame\n");
1433 av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1436 case AAC_AC3_PARSE_ERROR_CRC:
1437 case AAC_AC3_PARSE_ERROR_CHANNEL_CFG:
1439 default: // Normal AVERROR do not try to recover.
1444 /* check that reported frame size fits in input buffer */
1445 if (s->frame_size > buf_size) {
1446 av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1447 err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
1448 } else if (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL)) {
1449 /* check for crc mismatch */
1450 if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
1451 s->frame_size - 2)) {
1452 av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1453 if (avctx->err_recognition & AV_EF_EXPLODE)
1454 return AVERROR_INVALIDDATA;
1455 err = AAC_AC3_PARSE_ERROR_CRC;
1460 /* if frame is ok, set audio parameters */
1462 avctx->sample_rate = s->sample_rate;
1463 avctx->bit_rate = s->bit_rate;
1466 /* channel config */
1467 if (!err || (s->channels && s->out_channels != s->channels)) {
1468 s->out_channels = s->channels;
1469 s->output_mode = s->channel_mode;
1471 s->output_mode |= AC3_OUTPUT_LFEON;
1472 if (s->channels > 1 &&
1473 avctx->request_channel_layout == AV_CH_LAYOUT_MONO) {
1474 s->out_channels = 1;
1475 s->output_mode = AC3_CHMODE_MONO;
1476 } else if (s->channels > 2 &&
1477 avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
1478 s->out_channels = 2;
1479 s->output_mode = AC3_CHMODE_STEREO;
1482 s->loro_center_mix_level = gain_levels[s-> center_mix_level];
1483 s->loro_surround_mix_level = gain_levels[s->surround_mix_level];
1484 s->ltrt_center_mix_level = LEVEL_MINUS_3DB;
1485 s->ltrt_surround_mix_level = LEVEL_MINUS_3DB;
1486 /* set downmixing coefficients if needed */
1487 if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1488 s->fbw_channels == s->out_channels)) {
1489 set_downmix_coeffs(s);
1491 } else if (!s->channels) {
1492 av_log(avctx, AV_LOG_ERROR, "unable to determine channel mode\n");
1493 return AVERROR_INVALIDDATA;
1495 avctx->channels = s->out_channels;
1496 avctx->channel_layout = avpriv_ac3_channel_layout_tab[s->output_mode & ~AC3_OUTPUT_LFEON];
1497 if (s->output_mode & AC3_OUTPUT_LFEON)
1498 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1500 /* set audio service type based on bitstream mode for AC-3 */
1501 avctx->audio_service_type = s->bitstream_mode;
1502 if (s->bitstream_mode == 0x7 && s->channels > 1)
1503 avctx->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
1505 /* get output buffer */
1506 frame->nb_samples = s->num_blocks * AC3_BLOCK_SIZE;
1507 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1510 /* decode the audio blocks */
1511 channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1512 for (ch = 0; ch < AC3_MAX_CHANNELS; ch++) {
1513 output[ch] = s->output[ch];
1514 s->outptr[ch] = s->output[ch];
1516 for (ch = 0; ch < s->channels; ch++) {
1517 if (ch < s->out_channels)
1518 s->outptr[channel_map[ch]] = (SHORTFLOAT *)frame->data[ch];
1520 for (blk = 0; blk < s->num_blocks; blk++) {
1521 if (!err && decode_audio_block(s, blk)) {
1522 av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1526 for (ch = 0; ch < s->out_channels; ch++)
1527 memcpy(((SHORTFLOAT*)frame->data[ch]) + AC3_BLOCK_SIZE*blk, output[ch], AC3_BLOCK_SIZE*sizeof(SHORTFLOAT));
1528 for (ch = 0; ch < s->out_channels; ch++)
1529 output[ch] = s->outptr[channel_map[ch]];
1530 for (ch = 0; ch < s->out_channels; ch++) {
1531 if (!ch || channel_map[ch])
1532 s->outptr[channel_map[ch]] += AC3_BLOCK_SIZE;
1536 av_frame_set_decode_error_flags(frame, err ? FF_DECODE_ERROR_INVALID_BITSTREAM : 0);
1538 /* keep last block for error concealment in next frame */
1539 for (ch = 0; ch < s->out_channels; ch++)
1540 memcpy(s->output[ch], output[ch], AC3_BLOCK_SIZE*sizeof(SHORTFLOAT));
1545 * Check whether the input layout is compatible, and make sure we're not
1546 * downmixing (else the matrix encoding is no longer applicable).
1548 matrix_encoding = AV_MATRIX_ENCODING_NONE;
1549 if (s->channel_mode == AC3_CHMODE_STEREO &&
1550 s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1551 if (s->dolby_surround_mode == AC3_DSURMOD_ON)
1552 matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
1553 else if (s->dolby_headphone_mode == AC3_DHEADPHONMOD_ON)
1554 matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;
1555 } else if (s->channel_mode >= AC3_CHMODE_2F2R &&
1556 s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1557 switch (s->dolby_surround_ex_mode) {
1558 case AC3_DSUREXMOD_ON: // EX or PLIIx
1559 matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
1561 case AC3_DSUREXMOD_PLIIZ:
1562 matrix_encoding = AV_MATRIX_ENCODING_DPLIIZ;
1564 default: // not indicated or off
1568 if ((ret = ff_side_data_update_matrix_encoding(frame, matrix_encoding)) < 0)
1572 if ((downmix_info = av_downmix_info_update_side_data(frame))) {
1573 switch (s->preferred_downmix) {
1574 case AC3_DMIXMOD_LTRT:
1575 downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_LTRT;
1577 case AC3_DMIXMOD_LORO:
1578 downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_LORO;
1580 case AC3_DMIXMOD_DPLII:
1581 downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_DPLII;
1584 downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_UNKNOWN;
1587 downmix_info->center_mix_level = gain_levels[s-> center_mix_level];
1588 downmix_info->center_mix_level_ltrt = gain_levels[s-> center_mix_level_ltrt];
1589 downmix_info->surround_mix_level = gain_levels[s-> surround_mix_level];
1590 downmix_info->surround_mix_level_ltrt = gain_levels[s->surround_mix_level_ltrt];
1591 if (s->lfe_mix_level_exists)
1592 downmix_info->lfe_mix_level = gain_levels_lfe[s->lfe_mix_level];
1594 downmix_info->lfe_mix_level = 0.0; // -inf dB
1596 return AVERROR(ENOMEM);
1600 return FFMIN(buf_size, s->frame_size);
1604 * Uninitialize the AC-3 decoder.
1606 static av_cold int ac3_decode_end(AVCodecContext *avctx)
1608 AC3DecodeContext *s = avctx->priv_data;
1609 ff_mdct_end(&s->imdct_512);
1610 ff_mdct_end(&s->imdct_256);
1618 #define OFFSET(x) offsetof(AC3DecodeContext, x)
1619 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)