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
67 /** dynamic range table. converts codes to scale factors. */
68 static float dynamic_range_tab[256];
69 float ff_ac3_heavy_dynamic_range_tab[256];
72 /** Adjustments in dB gain */
73 static const float gain_levels[9] = {
77 LEVEL_MINUS_1POINT5DB,
79 LEVEL_MINUS_4POINT5DB,
85 /** Adjustments in dB gain (LFE, +10 to -21 dB) */
86 static const float gain_levels_lfe[32] = {
87 3.162275, 2.818382, 2.511886, 2.238719, 1.995261, 1.778278, 1.584893,
88 1.412536, 1.258924, 1.122018, 1.000000, 0.891251, 0.794328, 0.707946,
89 0.630957, 0.562341, 0.501187, 0.446683, 0.398107, 0.354813, 0.316227,
90 0.281838, 0.251188, 0.223872, 0.199526, 0.177828, 0.158489, 0.141253,
91 0.125892, 0.112201, 0.100000, 0.089125
95 * Table for default stereo downmixing coefficients
96 * reference: Section 7.8.2 Downmixing Into Two Channels
98 static const uint8_t ac3_default_coeffs[8][5][2] = {
99 { { 2, 7 }, { 7, 2 }, },
101 { { 2, 7 }, { 7, 2 }, },
102 { { 2, 7 }, { 5, 5 }, { 7, 2 }, },
103 { { 2, 7 }, { 7, 2 }, { 6, 6 }, },
104 { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 }, },
105 { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
106 { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
110 * Symmetrical Dequantization
111 * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization
112 * Tables 7.19 to 7.23
115 symmetric_dequant(int code, int levels)
117 return ((code - (levels >> 1)) * (1 << 24)) / levels;
121 * Initialize tables at runtime.
123 static av_cold void ac3_tables_init(void)
127 /* generate table for ungrouping 3 values in 7 bits
128 reference: Section 7.1.3 Exponent Decoding */
129 for (i = 0; i < 128; i++) {
130 ungroup_3_in_7_bits_tab[i][0] = i / 25;
131 ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5;
132 ungroup_3_in_7_bits_tab[i][2] = (i % 25) % 5;
135 /* generate grouped mantissa tables
136 reference: Section 7.3.5 Ungrouping of Mantissas */
137 for (i = 0; i < 32; i++) {
138 /* bap=1 mantissas */
139 b1_mantissas[i][0] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][0], 3);
140 b1_mantissas[i][1] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][1], 3);
141 b1_mantissas[i][2] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][2], 3);
143 for (i = 0; i < 128; i++) {
144 /* bap=2 mantissas */
145 b2_mantissas[i][0] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][0], 5);
146 b2_mantissas[i][1] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][1], 5);
147 b2_mantissas[i][2] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][2], 5);
149 /* bap=4 mantissas */
150 b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
151 b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
153 /* generate ungrouped mantissa tables
154 reference: Tables 7.21 and 7.23 */
155 for (i = 0; i < 7; i++) {
156 /* bap=3 mantissas */
157 b3_mantissas[i] = symmetric_dequant(i, 7);
159 for (i = 0; i < 15; i++) {
160 /* bap=5 mantissas */
161 b5_mantissas[i] = symmetric_dequant(i, 15);
165 /* generate dynamic range table
166 reference: Section 7.7.1 Dynamic Range Control */
167 for (i = 0; i < 256; i++) {
168 int v = (i >> 5) - ((i >> 7) << 3) - 5;
169 dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
172 /* generate compr dynamic range table
173 reference: Section 7.7.2 Heavy Compression */
174 for (i = 0; i < 256; i++) {
175 int v = (i >> 4) - ((i >> 7) << 4) - 4;
176 ff_ac3_heavy_dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0xF) | 0x10);
182 * AVCodec initialization
184 static av_cold int ac3_decode_init(AVCodecContext *avctx)
186 AC3DecodeContext *s = avctx->priv_data;
192 ff_mdct_init(&s->imdct_256, 8, 1, 1.0);
193 ff_mdct_init(&s->imdct_512, 9, 1, 1.0);
194 AC3_RENAME(ff_kbd_window_init)(s->window, 5.0, 256);
195 ff_bswapdsp_init(&s->bdsp);
198 s->fdsp = avpriv_alloc_fixed_dsp(avctx->flags & AV_CODEC_FLAG_BITEXACT);
200 s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
201 ff_fmt_convert_init(&s->fmt_conv, avctx);
204 ff_ac3dsp_init(&s->ac3dsp, avctx->flags & AV_CODEC_FLAG_BITEXACT);
205 av_lfg_init(&s->dith_state, 0);
208 avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
210 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
212 /* allow downmixing to stereo or mono */
213 if (avctx->channels > 1 &&
214 avctx->request_channel_layout == AV_CH_LAYOUT_MONO)
216 else if (avctx->channels > 2 &&
217 avctx->request_channel_layout == AV_CH_LAYOUT_STEREO)
221 for (i = 0; i < AC3_MAX_CHANNELS; i++) {
222 s->xcfptr[i] = s->transform_coeffs[i];
223 s->dlyptr[i] = s->delay[i];
230 * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
231 * GetBitContext within AC3DecodeContext must point to
232 * the start of the synchronized AC-3 bitstream.
234 static int ac3_parse_header(AC3DecodeContext *s)
236 GetBitContext *gbc = &s->gbc;
239 /* read the rest of the bsi. read twice for dual mono mode. */
240 i = !s->channel_mode;
242 s->dialog_normalization[(!s->channel_mode)-i] = -get_bits(gbc, 5);
243 if (s->dialog_normalization[(!s->channel_mode)-i] == 0) {
244 s->dialog_normalization[(!s->channel_mode)-i] = -31;
246 if (s->target_level != 0) {
247 s->level_gain[(!s->channel_mode)-i] = powf(2.0f,
248 (float)(s->target_level -
249 s->dialog_normalization[(!s->channel_mode)-i])/6.0f);
251 if (s->compression_exists[(!s->channel_mode)-i] = get_bits1(gbc)) {
252 s->heavy_dynamic_range[(!s->channel_mode)-i] =
253 AC3_HEAVY_RANGE(get_bits(gbc, 8));
256 skip_bits(gbc, 8); //skip language code
258 skip_bits(gbc, 7); //skip audio production information
261 skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
263 /* skip the timecodes or parse the Alternate Bit Stream Syntax */
264 if (s->bitstream_id != 6) {
266 skip_bits(gbc, 14); //skip timecode1
268 skip_bits(gbc, 14); //skip timecode2
270 if (get_bits1(gbc)) {
271 s->preferred_downmix = get_bits(gbc, 2);
272 s->center_mix_level_ltrt = get_bits(gbc, 3);
273 s->surround_mix_level_ltrt = av_clip(get_bits(gbc, 3), 3, 7);
274 s->center_mix_level = get_bits(gbc, 3);
275 s->surround_mix_level = av_clip(get_bits(gbc, 3), 3, 7);
277 if (get_bits1(gbc)) {
278 s->dolby_surround_ex_mode = get_bits(gbc, 2);
279 s->dolby_headphone_mode = get_bits(gbc, 2);
280 skip_bits(gbc, 10); // skip adconvtyp (1), xbsi2 (8), encinfo (1)
284 /* skip additional bitstream info */
285 if (get_bits1(gbc)) {
286 i = get_bits(gbc, 6);
296 * Common function to parse AC-3 or E-AC-3 frame header
298 static int parse_frame_header(AC3DecodeContext *s)
300 AC3HeaderInfo hdr, *phdr=&hdr;
303 err = avpriv_ac3_parse_header(&s->gbc, &phdr);
307 /* get decoding parameters from header info */
308 s->bit_alloc_params.sr_code = hdr.sr_code;
309 s->bitstream_id = hdr.bitstream_id;
310 s->bitstream_mode = hdr.bitstream_mode;
311 s->channel_mode = hdr.channel_mode;
312 s->lfe_on = hdr.lfe_on;
313 s->bit_alloc_params.sr_shift = hdr.sr_shift;
314 s->sample_rate = hdr.sample_rate;
315 s->bit_rate = hdr.bit_rate;
316 s->channels = hdr.channels;
317 s->fbw_channels = s->channels - s->lfe_on;
318 s->lfe_ch = s->fbw_channels + 1;
319 s->frame_size = hdr.frame_size;
320 s->preferred_downmix = AC3_DMIXMOD_NOTINDICATED;
321 s->center_mix_level = hdr.center_mix_level;
322 s->center_mix_level_ltrt = 4; // -3.0dB
323 s->surround_mix_level = hdr.surround_mix_level;
324 s->surround_mix_level_ltrt = 4; // -3.0dB
325 s->lfe_mix_level_exists = 0;
326 s->num_blocks = hdr.num_blocks;
327 s->frame_type = hdr.frame_type;
328 s->substreamid = hdr.substreamid;
329 s->dolby_surround_mode = hdr.dolby_surround_mode;
330 s->dolby_surround_ex_mode = AC3_DSUREXMOD_NOTINDICATED;
331 s->dolby_headphone_mode = AC3_DHEADPHONMOD_NOTINDICATED;
334 s->start_freq[s->lfe_ch] = 0;
335 s->end_freq[s->lfe_ch] = 7;
336 s->num_exp_groups[s->lfe_ch] = 2;
337 s->channel_in_cpl[s->lfe_ch] = 0;
340 if (s->bitstream_id <= 10) {
342 s->snr_offset_strategy = 2;
343 s->block_switch_syntax = 1;
344 s->dither_flag_syntax = 1;
345 s->bit_allocation_syntax = 1;
346 s->fast_gain_syntax = 0;
347 s->first_cpl_leak = 0;
350 memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
351 return ac3_parse_header(s);
352 } else if (CONFIG_EAC3_DECODER) {
354 return ff_eac3_parse_header(s);
356 av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n");
357 return AVERROR(ENOSYS);
362 * Set stereo downmixing coefficients based on frame header info.
363 * reference: Section 7.8.2 Downmixing Into Two Channels
365 static int set_downmix_coeffs(AC3DecodeContext *s)
368 float cmix = gain_levels[s-> center_mix_level];
369 float smix = gain_levels[s->surround_mix_level];
371 float downmix_coeffs[2][AC3_MAX_CHANNELS];
373 if (!s->downmix_coeffs[0]) {
374 s->downmix_coeffs[0] = av_malloc_array(2 * AC3_MAX_CHANNELS,
375 sizeof(**s->downmix_coeffs));
376 if (!s->downmix_coeffs[0])
377 return AVERROR(ENOMEM);
378 s->downmix_coeffs[1] = s->downmix_coeffs[0] + AC3_MAX_CHANNELS;
381 for (i = 0; i < s->fbw_channels; i++) {
382 downmix_coeffs[0][i] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
383 downmix_coeffs[1][i] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
385 if (s->channel_mode > 1 && s->channel_mode & 1) {
386 downmix_coeffs[0][1] = downmix_coeffs[1][1] = cmix;
388 if (s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
389 int nf = s->channel_mode - 2;
390 downmix_coeffs[0][nf] = downmix_coeffs[1][nf] = smix * LEVEL_MINUS_3DB;
392 if (s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
393 int nf = s->channel_mode - 4;
394 downmix_coeffs[0][nf] = downmix_coeffs[1][nf+1] = smix;
399 for (i = 0; i < s->fbw_channels; i++) {
400 norm0 += downmix_coeffs[0][i];
401 norm1 += downmix_coeffs[1][i];
403 norm0 = 1.0f / norm0;
404 norm1 = 1.0f / norm1;
405 for (i = 0; i < s->fbw_channels; i++) {
406 downmix_coeffs[0][i] *= norm0;
407 downmix_coeffs[1][i] *= norm1;
410 if (s->output_mode == AC3_CHMODE_MONO) {
411 for (i = 0; i < s->fbw_channels; i++)
412 downmix_coeffs[0][i] = (downmix_coeffs[0][i] +
413 downmix_coeffs[1][i]) * LEVEL_MINUS_3DB;
415 for (i = 0; i < s->fbw_channels; i++) {
416 s->downmix_coeffs[0][i] = FIXR12(downmix_coeffs[0][i]);
417 s->downmix_coeffs[1][i] = FIXR12(downmix_coeffs[1][i]);
424 * Decode the grouped exponents according to exponent strategy.
425 * reference: Section 7.1.3 Exponent Decoding
427 static int decode_exponents(AC3DecodeContext *s,
428 GetBitContext *gbc, int exp_strategy, int ngrps,
429 uint8_t absexp, int8_t *dexps)
431 int i, j, grp, group_size;
436 group_size = exp_strategy + (exp_strategy == EXP_D45);
437 for (grp = 0, i = 0; grp < ngrps; grp++) {
438 expacc = get_bits(gbc, 7);
440 av_log(s->avctx, AV_LOG_ERROR, "expacc %d is out-of-range\n", expacc);
441 return AVERROR_INVALIDDATA;
443 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
444 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
445 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
448 /* convert to absolute exps and expand groups */
450 for (i = 0, j = 0; i < ngrps * 3; i++) {
451 prevexp += dexp[i] - 2;
453 av_log(s->avctx, AV_LOG_ERROR, "exponent %d is out-of-range\n", prevexp);
456 switch (group_size) {
457 case 4: dexps[j++] = prevexp;
458 dexps[j++] = prevexp;
459 case 2: dexps[j++] = prevexp;
460 case 1: dexps[j++] = prevexp;
467 * Generate transform coefficients for each coupled channel in the coupling
468 * range using the coupling coefficients and coupling coordinates.
469 * reference: Section 7.4.3 Coupling Coordinate Format
471 static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
475 bin = s->start_freq[CPL_CH];
476 for (band = 0; band < s->num_cpl_bands; band++) {
477 int band_start = bin;
478 int band_end = bin + s->cpl_band_sizes[band];
479 for (ch = 1; ch <= s->fbw_channels; ch++) {
480 if (s->channel_in_cpl[ch]) {
481 int cpl_coord = s->cpl_coords[ch][band] << 5;
482 for (bin = band_start; bin < band_end; bin++) {
483 s->fixed_coeffs[ch][bin] =
484 MULH(s->fixed_coeffs[CPL_CH][bin] * (1 << 4), cpl_coord);
486 if (ch == 2 && s->phase_flags[band]) {
487 for (bin = band_start; bin < band_end; bin++)
488 s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin];
497 * Grouped mantissas for 3-level 5-level and 11-level quantization
499 typedef struct mant_groups {
509 * Decode the transform coefficients for a particular channel
510 * reference: Section 7.3 Quantization and Decoding of Mantissas
512 static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
514 int start_freq = s->start_freq[ch_index];
515 int end_freq = s->end_freq[ch_index];
516 uint8_t *baps = s->bap[ch_index];
517 int8_t *exps = s->dexps[ch_index];
518 int32_t *coeffs = s->fixed_coeffs[ch_index];
519 int dither = (ch_index == CPL_CH) || s->dither_flag[ch_index];
520 GetBitContext *gbc = &s->gbc;
523 for (freq = start_freq; freq < end_freq; freq++) {
524 int bap = baps[freq];
528 /* random noise with approximate range of -0.707 to 0.707 */
530 mantissa = (((av_lfg_get(&s->dith_state)>>8)*181)>>8) - 5931008;
537 mantissa = m->b1_mant[m->b1];
539 int bits = get_bits(gbc, 5);
540 mantissa = b1_mantissas[bits][0];
541 m->b1_mant[1] = b1_mantissas[bits][1];
542 m->b1_mant[0] = b1_mantissas[bits][2];
549 mantissa = m->b2_mant[m->b2];
551 int bits = get_bits(gbc, 7);
552 mantissa = b2_mantissas[bits][0];
553 m->b2_mant[1] = b2_mantissas[bits][1];
554 m->b2_mant[0] = b2_mantissas[bits][2];
559 mantissa = b3_mantissas[get_bits(gbc, 3)];
564 mantissa = m->b4_mant;
566 int bits = get_bits(gbc, 7);
567 mantissa = b4_mantissas[bits][0];
568 m->b4_mant = b4_mantissas[bits][1];
573 mantissa = b5_mantissas[get_bits(gbc, 4)];
575 default: /* 6 to 15 */
576 /* Shift mantissa and sign-extend it. */
578 av_log(s->avctx, AV_LOG_ERROR, "bap %d is invalid in plain AC-3\n", bap);
581 mantissa = (unsigned)get_sbits(gbc, quantization_tab[bap]) << (24 - quantization_tab[bap]);
584 coeffs[freq] = mantissa >> exps[freq];
589 * Remove random dithering from coupling range coefficients with zero-bit
590 * mantissas for coupled channels which do not use dithering.
591 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
593 static void remove_dithering(AC3DecodeContext *s) {
596 for (ch = 1; ch <= s->fbw_channels; ch++) {
597 if (!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
598 for (i = s->start_freq[CPL_CH]; i < s->end_freq[CPL_CH]; i++) {
599 if (!s->bap[CPL_CH][i])
600 s->fixed_coeffs[ch][i] = 0;
606 static inline void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk,
607 int ch, mant_groups *m)
609 if (!s->channel_uses_aht[ch]) {
610 ac3_decode_transform_coeffs_ch(s, ch, m);
612 /* if AHT is used, mantissas for all blocks are encoded in the first
613 block of the frame. */
615 if (CONFIG_EAC3_DECODER && !blk)
616 ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
617 for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
618 s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
624 * Decode the transform coefficients.
626 static inline void decode_transform_coeffs(AC3DecodeContext *s, int blk)
632 m.b1 = m.b2 = m.b4 = 0;
634 for (ch = 1; ch <= s->channels; ch++) {
635 /* transform coefficients for full-bandwidth channel */
636 decode_transform_coeffs_ch(s, blk, ch, &m);
637 /* transform coefficients for coupling channel come right after the
638 coefficients for the first coupled channel*/
639 if (s->channel_in_cpl[ch]) {
641 decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
642 calc_transform_coeffs_cpl(s);
645 end = s->end_freq[CPL_CH];
647 end = s->end_freq[ch];
650 s->fixed_coeffs[ch][end] = 0;
654 /* zero the dithered coefficients for appropriate channels */
659 * Stereo rematrixing.
660 * reference: Section 7.5.4 Rematrixing : Decoding Technique
662 static void do_rematrixing(AC3DecodeContext *s)
667 end = FFMIN(s->end_freq[1], s->end_freq[2]);
669 for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) {
670 if (s->rematrixing_flags[bnd]) {
671 bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd + 1]);
672 for (i = ff_ac3_rematrix_band_tab[bnd]; i < bndend; i++) {
673 int tmp0 = s->fixed_coeffs[1][i];
674 s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
675 s->fixed_coeffs[2][i] = tmp0 - s->fixed_coeffs[2][i];
682 * Inverse MDCT Transform.
683 * Convert frequency domain coefficients to time-domain audio samples.
684 * reference: Section 7.9.4 Transformation Equations
686 static inline void do_imdct(AC3DecodeContext *s, int channels)
690 for (ch = 1; ch <= channels; ch++) {
691 if (s->block_switch[ch]) {
693 FFTSample *x = s->tmp_output + 128;
694 for (i = 0; i < 128; i++)
695 x[i] = s->transform_coeffs[ch][2 * i];
696 s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
698 s->fdsp->vector_fmul_window_scaled(s->outptr[ch - 1], s->delay[ch - 1],
699 s->tmp_output, s->window, 128, 8);
701 s->fdsp->vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
702 s->tmp_output, s->window, 128);
704 for (i = 0; i < 128; i++)
705 x[i] = s->transform_coeffs[ch][2 * i + 1];
706 s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch - 1], x);
708 s->imdct_512.imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
710 s->fdsp->vector_fmul_window_scaled(s->outptr[ch - 1], s->delay[ch - 1],
711 s->tmp_output, s->window, 128, 8);
713 s->fdsp->vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
714 s->tmp_output, s->window, 128);
716 memcpy(s->delay[ch - 1], s->tmp_output + 128, 128 * sizeof(FFTSample));
722 * Upmix delay samples from stereo to original channel layout.
724 static void ac3_upmix_delay(AC3DecodeContext *s)
726 int channel_data_size = sizeof(s->delay[0]);
727 switch (s->channel_mode) {
728 case AC3_CHMODE_DUALMONO:
729 case AC3_CHMODE_STEREO:
730 /* upmix mono to stereo */
731 memcpy(s->delay[1], s->delay[0], channel_data_size);
733 case AC3_CHMODE_2F2R:
734 memset(s->delay[3], 0, channel_data_size);
735 case AC3_CHMODE_2F1R:
736 memset(s->delay[2], 0, channel_data_size);
738 case AC3_CHMODE_3F2R:
739 memset(s->delay[4], 0, channel_data_size);
740 case AC3_CHMODE_3F1R:
741 memset(s->delay[3], 0, channel_data_size);
743 memcpy(s->delay[2], s->delay[1], channel_data_size);
744 memset(s->delay[1], 0, channel_data_size);
750 * Decode band structure for coupling, spectral extension, or enhanced coupling.
751 * The band structure defines how many subbands are in each band. For each
752 * subband in the range, 1 means it is combined with the previous band, and 0
753 * means that it starts a new band.
755 * @param[in] gbc bit reader context
756 * @param[in] blk block number
757 * @param[in] eac3 flag to indicate E-AC-3
758 * @param[in] ecpl flag to indicate enhanced coupling
759 * @param[in] start_subband subband number for start of range
760 * @param[in] end_subband subband number for end of range
761 * @param[in] default_band_struct default band structure table
762 * @param[out] num_bands number of bands (optionally NULL)
763 * @param[out] band_sizes array containing the number of bins in each band (optionally NULL)
765 static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
766 int ecpl, int start_subband, int end_subband,
767 const uint8_t *default_band_struct,
768 int *num_bands, uint8_t *band_sizes)
770 int subbnd, bnd, n_subbands, n_bands=0;
772 uint8_t coded_band_struct[22];
773 const uint8_t *band_struct;
775 n_subbands = end_subband - start_subband;
777 /* decode band structure from bitstream or use default */
778 if (!eac3 || get_bits1(gbc)) {
779 for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
780 coded_band_struct[subbnd] = get_bits1(gbc);
782 band_struct = coded_band_struct;
784 band_struct = &default_band_struct[start_subband+1];
786 /* no change in band structure */
790 /* calculate number of bands and band sizes based on band structure.
791 note that the first 4 subbands in enhanced coupling span only 6 bins
793 if (num_bands || band_sizes ) {
794 n_bands = n_subbands;
795 bnd_sz[0] = ecpl ? 6 : 12;
796 for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
797 int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
798 if (band_struct[subbnd - 1]) {
800 bnd_sz[bnd] += subbnd_size;
802 bnd_sz[++bnd] = subbnd_size;
807 /* set optional output params */
809 *num_bands = n_bands;
811 memcpy(band_sizes, bnd_sz, n_bands);
814 static inline int spx_strategy(AC3DecodeContext *s, int blk)
816 GetBitContext *bc = &s->gbc;
817 int fbw_channels = s->fbw_channels;
818 int dst_start_freq, dst_end_freq, src_start_freq,
819 start_subband, end_subband, ch;
821 /* determine which channels use spx */
822 if (s->channel_mode == AC3_CHMODE_MONO) {
823 s->channel_uses_spx[1] = 1;
825 for (ch = 1; ch <= fbw_channels; ch++)
826 s->channel_uses_spx[ch] = get_bits1(bc);
829 /* get the frequency bins of the spx copy region and the spx start
831 dst_start_freq = get_bits(bc, 2);
832 start_subband = get_bits(bc, 3) + 2;
833 if (start_subband > 7)
834 start_subband += start_subband - 7;
835 end_subband = get_bits(bc, 3) + 5;
837 s->spx_dst_end_freq = end_freq_inv_tab[end_subband-5];
840 end_subband += end_subband - 7;
841 dst_start_freq = dst_start_freq * 12 + 25;
842 src_start_freq = start_subband * 12 + 25;
843 dst_end_freq = end_subband * 12 + 25;
845 /* check validity of spx ranges */
846 if (start_subband >= end_subband) {
847 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
848 "range (%d >= %d)\n", start_subband, end_subband);
849 return AVERROR_INVALIDDATA;
851 if (dst_start_freq >= src_start_freq) {
852 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
853 "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
854 return AVERROR_INVALIDDATA;
857 s->spx_dst_start_freq = dst_start_freq;
858 s->spx_src_start_freq = src_start_freq;
860 s->spx_dst_end_freq = dst_end_freq;
862 decode_band_structure(bc, blk, s->eac3, 0,
863 start_subband, end_subband,
864 ff_eac3_default_spx_band_struct,
870 static inline void spx_coordinates(AC3DecodeContext *s)
872 GetBitContext *bc = &s->gbc;
873 int fbw_channels = s->fbw_channels;
876 for (ch = 1; ch <= fbw_channels; ch++) {
877 if (s->channel_uses_spx[ch]) {
878 if (s->first_spx_coords[ch] || get_bits1(bc)) {
880 int bin, master_spx_coord;
882 s->first_spx_coords[ch] = 0;
883 spx_blend = AC3_SPX_BLEND(get_bits(bc, 5));
884 master_spx_coord = get_bits(bc, 2) * 3;
886 bin = s->spx_src_start_freq;
887 for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
888 int bandsize = s->spx_band_sizes[bnd];
889 int spx_coord_exp, spx_coord_mant;
890 INTFLOAT nratio, sblend, nblend;
892 /* calculate blending factors */
893 int64_t accu = ((bin << 23) + (bandsize << 22))
894 * (int64_t)s->spx_dst_end_freq;
895 nratio = (int)(accu >> 32);
896 nratio -= spx_blend << 18;
901 } else if (nratio > 0x7fffff) {
902 nblend = 14529495; // sqrt(3) in FP.23
905 nblend = fixed_sqrt(nratio, 23);
906 accu = (int64_t)nblend * 1859775393;
907 nblend = (int)((accu + (1<<29)) >> 30);
908 sblend = fixed_sqrt(0x800000 - nratio, 23);
913 /* calculate blending factors */
914 nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
915 nratio = av_clipf(nratio, 0.0f, 1.0f);
916 nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
917 // to give unity variance
918 sblend = sqrtf(1.0f - nratio);
922 /* decode spx coordinates */
923 spx_coord_exp = get_bits(bc, 4);
924 spx_coord_mant = get_bits(bc, 2);
925 if (spx_coord_exp == 15) spx_coord_mant <<= 1;
926 else spx_coord_mant += 4;
927 spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
929 /* multiply noise and signal blending factors by spx coordinate */
931 accu = (int64_t)nblend * spx_coord_mant;
932 s->spx_noise_blend[ch][bnd] = (int)((accu + (1<<22)) >> 23);
933 accu = (int64_t)sblend * spx_coord_mant;
934 s->spx_signal_blend[ch][bnd] = (int)((accu + (1<<22)) >> 23);
936 spx_coord = spx_coord_mant * (1.0f / (1 << 23));
937 s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
938 s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
943 s->first_spx_coords[ch] = 1;
948 static inline int coupling_strategy(AC3DecodeContext *s, int blk,
949 uint8_t *bit_alloc_stages)
951 GetBitContext *bc = &s->gbc;
952 int fbw_channels = s->fbw_channels;
953 int channel_mode = s->channel_mode;
956 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
958 s->cpl_in_use[blk] = get_bits1(bc);
959 if (s->cpl_in_use[blk]) {
960 /* coupling in use */
961 int cpl_start_subband, cpl_end_subband;
963 if (channel_mode < AC3_CHMODE_STEREO) {
964 av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
965 return AVERROR_INVALIDDATA;
968 /* check for enhanced coupling */
969 if (s->eac3 && get_bits1(bc)) {
970 /* TODO: parse enhanced coupling strategy info */
971 avpriv_request_sample(s->avctx, "Enhanced coupling");
972 return AVERROR_PATCHWELCOME;
975 /* determine which channels are coupled */
976 if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
977 s->channel_in_cpl[1] = 1;
978 s->channel_in_cpl[2] = 1;
980 for (ch = 1; ch <= fbw_channels; ch++)
981 s->channel_in_cpl[ch] = get_bits1(bc);
984 /* phase flags in use */
985 if (channel_mode == AC3_CHMODE_STEREO)
986 s->phase_flags_in_use = get_bits1(bc);
988 /* coupling frequency range */
989 cpl_start_subband = get_bits(bc, 4);
990 cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
992 if (cpl_start_subband >= cpl_end_subband) {
993 av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
994 cpl_start_subband, cpl_end_subband);
995 return AVERROR_INVALIDDATA;
997 s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
998 s->end_freq[CPL_CH] = cpl_end_subband * 12 + 37;
1000 decode_band_structure(bc, blk, s->eac3, 0, cpl_start_subband,
1002 ff_eac3_default_cpl_band_struct,
1003 &s->num_cpl_bands, s->cpl_band_sizes);
1005 /* coupling not in use */
1006 for (ch = 1; ch <= fbw_channels; ch++) {
1007 s->channel_in_cpl[ch] = 0;
1008 s->first_cpl_coords[ch] = 1;
1010 s->first_cpl_leak = s->eac3;
1011 s->phase_flags_in_use = 0;
1017 static inline int coupling_coordinates(AC3DecodeContext *s, int blk)
1019 GetBitContext *bc = &s->gbc;
1020 int fbw_channels = s->fbw_channels;
1022 int cpl_coords_exist = 0;
1024 for (ch = 1; ch <= fbw_channels; ch++) {
1025 if (s->channel_in_cpl[ch]) {
1026 if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(bc)) {
1027 int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
1028 s->first_cpl_coords[ch] = 0;
1029 cpl_coords_exist = 1;
1030 master_cpl_coord = 3 * get_bits(bc, 2);
1031 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1032 cpl_coord_exp = get_bits(bc, 4);
1033 cpl_coord_mant = get_bits(bc, 4);
1034 if (cpl_coord_exp == 15)
1035 s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
1037 s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
1038 s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
1041 av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
1042 "be present in block 0\n");
1043 return AVERROR_INVALIDDATA;
1046 /* channel not in coupling */
1047 s->first_cpl_coords[ch] = 1;
1051 if (s->channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
1052 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1053 s->phase_flags[bnd] = s->phase_flags_in_use ? get_bits1(bc) : 0;
1061 * Decode a single audio block from the AC-3 bitstream.
1063 static int decode_audio_block(AC3DecodeContext *s, int blk)
1065 int fbw_channels = s->fbw_channels;
1066 int channel_mode = s->channel_mode;
1067 int i, bnd, seg, ch, ret;
1068 int different_transforms;
1071 GetBitContext *gbc = &s->gbc;
1072 uint8_t bit_alloc_stages[AC3_MAX_CHANNELS] = { 0 };
1074 /* block switch flags */
1075 different_transforms = 0;
1076 if (s->block_switch_syntax) {
1077 for (ch = 1; ch <= fbw_channels; ch++) {
1078 s->block_switch[ch] = get_bits1(gbc);
1079 if (ch > 1 && s->block_switch[ch] != s->block_switch[1])
1080 different_transforms = 1;
1084 /* dithering flags */
1085 if (s->dither_flag_syntax) {
1086 for (ch = 1; ch <= fbw_channels; ch++) {
1087 s->dither_flag[ch] = get_bits1(gbc);
1092 i = !s->channel_mode;
1094 if (get_bits1(gbc)) {
1095 /* Allow asymmetric application of DRC when drc_scale > 1.
1096 Amplification of quiet sounds is enhanced */
1097 int range_bits = get_bits(gbc, 8);
1098 INTFLOAT range = AC3_RANGE(range_bits);
1099 if (range_bits <= 127 || s->drc_scale <= 1.0)
1100 s->dynamic_range[i] = AC3_DYNAMIC_RANGE(range);
1102 s->dynamic_range[i] = range;
1103 } else if (blk == 0) {
1104 s->dynamic_range[i] = AC3_DYNAMIC_RANGE1;
1108 /* spectral extension strategy */
1109 if (s->eac3 && (!blk || get_bits1(gbc))) {
1110 s->spx_in_use = get_bits1(gbc);
1111 if (s->spx_in_use) {
1112 if ((ret = spx_strategy(s, blk)) < 0)
1116 if (!s->eac3 || !s->spx_in_use) {
1118 for (ch = 1; ch <= fbw_channels; ch++) {
1119 s->channel_uses_spx[ch] = 0;
1120 s->first_spx_coords[ch] = 1;
1124 /* spectral extension coordinates */
1128 /* coupling strategy */
1129 if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
1130 if ((ret = coupling_strategy(s, blk, bit_alloc_stages)) < 0)
1132 } else if (!s->eac3) {
1134 av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "
1135 "be present in block 0\n");
1136 return AVERROR_INVALIDDATA;
1138 s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
1141 cpl_in_use = s->cpl_in_use[blk];
1143 /* coupling coordinates */
1145 if ((ret = coupling_coordinates(s, blk)) < 0)
1149 /* stereo rematrixing strategy and band structure */
1150 if (channel_mode == AC3_CHMODE_STEREO) {
1151 if ((s->eac3 && !blk) || get_bits1(gbc)) {
1152 s->num_rematrixing_bands = 4;
1153 if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
1154 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
1155 } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
1156 s->num_rematrixing_bands--;
1158 for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
1159 s->rematrixing_flags[bnd] = get_bits1(gbc);
1161 av_log(s->avctx, AV_LOG_WARNING, "Warning: "
1162 "new rematrixing strategy not present in block 0\n");
1163 s->num_rematrixing_bands = 0;
1167 /* exponent strategies for each channel */
1168 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1170 s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
1171 if (s->exp_strategy[blk][ch] != EXP_REUSE)
1172 bit_alloc_stages[ch] = 3;
1175 /* channel bandwidth */
1176 for (ch = 1; ch <= fbw_channels; ch++) {
1177 s->start_freq[ch] = 0;
1178 if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1180 int prev = s->end_freq[ch];
1181 if (s->channel_in_cpl[ch])
1182 s->end_freq[ch] = s->start_freq[CPL_CH];
1183 else if (s->channel_uses_spx[ch])
1184 s->end_freq[ch] = s->spx_src_start_freq;
1186 int bandwidth_code = get_bits(gbc, 6);
1187 if (bandwidth_code > 60) {
1188 av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1189 return AVERROR_INVALIDDATA;
1191 s->end_freq[ch] = bandwidth_code * 3 + 73;
1193 group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1194 s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
1195 if (blk > 0 && s->end_freq[ch] != prev)
1196 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1199 if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1200 s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
1201 (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1204 /* decode exponents for each channel */
1205 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1206 if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1207 s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1208 if (decode_exponents(s, gbc, s->exp_strategy[blk][ch],
1209 s->num_exp_groups[ch], s->dexps[ch][0],
1210 &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1211 return AVERROR_INVALIDDATA;
1213 if (ch != CPL_CH && ch != s->lfe_ch)
1214 skip_bits(gbc, 2); /* skip gainrng */
1218 /* bit allocation information */
1219 if (s->bit_allocation_syntax) {
1220 if (get_bits1(gbc)) {
1221 s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1222 s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1223 s->bit_alloc_params.slow_gain = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
1224 s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
1225 s->bit_alloc_params.floor = ff_ac3_floor_tab[get_bits(gbc, 3)];
1226 for (ch = !cpl_in_use; ch <= s->channels; ch++)
1227 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1229 av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must "
1230 "be present in block 0\n");
1231 return AVERROR_INVALIDDATA;
1235 /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1236 if (!s->eac3 || !blk) {
1237 if (s->snr_offset_strategy && get_bits1(gbc)) {
1240 csnr = (get_bits(gbc, 6) - 15) << 4;
1241 for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1243 if (ch == i || s->snr_offset_strategy == 2)
1244 snr = (csnr + get_bits(gbc, 4)) << 2;
1245 /* run at least last bit allocation stage if snr offset changes */
1246 if (blk && s->snr_offset[ch] != snr) {
1247 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1249 s->snr_offset[ch] = snr;
1251 /* fast gain (normal AC-3 only) */
1253 int prev = s->fast_gain[ch];
1254 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1255 /* run last 2 bit allocation stages if fast gain changes */
1256 if (blk && prev != s->fast_gain[ch])
1257 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1260 } else if (!s->eac3 && !blk) {
1261 av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1262 return AVERROR_INVALIDDATA;
1266 /* fast gain (E-AC-3 only) */
1267 if (s->fast_gain_syntax && get_bits1(gbc)) {
1268 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1269 int prev = s->fast_gain[ch];
1270 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1271 /* run last 2 bit allocation stages if fast gain changes */
1272 if (blk && prev != s->fast_gain[ch])
1273 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1275 } else if (s->eac3 && !blk) {
1276 for (ch = !cpl_in_use; ch <= s->channels; ch++)
1277 s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1280 /* E-AC-3 to AC-3 converter SNR offset */
1281 if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1282 skip_bits(gbc, 10); // skip converter snr offset
1285 /* coupling leak information */
1287 if (s->first_cpl_leak || get_bits1(gbc)) {
1288 int fl = get_bits(gbc, 3);
1289 int sl = get_bits(gbc, 3);
1290 /* run last 2 bit allocation stages for coupling channel if
1291 coupling leak changes */
1292 if (blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1293 sl != s->bit_alloc_params.cpl_slow_leak)) {
1294 bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1296 s->bit_alloc_params.cpl_fast_leak = fl;
1297 s->bit_alloc_params.cpl_slow_leak = sl;
1298 } else if (!s->eac3 && !blk) {
1299 av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must "
1300 "be present in block 0\n");
1301 return AVERROR_INVALIDDATA;
1303 s->first_cpl_leak = 0;
1306 /* delta bit allocation information */
1307 if (s->dba_syntax && get_bits1(gbc)) {
1308 /* delta bit allocation exists (strategy) */
1309 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1310 s->dba_mode[ch] = get_bits(gbc, 2);
1311 if (s->dba_mode[ch] == DBA_RESERVED) {
1312 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1313 return AVERROR_INVALIDDATA;
1315 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1317 /* channel delta offset, len and bit allocation */
1318 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1319 if (s->dba_mode[ch] == DBA_NEW) {
1320 s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;
1321 for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
1322 s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1323 s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1324 s->dba_values[ch][seg] = get_bits(gbc, 3);
1326 /* run last 2 bit allocation stages if new dba values */
1327 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1330 } else if (blk == 0) {
1331 for (ch = 0; ch <= s->channels; ch++) {
1332 s->dba_mode[ch] = DBA_NONE;
1336 /* Bit allocation */
1337 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1338 if (bit_alloc_stages[ch] > 2) {
1339 /* Exponent mapping into PSD and PSD integration */
1340 ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
1341 s->start_freq[ch], s->end_freq[ch],
1342 s->psd[ch], s->band_psd[ch]);
1344 if (bit_alloc_stages[ch] > 1) {
1345 /* Compute excitation function, Compute masking curve, and
1346 Apply delta bit allocation */
1347 if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1348 s->start_freq[ch], s->end_freq[ch],
1349 s->fast_gain[ch], (ch == s->lfe_ch),
1350 s->dba_mode[ch], s->dba_nsegs[ch],
1351 s->dba_offsets[ch], s->dba_lengths[ch],
1352 s->dba_values[ch], s->mask[ch])) {
1353 av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1354 return AVERROR_INVALIDDATA;
1357 if (bit_alloc_stages[ch] > 0) {
1358 /* Compute bit allocation */
1359 const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1360 ff_eac3_hebap_tab : ff_ac3_bap_tab;
1361 s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1362 s->start_freq[ch], s->end_freq[ch],
1364 s->bit_alloc_params.floor,
1365 bap_tab, s->bap[ch]);
1369 /* unused dummy data */
1370 if (s->skip_syntax && get_bits1(gbc)) {
1371 int skipl = get_bits(gbc, 9);
1372 skip_bits_long(gbc, 8 * skipl);
1375 /* unpack the transform coefficients
1376 this also uncouples channels if coupling is in use. */
1377 decode_transform_coeffs(s, blk);
1379 /* TODO: generate enhanced coupling coordinates and uncouple */
1381 /* recover coefficients if rematrixing is in use */
1382 if (s->channel_mode == AC3_CHMODE_STEREO)
1385 /* apply scaling to coefficients (headroom, dynrng) */
1386 for (ch = 1; ch <= s->channels; ch++) {
1387 int audio_channel = 0;
1389 if (s->channel_mode == AC3_CHMODE_DUALMONO)
1390 audio_channel = 2-ch;
1391 if (s->heavy_compression && s->compression_exists[audio_channel])
1392 gain = s->heavy_dynamic_range[audio_channel];
1394 gain = s->dynamic_range[audio_channel];
1397 scale_coefs(s->transform_coeffs[ch], s->fixed_coeffs[ch], gain, 256);
1399 if (s->target_level != 0)
1400 gain = gain * s->level_gain[audio_channel];
1401 gain *= 1.0 / 4194304.0f;
1402 s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch],
1403 s->fixed_coeffs[ch], gain, 256);
1407 /* apply spectral extension to high frequency bins */
1408 if (CONFIG_EAC3_DECODER && s->spx_in_use) {
1409 ff_eac3_apply_spectral_extension(s);
1412 /* downmix and MDCT. order depends on whether block switching is used for
1413 any channel in this block. this is because coefficients for the long
1414 and short transforms cannot be mixed. */
1415 downmix_output = s->channels != s->out_channels &&
1416 !((s->output_mode & AC3_OUTPUT_LFEON) &&
1417 s->fbw_channels == s->out_channels);
1418 if (different_transforms) {
1419 /* the delay samples have already been downmixed, so we upmix the delay
1420 samples in order to reconstruct all channels before downmixing. */
1426 do_imdct(s, s->channels);
1428 if (downmix_output) {
1430 ac3_downmix_c_fixed16(s->outptr, s->downmix_coeffs,
1431 s->out_channels, s->fbw_channels, 256);
1433 ff_ac3dsp_downmix(&s->ac3dsp, s->outptr, s->downmix_coeffs,
1434 s->out_channels, s->fbw_channels, 256);
1438 if (downmix_output) {
1439 AC3_RENAME(ff_ac3dsp_downmix)(&s->ac3dsp, s->xcfptr + 1, s->downmix_coeffs,
1440 s->out_channels, s->fbw_channels, 256);
1443 if (downmix_output && !s->downmixed) {
1445 AC3_RENAME(ff_ac3dsp_downmix)(&s->ac3dsp, s->dlyptr, s->downmix_coeffs,
1446 s->out_channels, s->fbw_channels, 128);
1449 do_imdct(s, s->out_channels);
1456 * Decode a single AC-3 frame.
1458 static int ac3_decode_frame(AVCodecContext * avctx, void *data,
1459 int *got_frame_ptr, AVPacket *avpkt)
1461 AVFrame *frame = data;
1462 const uint8_t *buf = avpkt->data;
1463 int buf_size = avpkt->size;
1464 AC3DecodeContext *s = avctx->priv_data;
1465 int blk, ch, err, ret;
1466 const uint8_t *channel_map;
1467 const SHORTFLOAT *output[AC3_MAX_CHANNELS];
1468 enum AVMatrixEncoding matrix_encoding;
1469 AVDownmixInfo *downmix_info;
1471 /* copy input buffer to decoder context to avoid reading past the end
1472 of the buffer, which can be caused by a damaged input stream. */
1473 if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
1474 // seems to be byte-swapped AC-3
1475 int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1476 s->bdsp.bswap16_buf((uint16_t *) s->input_buffer,
1477 (const uint16_t *) buf, cnt);
1479 memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1481 /* if consistent noise generation is enabled, seed the linear feedback generator
1482 * with the contents of the AC-3 frame so that the noise is identical across
1483 * decodes given the same AC-3 frame data, for use with non-linear edititing software. */
1484 if (s->consistent_noise_generation)
1485 av_lfg_init_from_data(&s->dith_state, s->input_buffer, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1487 buf = s->input_buffer;
1488 /* initialize the GetBitContext with the start of valid AC-3 Frame */
1489 if ((ret = init_get_bits8(&s->gbc, buf, buf_size)) < 0)
1492 /* parse the syncinfo */
1493 err = parse_frame_header(s);
1497 case AAC_AC3_PARSE_ERROR_SYNC:
1498 av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1499 return AVERROR_INVALIDDATA;
1500 case AAC_AC3_PARSE_ERROR_BSID:
1501 av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1503 case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
1504 av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1506 case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
1507 av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1509 case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
1510 /* skip frame if CRC is ok. otherwise use error concealment. */
1511 /* TODO: add support for substreams and dependent frames */
1512 if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
1513 av_log(avctx, AV_LOG_DEBUG,
1514 "unsupported frame type %d: skipping frame\n",
1519 av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1522 case AAC_AC3_PARSE_ERROR_CRC:
1523 case AAC_AC3_PARSE_ERROR_CHANNEL_CFG:
1525 default: // Normal AVERROR do not try to recover.
1530 /* check that reported frame size fits in input buffer */
1531 if (s->frame_size > buf_size) {
1532 av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1533 err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
1534 } else if (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL)) {
1535 /* check for crc mismatch */
1536 if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
1537 s->frame_size - 2)) {
1538 av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1539 if (avctx->err_recognition & AV_EF_EXPLODE)
1540 return AVERROR_INVALIDDATA;
1541 err = AAC_AC3_PARSE_ERROR_CRC;
1546 /* if frame is ok, set audio parameters */
1548 avctx->sample_rate = s->sample_rate;
1549 avctx->bit_rate = s->bit_rate;
1552 /* channel config */
1553 if (!err || (s->channels && s->out_channels != s->channels)) {
1554 s->out_channels = s->channels;
1555 s->output_mode = s->channel_mode;
1557 s->output_mode |= AC3_OUTPUT_LFEON;
1558 if (s->channels > 1 &&
1559 avctx->request_channel_layout == AV_CH_LAYOUT_MONO) {
1560 s->out_channels = 1;
1561 s->output_mode = AC3_CHMODE_MONO;
1562 } else if (s->channels > 2 &&
1563 avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
1564 s->out_channels = 2;
1565 s->output_mode = AC3_CHMODE_STEREO;
1568 s->loro_center_mix_level = gain_levels[s-> center_mix_level];
1569 s->loro_surround_mix_level = gain_levels[s->surround_mix_level];
1570 s->ltrt_center_mix_level = LEVEL_MINUS_3DB;
1571 s->ltrt_surround_mix_level = LEVEL_MINUS_3DB;
1572 /* set downmixing coefficients if needed */
1573 if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1574 s->fbw_channels == s->out_channels)) {
1575 if ((ret = set_downmix_coeffs(s)) < 0) {
1576 av_log(avctx, AV_LOG_ERROR, "error setting downmix coeffs\n");
1580 } else if (!s->channels) {
1581 av_log(avctx, AV_LOG_ERROR, "unable to determine channel mode\n");
1582 return AVERROR_INVALIDDATA;
1584 avctx->channels = s->out_channels;
1585 avctx->channel_layout = avpriv_ac3_channel_layout_tab[s->output_mode & ~AC3_OUTPUT_LFEON];
1586 if (s->output_mode & AC3_OUTPUT_LFEON)
1587 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1589 /* set audio service type based on bitstream mode for AC-3 */
1590 avctx->audio_service_type = s->bitstream_mode;
1591 if (s->bitstream_mode == 0x7 && s->channels > 1)
1592 avctx->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
1594 /* get output buffer */
1595 frame->nb_samples = s->num_blocks * AC3_BLOCK_SIZE;
1596 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1599 /* decode the audio blocks */
1600 channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1601 for (ch = 0; ch < AC3_MAX_CHANNELS; ch++) {
1602 output[ch] = s->output[ch];
1603 s->outptr[ch] = s->output[ch];
1605 for (ch = 0; ch < s->channels; ch++) {
1606 if (ch < s->out_channels)
1607 s->outptr[channel_map[ch]] = (SHORTFLOAT *)frame->data[ch];
1609 for (blk = 0; blk < s->num_blocks; blk++) {
1610 if (!err && decode_audio_block(s, blk)) {
1611 av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1615 for (ch = 0; ch < s->out_channels; ch++)
1616 memcpy(((SHORTFLOAT*)frame->data[ch]) + AC3_BLOCK_SIZE*blk, output[ch], AC3_BLOCK_SIZE*sizeof(SHORTFLOAT));
1617 for (ch = 0; ch < s->out_channels; ch++)
1618 output[ch] = s->outptr[channel_map[ch]];
1619 for (ch = 0; ch < s->out_channels; ch++) {
1620 if (!ch || channel_map[ch])
1621 s->outptr[channel_map[ch]] += AC3_BLOCK_SIZE;
1625 av_frame_set_decode_error_flags(frame, err ? FF_DECODE_ERROR_INVALID_BITSTREAM : 0);
1627 /* keep last block for error concealment in next frame */
1628 for (ch = 0; ch < s->out_channels; ch++)
1629 memcpy(s->output[ch], output[ch], AC3_BLOCK_SIZE*sizeof(SHORTFLOAT));
1634 * Check whether the input layout is compatible, and make sure we're not
1635 * downmixing (else the matrix encoding is no longer applicable).
1637 matrix_encoding = AV_MATRIX_ENCODING_NONE;
1638 if (s->channel_mode == AC3_CHMODE_STEREO &&
1639 s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1640 if (s->dolby_surround_mode == AC3_DSURMOD_ON)
1641 matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
1642 else if (s->dolby_headphone_mode == AC3_DHEADPHONMOD_ON)
1643 matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;
1644 } else if (s->channel_mode >= AC3_CHMODE_2F2R &&
1645 s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1646 switch (s->dolby_surround_ex_mode) {
1647 case AC3_DSUREXMOD_ON: // EX or PLIIx
1648 matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
1650 case AC3_DSUREXMOD_PLIIZ:
1651 matrix_encoding = AV_MATRIX_ENCODING_DPLIIZ;
1653 default: // not indicated or off
1657 if ((ret = ff_side_data_update_matrix_encoding(frame, matrix_encoding)) < 0)
1661 if ((downmix_info = av_downmix_info_update_side_data(frame))) {
1662 switch (s->preferred_downmix) {
1663 case AC3_DMIXMOD_LTRT:
1664 downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_LTRT;
1666 case AC3_DMIXMOD_LORO:
1667 downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_LORO;
1669 case AC3_DMIXMOD_DPLII:
1670 downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_DPLII;
1673 downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_UNKNOWN;
1676 downmix_info->center_mix_level = gain_levels[s-> center_mix_level];
1677 downmix_info->center_mix_level_ltrt = gain_levels[s-> center_mix_level_ltrt];
1678 downmix_info->surround_mix_level = gain_levels[s-> surround_mix_level];
1679 downmix_info->surround_mix_level_ltrt = gain_levels[s->surround_mix_level_ltrt];
1680 if (s->lfe_mix_level_exists)
1681 downmix_info->lfe_mix_level = gain_levels_lfe[s->lfe_mix_level];
1683 downmix_info->lfe_mix_level = 0.0; // -inf dB
1685 return AVERROR(ENOMEM);
1689 return FFMIN(buf_size, s->frame_size);
1693 * Uninitialize the AC-3 decoder.
1695 static av_cold int ac3_decode_end(AVCodecContext *avctx)
1697 AC3DecodeContext *s = avctx->priv_data;
1698 ff_mdct_end(&s->imdct_512);
1699 ff_mdct_end(&s->imdct_256);
1701 av_freep(&s->downmix_coeffs[0]);
1706 #define OFFSET(x) offsetof(AC3DecodeContext, x)
1707 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)