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"
36 #include "libavutil/thread.h"
39 #include "aac_ac3_parser.h"
40 #include "ac3_parser_internal.h"
42 #include "ac3dec_data.h"
46 * table for ungrouping 3 values in 7 bits.
47 * used for exponents and bap=2 mantissas
49 static uint8_t ungroup_3_in_7_bits_tab[128][3];
51 /** tables for ungrouping mantissas */
52 static int b1_mantissas[32][3];
53 static int b2_mantissas[128][3];
54 static int b3_mantissas[8];
55 static int b4_mantissas[128][2];
56 static int b5_mantissas[16];
59 * Quantization table: levels for symmetric. bits for asymmetric.
60 * reference: Table 7.18 Mapping of bap to Quantizer
62 static const uint8_t quantization_tab[16] = {
64 5, 6, 7, 8, 9, 10, 11, 12, 14, 16
68 /** dynamic range table. converts codes to scale factors. */
69 static float dynamic_range_tab[256];
70 float ff_ac3_heavy_dynamic_range_tab[256];
73 /** Adjustments in dB gain */
74 static const float gain_levels[9] = {
78 LEVEL_MINUS_1POINT5DB,
80 LEVEL_MINUS_4POINT5DB,
86 /** Adjustments in dB gain (LFE, +10 to -21 dB) */
87 static const float gain_levels_lfe[32] = {
88 3.162275, 2.818382, 2.511886, 2.238719, 1.995261, 1.778278, 1.584893,
89 1.412536, 1.258924, 1.122018, 1.000000, 0.891251, 0.794328, 0.707946,
90 0.630957, 0.562341, 0.501187, 0.446683, 0.398107, 0.354813, 0.316227,
91 0.281838, 0.251188, 0.223872, 0.199526, 0.177828, 0.158489, 0.141253,
92 0.125892, 0.112201, 0.100000, 0.089125
96 * Table for default stereo downmixing coefficients
97 * reference: Section 7.8.2 Downmixing Into Two Channels
99 static const uint8_t ac3_default_coeffs[8][5][2] = {
100 { { 2, 7 }, { 7, 2 }, },
102 { { 2, 7 }, { 7, 2 }, },
103 { { 2, 7 }, { 5, 5 }, { 7, 2 }, },
104 { { 2, 7 }, { 7, 2 }, { 6, 6 }, },
105 { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 }, },
106 { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
107 { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
111 * Symmetrical Dequantization
112 * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization
113 * Tables 7.19 to 7.23
116 symmetric_dequant(int code, int levels)
118 return ((code - (levels >> 1)) * (1 << 24)) / levels;
122 * Initialize tables at runtime.
124 static av_cold void ac3_tables_init(void)
128 /* generate table for ungrouping 3 values in 7 bits
129 reference: Section 7.1.3 Exponent Decoding */
130 for (i = 0; i < 128; i++) {
131 ungroup_3_in_7_bits_tab[i][0] = i / 25;
132 ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5;
133 ungroup_3_in_7_bits_tab[i][2] = (i % 25) % 5;
136 /* generate grouped mantissa tables
137 reference: Section 7.3.5 Ungrouping of Mantissas */
138 for (i = 0; i < 32; i++) {
139 /* bap=1 mantissas */
140 b1_mantissas[i][0] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][0], 3);
141 b1_mantissas[i][1] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][1], 3);
142 b1_mantissas[i][2] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][2], 3);
144 for (i = 0; i < 128; i++) {
145 /* bap=2 mantissas */
146 b2_mantissas[i][0] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][0], 5);
147 b2_mantissas[i][1] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][1], 5);
148 b2_mantissas[i][2] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][2], 5);
150 /* bap=4 mantissas */
151 b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
152 b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
154 /* generate ungrouped mantissa tables
155 reference: Tables 7.21 and 7.23 */
156 for (i = 0; i < 7; i++) {
157 /* bap=3 mantissas */
158 b3_mantissas[i] = symmetric_dequant(i, 7);
160 for (i = 0; i < 15; i++) {
161 /* bap=5 mantissas */
162 b5_mantissas[i] = symmetric_dequant(i, 15);
166 /* generate dynamic range table
167 reference: Section 7.7.1 Dynamic Range Control */
168 for (i = 0; i < 256; i++) {
169 int v = (i >> 5) - ((i >> 7) << 3) - 5;
170 dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
173 /* generate compr dynamic range table
174 reference: Section 7.7.2 Heavy Compression */
175 for (i = 0; i < 256; i++) {
176 int v = (i >> 4) - ((i >> 7) << 4) - 4;
177 ff_ac3_heavy_dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0xF) | 0x10);
183 * AVCodec initialization
185 static av_cold int ac3_decode_init(AVCodecContext *avctx)
187 static AVOnce init_static_once = AV_ONCE_INIT;
188 AC3DecodeContext *s = avctx->priv_data;
193 if ((ret = ff_mdct_init(&s->imdct_256, 8, 1, 1.0)) < 0 ||
194 (ret = ff_mdct_init(&s->imdct_512, 9, 1, 1.0)) < 0)
196 AC3_RENAME(ff_kbd_window_init)(s->window, 5.0, 256);
197 ff_bswapdsp_init(&s->bdsp);
200 s->fdsp = avpriv_alloc_fixed_dsp(avctx->flags & AV_CODEC_FLAG_BITEXACT);
202 ff_fmt_convert_init(&s->fmt_conv, avctx);
203 s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
206 return AVERROR(ENOMEM);
208 ff_ac3dsp_init(&s->ac3dsp, avctx->flags & AV_CODEC_FLAG_BITEXACT);
209 av_lfg_init(&s->dith_state, 0);
212 avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
214 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
216 /* allow downmixing to stereo or mono */
217 if (avctx->channels > 1 &&
218 avctx->request_channel_layout == AV_CH_LAYOUT_MONO)
220 else if (avctx->channels > 2 &&
221 avctx->request_channel_layout == AV_CH_LAYOUT_STEREO)
225 for (i = 0; i < AC3_MAX_CHANNELS; i++) {
226 s->xcfptr[i] = s->transform_coeffs[i];
227 s->dlyptr[i] = s->delay[i];
230 ff_thread_once(&init_static_once, ac3_tables_init);
236 * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
237 * GetBitContext within AC3DecodeContext must point to
238 * the start of the synchronized AC-3 bitstream.
240 static int ac3_parse_header(AC3DecodeContext *s)
242 GetBitContext *gbc = &s->gbc;
245 /* read the rest of the bsi. read twice for dual mono mode. */
246 i = !s->channel_mode;
248 s->dialog_normalization[(!s->channel_mode)-i] = -get_bits(gbc, 5);
249 if (s->dialog_normalization[(!s->channel_mode)-i] == 0) {
250 s->dialog_normalization[(!s->channel_mode)-i] = -31;
252 if (s->target_level != 0) {
253 s->level_gain[(!s->channel_mode)-i] = powf(2.0f,
254 (float)(s->target_level -
255 s->dialog_normalization[(!s->channel_mode)-i])/6.0f);
257 if (s->compression_exists[(!s->channel_mode)-i] = get_bits1(gbc)) {
258 s->heavy_dynamic_range[(!s->channel_mode)-i] =
259 AC3_HEAVY_RANGE(get_bits(gbc, 8));
262 skip_bits(gbc, 8); //skip language code
264 skip_bits(gbc, 7); //skip audio production information
267 skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
269 /* skip the timecodes or parse the Alternate Bit Stream Syntax */
270 if (s->bitstream_id != 6) {
272 skip_bits(gbc, 14); //skip timecode1
274 skip_bits(gbc, 14); //skip timecode2
276 if (get_bits1(gbc)) {
277 s->preferred_downmix = get_bits(gbc, 2);
278 s->center_mix_level_ltrt = get_bits(gbc, 3);
279 s->surround_mix_level_ltrt = av_clip(get_bits(gbc, 3), 3, 7);
280 s->center_mix_level = get_bits(gbc, 3);
281 s->surround_mix_level = av_clip(get_bits(gbc, 3), 3, 7);
283 if (get_bits1(gbc)) {
284 s->dolby_surround_ex_mode = get_bits(gbc, 2);
285 s->dolby_headphone_mode = get_bits(gbc, 2);
286 skip_bits(gbc, 10); // skip adconvtyp (1), xbsi2 (8), encinfo (1)
290 /* skip additional bitstream info */
291 if (get_bits1(gbc)) {
292 i = get_bits(gbc, 6);
302 * Common function to parse AC-3 or E-AC-3 frame header
304 static int parse_frame_header(AC3DecodeContext *s)
309 err = ff_ac3_parse_header(&s->gbc, &hdr);
313 /* get decoding parameters from header info */
314 s->bit_alloc_params.sr_code = hdr.sr_code;
315 s->bitstream_id = hdr.bitstream_id;
316 s->bitstream_mode = hdr.bitstream_mode;
317 s->channel_mode = hdr.channel_mode;
318 s->lfe_on = hdr.lfe_on;
319 s->bit_alloc_params.sr_shift = hdr.sr_shift;
320 s->sample_rate = hdr.sample_rate;
321 s->bit_rate = hdr.bit_rate;
322 s->channels = hdr.channels;
323 s->fbw_channels = s->channels - s->lfe_on;
324 s->lfe_ch = s->fbw_channels + 1;
325 s->frame_size = hdr.frame_size;
326 s->superframe_size += hdr.frame_size;
327 s->preferred_downmix = AC3_DMIXMOD_NOTINDICATED;
328 s->center_mix_level = hdr.center_mix_level;
329 s->center_mix_level_ltrt = 4; // -3.0dB
330 s->surround_mix_level = hdr.surround_mix_level;
331 s->surround_mix_level_ltrt = 4; // -3.0dB
332 s->lfe_mix_level_exists = 0;
333 s->num_blocks = hdr.num_blocks;
334 s->frame_type = hdr.frame_type;
335 s->substreamid = hdr.substreamid;
336 s->dolby_surround_mode = hdr.dolby_surround_mode;
337 s->dolby_surround_ex_mode = AC3_DSUREXMOD_NOTINDICATED;
338 s->dolby_headphone_mode = AC3_DHEADPHONMOD_NOTINDICATED;
341 s->start_freq[s->lfe_ch] = 0;
342 s->end_freq[s->lfe_ch] = 7;
343 s->num_exp_groups[s->lfe_ch] = 2;
344 s->channel_in_cpl[s->lfe_ch] = 0;
347 if (s->bitstream_id <= 10) {
349 s->snr_offset_strategy = 2;
350 s->block_switch_syntax = 1;
351 s->dither_flag_syntax = 1;
352 s->bit_allocation_syntax = 1;
353 s->fast_gain_syntax = 0;
354 s->first_cpl_leak = 0;
357 memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
358 return ac3_parse_header(s);
359 } else if (CONFIG_EAC3_DECODER) {
361 return ff_eac3_parse_header(s);
363 av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n");
364 return AVERROR(ENOSYS);
369 * Set stereo downmixing coefficients based on frame header info.
370 * reference: Section 7.8.2 Downmixing Into Two Channels
372 static int set_downmix_coeffs(AC3DecodeContext *s)
375 float cmix = gain_levels[s-> center_mix_level];
376 float smix = gain_levels[s->surround_mix_level];
378 float downmix_coeffs[2][AC3_MAX_CHANNELS];
380 if (!s->downmix_coeffs[0]) {
381 s->downmix_coeffs[0] = av_malloc_array(2 * AC3_MAX_CHANNELS,
382 sizeof(**s->downmix_coeffs));
383 if (!s->downmix_coeffs[0])
384 return AVERROR(ENOMEM);
385 s->downmix_coeffs[1] = s->downmix_coeffs[0] + AC3_MAX_CHANNELS;
388 for (i = 0; i < s->fbw_channels; i++) {
389 downmix_coeffs[0][i] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
390 downmix_coeffs[1][i] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
392 if (s->channel_mode > 1 && s->channel_mode & 1) {
393 downmix_coeffs[0][1] = downmix_coeffs[1][1] = cmix;
395 if (s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
396 int nf = s->channel_mode - 2;
397 downmix_coeffs[0][nf] = downmix_coeffs[1][nf] = smix * LEVEL_MINUS_3DB;
399 if (s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
400 int nf = s->channel_mode - 4;
401 downmix_coeffs[0][nf] = downmix_coeffs[1][nf+1] = smix;
406 for (i = 0; i < s->fbw_channels; i++) {
407 norm0 += downmix_coeffs[0][i];
408 norm1 += downmix_coeffs[1][i];
410 norm0 = 1.0f / norm0;
411 norm1 = 1.0f / norm1;
412 for (i = 0; i < s->fbw_channels; i++) {
413 downmix_coeffs[0][i] *= norm0;
414 downmix_coeffs[1][i] *= norm1;
417 if (s->output_mode == AC3_CHMODE_MONO) {
418 for (i = 0; i < s->fbw_channels; i++)
419 downmix_coeffs[0][i] = (downmix_coeffs[0][i] +
420 downmix_coeffs[1][i]) * LEVEL_MINUS_3DB;
422 for (i = 0; i < s->fbw_channels; i++) {
423 s->downmix_coeffs[0][i] = FIXR12(downmix_coeffs[0][i]);
424 s->downmix_coeffs[1][i] = FIXR12(downmix_coeffs[1][i]);
431 * Decode the grouped exponents according to exponent strategy.
432 * reference: Section 7.1.3 Exponent Decoding
434 static int decode_exponents(AC3DecodeContext *s,
435 GetBitContext *gbc, int exp_strategy, int ngrps,
436 uint8_t absexp, int8_t *dexps)
438 int i, j, grp, group_size;
443 group_size = exp_strategy + (exp_strategy == EXP_D45);
444 for (grp = 0, i = 0; grp < ngrps; grp++) {
445 expacc = get_bits(gbc, 7);
447 av_log(s->avctx, AV_LOG_ERROR, "expacc %d is out-of-range\n", expacc);
448 return AVERROR_INVALIDDATA;
450 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
451 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
452 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
455 /* convert to absolute exps and expand groups */
457 for (i = 0, j = 0; i < ngrps * 3; i++) {
458 prevexp += dexp[i] - 2;
460 av_log(s->avctx, AV_LOG_ERROR, "exponent %d is out-of-range\n", prevexp);
461 return AVERROR_INVALIDDATA;
463 switch (group_size) {
464 case 4: dexps[j++] = prevexp;
465 dexps[j++] = prevexp;
466 case 2: dexps[j++] = prevexp;
467 case 1: dexps[j++] = prevexp;
474 * Generate transform coefficients for each coupled channel in the coupling
475 * range using the coupling coefficients and coupling coordinates.
476 * reference: Section 7.4.3 Coupling Coordinate Format
478 static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
482 bin = s->start_freq[CPL_CH];
483 for (band = 0; band < s->num_cpl_bands; band++) {
484 int band_start = bin;
485 int band_end = bin + s->cpl_band_sizes[band];
486 for (ch = 1; ch <= s->fbw_channels; ch++) {
487 if (s->channel_in_cpl[ch]) {
488 int cpl_coord = s->cpl_coords[ch][band] << 5;
489 for (bin = band_start; bin < band_end; bin++) {
490 s->fixed_coeffs[ch][bin] =
491 MULH(s->fixed_coeffs[CPL_CH][bin] * (1 << 4), cpl_coord);
493 if (ch == 2 && s->phase_flags[band]) {
494 for (bin = band_start; bin < band_end; bin++)
495 s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin];
504 * Grouped mantissas for 3-level 5-level and 11-level quantization
506 typedef struct mant_groups {
516 * Decode the transform coefficients for a particular channel
517 * reference: Section 7.3 Quantization and Decoding of Mantissas
519 static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
521 int start_freq = s->start_freq[ch_index];
522 int end_freq = s->end_freq[ch_index];
523 uint8_t *baps = s->bap[ch_index];
524 int8_t *exps = s->dexps[ch_index];
525 int32_t *coeffs = s->fixed_coeffs[ch_index];
526 int dither = (ch_index == CPL_CH) || s->dither_flag[ch_index];
527 GetBitContext *gbc = &s->gbc;
530 for (freq = start_freq; freq < end_freq; freq++) {
531 int bap = baps[freq];
535 /* random noise with approximate range of -0.707 to 0.707 */
537 mantissa = (((av_lfg_get(&s->dith_state)>>8)*181)>>8) - 5931008;
544 mantissa = m->b1_mant[m->b1];
546 int bits = get_bits(gbc, 5);
547 mantissa = b1_mantissas[bits][0];
548 m->b1_mant[1] = b1_mantissas[bits][1];
549 m->b1_mant[0] = b1_mantissas[bits][2];
556 mantissa = m->b2_mant[m->b2];
558 int bits = get_bits(gbc, 7);
559 mantissa = b2_mantissas[bits][0];
560 m->b2_mant[1] = b2_mantissas[bits][1];
561 m->b2_mant[0] = b2_mantissas[bits][2];
566 mantissa = b3_mantissas[get_bits(gbc, 3)];
571 mantissa = m->b4_mant;
573 int bits = get_bits(gbc, 7);
574 mantissa = b4_mantissas[bits][0];
575 m->b4_mant = b4_mantissas[bits][1];
580 mantissa = b5_mantissas[get_bits(gbc, 4)];
582 default: /* 6 to 15 */
583 /* Shift mantissa and sign-extend it. */
585 av_log(s->avctx, AV_LOG_ERROR, "bap %d is invalid in plain AC-3\n", bap);
588 mantissa = (unsigned)get_sbits(gbc, quantization_tab[bap]) << (24 - quantization_tab[bap]);
591 coeffs[freq] = mantissa >> exps[freq];
596 * Remove random dithering from coupling range coefficients with zero-bit
597 * mantissas for coupled channels which do not use dithering.
598 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
600 static void remove_dithering(AC3DecodeContext *s) {
603 for (ch = 1; ch <= s->fbw_channels; ch++) {
604 if (!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
605 for (i = s->start_freq[CPL_CH]; i < s->end_freq[CPL_CH]; i++) {
606 if (!s->bap[CPL_CH][i])
607 s->fixed_coeffs[ch][i] = 0;
613 static inline void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk,
614 int ch, mant_groups *m)
616 if (!s->channel_uses_aht[ch]) {
617 ac3_decode_transform_coeffs_ch(s, ch, m);
619 /* if AHT is used, mantissas for all blocks are encoded in the first
620 block of the frame. */
622 if (CONFIG_EAC3_DECODER && !blk)
623 ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
624 for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
625 s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
631 * Decode the transform coefficients.
633 static inline void decode_transform_coeffs(AC3DecodeContext *s, int blk)
639 m.b1 = m.b2 = m.b4 = 0;
641 for (ch = 1; ch <= s->channels; ch++) {
642 /* transform coefficients for full-bandwidth channel */
643 decode_transform_coeffs_ch(s, blk, ch, &m);
644 /* transform coefficients for coupling channel come right after the
645 coefficients for the first coupled channel*/
646 if (s->channel_in_cpl[ch]) {
648 decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
649 calc_transform_coeffs_cpl(s);
652 end = s->end_freq[CPL_CH];
654 end = s->end_freq[ch];
657 s->fixed_coeffs[ch][end] = 0;
661 /* zero the dithered coefficients for appropriate channels */
666 * Stereo rematrixing.
667 * reference: Section 7.5.4 Rematrixing : Decoding Technique
669 static void do_rematrixing(AC3DecodeContext *s)
674 end = FFMIN(s->end_freq[1], s->end_freq[2]);
676 for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) {
677 if (s->rematrixing_flags[bnd]) {
678 bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd + 1]);
679 for (i = ff_ac3_rematrix_band_tab[bnd]; i < bndend; i++) {
680 int tmp0 = s->fixed_coeffs[1][i];
681 s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
682 s->fixed_coeffs[2][i] = tmp0 - s->fixed_coeffs[2][i];
689 * Inverse MDCT Transform.
690 * Convert frequency domain coefficients to time-domain audio samples.
691 * reference: Section 7.9.4 Transformation Equations
693 static inline void do_imdct(AC3DecodeContext *s, int channels, int offset)
697 for (ch = 1; ch <= channels; ch++) {
698 if (s->block_switch[ch]) {
700 FFTSample *x = s->tmp_output + 128;
701 for (i = 0; i < 128; i++)
702 x[i] = s->transform_coeffs[ch][2 * i];
703 s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
705 s->fdsp->vector_fmul_window_scaled(s->outptr[ch - 1], s->delay[ch - 1 + offset],
706 s->tmp_output, s->window, 128, 8);
708 s->fdsp->vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1 + offset],
709 s->tmp_output, s->window, 128);
711 for (i = 0; i < 128; i++)
712 x[i] = s->transform_coeffs[ch][2 * i + 1];
713 s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch - 1 + offset], x);
715 s->imdct_512.imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
717 s->fdsp->vector_fmul_window_scaled(s->outptr[ch - 1], s->delay[ch - 1 + offset],
718 s->tmp_output, s->window, 128, 8);
720 s->fdsp->vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1 + offset],
721 s->tmp_output, s->window, 128);
723 memcpy(s->delay[ch - 1 + offset], s->tmp_output + 128, 128 * sizeof(FFTSample));
729 * Upmix delay samples from stereo to original channel layout.
731 static void ac3_upmix_delay(AC3DecodeContext *s)
733 int channel_data_size = sizeof(s->delay[0]);
734 switch (s->channel_mode) {
735 case AC3_CHMODE_DUALMONO:
736 case AC3_CHMODE_STEREO:
737 /* upmix mono to stereo */
738 memcpy(s->delay[1], s->delay[0], channel_data_size);
740 case AC3_CHMODE_2F2R:
741 memset(s->delay[3], 0, channel_data_size);
742 case AC3_CHMODE_2F1R:
743 memset(s->delay[2], 0, channel_data_size);
745 case AC3_CHMODE_3F2R:
746 memset(s->delay[4], 0, channel_data_size);
747 case AC3_CHMODE_3F1R:
748 memset(s->delay[3], 0, channel_data_size);
750 memcpy(s->delay[2], s->delay[1], channel_data_size);
751 memset(s->delay[1], 0, channel_data_size);
757 * Decode band structure for coupling, spectral extension, or enhanced coupling.
758 * The band structure defines how many subbands are in each band. For each
759 * subband in the range, 1 means it is combined with the previous band, and 0
760 * means that it starts a new band.
762 * @param[in] gbc bit reader context
763 * @param[in] blk block number
764 * @param[in] eac3 flag to indicate E-AC-3
765 * @param[in] ecpl flag to indicate enhanced coupling
766 * @param[in] start_subband subband number for start of range
767 * @param[in] end_subband subband number for end of range
768 * @param[in] default_band_struct default band structure table
769 * @param[out] num_bands number of bands (optionally NULL)
770 * @param[out] band_sizes array containing the number of bins in each band (optionally NULL)
771 * @param[in,out] band_struct current band structure
773 static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
774 int ecpl, int start_subband, int end_subband,
775 const uint8_t *default_band_struct,
776 int *num_bands, uint8_t *band_sizes,
777 uint8_t *band_struct, int band_struct_size)
779 int subbnd, bnd, n_subbands, n_bands=0;
782 n_subbands = end_subband - start_subband;
785 memcpy(band_struct, default_band_struct, band_struct_size);
787 av_assert0(band_struct_size >= start_subband + n_subbands);
789 band_struct += start_subband + 1;
791 /* decode band structure from bitstream or use default */
792 if (!eac3 || get_bits1(gbc)) {
793 for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
794 band_struct[subbnd] = get_bits1(gbc);
798 /* calculate number of bands and band sizes based on band structure.
799 note that the first 4 subbands in enhanced coupling span only 6 bins
801 if (num_bands || band_sizes ) {
802 n_bands = n_subbands;
803 bnd_sz[0] = ecpl ? 6 : 12;
804 for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
805 int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
806 if (band_struct[subbnd - 1]) {
808 bnd_sz[bnd] += subbnd_size;
810 bnd_sz[++bnd] = subbnd_size;
815 /* set optional output params */
817 *num_bands = n_bands;
819 memcpy(band_sizes, bnd_sz, n_bands);
822 static inline int spx_strategy(AC3DecodeContext *s, int blk)
824 GetBitContext *bc = &s->gbc;
825 int fbw_channels = s->fbw_channels;
826 int dst_start_freq, dst_end_freq, src_start_freq,
827 start_subband, end_subband, ch;
829 /* determine which channels use spx */
830 if (s->channel_mode == AC3_CHMODE_MONO) {
831 s->channel_uses_spx[1] = 1;
833 for (ch = 1; ch <= fbw_channels; ch++)
834 s->channel_uses_spx[ch] = get_bits1(bc);
837 /* get the frequency bins of the spx copy region and the spx start
839 dst_start_freq = get_bits(bc, 2);
840 start_subband = get_bits(bc, 3) + 2;
841 if (start_subband > 7)
842 start_subband += start_subband - 7;
843 end_subband = get_bits(bc, 3) + 5;
845 s->spx_dst_end_freq = end_freq_inv_tab[end_subband-5];
848 end_subband += end_subband - 7;
849 dst_start_freq = dst_start_freq * 12 + 25;
850 src_start_freq = start_subband * 12 + 25;
851 dst_end_freq = end_subband * 12 + 25;
853 /* check validity of spx ranges */
854 if (start_subband >= end_subband) {
855 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
856 "range (%d >= %d)\n", start_subband, end_subband);
857 return AVERROR_INVALIDDATA;
859 if (dst_start_freq >= src_start_freq) {
860 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
861 "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
862 return AVERROR_INVALIDDATA;
865 s->spx_dst_start_freq = dst_start_freq;
866 s->spx_src_start_freq = src_start_freq;
868 s->spx_dst_end_freq = dst_end_freq;
870 decode_band_structure(bc, blk, s->eac3, 0,
871 start_subband, end_subband,
872 ff_eac3_default_spx_band_struct,
875 s->spx_band_struct, sizeof(s->spx_band_struct));
879 static inline void spx_coordinates(AC3DecodeContext *s)
881 GetBitContext *bc = &s->gbc;
882 int fbw_channels = s->fbw_channels;
885 for (ch = 1; ch <= fbw_channels; ch++) {
886 if (s->channel_uses_spx[ch]) {
887 if (s->first_spx_coords[ch] || get_bits1(bc)) {
889 int bin, master_spx_coord;
891 s->first_spx_coords[ch] = 0;
892 spx_blend = AC3_SPX_BLEND(get_bits(bc, 5));
893 master_spx_coord = get_bits(bc, 2) * 3;
895 bin = s->spx_src_start_freq;
896 for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
897 int bandsize = s->spx_band_sizes[bnd];
898 int spx_coord_exp, spx_coord_mant;
899 INTFLOAT nratio, sblend, nblend;
901 /* calculate blending factors */
902 int64_t accu = ((bin << 23) + (bandsize << 22))
903 * (int64_t)s->spx_dst_end_freq;
904 nratio = (int)(accu >> 32);
905 nratio -= spx_blend << 18;
910 } else if (nratio > 0x7fffff) {
911 nblend = 14529495; // sqrt(3) in FP.23
914 nblend = fixed_sqrt(nratio, 23);
915 accu = (int64_t)nblend * 1859775393;
916 nblend = (int)((accu + (1<<29)) >> 30);
917 sblend = fixed_sqrt(0x800000 - nratio, 23);
922 /* calculate blending factors */
923 nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
924 nratio = av_clipf(nratio, 0.0f, 1.0f);
925 nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
926 // to give unity variance
927 sblend = sqrtf(1.0f - nratio);
931 /* decode spx coordinates */
932 spx_coord_exp = get_bits(bc, 4);
933 spx_coord_mant = get_bits(bc, 2);
934 if (spx_coord_exp == 15) spx_coord_mant <<= 1;
935 else spx_coord_mant += 4;
936 spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
938 /* multiply noise and signal blending factors by spx coordinate */
940 accu = (int64_t)nblend * spx_coord_mant;
941 s->spx_noise_blend[ch][bnd] = (int)((accu + (1<<22)) >> 23);
942 accu = (int64_t)sblend * spx_coord_mant;
943 s->spx_signal_blend[ch][bnd] = (int)((accu + (1<<22)) >> 23);
945 spx_coord = spx_coord_mant * (1.0f / (1 << 23));
946 s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
947 s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
952 s->first_spx_coords[ch] = 1;
957 static inline int coupling_strategy(AC3DecodeContext *s, int blk,
958 uint8_t *bit_alloc_stages)
960 GetBitContext *bc = &s->gbc;
961 int fbw_channels = s->fbw_channels;
962 int channel_mode = s->channel_mode;
965 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
967 s->cpl_in_use[blk] = get_bits1(bc);
968 if (s->cpl_in_use[blk]) {
969 /* coupling in use */
970 int cpl_start_subband, cpl_end_subband;
972 if (channel_mode < AC3_CHMODE_STEREO) {
973 av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
974 return AVERROR_INVALIDDATA;
977 /* check for enhanced coupling */
978 if (s->eac3 && get_bits1(bc)) {
979 /* TODO: parse enhanced coupling strategy info */
980 avpriv_request_sample(s->avctx, "Enhanced coupling");
981 return AVERROR_PATCHWELCOME;
984 /* determine which channels are coupled */
985 if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
986 s->channel_in_cpl[1] = 1;
987 s->channel_in_cpl[2] = 1;
989 for (ch = 1; ch <= fbw_channels; ch++)
990 s->channel_in_cpl[ch] = get_bits1(bc);
993 /* phase flags in use */
994 if (channel_mode == AC3_CHMODE_STEREO)
995 s->phase_flags_in_use = get_bits1(bc);
997 /* coupling frequency range */
998 cpl_start_subband = get_bits(bc, 4);
999 cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
1000 get_bits(bc, 4) + 3;
1001 if (cpl_start_subband >= cpl_end_subband) {
1002 av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
1003 cpl_start_subband, cpl_end_subband);
1004 return AVERROR_INVALIDDATA;
1006 s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
1007 s->end_freq[CPL_CH] = cpl_end_subband * 12 + 37;
1009 decode_band_structure(bc, blk, s->eac3, 0, cpl_start_subband,
1011 ff_eac3_default_cpl_band_struct,
1012 &s->num_cpl_bands, s->cpl_band_sizes,
1013 s->cpl_band_struct, sizeof(s->cpl_band_struct));
1015 /* coupling not in use */
1016 for (ch = 1; ch <= fbw_channels; ch++) {
1017 s->channel_in_cpl[ch] = 0;
1018 s->first_cpl_coords[ch] = 1;
1020 s->first_cpl_leak = s->eac3;
1021 s->phase_flags_in_use = 0;
1027 static inline int coupling_coordinates(AC3DecodeContext *s, int blk)
1029 GetBitContext *bc = &s->gbc;
1030 int fbw_channels = s->fbw_channels;
1032 int cpl_coords_exist = 0;
1034 for (ch = 1; ch <= fbw_channels; ch++) {
1035 if (s->channel_in_cpl[ch]) {
1036 if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(bc)) {
1037 int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
1038 s->first_cpl_coords[ch] = 0;
1039 cpl_coords_exist = 1;
1040 master_cpl_coord = 3 * get_bits(bc, 2);
1041 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1042 cpl_coord_exp = get_bits(bc, 4);
1043 cpl_coord_mant = get_bits(bc, 4);
1044 if (cpl_coord_exp == 15)
1045 s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
1047 s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
1048 s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
1051 av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
1052 "be present in block 0\n");
1053 return AVERROR_INVALIDDATA;
1056 /* channel not in coupling */
1057 s->first_cpl_coords[ch] = 1;
1061 if (s->channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
1062 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1063 s->phase_flags[bnd] = s->phase_flags_in_use ? get_bits1(bc) : 0;
1071 * Decode a single audio block from the AC-3 bitstream.
1073 static int decode_audio_block(AC3DecodeContext *s, int blk, int offset)
1075 int fbw_channels = s->fbw_channels;
1076 int channel_mode = s->channel_mode;
1077 int i, bnd, seg, ch, ret;
1078 int different_transforms;
1081 GetBitContext *gbc = &s->gbc;
1082 uint8_t bit_alloc_stages[AC3_MAX_CHANNELS] = { 0 };
1084 /* block switch flags */
1085 different_transforms = 0;
1086 if (s->block_switch_syntax) {
1087 for (ch = 1; ch <= fbw_channels; ch++) {
1088 s->block_switch[ch] = get_bits1(gbc);
1089 if (ch > 1 && s->block_switch[ch] != s->block_switch[1])
1090 different_transforms = 1;
1094 /* dithering flags */
1095 if (s->dither_flag_syntax) {
1096 for (ch = 1; ch <= fbw_channels; ch++) {
1097 s->dither_flag[ch] = get_bits1(gbc);
1102 i = !s->channel_mode;
1104 if (get_bits1(gbc)) {
1105 /* Allow asymmetric application of DRC when drc_scale > 1.
1106 Amplification of quiet sounds is enhanced */
1107 int range_bits = get_bits(gbc, 8);
1108 INTFLOAT range = AC3_RANGE(range_bits);
1109 if (range_bits <= 127 || s->drc_scale <= 1.0)
1110 s->dynamic_range[i] = AC3_DYNAMIC_RANGE(range);
1112 s->dynamic_range[i] = range;
1113 } else if (blk == 0) {
1114 s->dynamic_range[i] = AC3_DYNAMIC_RANGE1;
1118 /* spectral extension strategy */
1119 if (s->eac3 && (!blk || get_bits1(gbc))) {
1120 s->spx_in_use = get_bits1(gbc);
1121 if (s->spx_in_use) {
1122 if ((ret = spx_strategy(s, blk)) < 0)
1126 if (!s->eac3 || !s->spx_in_use) {
1128 for (ch = 1; ch <= fbw_channels; ch++) {
1129 s->channel_uses_spx[ch] = 0;
1130 s->first_spx_coords[ch] = 1;
1134 /* spectral extension coordinates */
1138 /* coupling strategy */
1139 if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
1140 if ((ret = coupling_strategy(s, blk, bit_alloc_stages)) < 0)
1142 } else if (!s->eac3) {
1144 av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "
1145 "be present in block 0\n");
1146 return AVERROR_INVALIDDATA;
1148 s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
1151 cpl_in_use = s->cpl_in_use[blk];
1153 /* coupling coordinates */
1155 if ((ret = coupling_coordinates(s, blk)) < 0)
1159 /* stereo rematrixing strategy and band structure */
1160 if (channel_mode == AC3_CHMODE_STEREO) {
1161 if ((s->eac3 && !blk) || get_bits1(gbc)) {
1162 s->num_rematrixing_bands = 4;
1163 if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
1164 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
1165 } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
1166 s->num_rematrixing_bands--;
1168 for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
1169 s->rematrixing_flags[bnd] = get_bits1(gbc);
1171 av_log(s->avctx, AV_LOG_WARNING, "Warning: "
1172 "new rematrixing strategy not present in block 0\n");
1173 s->num_rematrixing_bands = 0;
1177 /* exponent strategies for each channel */
1178 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1180 s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
1181 if (s->exp_strategy[blk][ch] != EXP_REUSE)
1182 bit_alloc_stages[ch] = 3;
1185 /* channel bandwidth */
1186 for (ch = 1; ch <= fbw_channels; ch++) {
1187 s->start_freq[ch] = 0;
1188 if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1190 int prev = s->end_freq[ch];
1191 if (s->channel_in_cpl[ch])
1192 s->end_freq[ch] = s->start_freq[CPL_CH];
1193 else if (s->channel_uses_spx[ch])
1194 s->end_freq[ch] = s->spx_src_start_freq;
1196 int bandwidth_code = get_bits(gbc, 6);
1197 if (bandwidth_code > 60) {
1198 av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1199 return AVERROR_INVALIDDATA;
1201 s->end_freq[ch] = bandwidth_code * 3 + 73;
1203 group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1204 s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
1205 if (blk > 0 && s->end_freq[ch] != prev)
1206 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1209 if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1210 s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
1211 (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1214 /* decode exponents for each channel */
1215 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1216 if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1217 s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1218 if (decode_exponents(s, gbc, s->exp_strategy[blk][ch],
1219 s->num_exp_groups[ch], s->dexps[ch][0],
1220 &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1221 return AVERROR_INVALIDDATA;
1223 if (ch != CPL_CH && ch != s->lfe_ch)
1224 skip_bits(gbc, 2); /* skip gainrng */
1228 /* bit allocation information */
1229 if (s->bit_allocation_syntax) {
1230 if (get_bits1(gbc)) {
1231 s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1232 s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1233 s->bit_alloc_params.slow_gain = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
1234 s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
1235 s->bit_alloc_params.floor = ff_ac3_floor_tab[get_bits(gbc, 3)];
1236 for (ch = !cpl_in_use; ch <= s->channels; ch++)
1237 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1239 av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must "
1240 "be present in block 0\n");
1241 return AVERROR_INVALIDDATA;
1245 /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1246 if (!s->eac3 || !blk) {
1247 if (s->snr_offset_strategy && get_bits1(gbc)) {
1250 csnr = (get_bits(gbc, 6) - 15) << 4;
1251 for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1253 if (ch == i || s->snr_offset_strategy == 2)
1254 snr = (csnr + get_bits(gbc, 4)) << 2;
1255 /* run at least last bit allocation stage if snr offset changes */
1256 if (blk && s->snr_offset[ch] != snr) {
1257 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1259 s->snr_offset[ch] = snr;
1261 /* fast gain (normal AC-3 only) */
1263 int prev = s->fast_gain[ch];
1264 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1265 /* run last 2 bit allocation stages if fast gain changes */
1266 if (blk && prev != s->fast_gain[ch])
1267 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1270 } else if (!s->eac3 && !blk) {
1271 av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1272 return AVERROR_INVALIDDATA;
1276 /* fast gain (E-AC-3 only) */
1277 if (s->fast_gain_syntax && get_bits1(gbc)) {
1278 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1279 int prev = s->fast_gain[ch];
1280 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1281 /* run last 2 bit allocation stages if fast gain changes */
1282 if (blk && prev != s->fast_gain[ch])
1283 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1285 } else if (s->eac3 && !blk) {
1286 for (ch = !cpl_in_use; ch <= s->channels; ch++)
1287 s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1290 /* E-AC-3 to AC-3 converter SNR offset */
1291 if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1292 skip_bits(gbc, 10); // skip converter snr offset
1295 /* coupling leak information */
1297 if (s->first_cpl_leak || get_bits1(gbc)) {
1298 int fl = get_bits(gbc, 3);
1299 int sl = get_bits(gbc, 3);
1300 /* run last 2 bit allocation stages for coupling channel if
1301 coupling leak changes */
1302 if (blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1303 sl != s->bit_alloc_params.cpl_slow_leak)) {
1304 bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1306 s->bit_alloc_params.cpl_fast_leak = fl;
1307 s->bit_alloc_params.cpl_slow_leak = sl;
1308 } else if (!s->eac3 && !blk) {
1309 av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must "
1310 "be present in block 0\n");
1311 return AVERROR_INVALIDDATA;
1313 s->first_cpl_leak = 0;
1316 /* delta bit allocation information */
1317 if (s->dba_syntax && get_bits1(gbc)) {
1318 /* delta bit allocation exists (strategy) */
1319 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1320 s->dba_mode[ch] = get_bits(gbc, 2);
1321 if (s->dba_mode[ch] == DBA_RESERVED) {
1322 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1323 return AVERROR_INVALIDDATA;
1325 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1327 /* channel delta offset, len and bit allocation */
1328 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1329 if (s->dba_mode[ch] == DBA_NEW) {
1330 s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;
1331 for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
1332 s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1333 s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1334 s->dba_values[ch][seg] = get_bits(gbc, 3);
1336 /* run last 2 bit allocation stages if new dba values */
1337 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1340 } else if (blk == 0) {
1341 for (ch = 0; ch <= s->channels; ch++) {
1342 s->dba_mode[ch] = DBA_NONE;
1346 /* Bit allocation */
1347 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1348 if (bit_alloc_stages[ch] > 2) {
1349 /* Exponent mapping into PSD and PSD integration */
1350 ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
1351 s->start_freq[ch], s->end_freq[ch],
1352 s->psd[ch], s->band_psd[ch]);
1354 if (bit_alloc_stages[ch] > 1) {
1355 /* Compute excitation function, Compute masking curve, and
1356 Apply delta bit allocation */
1357 if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1358 s->start_freq[ch], s->end_freq[ch],
1359 s->fast_gain[ch], (ch == s->lfe_ch),
1360 s->dba_mode[ch], s->dba_nsegs[ch],
1361 s->dba_offsets[ch], s->dba_lengths[ch],
1362 s->dba_values[ch], s->mask[ch])) {
1363 av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1364 return AVERROR_INVALIDDATA;
1367 if (bit_alloc_stages[ch] > 0) {
1368 /* Compute bit allocation */
1369 const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1370 ff_eac3_hebap_tab : ff_ac3_bap_tab;
1371 s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1372 s->start_freq[ch], s->end_freq[ch],
1374 s->bit_alloc_params.floor,
1375 bap_tab, s->bap[ch]);
1379 /* unused dummy data */
1380 if (s->skip_syntax && get_bits1(gbc)) {
1381 int skipl = get_bits(gbc, 9);
1382 skip_bits_long(gbc, 8 * skipl);
1385 /* unpack the transform coefficients
1386 this also uncouples channels if coupling is in use. */
1387 decode_transform_coeffs(s, blk);
1389 /* TODO: generate enhanced coupling coordinates and uncouple */
1391 /* recover coefficients if rematrixing is in use */
1392 if (s->channel_mode == AC3_CHMODE_STEREO)
1395 /* apply scaling to coefficients (headroom, dynrng) */
1396 for (ch = 1; ch <= s->channels; ch++) {
1397 int audio_channel = 0;
1399 if (s->channel_mode == AC3_CHMODE_DUALMONO && ch <= 2)
1400 audio_channel = 2-ch;
1401 if (s->heavy_compression && s->compression_exists[audio_channel])
1402 gain = s->heavy_dynamic_range[audio_channel];
1404 gain = s->dynamic_range[audio_channel];
1407 scale_coefs(s->transform_coeffs[ch], s->fixed_coeffs[ch], gain, 256);
1409 if (s->target_level != 0)
1410 gain = gain * s->level_gain[audio_channel];
1411 gain *= 1.0 / 4194304.0f;
1412 s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch],
1413 s->fixed_coeffs[ch], gain, 256);
1417 /* apply spectral extension to high frequency bins */
1418 if (CONFIG_EAC3_DECODER && s->spx_in_use) {
1419 ff_eac3_apply_spectral_extension(s);
1422 /* downmix and MDCT. order depends on whether block switching is used for
1423 any channel in this block. this is because coefficients for the long
1424 and short transforms cannot be mixed. */
1425 downmix_output = s->channels != s->out_channels &&
1426 !((s->output_mode & AC3_OUTPUT_LFEON) &&
1427 s->fbw_channels == s->out_channels);
1428 if (different_transforms) {
1429 /* the delay samples have already been downmixed, so we upmix the delay
1430 samples in order to reconstruct all channels before downmixing. */
1436 do_imdct(s, s->channels, offset);
1438 if (downmix_output) {
1440 ac3_downmix_c_fixed16(s->outptr, s->downmix_coeffs,
1441 s->out_channels, s->fbw_channels, 256);
1443 ff_ac3dsp_downmix(&s->ac3dsp, s->outptr, s->downmix_coeffs,
1444 s->out_channels, s->fbw_channels, 256);
1448 if (downmix_output) {
1449 AC3_RENAME(ff_ac3dsp_downmix)(&s->ac3dsp, s->xcfptr + 1, s->downmix_coeffs,
1450 s->out_channels, s->fbw_channels, 256);
1453 if (downmix_output && !s->downmixed) {
1455 AC3_RENAME(ff_ac3dsp_downmix)(&s->ac3dsp, s->dlyptr, s->downmix_coeffs,
1456 s->out_channels, s->fbw_channels, 128);
1459 do_imdct(s, s->out_channels, offset);
1466 * Decode a single AC-3 frame.
1468 static int ac3_decode_frame(AVCodecContext * avctx, void *data,
1469 int *got_frame_ptr, AVPacket *avpkt)
1471 AVFrame *frame = data;
1472 const uint8_t *buf = avpkt->data;
1473 int buf_size, full_buf_size = avpkt->size;
1474 AC3DecodeContext *s = avctx->priv_data;
1475 int blk, ch, err, offset, ret;
1477 int skip = 0, got_independent_frame = 0;
1478 const uint8_t *channel_map;
1479 uint8_t extended_channel_map[EAC3_MAX_CHANNELS];
1480 const SHORTFLOAT *output[AC3_MAX_CHANNELS];
1481 enum AVMatrixEncoding matrix_encoding;
1482 AVDownmixInfo *downmix_info;
1484 s->superframe_size = 0;
1486 buf_size = full_buf_size;
1487 for (i = 1; i < buf_size; i += 2) {
1488 if (buf[i] == 0x77 || buf[i] == 0x0B) {
1489 if ((buf[i] ^ buf[i-1]) == (0x77 ^ 0x0B)) {
1492 } else if ((buf[i] ^ buf[i+1]) == (0x77 ^ 0x0B)) {
1498 return AVERROR_INVALIDDATA;
1504 /* copy input buffer to decoder context to avoid reading past the end
1505 of the buffer, which can be caused by a damaged input stream. */
1506 if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
1507 // seems to be byte-swapped AC-3
1508 int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1509 s->bdsp.bswap16_buf((uint16_t *) s->input_buffer,
1510 (const uint16_t *) buf, cnt);
1512 memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1514 /* if consistent noise generation is enabled, seed the linear feedback generator
1515 * with the contents of the AC-3 frame so that the noise is identical across
1516 * decodes given the same AC-3 frame data, for use with non-linear edititing software. */
1517 if (s->consistent_noise_generation)
1518 av_lfg_init_from_data(&s->dith_state, s->input_buffer, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1520 buf = s->input_buffer;
1522 /* initialize the GetBitContext with the start of valid AC-3 Frame */
1523 if ((ret = init_get_bits8(&s->gbc, buf, buf_size)) < 0)
1526 /* parse the syncinfo */
1527 err = parse_frame_header(s);
1531 case AAC_AC3_PARSE_ERROR_SYNC:
1532 av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1533 return AVERROR_INVALIDDATA;
1534 case AAC_AC3_PARSE_ERROR_BSID:
1535 av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1537 case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
1538 av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1540 case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
1541 av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1543 case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
1544 /* skip frame if CRC is ok. otherwise use error concealment. */
1545 /* TODO: add support for substreams */
1546 if (s->substreamid) {
1547 av_log(avctx, AV_LOG_DEBUG,
1548 "unsupported substream %d: skipping frame\n",
1553 av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1556 case AAC_AC3_PARSE_ERROR_CRC:
1557 case AAC_AC3_PARSE_ERROR_CHANNEL_CFG:
1559 default: // Normal AVERROR do not try to recover.
1564 /* check that reported frame size fits in input buffer */
1565 if (s->frame_size > buf_size) {
1566 av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1567 err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
1568 } else if (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL)) {
1569 /* check for crc mismatch */
1570 if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
1571 s->frame_size - 2)) {
1572 av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1573 if (avctx->err_recognition & AV_EF_EXPLODE)
1574 return AVERROR_INVALIDDATA;
1575 err = AAC_AC3_PARSE_ERROR_CRC;
1580 if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT && !got_independent_frame) {
1581 av_log(avctx, AV_LOG_WARNING, "Ignoring dependent frame without independent frame.\n");
1583 return FFMIN(full_buf_size, s->frame_size);
1586 /* channel config */
1587 if (!err || (s->channels && s->out_channels != s->channels)) {
1588 s->out_channels = s->channels;
1589 s->output_mode = s->channel_mode;
1591 s->output_mode |= AC3_OUTPUT_LFEON;
1592 if (s->channels > 1 &&
1593 avctx->request_channel_layout == AV_CH_LAYOUT_MONO) {
1594 s->out_channels = 1;
1595 s->output_mode = AC3_CHMODE_MONO;
1596 } else if (s->channels > 2 &&
1597 avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
1598 s->out_channels = 2;
1599 s->output_mode = AC3_CHMODE_STEREO;
1602 s->loro_center_mix_level = gain_levels[s-> center_mix_level];
1603 s->loro_surround_mix_level = gain_levels[s->surround_mix_level];
1604 s->ltrt_center_mix_level = LEVEL_MINUS_3DB;
1605 s->ltrt_surround_mix_level = LEVEL_MINUS_3DB;
1606 /* set downmixing coefficients if needed */
1607 if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1608 s->fbw_channels == s->out_channels)) {
1609 if ((ret = set_downmix_coeffs(s)) < 0) {
1610 av_log(avctx, AV_LOG_ERROR, "error setting downmix coeffs\n");
1614 } else if (!s->channels) {
1615 av_log(avctx, AV_LOG_ERROR, "unable to determine channel mode\n");
1616 return AVERROR_INVALIDDATA;
1618 avctx->channels = s->out_channels;
1619 avctx->channel_layout = avpriv_ac3_channel_layout_tab[s->output_mode & ~AC3_OUTPUT_LFEON];
1620 if (s->output_mode & AC3_OUTPUT_LFEON)
1621 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1623 /* set audio service type based on bitstream mode for AC-3 */
1624 avctx->audio_service_type = s->bitstream_mode;
1625 if (s->bitstream_mode == 0x7 && s->channels > 1)
1626 avctx->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
1628 /* decode the audio blocks */
1629 channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1630 offset = s->frame_type == EAC3_FRAME_TYPE_DEPENDENT ? AC3_MAX_CHANNELS : 0;
1631 for (ch = 0; ch < AC3_MAX_CHANNELS; ch++) {
1632 output[ch] = s->output[ch + offset];
1633 s->outptr[ch] = s->output[ch + offset];
1635 for (ch = 0; ch < s->channels; ch++) {
1636 if (ch < s->out_channels)
1637 s->outptr[channel_map[ch]] = s->output_buffer[ch + offset];
1639 for (blk = 0; blk < s->num_blocks; blk++) {
1640 if (!err && decode_audio_block(s, blk, offset)) {
1641 av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1645 for (ch = 0; ch < s->out_channels; ch++)
1646 memcpy(s->output_buffer[ch + offset] + AC3_BLOCK_SIZE*blk, output[ch], AC3_BLOCK_SIZE*sizeof(SHORTFLOAT));
1647 for (ch = 0; ch < s->out_channels; ch++)
1648 output[ch] = s->outptr[channel_map[ch]];
1649 for (ch = 0; ch < s->out_channels; ch++) {
1650 if (!ch || channel_map[ch])
1651 s->outptr[channel_map[ch]] += AC3_BLOCK_SIZE;
1655 /* keep last block for error concealment in next frame */
1656 for (ch = 0; ch < s->out_channels; ch++)
1657 memcpy(s->output[ch + offset], output[ch], AC3_BLOCK_SIZE*sizeof(SHORTFLOAT));
1659 /* check if there is dependent frame */
1660 if (buf_size > s->frame_size) {
1664 if (buf_size - s->frame_size <= 16) {
1665 skip = buf_size - s->frame_size;
1669 if ((ret = init_get_bits8(&s->gbc, buf + s->frame_size, buf_size - s->frame_size)) < 0)
1672 err = ff_ac3_parse_header(&s->gbc, &hdr);
1676 if (hdr.frame_type == EAC3_FRAME_TYPE_DEPENDENT) {
1677 if (hdr.num_blocks != s->num_blocks || s->sample_rate != hdr.sample_rate) {
1678 av_log(avctx, AV_LOG_WARNING, "Ignoring non-compatible dependent frame.\n");
1680 buf += s->frame_size;
1681 buf_size -= s->frame_size;
1682 s->prev_output_mode = s->output_mode;
1683 s->prev_bit_rate = s->bit_rate;
1684 got_independent_frame = 1;
1685 goto dependent_frame;
1691 frame->decode_error_flags = err ? FF_DECODE_ERROR_INVALID_BITSTREAM : 0;
1693 /* if frame is ok, set audio parameters */
1695 avctx->sample_rate = s->sample_rate;
1696 avctx->bit_rate = s->bit_rate + s->prev_bit_rate;
1699 for (ch = 0; ch < EAC3_MAX_CHANNELS; ch++)
1700 extended_channel_map[ch] = ch;
1702 if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT) {
1703 uint64_t ich_layout = avpriv_ac3_channel_layout_tab[s->prev_output_mode & ~AC3_OUTPUT_LFEON];
1704 int channel_map_size = ff_ac3_channels_tab[s->output_mode & ~AC3_OUTPUT_LFEON] + s->lfe_on;
1705 uint64_t channel_layout;
1708 if (s->prev_output_mode & AC3_OUTPUT_LFEON)
1709 ich_layout |= AV_CH_LOW_FREQUENCY;
1711 channel_layout = ich_layout;
1712 for (ch = 0; ch < 16; ch++) {
1713 if (s->channel_map & (1 << (EAC3_MAX_CHANNELS - ch - 1))) {
1714 channel_layout |= ff_eac3_custom_channel_map_locations[ch][1];
1717 if (av_get_channel_layout_nb_channels(channel_layout) > EAC3_MAX_CHANNELS) {
1718 av_log(avctx, AV_LOG_ERROR, "Too many channels (%d) coded\n",
1719 av_get_channel_layout_nb_channels(channel_layout));
1720 return AVERROR_INVALIDDATA;
1723 avctx->channel_layout = channel_layout;
1724 avctx->channels = av_get_channel_layout_nb_channels(channel_layout);
1726 for (ch = 0; ch < EAC3_MAX_CHANNELS; ch++) {
1727 if (s->channel_map & (1 << (EAC3_MAX_CHANNELS - ch - 1))) {
1728 if (ff_eac3_custom_channel_map_locations[ch][0]) {
1729 int index = av_get_channel_layout_channel_index(channel_layout,
1730 ff_eac3_custom_channel_map_locations[ch][1]);
1732 return AVERROR_INVALIDDATA;
1733 if (extend >= channel_map_size)
1734 return AVERROR_INVALIDDATA;
1736 extended_channel_map[index] = offset + channel_map[extend++];
1740 for (i = 0; i < 64; i++) {
1741 if ((1ULL << i) & ff_eac3_custom_channel_map_locations[ch][1]) {
1742 int index = av_get_channel_layout_channel_index(channel_layout,
1745 return AVERROR_INVALIDDATA;
1746 if (extend >= channel_map_size)
1747 return AVERROR_INVALIDDATA;
1749 extended_channel_map[index] = offset + channel_map[extend++];
1757 /* get output buffer */
1758 frame->nb_samples = s->num_blocks * AC3_BLOCK_SIZE;
1759 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1762 for (ch = 0; ch < avctx->channels; ch++) {
1763 int map = extended_channel_map[ch];
1764 av_assert0(ch>=AV_NUM_DATA_POINTERS || frame->extended_data[ch] == frame->data[ch]);
1765 memcpy((SHORTFLOAT *)frame->extended_data[ch],
1766 s->output_buffer[map],
1767 s->num_blocks * AC3_BLOCK_SIZE * sizeof(SHORTFLOAT));
1773 * Check whether the input layout is compatible, and make sure we're not
1774 * downmixing (else the matrix encoding is no longer applicable).
1776 matrix_encoding = AV_MATRIX_ENCODING_NONE;
1777 if (s->channel_mode == AC3_CHMODE_STEREO &&
1778 s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1779 if (s->dolby_surround_mode == AC3_DSURMOD_ON)
1780 matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
1781 else if (s->dolby_headphone_mode == AC3_DHEADPHONMOD_ON)
1782 matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;
1783 } else if (s->channel_mode >= AC3_CHMODE_2F2R &&
1784 s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1785 switch (s->dolby_surround_ex_mode) {
1786 case AC3_DSUREXMOD_ON: // EX or PLIIx
1787 matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
1789 case AC3_DSUREXMOD_PLIIZ:
1790 matrix_encoding = AV_MATRIX_ENCODING_DPLIIZ;
1792 default: // not indicated or off
1796 if ((ret = ff_side_data_update_matrix_encoding(frame, matrix_encoding)) < 0)
1800 if ((downmix_info = av_downmix_info_update_side_data(frame))) {
1801 switch (s->preferred_downmix) {
1802 case AC3_DMIXMOD_LTRT:
1803 downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_LTRT;
1805 case AC3_DMIXMOD_LORO:
1806 downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_LORO;
1808 case AC3_DMIXMOD_DPLII:
1809 downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_DPLII;
1812 downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_UNKNOWN;
1815 downmix_info->center_mix_level = gain_levels[s-> center_mix_level];
1816 downmix_info->center_mix_level_ltrt = gain_levels[s-> center_mix_level_ltrt];
1817 downmix_info->surround_mix_level = gain_levels[s-> surround_mix_level];
1818 downmix_info->surround_mix_level_ltrt = gain_levels[s->surround_mix_level_ltrt];
1819 if (s->lfe_mix_level_exists)
1820 downmix_info->lfe_mix_level = gain_levels_lfe[s->lfe_mix_level];
1822 downmix_info->lfe_mix_level = 0.0; // -inf dB
1824 return AVERROR(ENOMEM);
1828 if (!s->superframe_size)
1829 return FFMIN(full_buf_size, s->frame_size + skip);
1831 return FFMIN(full_buf_size, s->superframe_size + skip);
1835 * Uninitialize the AC-3 decoder.
1837 static av_cold int ac3_decode_end(AVCodecContext *avctx)
1839 AC3DecodeContext *s = avctx->priv_data;
1840 ff_mdct_end(&s->imdct_512);
1841 ff_mdct_end(&s->imdct_256);
1843 av_freep(&s->downmix_coeffs[0]);
1848 #define OFFSET(x) offsetof(AC3DecodeContext, x)
1849 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)