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"
38 #include "aac_ac3_parser.h"
39 #include "ac3_parser.h"
41 #include "ac3dec_data.h"
45 * table for ungrouping 3 values in 7 bits.
46 * used for exponents and bap=2 mantissas
48 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];
68 static float heavy_dynamic_range_tab[256];
70 /** Adjustments in dB gain */
71 static const float gain_levels[9] = {
75 LEVEL_MINUS_1POINT5DB,
77 LEVEL_MINUS_4POINT5DB,
83 /** Adjustments in dB gain (LFE, +10 to -21 dB) */
84 static const float gain_levels_lfe[32] = {
85 3.162275, 2.818382, 2.511886, 2.238719, 1.995261, 1.778278, 1.584893,
86 1.412536, 1.258924, 1.122018, 1.000000, 0.891251, 0.794328, 0.707946,
87 0.630957, 0.562341, 0.501187, 0.446683, 0.398107, 0.354813, 0.316227,
88 0.281838, 0.251188, 0.223872, 0.199526, 0.177828, 0.158489, 0.141253,
89 0.125892, 0.112201, 0.100000, 0.089125
93 * Table for default stereo downmixing coefficients
94 * reference: Section 7.8.2 Downmixing Into Two Channels
96 static const uint8_t ac3_default_coeffs[8][5][2] = {
97 { { 2, 7 }, { 7, 2 }, },
99 { { 2, 7 }, { 7, 2 }, },
100 { { 2, 7 }, { 5, 5 }, { 7, 2 }, },
101 { { 2, 7 }, { 7, 2 }, { 6, 6 }, },
102 { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 }, },
103 { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
104 { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
108 * Symmetrical Dequantization
109 * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization
110 * Tables 7.19 to 7.23
113 symmetric_dequant(int code, int levels)
115 return ((code - (levels >> 1)) * (1 << 24)) / levels;
119 * Initialize tables at runtime.
121 static av_cold void ac3_tables_init(void)
125 /* generate table for ungrouping 3 values in 7 bits
126 reference: Section 7.1.3 Exponent Decoding */
127 for (i = 0; i < 128; i++) {
128 ungroup_3_in_7_bits_tab[i][0] = i / 25;
129 ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5;
130 ungroup_3_in_7_bits_tab[i][2] = (i % 25) % 5;
133 /* generate grouped mantissa tables
134 reference: Section 7.3.5 Ungrouping of Mantissas */
135 for (i = 0; i < 32; i++) {
136 /* bap=1 mantissas */
137 b1_mantissas[i][0] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][0], 3);
138 b1_mantissas[i][1] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][1], 3);
139 b1_mantissas[i][2] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][2], 3);
141 for (i = 0; i < 128; i++) {
142 /* bap=2 mantissas */
143 b2_mantissas[i][0] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][0], 5);
144 b2_mantissas[i][1] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][1], 5);
145 b2_mantissas[i][2] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][2], 5);
147 /* bap=4 mantissas */
148 b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
149 b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
151 /* generate ungrouped mantissa tables
152 reference: Tables 7.21 and 7.23 */
153 for (i = 0; i < 7; i++) {
154 /* bap=3 mantissas */
155 b3_mantissas[i] = symmetric_dequant(i, 7);
157 for (i = 0; i < 15; i++) {
158 /* bap=5 mantissas */
159 b5_mantissas[i] = symmetric_dequant(i, 15);
162 /* generate dynamic range table
163 reference: Section 7.7.1 Dynamic Range Control */
164 for (i = 0; i < 256; i++) {
165 int v = (i >> 5) - ((i >> 7) << 3) - 5;
166 dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
169 /* generate compr dynamic range table
170 reference: Section 7.7.2 Heavy Compression */
171 for (i = 0; i < 256; i++) {
172 int v = (i >> 4) - ((i >> 7) << 4) - 4;
173 heavy_dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0xF) | 0x10);
179 * AVCodec initialization
181 static av_cold int ac3_decode_init(AVCodecContext *avctx)
183 AC3DecodeContext *s = avctx->priv_data;
189 ff_mdct_init(&s->imdct_256, 8, 1, 1.0);
190 ff_mdct_init(&s->imdct_512, 9, 1, 1.0);
191 AC3_RENAME(ff_kbd_window_init)(s->window, 5.0, 256);
192 ff_bswapdsp_init(&s->bdsp);
195 s->fdsp = avpriv_alloc_fixed_dsp(avctx->flags & AV_CODEC_FLAG_BITEXACT);
197 s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
198 ff_fmt_convert_init(&s->fmt_conv, avctx);
201 ff_ac3dsp_init(&s->ac3dsp, avctx->flags & AV_CODEC_FLAG_BITEXACT);
202 av_lfg_init(&s->dith_state, 0);
205 avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
207 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
209 /* allow downmixing to stereo or mono */
210 if (avctx->channels > 1 &&
211 avctx->request_channel_layout == AV_CH_LAYOUT_MONO)
213 else if (avctx->channels > 2 &&
214 avctx->request_channel_layout == AV_CH_LAYOUT_STEREO)
218 for (i = 0; i < AC3_MAX_CHANNELS; i++) {
219 s->xcfptr[i] = s->transform_coeffs[i];
220 s->dlyptr[i] = s->delay[i];
227 * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
228 * GetBitContext within AC3DecodeContext must point to
229 * the start of the synchronized AC-3 bitstream.
231 static int ac3_parse_header(AC3DecodeContext *s)
233 GetBitContext *gbc = &s->gbc;
236 /* read the rest of the bsi. read twice for dual mono mode. */
237 i = !s->channel_mode;
239 s->dialog_normalization[(!s->channel_mode)-i] = -get_bits(gbc, 5);
240 if (s->dialog_normalization[(!s->channel_mode)-i] == 0) {
241 s->dialog_normalization[(!s->channel_mode)-i] = -31;
243 if (s->target_level != 0) {
244 s->level_gain[(!s->channel_mode)-i] = powf(2.0f,
245 (float)(s->target_level -
246 s->dialog_normalization[(!s->channel_mode)-i])/6.0f);
248 if (s->compression_exists[(!s->channel_mode)-i] = get_bits1(gbc)) {
249 s->heavy_dynamic_range[(!s->channel_mode)-i] =
250 AC3_HEAVY_RANGE(get_bits(gbc, 8));
253 skip_bits(gbc, 8); //skip language code
255 skip_bits(gbc, 7); //skip audio production information
258 skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
260 /* skip the timecodes or parse the Alternate Bit Stream Syntax */
261 if (s->bitstream_id != 6) {
263 skip_bits(gbc, 14); //skip timecode1
265 skip_bits(gbc, 14); //skip timecode2
267 if (get_bits1(gbc)) {
268 s->preferred_downmix = get_bits(gbc, 2);
269 s->center_mix_level_ltrt = get_bits(gbc, 3);
270 s->surround_mix_level_ltrt = av_clip(get_bits(gbc, 3), 3, 7);
271 s->center_mix_level = get_bits(gbc, 3);
272 s->surround_mix_level = av_clip(get_bits(gbc, 3), 3, 7);
274 if (get_bits1(gbc)) {
275 s->dolby_surround_ex_mode = get_bits(gbc, 2);
276 s->dolby_headphone_mode = get_bits(gbc, 2);
277 skip_bits(gbc, 10); // skip adconvtyp (1), xbsi2 (8), encinfo (1)
281 /* skip additional bitstream info */
282 if (get_bits1(gbc)) {
283 i = get_bits(gbc, 6);
293 * Common function to parse AC-3 or E-AC-3 frame header
295 static int parse_frame_header(AC3DecodeContext *s)
297 AC3HeaderInfo hdr, *phdr=&hdr;
300 err = avpriv_ac3_parse_header(&s->gbc, &phdr);
304 /* get decoding parameters from header info */
305 s->bit_alloc_params.sr_code = hdr.sr_code;
306 s->bitstream_id = hdr.bitstream_id;
307 s->bitstream_mode = hdr.bitstream_mode;
308 s->channel_mode = hdr.channel_mode;
309 s->lfe_on = hdr.lfe_on;
310 s->bit_alloc_params.sr_shift = hdr.sr_shift;
311 s->sample_rate = hdr.sample_rate;
312 s->bit_rate = hdr.bit_rate;
313 s->channels = hdr.channels;
314 s->fbw_channels = s->channels - s->lfe_on;
315 s->lfe_ch = s->fbw_channels + 1;
316 s->frame_size = hdr.frame_size;
317 s->preferred_downmix = AC3_DMIXMOD_NOTINDICATED;
318 s->center_mix_level = hdr.center_mix_level;
319 s->center_mix_level_ltrt = 4; // -3.0dB
320 s->surround_mix_level = hdr.surround_mix_level;
321 s->surround_mix_level_ltrt = 4; // -3.0dB
322 s->lfe_mix_level_exists = 0;
323 s->num_blocks = hdr.num_blocks;
324 s->frame_type = hdr.frame_type;
325 s->substreamid = hdr.substreamid;
326 s->dolby_surround_mode = hdr.dolby_surround_mode;
327 s->dolby_surround_ex_mode = AC3_DSUREXMOD_NOTINDICATED;
328 s->dolby_headphone_mode = AC3_DHEADPHONMOD_NOTINDICATED;
331 s->start_freq[s->lfe_ch] = 0;
332 s->end_freq[s->lfe_ch] = 7;
333 s->num_exp_groups[s->lfe_ch] = 2;
334 s->channel_in_cpl[s->lfe_ch] = 0;
337 if (s->bitstream_id <= 10) {
339 s->snr_offset_strategy = 2;
340 s->block_switch_syntax = 1;
341 s->dither_flag_syntax = 1;
342 s->bit_allocation_syntax = 1;
343 s->fast_gain_syntax = 0;
344 s->first_cpl_leak = 0;
347 memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
348 return ac3_parse_header(s);
349 } else if (CONFIG_EAC3_DECODER) {
351 return ff_eac3_parse_header(s);
353 av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n");
354 return AVERROR(ENOSYS);
359 * Set stereo downmixing coefficients based on frame header info.
360 * reference: Section 7.8.2 Downmixing Into Two Channels
362 static void set_downmix_coeffs(AC3DecodeContext *s)
365 float cmix = gain_levels[s-> center_mix_level];
366 float smix = gain_levels[s->surround_mix_level];
368 float downmix_coeffs[AC3_MAX_CHANNELS][2];
370 for (i = 0; i < s->fbw_channels; i++) {
371 downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
372 downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
374 if (s->channel_mode > 1 && s->channel_mode & 1) {
375 downmix_coeffs[1][0] = downmix_coeffs[1][1] = cmix;
377 if (s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
378 int nf = s->channel_mode - 2;
379 downmix_coeffs[nf][0] = downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
381 if (s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
382 int nf = s->channel_mode - 4;
383 downmix_coeffs[nf][0] = downmix_coeffs[nf+1][1] = smix;
388 for (i = 0; i < s->fbw_channels; i++) {
389 norm0 += downmix_coeffs[i][0];
390 norm1 += downmix_coeffs[i][1];
392 norm0 = 1.0f / norm0;
393 norm1 = 1.0f / norm1;
394 for (i = 0; i < s->fbw_channels; i++) {
395 downmix_coeffs[i][0] *= norm0;
396 downmix_coeffs[i][1] *= norm1;
399 if (s->output_mode == AC3_CHMODE_MONO) {
400 for (i = 0; i < s->fbw_channels; i++)
401 downmix_coeffs[i][0] = (downmix_coeffs[i][0] +
402 downmix_coeffs[i][1]) * LEVEL_MINUS_3DB;
404 for (i = 0; i < s->fbw_channels; i++) {
405 s->downmix_coeffs[i][0] = FIXR12(downmix_coeffs[i][0]);
406 s->downmix_coeffs[i][1] = FIXR12(downmix_coeffs[i][1]);
411 * Decode the grouped exponents according to exponent strategy.
412 * reference: Section 7.1.3 Exponent Decoding
414 static int decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
415 uint8_t absexp, int8_t *dexps)
417 int i, j, grp, group_size;
422 group_size = exp_strategy + (exp_strategy == EXP_D45);
423 for (grp = 0, i = 0; grp < ngrps; grp++) {
424 expacc = get_bits(gbc, 7);
425 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
426 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
427 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
430 /* convert to absolute exps and expand groups */
432 for (i = 0, j = 0; i < ngrps * 3; i++) {
433 prevexp += dexp[i] - 2;
436 switch (group_size) {
437 case 4: dexps[j++] = prevexp;
438 dexps[j++] = prevexp;
439 case 2: dexps[j++] = prevexp;
440 case 1: dexps[j++] = prevexp;
447 * Generate transform coefficients for each coupled channel in the coupling
448 * range using the coupling coefficients and coupling coordinates.
449 * reference: Section 7.4.3 Coupling Coordinate Format
451 static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
455 bin = s->start_freq[CPL_CH];
456 for (band = 0; band < s->num_cpl_bands; band++) {
457 int band_start = bin;
458 int band_end = bin + s->cpl_band_sizes[band];
459 for (ch = 1; ch <= s->fbw_channels; ch++) {
460 if (s->channel_in_cpl[ch]) {
461 int cpl_coord = s->cpl_coords[ch][band] << 5;
462 for (bin = band_start; bin < band_end; bin++) {
463 s->fixed_coeffs[ch][bin] =
464 MULH(s->fixed_coeffs[CPL_CH][bin] * (1 << 4), cpl_coord);
466 if (ch == 2 && s->phase_flags[band]) {
467 for (bin = band_start; bin < band_end; bin++)
468 s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin];
477 * Grouped mantissas for 3-level 5-level and 11-level quantization
479 typedef struct mant_groups {
489 * Decode the transform coefficients for a particular channel
490 * reference: Section 7.3 Quantization and Decoding of Mantissas
492 static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
494 int start_freq = s->start_freq[ch_index];
495 int end_freq = s->end_freq[ch_index];
496 uint8_t *baps = s->bap[ch_index];
497 int8_t *exps = s->dexps[ch_index];
498 int32_t *coeffs = s->fixed_coeffs[ch_index];
499 int dither = (ch_index == CPL_CH) || s->dither_flag[ch_index];
500 GetBitContext *gbc = &s->gbc;
503 for (freq = start_freq; freq < end_freq; freq++) {
504 int bap = baps[freq];
508 /* random noise with approximate range of -0.707 to 0.707 */
510 mantissa = (((av_lfg_get(&s->dith_state)>>8)*181)>>8) - 5931008;
517 mantissa = m->b1_mant[m->b1];
519 int bits = get_bits(gbc, 5);
520 mantissa = b1_mantissas[bits][0];
521 m->b1_mant[1] = b1_mantissas[bits][1];
522 m->b1_mant[0] = b1_mantissas[bits][2];
529 mantissa = m->b2_mant[m->b2];
531 int bits = get_bits(gbc, 7);
532 mantissa = b2_mantissas[bits][0];
533 m->b2_mant[1] = b2_mantissas[bits][1];
534 m->b2_mant[0] = b2_mantissas[bits][2];
539 mantissa = b3_mantissas[get_bits(gbc, 3)];
544 mantissa = m->b4_mant;
546 int bits = get_bits(gbc, 7);
547 mantissa = b4_mantissas[bits][0];
548 m->b4_mant = b4_mantissas[bits][1];
553 mantissa = b5_mantissas[get_bits(gbc, 4)];
555 default: /* 6 to 15 */
556 /* Shift mantissa and sign-extend it. */
558 av_log(s->avctx, AV_LOG_ERROR, "bap %d is invalid in plain AC-3\n", bap);
561 mantissa = (unsigned)get_sbits(gbc, quantization_tab[bap]) << (24 - quantization_tab[bap]);
564 coeffs[freq] = mantissa >> exps[freq];
569 * Remove random dithering from coupling range coefficients with zero-bit
570 * mantissas for coupled channels which do not use dithering.
571 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
573 static void remove_dithering(AC3DecodeContext *s) {
576 for (ch = 1; ch <= s->fbw_channels; ch++) {
577 if (!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
578 for (i = s->start_freq[CPL_CH]; i < s->end_freq[CPL_CH]; i++) {
579 if (!s->bap[CPL_CH][i])
580 s->fixed_coeffs[ch][i] = 0;
586 static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,
589 if (!s->channel_uses_aht[ch]) {
590 ac3_decode_transform_coeffs_ch(s, ch, m);
592 /* if AHT is used, mantissas for all blocks are encoded in the first
593 block of the frame. */
595 if (CONFIG_EAC3_DECODER && !blk)
596 ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
597 for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
598 s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
604 * Decode the transform coefficients.
606 static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
612 m.b1 = m.b2 = m.b4 = 0;
614 for (ch = 1; ch <= s->channels; ch++) {
615 /* transform coefficients for full-bandwidth channel */
616 decode_transform_coeffs_ch(s, blk, ch, &m);
617 /* transform coefficients for coupling channel come right after the
618 coefficients for the first coupled channel*/
619 if (s->channel_in_cpl[ch]) {
621 decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
622 calc_transform_coeffs_cpl(s);
625 end = s->end_freq[CPL_CH];
627 end = s->end_freq[ch];
630 s->fixed_coeffs[ch][end] = 0;
634 /* zero the dithered coefficients for appropriate channels */
639 * Stereo rematrixing.
640 * reference: Section 7.5.4 Rematrixing : Decoding Technique
642 static void do_rematrixing(AC3DecodeContext *s)
647 end = FFMIN(s->end_freq[1], s->end_freq[2]);
649 for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) {
650 if (s->rematrixing_flags[bnd]) {
651 bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd + 1]);
652 for (i = ff_ac3_rematrix_band_tab[bnd]; i < bndend; i++) {
653 int tmp0 = s->fixed_coeffs[1][i];
654 s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
655 s->fixed_coeffs[2][i] = tmp0 - s->fixed_coeffs[2][i];
662 * Inverse MDCT Transform.
663 * Convert frequency domain coefficients to time-domain audio samples.
664 * reference: Section 7.9.4 Transformation Equations
666 static inline void do_imdct(AC3DecodeContext *s, int channels)
670 for (ch = 1; ch <= channels; ch++) {
671 if (s->block_switch[ch]) {
673 FFTSample *x = s->tmp_output + 128;
674 for (i = 0; i < 128; i++)
675 x[i] = s->transform_coeffs[ch][2 * i];
676 s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
678 s->fdsp->vector_fmul_window_scaled(s->outptr[ch - 1], s->delay[ch - 1],
679 s->tmp_output, s->window, 128, 8);
681 s->fdsp->vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
682 s->tmp_output, s->window, 128);
684 for (i = 0; i < 128; i++)
685 x[i] = s->transform_coeffs[ch][2 * i + 1];
686 s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch - 1], x);
688 s->imdct_512.imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
690 s->fdsp->vector_fmul_window_scaled(s->outptr[ch - 1], s->delay[ch - 1],
691 s->tmp_output, s->window, 128, 8);
693 s->fdsp->vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
694 s->tmp_output, s->window, 128);
696 memcpy(s->delay[ch - 1], s->tmp_output + 128, 128 * sizeof(FFTSample));
702 * Upmix delay samples from stereo to original channel layout.
704 static void ac3_upmix_delay(AC3DecodeContext *s)
706 int channel_data_size = sizeof(s->delay[0]);
707 switch (s->channel_mode) {
708 case AC3_CHMODE_DUALMONO:
709 case AC3_CHMODE_STEREO:
710 /* upmix mono to stereo */
711 memcpy(s->delay[1], s->delay[0], channel_data_size);
713 case AC3_CHMODE_2F2R:
714 memset(s->delay[3], 0, channel_data_size);
715 case AC3_CHMODE_2F1R:
716 memset(s->delay[2], 0, channel_data_size);
718 case AC3_CHMODE_3F2R:
719 memset(s->delay[4], 0, channel_data_size);
720 case AC3_CHMODE_3F1R:
721 memset(s->delay[3], 0, channel_data_size);
723 memcpy(s->delay[2], s->delay[1], channel_data_size);
724 memset(s->delay[1], 0, channel_data_size);
730 * Decode band structure for coupling, spectral extension, or enhanced coupling.
731 * The band structure defines how many subbands are in each band. For each
732 * subband in the range, 1 means it is combined with the previous band, and 0
733 * means that it starts a new band.
735 * @param[in] gbc bit reader context
736 * @param[in] blk block number
737 * @param[in] eac3 flag to indicate E-AC-3
738 * @param[in] ecpl flag to indicate enhanced coupling
739 * @param[in] start_subband subband number for start of range
740 * @param[in] end_subband subband number for end of range
741 * @param[in] default_band_struct default band structure table
742 * @param[out] num_bands number of bands (optionally NULL)
743 * @param[out] band_sizes array containing the number of bins in each band (optionally NULL)
745 static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
746 int ecpl, int start_subband, int end_subband,
747 const uint8_t *default_band_struct,
748 int *num_bands, uint8_t *band_sizes)
750 int subbnd, bnd, n_subbands, n_bands=0;
752 uint8_t coded_band_struct[22];
753 const uint8_t *band_struct;
755 n_subbands = end_subband - start_subband;
757 /* decode band structure from bitstream or use default */
758 if (!eac3 || get_bits1(gbc)) {
759 for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
760 coded_band_struct[subbnd] = get_bits1(gbc);
762 band_struct = coded_band_struct;
764 band_struct = &default_band_struct[start_subband+1];
766 /* no change in band structure */
770 /* calculate number of bands and band sizes based on band structure.
771 note that the first 4 subbands in enhanced coupling span only 6 bins
773 if (num_bands || band_sizes ) {
774 n_bands = n_subbands;
775 bnd_sz[0] = ecpl ? 6 : 12;
776 for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
777 int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
778 if (band_struct[subbnd - 1]) {
780 bnd_sz[bnd] += subbnd_size;
782 bnd_sz[++bnd] = subbnd_size;
787 /* set optional output params */
789 *num_bands = n_bands;
791 memcpy(band_sizes, bnd_sz, n_bands);
795 * Decode a single audio block from the AC-3 bitstream.
797 static int decode_audio_block(AC3DecodeContext *s, int blk)
799 int fbw_channels = s->fbw_channels;
800 int channel_mode = s->channel_mode;
802 int different_transforms;
805 GetBitContext *gbc = &s->gbc;
806 uint8_t bit_alloc_stages[AC3_MAX_CHANNELS] = { 0 };
808 /* block switch flags */
809 different_transforms = 0;
810 if (s->block_switch_syntax) {
811 for (ch = 1; ch <= fbw_channels; ch++) {
812 s->block_switch[ch] = get_bits1(gbc);
813 if (ch > 1 && s->block_switch[ch] != s->block_switch[1])
814 different_transforms = 1;
818 /* dithering flags */
819 if (s->dither_flag_syntax) {
820 for (ch = 1; ch <= fbw_channels; ch++) {
821 s->dither_flag[ch] = get_bits1(gbc);
826 i = !s->channel_mode;
828 if (get_bits1(gbc)) {
829 /* Allow asymmetric application of DRC when drc_scale > 1.
830 Amplification of quiet sounds is enhanced */
831 int range_bits = get_bits(gbc, 8);
832 INTFLOAT range = AC3_RANGE(range_bits);
833 if (range_bits <= 127 || s->drc_scale <= 1.0)
834 s->dynamic_range[i] = AC3_DYNAMIC_RANGE(range);
836 s->dynamic_range[i] = range;
837 } else if (blk == 0) {
838 s->dynamic_range[i] = AC3_DYNAMIC_RANGE1;
842 /* spectral extension strategy */
843 if (s->eac3 && (!blk || get_bits1(gbc))) {
844 s->spx_in_use = get_bits1(gbc);
846 int dst_start_freq, dst_end_freq, src_start_freq,
847 start_subband, end_subband;
849 /* determine which channels use spx */
850 if (s->channel_mode == AC3_CHMODE_MONO) {
851 s->channel_uses_spx[1] = 1;
853 for (ch = 1; ch <= fbw_channels; ch++)
854 s->channel_uses_spx[ch] = get_bits1(gbc);
857 /* get the frequency bins of the spx copy region and the spx start
859 dst_start_freq = get_bits(gbc, 2);
860 start_subband = get_bits(gbc, 3) + 2;
861 if (start_subband > 7)
862 start_subband += start_subband - 7;
863 end_subband = get_bits(gbc, 3) + 5;
865 s->spx_dst_end_freq = end_freq_inv_tab[end_subband-5];
868 end_subband += end_subband - 7;
869 dst_start_freq = dst_start_freq * 12 + 25;
870 src_start_freq = start_subband * 12 + 25;
871 dst_end_freq = end_subband * 12 + 25;
873 /* check validity of spx ranges */
874 if (start_subband >= end_subband) {
875 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
876 "range (%d >= %d)\n", start_subband, end_subband);
877 return AVERROR_INVALIDDATA;
879 if (dst_start_freq >= src_start_freq) {
880 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
881 "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
882 return AVERROR_INVALIDDATA;
885 s->spx_dst_start_freq = dst_start_freq;
886 s->spx_src_start_freq = src_start_freq;
888 s->spx_dst_end_freq = dst_end_freq;
890 decode_band_structure(gbc, blk, s->eac3, 0,
891 start_subband, end_subband,
892 ff_eac3_default_spx_band_struct,
896 for (ch = 1; ch <= fbw_channels; ch++) {
897 s->channel_uses_spx[ch] = 0;
898 s->first_spx_coords[ch] = 1;
903 /* spectral extension coordinates */
905 for (ch = 1; ch <= fbw_channels; ch++) {
906 if (s->channel_uses_spx[ch]) {
907 if (s->first_spx_coords[ch] || get_bits1(gbc)) {
909 int bin, master_spx_coord;
911 s->first_spx_coords[ch] = 0;
912 spx_blend = AC3_SPX_BLEND(get_bits(gbc, 5));
913 master_spx_coord = get_bits(gbc, 2) * 3;
915 bin = s->spx_src_start_freq;
916 for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
917 int bandsize = s->spx_band_sizes[bnd];
918 int spx_coord_exp, spx_coord_mant;
919 INTFLOAT nratio, sblend, nblend;
921 /* calculate blending factors */
922 int64_t accu = ((bin << 23) + (bandsize << 22))
923 * (int64_t)s->spx_dst_end_freq;
924 nratio = (int)(accu >> 32);
925 nratio -= spx_blend << 18;
930 } else if (nratio > 0x7fffff) {
931 nblend = 14529495; // sqrt(3) in FP.23
934 nblend = fixed_sqrt(nratio, 23);
935 accu = (int64_t)nblend * 1859775393;
936 nblend = (int)((accu + (1<<29)) >> 30);
937 sblend = fixed_sqrt(0x800000 - nratio, 23);
942 /* calculate blending factors */
943 nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
944 nratio = av_clipf(nratio, 0.0f, 1.0f);
945 nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
946 // to give unity variance
947 sblend = sqrtf(1.0f - nratio);
951 /* decode spx coordinates */
952 spx_coord_exp = get_bits(gbc, 4);
953 spx_coord_mant = get_bits(gbc, 2);
954 if (spx_coord_exp == 15) spx_coord_mant <<= 1;
955 else spx_coord_mant += 4;
956 spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
958 /* multiply noise and signal blending factors by spx coordinate */
960 accu = (int64_t)nblend * spx_coord_mant;
961 s->spx_noise_blend[ch][bnd] = (int)((accu + (1<<22)) >> 23);
962 accu = (int64_t)sblend * spx_coord_mant;
963 s->spx_signal_blend[ch][bnd] = (int)((accu + (1<<22)) >> 23);
965 spx_coord = spx_coord_mant * (1.0f / (1 << 23));
966 s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
967 s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
972 s->first_spx_coords[ch] = 1;
977 /* coupling strategy */
978 if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
979 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
981 s->cpl_in_use[blk] = get_bits1(gbc);
982 if (s->cpl_in_use[blk]) {
983 /* coupling in use */
984 int cpl_start_subband, cpl_end_subband;
986 if (channel_mode < AC3_CHMODE_STEREO) {
987 av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
988 return AVERROR_INVALIDDATA;
991 /* check for enhanced coupling */
992 if (s->eac3 && get_bits1(gbc)) {
993 /* TODO: parse enhanced coupling strategy info */
994 avpriv_request_sample(s->avctx, "Enhanced coupling");
995 return AVERROR_PATCHWELCOME;
998 /* determine which channels are coupled */
999 if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
1000 s->channel_in_cpl[1] = 1;
1001 s->channel_in_cpl[2] = 1;
1003 for (ch = 1; ch <= fbw_channels; ch++)
1004 s->channel_in_cpl[ch] = get_bits1(gbc);
1007 /* phase flags in use */
1008 if (channel_mode == AC3_CHMODE_STEREO)
1009 s->phase_flags_in_use = get_bits1(gbc);
1011 /* coupling frequency range */
1012 cpl_start_subband = get_bits(gbc, 4);
1013 cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
1014 get_bits(gbc, 4) + 3;
1015 if (cpl_start_subband >= cpl_end_subband) {
1016 av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
1017 cpl_start_subband, cpl_end_subband);
1018 return AVERROR_INVALIDDATA;
1020 s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
1021 s->end_freq[CPL_CH] = cpl_end_subband * 12 + 37;
1023 decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
1025 ff_eac3_default_cpl_band_struct,
1026 &s->num_cpl_bands, s->cpl_band_sizes);
1028 /* coupling not in use */
1029 for (ch = 1; ch <= fbw_channels; ch++) {
1030 s->channel_in_cpl[ch] = 0;
1031 s->first_cpl_coords[ch] = 1;
1033 s->first_cpl_leak = s->eac3;
1034 s->phase_flags_in_use = 0;
1036 } else if (!s->eac3) {
1038 av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "
1039 "be present in block 0\n");
1040 return AVERROR_INVALIDDATA;
1042 s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
1045 cpl_in_use = s->cpl_in_use[blk];
1047 /* coupling coordinates */
1049 int cpl_coords_exist = 0;
1051 for (ch = 1; ch <= fbw_channels; ch++) {
1052 if (s->channel_in_cpl[ch]) {
1053 if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
1054 int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
1055 s->first_cpl_coords[ch] = 0;
1056 cpl_coords_exist = 1;
1057 master_cpl_coord = 3 * get_bits(gbc, 2);
1058 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1059 cpl_coord_exp = get_bits(gbc, 4);
1060 cpl_coord_mant = get_bits(gbc, 4);
1061 if (cpl_coord_exp == 15)
1062 s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
1064 s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
1065 s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
1068 av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
1069 "be present in block 0\n");
1070 return AVERROR_INVALIDDATA;
1073 /* channel not in coupling */
1074 s->first_cpl_coords[ch] = 1;
1078 if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
1079 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1080 s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
1085 /* stereo rematrixing strategy and band structure */
1086 if (channel_mode == AC3_CHMODE_STEREO) {
1087 if ((s->eac3 && !blk) || get_bits1(gbc)) {
1088 s->num_rematrixing_bands = 4;
1089 if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
1090 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
1091 } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
1092 s->num_rematrixing_bands--;
1094 for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
1095 s->rematrixing_flags[bnd] = get_bits1(gbc);
1097 av_log(s->avctx, AV_LOG_WARNING, "Warning: "
1098 "new rematrixing strategy not present in block 0\n");
1099 s->num_rematrixing_bands = 0;
1103 /* exponent strategies for each channel */
1104 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1106 s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
1107 if (s->exp_strategy[blk][ch] != EXP_REUSE)
1108 bit_alloc_stages[ch] = 3;
1111 /* channel bandwidth */
1112 for (ch = 1; ch <= fbw_channels; ch++) {
1113 s->start_freq[ch] = 0;
1114 if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1116 int prev = s->end_freq[ch];
1117 if (s->channel_in_cpl[ch])
1118 s->end_freq[ch] = s->start_freq[CPL_CH];
1119 else if (s->channel_uses_spx[ch])
1120 s->end_freq[ch] = s->spx_src_start_freq;
1122 int bandwidth_code = get_bits(gbc, 6);
1123 if (bandwidth_code > 60) {
1124 av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1125 return AVERROR_INVALIDDATA;
1127 s->end_freq[ch] = bandwidth_code * 3 + 73;
1129 group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1130 s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
1131 if (blk > 0 && s->end_freq[ch] != prev)
1132 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1135 if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1136 s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
1137 (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1140 /* decode exponents for each channel */
1141 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1142 if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1143 s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1144 if (decode_exponents(gbc, s->exp_strategy[blk][ch],
1145 s->num_exp_groups[ch], s->dexps[ch][0],
1146 &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1147 av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
1148 return AVERROR_INVALIDDATA;
1150 if (ch != CPL_CH && ch != s->lfe_ch)
1151 skip_bits(gbc, 2); /* skip gainrng */
1155 /* bit allocation information */
1156 if (s->bit_allocation_syntax) {
1157 if (get_bits1(gbc)) {
1158 s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1159 s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1160 s->bit_alloc_params.slow_gain = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
1161 s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
1162 s->bit_alloc_params.floor = ff_ac3_floor_tab[get_bits(gbc, 3)];
1163 for (ch = !cpl_in_use; ch <= s->channels; ch++)
1164 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1166 av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must "
1167 "be present in block 0\n");
1168 return AVERROR_INVALIDDATA;
1172 /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1173 if (!s->eac3 || !blk) {
1174 if (s->snr_offset_strategy && get_bits1(gbc)) {
1177 csnr = (get_bits(gbc, 6) - 15) << 4;
1178 for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1180 if (ch == i || s->snr_offset_strategy == 2)
1181 snr = (csnr + get_bits(gbc, 4)) << 2;
1182 /* run at least last bit allocation stage if snr offset changes */
1183 if (blk && s->snr_offset[ch] != snr) {
1184 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1186 s->snr_offset[ch] = snr;
1188 /* fast gain (normal AC-3 only) */
1190 int prev = s->fast_gain[ch];
1191 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1192 /* run last 2 bit allocation stages if fast gain changes */
1193 if (blk && prev != s->fast_gain[ch])
1194 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1197 } else if (!s->eac3 && !blk) {
1198 av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1199 return AVERROR_INVALIDDATA;
1203 /* fast gain (E-AC-3 only) */
1204 if (s->fast_gain_syntax && get_bits1(gbc)) {
1205 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1206 int prev = s->fast_gain[ch];
1207 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1208 /* run last 2 bit allocation stages if fast gain changes */
1209 if (blk && prev != s->fast_gain[ch])
1210 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1212 } else if (s->eac3 && !blk) {
1213 for (ch = !cpl_in_use; ch <= s->channels; ch++)
1214 s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1217 /* E-AC-3 to AC-3 converter SNR offset */
1218 if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1219 skip_bits(gbc, 10); // skip converter snr offset
1222 /* coupling leak information */
1224 if (s->first_cpl_leak || get_bits1(gbc)) {
1225 int fl = get_bits(gbc, 3);
1226 int sl = get_bits(gbc, 3);
1227 /* run last 2 bit allocation stages for coupling channel if
1228 coupling leak changes */
1229 if (blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1230 sl != s->bit_alloc_params.cpl_slow_leak)) {
1231 bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1233 s->bit_alloc_params.cpl_fast_leak = fl;
1234 s->bit_alloc_params.cpl_slow_leak = sl;
1235 } else if (!s->eac3 && !blk) {
1236 av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must "
1237 "be present in block 0\n");
1238 return AVERROR_INVALIDDATA;
1240 s->first_cpl_leak = 0;
1243 /* delta bit allocation information */
1244 if (s->dba_syntax && get_bits1(gbc)) {
1245 /* delta bit allocation exists (strategy) */
1246 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1247 s->dba_mode[ch] = get_bits(gbc, 2);
1248 if (s->dba_mode[ch] == DBA_RESERVED) {
1249 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1250 return AVERROR_INVALIDDATA;
1252 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1254 /* channel delta offset, len and bit allocation */
1255 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1256 if (s->dba_mode[ch] == DBA_NEW) {
1257 s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;
1258 for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
1259 s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1260 s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1261 s->dba_values[ch][seg] = get_bits(gbc, 3);
1263 /* run last 2 bit allocation stages if new dba values */
1264 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1267 } else if (blk == 0) {
1268 for (ch = 0; ch <= s->channels; ch++) {
1269 s->dba_mode[ch] = DBA_NONE;
1273 /* Bit allocation */
1274 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1275 if (bit_alloc_stages[ch] > 2) {
1276 /* Exponent mapping into PSD and PSD integration */
1277 ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
1278 s->start_freq[ch], s->end_freq[ch],
1279 s->psd[ch], s->band_psd[ch]);
1281 if (bit_alloc_stages[ch] > 1) {
1282 /* Compute excitation function, Compute masking curve, and
1283 Apply delta bit allocation */
1284 if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1285 s->start_freq[ch], s->end_freq[ch],
1286 s->fast_gain[ch], (ch == s->lfe_ch),
1287 s->dba_mode[ch], s->dba_nsegs[ch],
1288 s->dba_offsets[ch], s->dba_lengths[ch],
1289 s->dba_values[ch], s->mask[ch])) {
1290 av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1291 return AVERROR_INVALIDDATA;
1294 if (bit_alloc_stages[ch] > 0) {
1295 /* Compute bit allocation */
1296 const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1297 ff_eac3_hebap_tab : ff_ac3_bap_tab;
1298 s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1299 s->start_freq[ch], s->end_freq[ch],
1301 s->bit_alloc_params.floor,
1302 bap_tab, s->bap[ch]);
1306 /* unused dummy data */
1307 if (s->skip_syntax && get_bits1(gbc)) {
1308 int skipl = get_bits(gbc, 9);
1313 /* unpack the transform coefficients
1314 this also uncouples channels if coupling is in use. */
1315 decode_transform_coeffs(s, blk);
1317 /* TODO: generate enhanced coupling coordinates and uncouple */
1319 /* recover coefficients if rematrixing is in use */
1320 if (s->channel_mode == AC3_CHMODE_STEREO)
1323 /* apply scaling to coefficients (headroom, dynrng) */
1324 for (ch = 1; ch <= s->channels; ch++) {
1325 int audio_channel = 0;
1327 if (s->channel_mode == AC3_CHMODE_DUALMONO)
1328 audio_channel = 2-ch;
1329 if (s->heavy_compression && s->compression_exists[audio_channel])
1330 gain = s->heavy_dynamic_range[audio_channel];
1332 gain = s->dynamic_range[audio_channel];
1335 scale_coefs(s->transform_coeffs[ch], s->fixed_coeffs[ch], gain, 256);
1337 if (s->target_level != 0)
1338 gain = gain * s->level_gain[audio_channel];
1339 gain *= 1.0 / 4194304.0f;
1340 s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch],
1341 s->fixed_coeffs[ch], gain, 256);
1345 /* apply spectral extension to high frequency bins */
1346 if (CONFIG_EAC3_DECODER && s->spx_in_use) {
1347 ff_eac3_apply_spectral_extension(s);
1350 /* downmix and MDCT. order depends on whether block switching is used for
1351 any channel in this block. this is because coefficients for the long
1352 and short transforms cannot be mixed. */
1353 downmix_output = s->channels != s->out_channels &&
1354 !((s->output_mode & AC3_OUTPUT_LFEON) &&
1355 s->fbw_channels == s->out_channels);
1356 if (different_transforms) {
1357 /* the delay samples have already been downmixed, so we upmix the delay
1358 samples in order to reconstruct all channels before downmixing. */
1364 do_imdct(s, s->channels);
1366 if (downmix_output) {
1368 ac3_downmix_c_fixed16(s->outptr, s->downmix_coeffs,
1369 s->out_channels, s->fbw_channels, 256);
1371 s->ac3dsp.downmix(s->outptr, s->downmix_coeffs,
1372 s->out_channels, s->fbw_channels, 256);
1376 if (downmix_output) {
1377 s->ac3dsp.AC3_RENAME(downmix)(s->xcfptr + 1, s->downmix_coeffs,
1378 s->out_channels, s->fbw_channels, 256);
1381 if (downmix_output && !s->downmixed) {
1383 s->ac3dsp.AC3_RENAME(downmix)(s->dlyptr, s->downmix_coeffs,
1384 s->out_channels, s->fbw_channels, 128);
1387 do_imdct(s, s->out_channels);
1394 * Decode a single AC-3 frame.
1396 static int ac3_decode_frame(AVCodecContext * avctx, void *data,
1397 int *got_frame_ptr, AVPacket *avpkt)
1399 AVFrame *frame = data;
1400 const uint8_t *buf = avpkt->data;
1401 int buf_size = avpkt->size;
1402 AC3DecodeContext *s = avctx->priv_data;
1403 int blk, ch, err, ret;
1404 const uint8_t *channel_map;
1405 const SHORTFLOAT *output[AC3_MAX_CHANNELS];
1406 enum AVMatrixEncoding matrix_encoding;
1407 AVDownmixInfo *downmix_info;
1409 /* copy input buffer to decoder context to avoid reading past the end
1410 of the buffer, which can be caused by a damaged input stream. */
1411 if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
1412 // seems to be byte-swapped AC-3
1413 int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1414 s->bdsp.bswap16_buf((uint16_t *) s->input_buffer,
1415 (const uint16_t *) buf, cnt);
1417 memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1418 buf = s->input_buffer;
1419 /* initialize the GetBitContext with the start of valid AC-3 Frame */
1420 if ((ret = init_get_bits8(&s->gbc, buf, buf_size)) < 0)
1423 /* parse the syncinfo */
1424 err = parse_frame_header(s);
1428 case AAC_AC3_PARSE_ERROR_SYNC:
1429 av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1430 return AVERROR_INVALIDDATA;
1431 case AAC_AC3_PARSE_ERROR_BSID:
1432 av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1434 case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
1435 av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1437 case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
1438 av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1440 case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
1441 /* skip frame if CRC is ok. otherwise use error concealment. */
1442 /* TODO: add support for substreams and dependent frames */
1443 if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
1444 av_log(avctx, AV_LOG_WARNING, "unsupported frame type : "
1445 "skipping frame\n");
1449 av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1452 case AAC_AC3_PARSE_ERROR_CRC:
1453 case AAC_AC3_PARSE_ERROR_CHANNEL_CFG:
1455 default: // Normal AVERROR do not try to recover.
1460 /* check that reported frame size fits in input buffer */
1461 if (s->frame_size > buf_size) {
1462 av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1463 err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
1464 } else if (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL)) {
1465 /* check for crc mismatch */
1466 if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
1467 s->frame_size - 2)) {
1468 av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1469 if (avctx->err_recognition & AV_EF_EXPLODE)
1470 return AVERROR_INVALIDDATA;
1471 err = AAC_AC3_PARSE_ERROR_CRC;
1476 /* if frame is ok, set audio parameters */
1478 avctx->sample_rate = s->sample_rate;
1479 avctx->bit_rate = s->bit_rate;
1482 /* channel config */
1483 if (!err || (s->channels && s->out_channels != s->channels)) {
1484 s->out_channels = s->channels;
1485 s->output_mode = s->channel_mode;
1487 s->output_mode |= AC3_OUTPUT_LFEON;
1488 if (s->channels > 1 &&
1489 avctx->request_channel_layout == AV_CH_LAYOUT_MONO) {
1490 s->out_channels = 1;
1491 s->output_mode = AC3_CHMODE_MONO;
1492 } else if (s->channels > 2 &&
1493 avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
1494 s->out_channels = 2;
1495 s->output_mode = AC3_CHMODE_STEREO;
1498 s->loro_center_mix_level = gain_levels[s-> center_mix_level];
1499 s->loro_surround_mix_level = gain_levels[s->surround_mix_level];
1500 s->ltrt_center_mix_level = LEVEL_MINUS_3DB;
1501 s->ltrt_surround_mix_level = LEVEL_MINUS_3DB;
1502 /* set downmixing coefficients if needed */
1503 if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1504 s->fbw_channels == s->out_channels)) {
1505 set_downmix_coeffs(s);
1507 } else if (!s->channels) {
1508 av_log(avctx, AV_LOG_ERROR, "unable to determine channel mode\n");
1509 return AVERROR_INVALIDDATA;
1511 avctx->channels = s->out_channels;
1512 avctx->channel_layout = avpriv_ac3_channel_layout_tab[s->output_mode & ~AC3_OUTPUT_LFEON];
1513 if (s->output_mode & AC3_OUTPUT_LFEON)
1514 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1516 /* set audio service type based on bitstream mode for AC-3 */
1517 avctx->audio_service_type = s->bitstream_mode;
1518 if (s->bitstream_mode == 0x7 && s->channels > 1)
1519 avctx->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
1521 /* get output buffer */
1522 frame->nb_samples = s->num_blocks * AC3_BLOCK_SIZE;
1523 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1526 /* decode the audio blocks */
1527 channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1528 for (ch = 0; ch < AC3_MAX_CHANNELS; ch++) {
1529 output[ch] = s->output[ch];
1530 s->outptr[ch] = s->output[ch];
1532 for (ch = 0; ch < s->channels; ch++) {
1533 if (ch < s->out_channels)
1534 s->outptr[channel_map[ch]] = (SHORTFLOAT *)frame->data[ch];
1536 for (blk = 0; blk < s->num_blocks; blk++) {
1537 if (!err && decode_audio_block(s, blk)) {
1538 av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1542 for (ch = 0; ch < s->out_channels; ch++)
1543 memcpy(((SHORTFLOAT*)frame->data[ch]) + AC3_BLOCK_SIZE*blk, output[ch], AC3_BLOCK_SIZE*sizeof(SHORTFLOAT));
1544 for (ch = 0; ch < s->out_channels; ch++)
1545 output[ch] = s->outptr[channel_map[ch]];
1546 for (ch = 0; ch < s->out_channels; ch++) {
1547 if (!ch || channel_map[ch])
1548 s->outptr[channel_map[ch]] += AC3_BLOCK_SIZE;
1552 av_frame_set_decode_error_flags(frame, err ? FF_DECODE_ERROR_INVALID_BITSTREAM : 0);
1554 /* keep last block for error concealment in next frame */
1555 for (ch = 0; ch < s->out_channels; ch++)
1556 memcpy(s->output[ch], output[ch], AC3_BLOCK_SIZE*sizeof(SHORTFLOAT));
1561 * Check whether the input layout is compatible, and make sure we're not
1562 * downmixing (else the matrix encoding is no longer applicable).
1564 matrix_encoding = AV_MATRIX_ENCODING_NONE;
1565 if (s->channel_mode == AC3_CHMODE_STEREO &&
1566 s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1567 if (s->dolby_surround_mode == AC3_DSURMOD_ON)
1568 matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
1569 else if (s->dolby_headphone_mode == AC3_DHEADPHONMOD_ON)
1570 matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;
1571 } else if (s->channel_mode >= AC3_CHMODE_2F2R &&
1572 s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1573 switch (s->dolby_surround_ex_mode) {
1574 case AC3_DSUREXMOD_ON: // EX or PLIIx
1575 matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
1577 case AC3_DSUREXMOD_PLIIZ:
1578 matrix_encoding = AV_MATRIX_ENCODING_DPLIIZ;
1580 default: // not indicated or off
1584 if ((ret = ff_side_data_update_matrix_encoding(frame, matrix_encoding)) < 0)
1588 if ((downmix_info = av_downmix_info_update_side_data(frame))) {
1589 switch (s->preferred_downmix) {
1590 case AC3_DMIXMOD_LTRT:
1591 downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_LTRT;
1593 case AC3_DMIXMOD_LORO:
1594 downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_LORO;
1596 case AC3_DMIXMOD_DPLII:
1597 downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_DPLII;
1600 downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_UNKNOWN;
1603 downmix_info->center_mix_level = gain_levels[s-> center_mix_level];
1604 downmix_info->center_mix_level_ltrt = gain_levels[s-> center_mix_level_ltrt];
1605 downmix_info->surround_mix_level = gain_levels[s-> surround_mix_level];
1606 downmix_info->surround_mix_level_ltrt = gain_levels[s->surround_mix_level_ltrt];
1607 if (s->lfe_mix_level_exists)
1608 downmix_info->lfe_mix_level = gain_levels_lfe[s->lfe_mix_level];
1610 downmix_info->lfe_mix_level = 0.0; // -inf dB
1612 return AVERROR(ENOMEM);
1616 return FFMIN(buf_size, s->frame_size);
1620 * Uninitialize the AC-3 decoder.
1622 static av_cold int ac3_decode_end(AVCodecContext *avctx)
1624 AC3DecodeContext *s = avctx->priv_data;
1625 ff_mdct_end(&s->imdct_512);
1626 ff_mdct_end(&s->imdct_256);
1632 #define OFFSET(x) offsetof(AC3DecodeContext, x)
1633 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)