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 Libav.
12 * Libav 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 * Libav 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 Libav; if not, write to the Free Software
24 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
32 #include "libavutil/channel_layout.h"
33 #include "libavutil/crc.h"
34 #include "libavutil/downmix_info.h"
35 #include "libavutil/opt.h"
38 #include "aac_ac3_parser.h"
39 #include "ac3_parser.h"
41 #include "ac3dec_data.h"
45 * table for ungrouping 3 values in 7 bits.
46 * used for exponents and bap=2 mantissas
48 static uint8_t ungroup_3_in_7_bits_tab[128][3];
50 /** tables for ungrouping mantissas */
51 static int b1_mantissas[32][3];
52 static int b2_mantissas[128][3];
53 static int b3_mantissas[8];
54 static int b4_mantissas[128][2];
55 static int b5_mantissas[16];
58 * Quantization table: levels for symmetric. bits for asymmetric.
59 * reference: Table 7.18 Mapping of bap to Quantizer
61 static const uint8_t quantization_tab[16] = {
63 5, 6, 7, 8, 9, 10, 11, 12, 14, 16
66 /** dynamic range table. converts codes to scale factors. */
67 static float dynamic_range_tab[256];
69 /** Adjustments in dB gain */
70 static const float gain_levels[9] = {
74 LEVEL_MINUS_1POINT5DB,
76 LEVEL_MINUS_4POINT5DB,
82 /** Adjustments in dB gain (LFE, +10 to -21 dB) */
83 static const float gain_levels_lfe[32] = {
84 3.162275, 2.818382, 2.511886, 2.238719, 1.995261, 1.778278, 1.584893,
85 1.412536, 1.258924, 1.122018, 1.000000, 0.891251, 0.794328, 0.707946,
86 0.630957, 0.562341, 0.501187, 0.446683, 0.398107, 0.354813, 0.316227,
87 0.281838, 0.251188, 0.223872, 0.199526, 0.177828, 0.158489, 0.141253,
88 0.125892, 0.112201, 0.100000, 0.089125
92 * Table for default stereo downmixing coefficients
93 * reference: Section 7.8.2 Downmixing Into Two Channels
95 static const uint8_t ac3_default_coeffs[8][5][2] = {
96 { { 2, 7 }, { 7, 2 }, },
98 { { 2, 7 }, { 7, 2 }, },
99 { { 2, 7 }, { 5, 5 }, { 7, 2 }, },
100 { { 2, 7 }, { 7, 2 }, { 6, 6 }, },
101 { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 }, },
102 { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
103 { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
107 * Symmetrical Dequantization
108 * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization
109 * Tables 7.19 to 7.23
112 symmetric_dequant(int code, int levels)
114 return ((code - (levels >> 1)) << 24) / levels;
118 * Initialize tables at runtime.
120 static av_cold void ac3_tables_init(void)
124 /* generate table for ungrouping 3 values in 7 bits
125 reference: Section 7.1.3 Exponent Decoding */
126 for (i = 0; i < 128; i++) {
127 ungroup_3_in_7_bits_tab[i][0] = i / 25;
128 ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5;
129 ungroup_3_in_7_bits_tab[i][2] = (i % 25) % 5;
132 /* generate grouped mantissa tables
133 reference: Section 7.3.5 Ungrouping of Mantissas */
134 for (i = 0; i < 32; i++) {
135 /* bap=1 mantissas */
136 b1_mantissas[i][0] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][0], 3);
137 b1_mantissas[i][1] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][1], 3);
138 b1_mantissas[i][2] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][2], 3);
140 for (i = 0; i < 128; i++) {
141 /* bap=2 mantissas */
142 b2_mantissas[i][0] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][0], 5);
143 b2_mantissas[i][1] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][1], 5);
144 b2_mantissas[i][2] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][2], 5);
146 /* bap=4 mantissas */
147 b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
148 b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
150 /* generate ungrouped mantissa tables
151 reference: Tables 7.21 and 7.23 */
152 for (i = 0; i < 7; i++) {
153 /* bap=3 mantissas */
154 b3_mantissas[i] = symmetric_dequant(i, 7);
156 for (i = 0; i < 15; i++) {
157 /* bap=5 mantissas */
158 b5_mantissas[i] = symmetric_dequant(i, 15);
161 /* generate dynamic range table
162 reference: Section 7.7.1 Dynamic Range Control */
163 for (i = 0; i < 256; i++) {
164 int v = (i >> 5) - ((i >> 7) << 3) - 5;
165 dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
170 * AVCodec initialization
172 static av_cold int ac3_decode_init(AVCodecContext *avctx)
174 AC3DecodeContext *s = avctx->priv_data;
179 ff_ac3_common_init();
181 ff_mdct_init(&s->imdct_256, 8, 1, 1.0);
182 ff_mdct_init(&s->imdct_512, 9, 1, 1.0);
183 ff_kbd_window_init(s->window, 5.0, 256);
184 ff_bswapdsp_init(&s->bdsp);
185 avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
186 ff_ac3dsp_init(&s->ac3dsp, avctx->flags & CODEC_FLAG_BITEXACT);
187 ff_fmt_convert_init(&s->fmt_conv, avctx);
188 av_lfg_init(&s->dith_state, 0);
190 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
192 /* allow downmixing to stereo or mono */
193 #if FF_API_REQUEST_CHANNELS
194 FF_DISABLE_DEPRECATION_WARNINGS
195 if (avctx->request_channels == 1)
196 avctx->request_channel_layout = AV_CH_LAYOUT_MONO;
197 else if (avctx->request_channels == 2)
198 avctx->request_channel_layout = AV_CH_LAYOUT_STEREO;
199 FF_ENABLE_DEPRECATION_WARNINGS
201 if (avctx->channels > 1 &&
202 avctx->request_channel_layout == AV_CH_LAYOUT_MONO)
204 else if (avctx->channels > 2 &&
205 avctx->request_channel_layout == AV_CH_LAYOUT_STEREO)
209 for (i = 0; i < AC3_MAX_CHANNELS; i++) {
210 s->xcfptr[i] = s->transform_coeffs[i];
211 s->dlyptr[i] = s->delay[i];
218 * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
219 * GetBitContext within AC3DecodeContext must point to
220 * the start of the synchronized AC-3 bitstream.
222 static int ac3_parse_header(AC3DecodeContext *s)
224 GetBitContext *gbc = &s->gbc;
227 /* read the rest of the bsi. read twice for dual mono mode. */
228 i = !s->channel_mode;
230 skip_bits(gbc, 5); // skip dialog normalization
232 skip_bits(gbc, 8); //skip compression
234 skip_bits(gbc, 8); //skip language code
236 skip_bits(gbc, 7); //skip audio production information
239 skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
241 /* skip the timecodes or parse the Alternate Bit Stream Syntax */
242 if (s->bitstream_id != 6) {
244 skip_bits(gbc, 14); //skip timecode1
246 skip_bits(gbc, 14); //skip timecode2
248 if (get_bits1(gbc)) {
249 s->preferred_downmix = get_bits(gbc, 2);
250 s->center_mix_level_ltrt = get_bits(gbc, 3);
251 s->surround_mix_level_ltrt = av_clip(get_bits(gbc, 3), 3, 7);
252 s->center_mix_level = get_bits(gbc, 3);
253 s->surround_mix_level = av_clip(get_bits(gbc, 3), 3, 7);
255 if (get_bits1(gbc)) {
256 s->dolby_surround_ex_mode = get_bits(gbc, 2);
257 s->dolby_headphone_mode = get_bits(gbc, 2);
258 skip_bits(gbc, 10); // skip adconvtyp (1), xbsi2 (8), encinfo (1)
262 /* skip additional bitstream info */
263 if (get_bits1(gbc)) {
264 i = get_bits(gbc, 6);
274 * Common function to parse AC-3 or E-AC-3 frame header
276 static int parse_frame_header(AC3DecodeContext *s)
281 err = avpriv_ac3_parse_header(&s->gbc, &hdr);
285 /* get decoding parameters from header info */
286 s->bit_alloc_params.sr_code = hdr.sr_code;
287 s->bitstream_id = hdr.bitstream_id;
288 s->bitstream_mode = hdr.bitstream_mode;
289 s->channel_mode = hdr.channel_mode;
290 s->lfe_on = hdr.lfe_on;
291 s->bit_alloc_params.sr_shift = hdr.sr_shift;
292 s->sample_rate = hdr.sample_rate;
293 s->bit_rate = hdr.bit_rate;
294 s->channels = hdr.channels;
295 s->fbw_channels = s->channels - s->lfe_on;
296 s->lfe_ch = s->fbw_channels + 1;
297 s->frame_size = hdr.frame_size;
298 s->preferred_downmix = AC3_DMIXMOD_NOTINDICATED;
299 s->center_mix_level = hdr.center_mix_level;
300 s->center_mix_level_ltrt = 4; // -3.0dB
301 s->surround_mix_level = hdr.surround_mix_level;
302 s->surround_mix_level_ltrt = 4; // -3.0dB
303 s->lfe_mix_level_exists = 0;
304 s->num_blocks = hdr.num_blocks;
305 s->frame_type = hdr.frame_type;
306 s->substreamid = hdr.substreamid;
307 s->dolby_surround_mode = hdr.dolby_surround_mode;
308 s->dolby_surround_ex_mode = AC3_DSUREXMOD_NOTINDICATED;
309 s->dolby_headphone_mode = AC3_DHEADPHONMOD_NOTINDICATED;
312 s->start_freq[s->lfe_ch] = 0;
313 s->end_freq[s->lfe_ch] = 7;
314 s->num_exp_groups[s->lfe_ch] = 2;
315 s->channel_in_cpl[s->lfe_ch] = 0;
318 if (s->bitstream_id <= 10) {
320 s->snr_offset_strategy = 2;
321 s->block_switch_syntax = 1;
322 s->dither_flag_syntax = 1;
323 s->bit_allocation_syntax = 1;
324 s->fast_gain_syntax = 0;
325 s->first_cpl_leak = 0;
328 memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
329 return ac3_parse_header(s);
330 } else if (CONFIG_EAC3_DECODER) {
332 return ff_eac3_parse_header(s);
334 av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n");
335 return AVERROR(ENOSYS);
340 * Set stereo downmixing coefficients based on frame header info.
341 * reference: Section 7.8.2 Downmixing Into Two Channels
343 static void set_downmix_coeffs(AC3DecodeContext *s)
346 float cmix = gain_levels[s-> center_mix_level];
347 float smix = gain_levels[s->surround_mix_level];
350 for (i = 0; i < s->fbw_channels; i++) {
351 s->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
352 s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
354 if (s->channel_mode > 1 && s->channel_mode & 1) {
355 s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix;
357 if (s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
358 int nf = s->channel_mode - 2;
359 s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
361 if (s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
362 int nf = s->channel_mode - 4;
363 s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix;
368 for (i = 0; i < s->fbw_channels; i++) {
369 norm0 += s->downmix_coeffs[i][0];
370 norm1 += s->downmix_coeffs[i][1];
372 norm0 = 1.0f / norm0;
373 norm1 = 1.0f / norm1;
374 for (i = 0; i < s->fbw_channels; i++) {
375 s->downmix_coeffs[i][0] *= norm0;
376 s->downmix_coeffs[i][1] *= norm1;
379 if (s->output_mode == AC3_CHMODE_MONO) {
380 for (i = 0; i < s->fbw_channels; i++)
381 s->downmix_coeffs[i][0] = (s->downmix_coeffs[i][0] +
382 s->downmix_coeffs[i][1]) * LEVEL_MINUS_3DB;
387 * Decode the grouped exponents according to exponent strategy.
388 * reference: Section 7.1.3 Exponent Decoding
390 static int decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
391 uint8_t absexp, int8_t *dexps)
393 int i, j, grp, group_size;
398 group_size = exp_strategy + (exp_strategy == EXP_D45);
399 for (grp = 0, i = 0; grp < ngrps; grp++) {
400 expacc = get_bits(gbc, 7);
401 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
402 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
403 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
406 /* convert to absolute exps and expand groups */
408 for (i = 0, j = 0; i < ngrps * 3; i++) {
409 prevexp += dexp[i] - 2;
412 switch (group_size) {
413 case 4: dexps[j++] = prevexp;
414 dexps[j++] = prevexp;
415 case 2: dexps[j++] = prevexp;
416 case 1: dexps[j++] = prevexp;
423 * Generate transform coefficients for each coupled channel in the coupling
424 * range using the coupling coefficients and coupling coordinates.
425 * reference: Section 7.4.3 Coupling Coordinate Format
427 static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
431 bin = s->start_freq[CPL_CH];
432 for (band = 0; band < s->num_cpl_bands; band++) {
433 int band_start = bin;
434 int band_end = bin + s->cpl_band_sizes[band];
435 for (ch = 1; ch <= s->fbw_channels; ch++) {
436 if (s->channel_in_cpl[ch]) {
437 int cpl_coord = s->cpl_coords[ch][band] << 5;
438 for (bin = band_start; bin < band_end; bin++) {
439 s->fixed_coeffs[ch][bin] =
440 MULH(s->fixed_coeffs[CPL_CH][bin] << 4, cpl_coord);
442 if (ch == 2 && s->phase_flags[band]) {
443 for (bin = band_start; bin < band_end; bin++)
444 s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin];
453 * Grouped mantissas for 3-level 5-level and 11-level quantization
465 * Decode the transform coefficients for a particular channel
466 * reference: Section 7.3 Quantization and Decoding of Mantissas
468 static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
470 int start_freq = s->start_freq[ch_index];
471 int end_freq = s->end_freq[ch_index];
472 uint8_t *baps = s->bap[ch_index];
473 int8_t *exps = s->dexps[ch_index];
474 int32_t *coeffs = s->fixed_coeffs[ch_index];
475 int dither = (ch_index == CPL_CH) || s->dither_flag[ch_index];
476 GetBitContext *gbc = &s->gbc;
479 for (freq = start_freq; freq < end_freq; freq++) {
480 int bap = baps[freq];
484 /* random noise with approximate range of -0.707 to 0.707 */
486 mantissa = (av_lfg_get(&s->dith_state) / 362) - 5932275;
493 mantissa = m->b1_mant[m->b1];
495 int bits = get_bits(gbc, 5);
496 mantissa = b1_mantissas[bits][0];
497 m->b1_mant[1] = b1_mantissas[bits][1];
498 m->b1_mant[0] = b1_mantissas[bits][2];
505 mantissa = m->b2_mant[m->b2];
507 int bits = get_bits(gbc, 7);
508 mantissa = b2_mantissas[bits][0];
509 m->b2_mant[1] = b2_mantissas[bits][1];
510 m->b2_mant[0] = b2_mantissas[bits][2];
515 mantissa = b3_mantissas[get_bits(gbc, 3)];
520 mantissa = m->b4_mant;
522 int bits = get_bits(gbc, 7);
523 mantissa = b4_mantissas[bits][0];
524 m->b4_mant = b4_mantissas[bits][1];
529 mantissa = b5_mantissas[get_bits(gbc, 4)];
531 default: /* 6 to 15 */
532 /* Shift mantissa and sign-extend it. */
533 mantissa = get_sbits(gbc, quantization_tab[bap]);
534 mantissa <<= 24 - quantization_tab[bap];
537 coeffs[freq] = mantissa >> exps[freq];
542 * Remove random dithering from coupling range coefficients with zero-bit
543 * mantissas for coupled channels which do not use dithering.
544 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
546 static void remove_dithering(AC3DecodeContext *s) {
549 for (ch = 1; ch <= s->fbw_channels; ch++) {
550 if (!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
551 for (i = s->start_freq[CPL_CH]; i < s->end_freq[CPL_CH]; i++) {
552 if (!s->bap[CPL_CH][i])
553 s->fixed_coeffs[ch][i] = 0;
559 static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,
562 if (!s->channel_uses_aht[ch]) {
563 ac3_decode_transform_coeffs_ch(s, ch, m);
565 /* if AHT is used, mantissas for all blocks are encoded in the first
566 block of the frame. */
568 if (!blk && CONFIG_EAC3_DECODER)
569 ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
570 for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
571 s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
577 * Decode the transform coefficients.
579 static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
585 m.b1 = m.b2 = m.b4 = 0;
587 for (ch = 1; ch <= s->channels; ch++) {
588 /* transform coefficients for full-bandwidth channel */
589 decode_transform_coeffs_ch(s, blk, ch, &m);
590 /* transform coefficients for coupling channel come right after the
591 coefficients for the first coupled channel*/
592 if (s->channel_in_cpl[ch]) {
594 decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
595 calc_transform_coeffs_cpl(s);
598 end = s->end_freq[CPL_CH];
600 end = s->end_freq[ch];
603 s->fixed_coeffs[ch][end] = 0;
607 /* zero the dithered coefficients for appropriate channels */
612 * Stereo rematrixing.
613 * reference: Section 7.5.4 Rematrixing : Decoding Technique
615 static void do_rematrixing(AC3DecodeContext *s)
620 end = FFMIN(s->end_freq[1], s->end_freq[2]);
622 for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) {
623 if (s->rematrixing_flags[bnd]) {
624 bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd + 1]);
625 for (i = ff_ac3_rematrix_band_tab[bnd]; i < bndend; i++) {
626 int tmp0 = s->fixed_coeffs[1][i];
627 s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
628 s->fixed_coeffs[2][i] = tmp0 - s->fixed_coeffs[2][i];
635 * Inverse MDCT Transform.
636 * Convert frequency domain coefficients to time-domain audio samples.
637 * reference: Section 7.9.4 Transformation Equations
639 static inline void do_imdct(AC3DecodeContext *s, int channels)
643 for (ch = 1; ch <= channels; ch++) {
644 if (s->block_switch[ch]) {
646 float *x = s->tmp_output + 128;
647 for (i = 0; i < 128; i++)
648 x[i] = s->transform_coeffs[ch][2 * i];
649 s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
650 s->fdsp.vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
651 s->tmp_output, s->window, 128);
652 for (i = 0; i < 128; i++)
653 x[i] = s->transform_coeffs[ch][2 * i + 1];
654 s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch - 1], x);
656 s->imdct_512.imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
657 s->fdsp.vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
658 s->tmp_output, s->window, 128);
659 memcpy(s->delay[ch - 1], s->tmp_output + 128, 128 * sizeof(float));
665 * Upmix delay samples from stereo to original channel layout.
667 static void ac3_upmix_delay(AC3DecodeContext *s)
669 int channel_data_size = sizeof(s->delay[0]);
670 switch (s->channel_mode) {
671 case AC3_CHMODE_DUALMONO:
672 case AC3_CHMODE_STEREO:
673 /* upmix mono to stereo */
674 memcpy(s->delay[1], s->delay[0], channel_data_size);
676 case AC3_CHMODE_2F2R:
677 memset(s->delay[3], 0, channel_data_size);
678 case AC3_CHMODE_2F1R:
679 memset(s->delay[2], 0, channel_data_size);
681 case AC3_CHMODE_3F2R:
682 memset(s->delay[4], 0, channel_data_size);
683 case AC3_CHMODE_3F1R:
684 memset(s->delay[3], 0, channel_data_size);
686 memcpy(s->delay[2], s->delay[1], channel_data_size);
687 memset(s->delay[1], 0, channel_data_size);
693 * Decode band structure for coupling, spectral extension, or enhanced coupling.
694 * The band structure defines how many subbands are in each band. For each
695 * subband in the range, 1 means it is combined with the previous band, and 0
696 * means that it starts a new band.
698 * @param[in] gbc bit reader context
699 * @param[in] blk block number
700 * @param[in] eac3 flag to indicate E-AC-3
701 * @param[in] ecpl flag to indicate enhanced coupling
702 * @param[in] start_subband subband number for start of range
703 * @param[in] end_subband subband number for end of range
704 * @param[in] default_band_struct default band structure table
705 * @param[out] num_bands number of bands (optionally NULL)
706 * @param[out] band_sizes array containing the number of bins in each band (optionally NULL)
708 static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
709 int ecpl, int start_subband, int end_subband,
710 const uint8_t *default_band_struct,
711 int *num_bands, uint8_t *band_sizes)
713 int subbnd, bnd, n_subbands, n_bands=0;
715 uint8_t coded_band_struct[22];
716 const uint8_t *band_struct;
718 n_subbands = end_subband - start_subband;
720 /* decode band structure from bitstream or use default */
721 if (!eac3 || get_bits1(gbc)) {
722 for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
723 coded_band_struct[subbnd] = get_bits1(gbc);
725 band_struct = coded_band_struct;
727 band_struct = &default_band_struct[start_subband+1];
729 /* no change in band structure */
733 /* calculate number of bands and band sizes based on band structure.
734 note that the first 4 subbands in enhanced coupling span only 6 bins
736 if (num_bands || band_sizes ) {
737 n_bands = n_subbands;
738 bnd_sz[0] = ecpl ? 6 : 12;
739 for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
740 int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
741 if (band_struct[subbnd - 1]) {
743 bnd_sz[bnd] += subbnd_size;
745 bnd_sz[++bnd] = subbnd_size;
750 /* set optional output params */
752 *num_bands = n_bands;
754 memcpy(band_sizes, bnd_sz, n_bands);
758 * Decode a single audio block from the AC-3 bitstream.
760 static int decode_audio_block(AC3DecodeContext *s, int blk)
762 int fbw_channels = s->fbw_channels;
763 int channel_mode = s->channel_mode;
765 int different_transforms;
768 GetBitContext *gbc = &s->gbc;
769 uint8_t bit_alloc_stages[AC3_MAX_CHANNELS] = { 0 };
771 /* block switch flags */
772 different_transforms = 0;
773 if (s->block_switch_syntax) {
774 for (ch = 1; ch <= fbw_channels; ch++) {
775 s->block_switch[ch] = get_bits1(gbc);
776 if (ch > 1 && s->block_switch[ch] != s->block_switch[1])
777 different_transforms = 1;
781 /* dithering flags */
782 if (s->dither_flag_syntax) {
783 for (ch = 1; ch <= fbw_channels; ch++) {
784 s->dither_flag[ch] = get_bits1(gbc);
789 i = !s->channel_mode;
791 if (get_bits1(gbc)) {
792 /* Allow asymmetric application of DRC when drc_scale > 1.
793 Amplification of quiet sounds is enhanced */
794 float range = dynamic_range_tab[get_bits(gbc, 8)];
795 if (range > 1.0 || s->drc_scale <= 1.0)
796 s->dynamic_range[i] = powf(range, s->drc_scale);
798 s->dynamic_range[i] = range;
799 } else if (blk == 0) {
800 s->dynamic_range[i] = 1.0f;
804 /* spectral extension strategy */
805 if (s->eac3 && (!blk || get_bits1(gbc))) {
806 s->spx_in_use = get_bits1(gbc);
808 int dst_start_freq, dst_end_freq, src_start_freq,
809 start_subband, end_subband;
811 /* determine which channels use spx */
812 if (s->channel_mode == AC3_CHMODE_MONO) {
813 s->channel_uses_spx[1] = 1;
815 for (ch = 1; ch <= fbw_channels; ch++)
816 s->channel_uses_spx[ch] = get_bits1(gbc);
819 /* get the frequency bins of the spx copy region and the spx start
821 dst_start_freq = get_bits(gbc, 2);
822 start_subband = get_bits(gbc, 3) + 2;
823 if (start_subband > 7)
824 start_subband += start_subband - 7;
825 end_subband = get_bits(gbc, 3) + 5;
827 end_subband += end_subband - 7;
828 dst_start_freq = dst_start_freq * 12 + 25;
829 src_start_freq = start_subband * 12 + 25;
830 dst_end_freq = end_subband * 12 + 25;
832 /* check validity of spx ranges */
833 if (start_subband >= end_subband) {
834 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
835 "range (%d >= %d)\n", start_subband, end_subband);
836 return AVERROR_INVALIDDATA;
838 if (dst_start_freq >= src_start_freq) {
839 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
840 "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
841 return AVERROR_INVALIDDATA;
844 s->spx_dst_start_freq = dst_start_freq;
845 s->spx_src_start_freq = src_start_freq;
846 s->spx_dst_end_freq = dst_end_freq;
848 decode_band_structure(gbc, blk, s->eac3, 0,
849 start_subband, end_subband,
850 ff_eac3_default_spx_band_struct,
854 for (ch = 1; ch <= fbw_channels; ch++) {
855 s->channel_uses_spx[ch] = 0;
856 s->first_spx_coords[ch] = 1;
861 /* spectral extension coordinates */
863 for (ch = 1; ch <= fbw_channels; ch++) {
864 if (s->channel_uses_spx[ch]) {
865 if (s->first_spx_coords[ch] || get_bits1(gbc)) {
867 int bin, master_spx_coord;
869 s->first_spx_coords[ch] = 0;
870 spx_blend = get_bits(gbc, 5) * (1.0f/32);
871 master_spx_coord = get_bits(gbc, 2) * 3;
873 bin = s->spx_src_start_freq;
874 for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
876 int spx_coord_exp, spx_coord_mant;
877 float nratio, sblend, nblend, spx_coord;
879 /* calculate blending factors */
880 bandsize = s->spx_band_sizes[bnd];
881 nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
882 nratio = av_clipf(nratio, 0.0f, 1.0f);
883 nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
884 // to give unity variance
885 sblend = sqrtf(1.0f - nratio);
888 /* decode spx coordinates */
889 spx_coord_exp = get_bits(gbc, 4);
890 spx_coord_mant = get_bits(gbc, 2);
891 if (spx_coord_exp == 15) spx_coord_mant <<= 1;
892 else spx_coord_mant += 4;
893 spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
894 spx_coord = spx_coord_mant * (1.0f / (1 << 23));
896 /* multiply noise and signal blending factors by spx coordinate */
897 s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
898 s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
902 s->first_spx_coords[ch] = 1;
907 /* coupling strategy */
908 if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
909 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
911 s->cpl_in_use[blk] = get_bits1(gbc);
912 if (s->cpl_in_use[blk]) {
913 /* coupling in use */
914 int cpl_start_subband, cpl_end_subband;
916 if (channel_mode < AC3_CHMODE_STEREO) {
917 av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
918 return AVERROR_INVALIDDATA;
921 /* check for enhanced coupling */
922 if (s->eac3 && get_bits1(gbc)) {
923 /* TODO: parse enhanced coupling strategy info */
924 avpriv_request_sample(s->avctx, "Enhanced coupling");
925 return AVERROR_PATCHWELCOME;
928 /* determine which channels are coupled */
929 if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
930 s->channel_in_cpl[1] = 1;
931 s->channel_in_cpl[2] = 1;
933 for (ch = 1; ch <= fbw_channels; ch++)
934 s->channel_in_cpl[ch] = get_bits1(gbc);
937 /* phase flags in use */
938 if (channel_mode == AC3_CHMODE_STEREO)
939 s->phase_flags_in_use = get_bits1(gbc);
941 /* coupling frequency range */
942 cpl_start_subband = get_bits(gbc, 4);
943 cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
944 get_bits(gbc, 4) + 3;
945 if (cpl_start_subband >= cpl_end_subband) {
946 av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
947 cpl_start_subband, cpl_end_subband);
948 return AVERROR_INVALIDDATA;
950 s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
951 s->end_freq[CPL_CH] = cpl_end_subband * 12 + 37;
953 decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
955 ff_eac3_default_cpl_band_struct,
956 &s->num_cpl_bands, s->cpl_band_sizes);
958 /* coupling not in use */
959 for (ch = 1; ch <= fbw_channels; ch++) {
960 s->channel_in_cpl[ch] = 0;
961 s->first_cpl_coords[ch] = 1;
963 s->first_cpl_leak = s->eac3;
964 s->phase_flags_in_use = 0;
966 } else if (!s->eac3) {
968 av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "
969 "be present in block 0\n");
970 return AVERROR_INVALIDDATA;
972 s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
975 cpl_in_use = s->cpl_in_use[blk];
977 /* coupling coordinates */
979 int cpl_coords_exist = 0;
981 for (ch = 1; ch <= fbw_channels; ch++) {
982 if (s->channel_in_cpl[ch]) {
983 if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
984 int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
985 s->first_cpl_coords[ch] = 0;
986 cpl_coords_exist = 1;
987 master_cpl_coord = 3 * get_bits(gbc, 2);
988 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
989 cpl_coord_exp = get_bits(gbc, 4);
990 cpl_coord_mant = get_bits(gbc, 4);
991 if (cpl_coord_exp == 15)
992 s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
994 s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
995 s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
998 av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
999 "be present in block 0\n");
1000 return AVERROR_INVALIDDATA;
1003 /* channel not in coupling */
1004 s->first_cpl_coords[ch] = 1;
1008 if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
1009 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1010 s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
1015 /* stereo rematrixing strategy and band structure */
1016 if (channel_mode == AC3_CHMODE_STEREO) {
1017 if ((s->eac3 && !blk) || get_bits1(gbc)) {
1018 s->num_rematrixing_bands = 4;
1019 if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
1020 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
1021 } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
1022 s->num_rematrixing_bands--;
1024 for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
1025 s->rematrixing_flags[bnd] = get_bits1(gbc);
1027 av_log(s->avctx, AV_LOG_WARNING, "Warning: "
1028 "new rematrixing strategy not present in block 0\n");
1029 s->num_rematrixing_bands = 0;
1033 /* exponent strategies for each channel */
1034 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1036 s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
1037 if (s->exp_strategy[blk][ch] != EXP_REUSE)
1038 bit_alloc_stages[ch] = 3;
1041 /* channel bandwidth */
1042 for (ch = 1; ch <= fbw_channels; ch++) {
1043 s->start_freq[ch] = 0;
1044 if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1046 int prev = s->end_freq[ch];
1047 if (s->channel_in_cpl[ch])
1048 s->end_freq[ch] = s->start_freq[CPL_CH];
1049 else if (s->channel_uses_spx[ch])
1050 s->end_freq[ch] = s->spx_src_start_freq;
1052 int bandwidth_code = get_bits(gbc, 6);
1053 if (bandwidth_code > 60) {
1054 av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1055 return AVERROR_INVALIDDATA;
1057 s->end_freq[ch] = bandwidth_code * 3 + 73;
1059 group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1060 s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
1061 if (blk > 0 && s->end_freq[ch] != prev)
1062 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1065 if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1066 s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
1067 (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1070 /* decode exponents for each channel */
1071 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1072 if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1073 s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1074 if (decode_exponents(gbc, s->exp_strategy[blk][ch],
1075 s->num_exp_groups[ch], s->dexps[ch][0],
1076 &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1077 av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
1078 return AVERROR_INVALIDDATA;
1080 if (ch != CPL_CH && ch != s->lfe_ch)
1081 skip_bits(gbc, 2); /* skip gainrng */
1085 /* bit allocation information */
1086 if (s->bit_allocation_syntax) {
1087 if (get_bits1(gbc)) {
1088 s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1089 s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1090 s->bit_alloc_params.slow_gain = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
1091 s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
1092 s->bit_alloc_params.floor = ff_ac3_floor_tab[get_bits(gbc, 3)];
1093 for (ch = !cpl_in_use; ch <= s->channels; ch++)
1094 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1096 av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must "
1097 "be present in block 0\n");
1098 return AVERROR_INVALIDDATA;
1102 /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1103 if (!s->eac3 || !blk) {
1104 if (s->snr_offset_strategy && get_bits1(gbc)) {
1107 csnr = (get_bits(gbc, 6) - 15) << 4;
1108 for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1110 if (ch == i || s->snr_offset_strategy == 2)
1111 snr = (csnr + get_bits(gbc, 4)) << 2;
1112 /* run at least last bit allocation stage if snr offset changes */
1113 if (blk && s->snr_offset[ch] != snr) {
1114 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1116 s->snr_offset[ch] = snr;
1118 /* fast gain (normal AC-3 only) */
1120 int prev = s->fast_gain[ch];
1121 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1122 /* run last 2 bit allocation stages if fast gain changes */
1123 if (blk && prev != s->fast_gain[ch])
1124 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1127 } else if (!s->eac3 && !blk) {
1128 av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1129 return AVERROR_INVALIDDATA;
1133 /* fast gain (E-AC-3 only) */
1134 if (s->fast_gain_syntax && get_bits1(gbc)) {
1135 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1136 int prev = s->fast_gain[ch];
1137 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1138 /* run last 2 bit allocation stages if fast gain changes */
1139 if (blk && prev != s->fast_gain[ch])
1140 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1142 } else if (s->eac3 && !blk) {
1143 for (ch = !cpl_in_use; ch <= s->channels; ch++)
1144 s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1147 /* E-AC-3 to AC-3 converter SNR offset */
1148 if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1149 skip_bits(gbc, 10); // skip converter snr offset
1152 /* coupling leak information */
1154 if (s->first_cpl_leak || get_bits1(gbc)) {
1155 int fl = get_bits(gbc, 3);
1156 int sl = get_bits(gbc, 3);
1157 /* run last 2 bit allocation stages for coupling channel if
1158 coupling leak changes */
1159 if (blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1160 sl != s->bit_alloc_params.cpl_slow_leak)) {
1161 bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1163 s->bit_alloc_params.cpl_fast_leak = fl;
1164 s->bit_alloc_params.cpl_slow_leak = sl;
1165 } else if (!s->eac3 && !blk) {
1166 av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must "
1167 "be present in block 0\n");
1168 return AVERROR_INVALIDDATA;
1170 s->first_cpl_leak = 0;
1173 /* delta bit allocation information */
1174 if (s->dba_syntax && get_bits1(gbc)) {
1175 /* delta bit allocation exists (strategy) */
1176 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1177 s->dba_mode[ch] = get_bits(gbc, 2);
1178 if (s->dba_mode[ch] == DBA_RESERVED) {
1179 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1180 return AVERROR_INVALIDDATA;
1182 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1184 /* channel delta offset, len and bit allocation */
1185 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1186 if (s->dba_mode[ch] == DBA_NEW) {
1187 s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;
1188 for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
1189 s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1190 s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1191 s->dba_values[ch][seg] = get_bits(gbc, 3);
1193 /* run last 2 bit allocation stages if new dba values */
1194 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1197 } else if (blk == 0) {
1198 for (ch = 0; ch <= s->channels; ch++) {
1199 s->dba_mode[ch] = DBA_NONE;
1203 /* Bit allocation */
1204 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1205 if (bit_alloc_stages[ch] > 2) {
1206 /* Exponent mapping into PSD and PSD integration */
1207 ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
1208 s->start_freq[ch], s->end_freq[ch],
1209 s->psd[ch], s->band_psd[ch]);
1211 if (bit_alloc_stages[ch] > 1) {
1212 /* Compute excitation function, Compute masking curve, and
1213 Apply delta bit allocation */
1214 if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1215 s->start_freq[ch], s->end_freq[ch],
1216 s->fast_gain[ch], (ch == s->lfe_ch),
1217 s->dba_mode[ch], s->dba_nsegs[ch],
1218 s->dba_offsets[ch], s->dba_lengths[ch],
1219 s->dba_values[ch], s->mask[ch])) {
1220 av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1221 return AVERROR_INVALIDDATA;
1224 if (bit_alloc_stages[ch] > 0) {
1225 /* Compute bit allocation */
1226 const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1227 ff_eac3_hebap_tab : ff_ac3_bap_tab;
1228 s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1229 s->start_freq[ch], s->end_freq[ch],
1231 s->bit_alloc_params.floor,
1232 bap_tab, s->bap[ch]);
1236 /* unused dummy data */
1237 if (s->skip_syntax && get_bits1(gbc)) {
1238 int skipl = get_bits(gbc, 9);
1243 /* unpack the transform coefficients
1244 this also uncouples channels if coupling is in use. */
1245 decode_transform_coeffs(s, blk);
1247 /* TODO: generate enhanced coupling coordinates and uncouple */
1249 /* recover coefficients if rematrixing is in use */
1250 if (s->channel_mode == AC3_CHMODE_STEREO)
1253 /* apply scaling to coefficients (headroom, dynrng) */
1254 for (ch = 1; ch <= s->channels; ch++) {
1255 float gain = 1.0 / 4194304.0f;
1256 if (s->channel_mode == AC3_CHMODE_DUALMONO) {
1257 gain *= s->dynamic_range[2 - ch];
1259 gain *= s->dynamic_range[0];
1261 s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch],
1262 s->fixed_coeffs[ch], gain, 256);
1265 /* apply spectral extension to high frequency bins */
1266 if (s->spx_in_use && CONFIG_EAC3_DECODER) {
1267 ff_eac3_apply_spectral_extension(s);
1270 /* downmix and MDCT. order depends on whether block switching is used for
1271 any channel in this block. this is because coefficients for the long
1272 and short transforms cannot be mixed. */
1273 downmix_output = s->channels != s->out_channels &&
1274 !((s->output_mode & AC3_OUTPUT_LFEON) &&
1275 s->fbw_channels == s->out_channels);
1276 if (different_transforms) {
1277 /* the delay samples have already been downmixed, so we upmix the delay
1278 samples in order to reconstruct all channels before downmixing. */
1284 do_imdct(s, s->channels);
1286 if (downmix_output) {
1287 s->ac3dsp.downmix(s->outptr, s->downmix_coeffs,
1288 s->out_channels, s->fbw_channels, 256);
1291 if (downmix_output) {
1292 s->ac3dsp.downmix(s->xcfptr + 1, s->downmix_coeffs,
1293 s->out_channels, s->fbw_channels, 256);
1296 if (downmix_output && !s->downmixed) {
1298 s->ac3dsp.downmix(s->dlyptr, s->downmix_coeffs, s->out_channels,
1299 s->fbw_channels, 128);
1302 do_imdct(s, s->out_channels);
1309 * Decode a single AC-3 frame.
1311 static int ac3_decode_frame(AVCodecContext * avctx, void *data,
1312 int *got_frame_ptr, AVPacket *avpkt)
1314 AVFrame *frame = data;
1315 const uint8_t *buf = avpkt->data;
1316 int buf_size = avpkt->size;
1317 AC3DecodeContext *s = avctx->priv_data;
1318 int blk, ch, err, ret;
1319 const uint8_t *channel_map;
1320 const float *output[AC3_MAX_CHANNELS];
1321 enum AVMatrixEncoding matrix_encoding;
1322 AVDownmixInfo *downmix_info;
1324 /* copy input buffer to decoder context to avoid reading past the end
1325 of the buffer, which can be caused by a damaged input stream. */
1326 if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
1327 // seems to be byte-swapped AC-3
1328 int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1329 s->bdsp.bswap16_buf((uint16_t *) s->input_buffer,
1330 (const uint16_t *) buf, cnt);
1332 memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1333 buf = s->input_buffer;
1334 /* initialize the GetBitContext with the start of valid AC-3 Frame */
1335 init_get_bits(&s->gbc, buf, buf_size * 8);
1337 /* parse the syncinfo */
1338 err = parse_frame_header(s);
1342 case AAC_AC3_PARSE_ERROR_SYNC:
1343 av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1344 return AVERROR_INVALIDDATA;
1345 case AAC_AC3_PARSE_ERROR_BSID:
1346 av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1348 case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
1349 av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1351 case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
1352 av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1354 case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
1355 /* skip frame if CRC is ok. otherwise use error concealment. */
1356 /* TODO: add support for substreams and dependent frames */
1357 if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
1358 av_log(avctx, AV_LOG_WARNING, "unsupported frame type : "
1359 "skipping frame\n");
1363 av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1366 case AAC_AC3_PARSE_ERROR_CRC:
1367 case AAC_AC3_PARSE_ERROR_CHANNEL_CFG:
1369 default: // Normal AVERROR do not try to recover.
1374 /* check that reported frame size fits in input buffer */
1375 if (s->frame_size > buf_size) {
1376 av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1377 err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
1378 } else if (avctx->err_recognition & AV_EF_CRCCHECK) {
1379 /* check for crc mismatch */
1380 if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
1381 s->frame_size - 2)) {
1382 av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1383 if (avctx->err_recognition & AV_EF_EXPLODE)
1384 return AVERROR_INVALIDDATA;
1385 err = AAC_AC3_PARSE_ERROR_CRC;
1390 /* if frame is ok, set audio parameters */
1392 avctx->sample_rate = s->sample_rate;
1393 avctx->bit_rate = s->bit_rate;
1396 /* channel config */
1397 if (!err || (s->channels && s->out_channels != s->channels)) {
1398 s->out_channels = s->channels;
1399 s->output_mode = s->channel_mode;
1401 s->output_mode |= AC3_OUTPUT_LFEON;
1402 if (s->channels > 1 &&
1403 avctx->request_channel_layout == AV_CH_LAYOUT_MONO) {
1404 s->out_channels = 1;
1405 s->output_mode = AC3_CHMODE_MONO;
1406 } else if (s->channels > 2 &&
1407 avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
1408 s->out_channels = 2;
1409 s->output_mode = AC3_CHMODE_STEREO;
1412 /* set downmixing coefficients if needed */
1413 if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1414 s->fbw_channels == s->out_channels)) {
1415 set_downmix_coeffs(s);
1417 } else if (!s->channels) {
1418 av_log(avctx, AV_LOG_ERROR, "unable to determine channel mode\n");
1419 return AVERROR_INVALIDDATA;
1421 avctx->channels = s->out_channels;
1422 avctx->channel_layout = avpriv_ac3_channel_layout_tab[s->output_mode & ~AC3_OUTPUT_LFEON];
1423 if (s->output_mode & AC3_OUTPUT_LFEON)
1424 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1426 /* set audio service type based on bitstream mode for AC-3 */
1427 avctx->audio_service_type = s->bitstream_mode;
1428 if (s->bitstream_mode == 0x7 && s->channels > 1)
1429 avctx->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
1431 /* get output buffer */
1432 frame->nb_samples = s->num_blocks * AC3_BLOCK_SIZE;
1433 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
1434 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1438 /* decode the audio blocks */
1439 channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1440 for (ch = 0; ch < s->channels; ch++) {
1441 if (ch < s->out_channels)
1442 s->outptr[channel_map[ch]] = (float *)frame->data[ch];
1444 s->outptr[ch] = s->output[ch];
1445 output[ch] = s->output[ch];
1447 for (blk = 0; blk < s->num_blocks; blk++) {
1448 if (!err && decode_audio_block(s, blk)) {
1449 av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1453 for (ch = 0; ch < s->out_channels; ch++)
1454 memcpy(s->outptr[channel_map[ch]], output[ch], sizeof(**output) * AC3_BLOCK_SIZE);
1455 for (ch = 0; ch < s->out_channels; ch++)
1456 output[ch] = s->outptr[channel_map[ch]];
1457 for (ch = 0; ch < s->out_channels; ch++)
1458 s->outptr[ch] += AC3_BLOCK_SIZE;
1461 /* keep last block for error concealment in next frame */
1462 for (ch = 0; ch < s->out_channels; ch++)
1463 memcpy(s->output[ch], output[ch], sizeof(**output) * AC3_BLOCK_SIZE);
1468 * Check whether the input layout is compatible, and make sure we're not
1469 * downmixing (else the matrix encoding is no longer applicable).
1471 matrix_encoding = AV_MATRIX_ENCODING_NONE;
1472 if (s->channel_mode == AC3_CHMODE_STEREO &&
1473 s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1474 if (s->dolby_surround_mode == AC3_DSURMOD_ON)
1475 matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
1476 else if (s->dolby_headphone_mode == AC3_DHEADPHONMOD_ON)
1477 matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;
1478 } else if (s->channel_mode >= AC3_CHMODE_2F2R &&
1479 s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1480 switch (s->dolby_surround_ex_mode) {
1481 case AC3_DSUREXMOD_ON: // EX or PLIIx
1482 matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
1484 case AC3_DSUREXMOD_PLIIZ:
1485 matrix_encoding = AV_MATRIX_ENCODING_DPLIIZ;
1487 default: // not indicated or off
1491 if ((ret = ff_side_data_update_matrix_encoding(frame, matrix_encoding)) < 0)
1495 if ((downmix_info = av_downmix_info_update_side_data(frame))) {
1496 switch (s->preferred_downmix) {
1497 case AC3_DMIXMOD_LTRT:
1498 downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_LTRT;
1500 case AC3_DMIXMOD_LORO:
1501 downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_LORO;
1503 case AC3_DMIXMOD_DPLII:
1504 downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_DPLII;
1507 downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_UNKNOWN;
1510 downmix_info->center_mix_level = gain_levels[s-> center_mix_level];
1511 downmix_info->center_mix_level_ltrt = gain_levels[s-> center_mix_level_ltrt];
1512 downmix_info->surround_mix_level = gain_levels[s-> surround_mix_level];
1513 downmix_info->surround_mix_level_ltrt = gain_levels[s->surround_mix_level_ltrt];
1514 if (s->lfe_mix_level_exists)
1515 downmix_info->lfe_mix_level = gain_levels_lfe[s->lfe_mix_level];
1517 downmix_info->lfe_mix_level = 0.0; // -inf dB
1519 return AVERROR(ENOMEM);
1523 return FFMIN(buf_size, s->frame_size);
1527 * Uninitialize the AC-3 decoder.
1529 static av_cold int ac3_decode_end(AVCodecContext *avctx)
1531 AC3DecodeContext *s = avctx->priv_data;
1532 ff_mdct_end(&s->imdct_512);
1533 ff_mdct_end(&s->imdct_256);
1538 #define OFFSET(x) offsetof(AC3DecodeContext, x)
1539 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)
1540 static const AVOption options[] = {
1541 { "drc_scale", "percentage of dynamic range compression to apply", OFFSET(drc_scale), AV_OPT_TYPE_FLOAT, {.dbl = 1.0}, 0.0, 6.0, PAR },
1545 static const AVClass ac3_decoder_class = {
1546 .class_name = "AC3 decoder",
1547 .item_name = av_default_item_name,
1549 .version = LIBAVUTIL_VERSION_INT,
1552 AVCodec ff_ac3_decoder = {
1554 .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
1555 .type = AVMEDIA_TYPE_AUDIO,
1556 .id = AV_CODEC_ID_AC3,
1557 .priv_data_size = sizeof (AC3DecodeContext),
1558 .init = ac3_decode_init,
1559 .close = ac3_decode_end,
1560 .decode = ac3_decode_frame,
1561 .capabilities = CODEC_CAP_DR1,
1562 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1563 AV_SAMPLE_FMT_NONE },
1564 .priv_class = &ac3_decoder_class,
1567 #if CONFIG_EAC3_DECODER
1568 static const AVClass eac3_decoder_class = {
1569 .class_name = "E-AC3 decoder",
1570 .item_name = av_default_item_name,
1572 .version = LIBAVUTIL_VERSION_INT,
1575 AVCodec ff_eac3_decoder = {
1577 .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
1578 .type = AVMEDIA_TYPE_AUDIO,
1579 .id = AV_CODEC_ID_EAC3,
1580 .priv_data_size = sizeof (AC3DecodeContext),
1581 .init = ac3_decode_init,
1582 .close = ac3_decode_end,
1583 .decode = ac3_decode_frame,
1584 .capabilities = CODEC_CAP_DR1,
1585 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1586 AV_SAMPLE_FMT_NONE },
1587 .priv_class = &eac3_decoder_class,