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/opt.h"
36 #include "aac_ac3_parser.h"
37 #include "ac3_parser.h"
39 #include "ac3dec_data.h"
43 * table for ungrouping 3 values in 7 bits.
44 * used for exponents and bap=2 mantissas
46 static uint8_t ungroup_3_in_7_bits_tab[128][3];
48 /** tables for ungrouping mantissas */
49 static int b1_mantissas[32][3];
50 static int b2_mantissas[128][3];
51 static int b3_mantissas[8];
52 static int b4_mantissas[128][2];
53 static int b5_mantissas[16];
56 * Quantization table: levels for symmetric. bits for asymmetric.
57 * reference: Table 7.18 Mapping of bap to Quantizer
59 static const uint8_t quantization_tab[16] = {
61 5, 6, 7, 8, 9, 10, 11, 12, 14, 16
64 /** dynamic range table. converts codes to scale factors. */
65 static float dynamic_range_tab[256];
67 /** Adjustments in dB gain */
68 static const float gain_levels[9] = {
72 LEVEL_MINUS_1POINT5DB,
74 LEVEL_MINUS_4POINT5DB,
81 * Table for default stereo downmixing coefficients
82 * reference: Section 7.8.2 Downmixing Into Two Channels
84 static const uint8_t ac3_default_coeffs[8][5][2] = {
85 { { 2, 7 }, { 7, 2 }, },
87 { { 2, 7 }, { 7, 2 }, },
88 { { 2, 7 }, { 5, 5 }, { 7, 2 }, },
89 { { 2, 7 }, { 7, 2 }, { 6, 6 }, },
90 { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 }, },
91 { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
92 { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
96 * Symmetrical Dequantization
97 * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization
101 symmetric_dequant(int code, int levels)
103 return ((code - (levels >> 1)) << 24) / levels;
107 * Initialize tables at runtime.
109 static av_cold void ac3_tables_init(void)
113 /* generate table for ungrouping 3 values in 7 bits
114 reference: Section 7.1.3 Exponent Decoding */
115 for (i = 0; i < 128; i++) {
116 ungroup_3_in_7_bits_tab[i][0] = i / 25;
117 ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5;
118 ungroup_3_in_7_bits_tab[i][2] = (i % 25) % 5;
121 /* generate grouped mantissa tables
122 reference: Section 7.3.5 Ungrouping of Mantissas */
123 for (i = 0; i < 32; i++) {
124 /* bap=1 mantissas */
125 b1_mantissas[i][0] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][0], 3);
126 b1_mantissas[i][1] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][1], 3);
127 b1_mantissas[i][2] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][2], 3);
129 for (i = 0; i < 128; i++) {
130 /* bap=2 mantissas */
131 b2_mantissas[i][0] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][0], 5);
132 b2_mantissas[i][1] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][1], 5);
133 b2_mantissas[i][2] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][2], 5);
135 /* bap=4 mantissas */
136 b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
137 b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
139 /* generate ungrouped mantissa tables
140 reference: Tables 7.21 and 7.23 */
141 for (i = 0; i < 7; i++) {
142 /* bap=3 mantissas */
143 b3_mantissas[i] = symmetric_dequant(i, 7);
145 for (i = 0; i < 15; i++) {
146 /* bap=5 mantissas */
147 b5_mantissas[i] = symmetric_dequant(i, 15);
150 /* generate dynamic range table
151 reference: Section 7.7.1 Dynamic Range Control */
152 for (i = 0; i < 256; i++) {
153 int v = (i >> 5) - ((i >> 7) << 3) - 5;
154 dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
159 * AVCodec initialization
161 static av_cold int ac3_decode_init(AVCodecContext *avctx)
163 AC3DecodeContext *s = avctx->priv_data;
168 ff_ac3_common_init();
170 ff_mdct_init(&s->imdct_256, 8, 1, 1.0);
171 ff_mdct_init(&s->imdct_512, 9, 1, 1.0);
172 ff_kbd_window_init(s->window, 5.0, 256);
173 ff_dsputil_init(&s->dsp, avctx);
174 avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
175 ff_ac3dsp_init(&s->ac3dsp, avctx->flags & CODEC_FLAG_BITEXACT);
176 ff_fmt_convert_init(&s->fmt_conv, avctx);
177 av_lfg_init(&s->dith_state, 0);
179 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
181 /* allow downmixing to stereo or mono */
182 #if FF_API_REQUEST_CHANNELS
183 FF_DISABLE_DEPRECATION_WARNINGS
184 if (avctx->request_channels == 1)
185 avctx->request_channel_layout = AV_CH_LAYOUT_MONO;
186 else if (avctx->request_channels == 2)
187 avctx->request_channel_layout = AV_CH_LAYOUT_STEREO;
188 FF_ENABLE_DEPRECATION_WARNINGS
190 if (avctx->channels > 1 &&
191 avctx->request_channel_layout == AV_CH_LAYOUT_MONO)
193 else if (avctx->channels > 2 &&
194 avctx->request_channel_layout == AV_CH_LAYOUT_STEREO)
198 for (i = 0; i < AC3_MAX_CHANNELS; i++) {
199 s->xcfptr[i] = s->transform_coeffs[i];
200 s->dlyptr[i] = s->delay[i];
207 * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
208 * GetBitContext within AC3DecodeContext must point to
209 * the start of the synchronized AC-3 bitstream.
211 static int ac3_parse_header(AC3DecodeContext *s)
213 GetBitContext *gbc = &s->gbc;
216 /* read the rest of the bsi. read twice for dual mono mode. */
217 i = !s->channel_mode;
219 skip_bits(gbc, 5); // skip dialog normalization
221 skip_bits(gbc, 8); //skip compression
223 skip_bits(gbc, 8); //skip language code
225 skip_bits(gbc, 7); //skip audio production information
228 skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
230 /* skip the timecodes or parse the Alternate Bit Stream Syntax */
231 if (s->bitstream_id != 6) {
233 skip_bits(gbc, 14); //skip timecode1
235 skip_bits(gbc, 14); //skip timecode2
237 if (get_bits1(gbc)) {
238 s->preferred_downmix = get_bits(gbc, 2);
239 s->center_mix_level_ltrt = get_bits(gbc, 3);
240 s->surround_mix_level_ltrt = av_clip(get_bits(gbc, 3), 3, 7);
241 s->center_mix_level = get_bits(gbc, 3);
242 s->surround_mix_level = av_clip(get_bits(gbc, 3), 3, 7);
244 if (get_bits1(gbc)) {
245 s->dolby_surround_ex_mode = get_bits(gbc, 2);
246 s->dolby_headphone_mode = get_bits(gbc, 2);
247 skip_bits(gbc, 10); // skip adconvtyp (1), xbsi2 (8), encinfo (1)
251 /* skip additional bitstream info */
252 if (get_bits1(gbc)) {
253 i = get_bits(gbc, 6);
263 * Common function to parse AC-3 or E-AC-3 frame header
265 static int parse_frame_header(AC3DecodeContext *s)
270 err = avpriv_ac3_parse_header(&s->gbc, &hdr);
274 /* get decoding parameters from header info */
275 s->bit_alloc_params.sr_code = hdr.sr_code;
276 s->bitstream_id = hdr.bitstream_id;
277 s->bitstream_mode = hdr.bitstream_mode;
278 s->channel_mode = hdr.channel_mode;
279 s->lfe_on = hdr.lfe_on;
280 s->bit_alloc_params.sr_shift = hdr.sr_shift;
281 s->sample_rate = hdr.sample_rate;
282 s->bit_rate = hdr.bit_rate;
283 s->channels = hdr.channels;
284 s->fbw_channels = s->channels - s->lfe_on;
285 s->lfe_ch = s->fbw_channels + 1;
286 s->frame_size = hdr.frame_size;
287 s->preferred_downmix = AC3_DMIXMOD_NOTINDICATED;
288 s->center_mix_level = hdr.center_mix_level;
289 s->center_mix_level_ltrt = 4; // -3.0dB
290 s->surround_mix_level = hdr.surround_mix_level;
291 s->surround_mix_level_ltrt = 4; // -3.0dB
292 s->lfe_mix_level_exists = 0;
293 s->num_blocks = hdr.num_blocks;
294 s->frame_type = hdr.frame_type;
295 s->substreamid = hdr.substreamid;
296 s->dolby_surround_mode = hdr.dolby_surround_mode;
297 s->dolby_surround_ex_mode = AC3_DSUREXMOD_NOTINDICATED;
298 s->dolby_headphone_mode = AC3_DHEADPHONMOD_NOTINDICATED;
301 s->start_freq[s->lfe_ch] = 0;
302 s->end_freq[s->lfe_ch] = 7;
303 s->num_exp_groups[s->lfe_ch] = 2;
304 s->channel_in_cpl[s->lfe_ch] = 0;
307 if (s->bitstream_id <= 10) {
309 s->snr_offset_strategy = 2;
310 s->block_switch_syntax = 1;
311 s->dither_flag_syntax = 1;
312 s->bit_allocation_syntax = 1;
313 s->fast_gain_syntax = 0;
314 s->first_cpl_leak = 0;
317 memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
318 return ac3_parse_header(s);
319 } else if (CONFIG_EAC3_DECODER) {
321 return ff_eac3_parse_header(s);
323 av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n");
324 return AVERROR(ENOSYS);
329 * Set stereo downmixing coefficients based on frame header info.
330 * reference: Section 7.8.2 Downmixing Into Two Channels
332 static void set_downmix_coeffs(AC3DecodeContext *s)
335 float cmix = gain_levels[s-> center_mix_level];
336 float smix = gain_levels[s->surround_mix_level];
339 for (i = 0; i < s->fbw_channels; i++) {
340 s->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
341 s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
343 if (s->channel_mode > 1 && s->channel_mode & 1) {
344 s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix;
346 if (s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
347 int nf = s->channel_mode - 2;
348 s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
350 if (s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
351 int nf = s->channel_mode - 4;
352 s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix;
357 for (i = 0; i < s->fbw_channels; i++) {
358 norm0 += s->downmix_coeffs[i][0];
359 norm1 += s->downmix_coeffs[i][1];
361 norm0 = 1.0f / norm0;
362 norm1 = 1.0f / norm1;
363 for (i = 0; i < s->fbw_channels; i++) {
364 s->downmix_coeffs[i][0] *= norm0;
365 s->downmix_coeffs[i][1] *= norm1;
368 if (s->output_mode == AC3_CHMODE_MONO) {
369 for (i = 0; i < s->fbw_channels; i++)
370 s->downmix_coeffs[i][0] = (s->downmix_coeffs[i][0] +
371 s->downmix_coeffs[i][1]) * LEVEL_MINUS_3DB;
376 * Decode the grouped exponents according to exponent strategy.
377 * reference: Section 7.1.3 Exponent Decoding
379 static int decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
380 uint8_t absexp, int8_t *dexps)
382 int i, j, grp, group_size;
387 group_size = exp_strategy + (exp_strategy == EXP_D45);
388 for (grp = 0, i = 0; grp < ngrps; grp++) {
389 expacc = get_bits(gbc, 7);
390 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
391 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
392 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
395 /* convert to absolute exps and expand groups */
397 for (i = 0, j = 0; i < ngrps * 3; i++) {
398 prevexp += dexp[i] - 2;
401 switch (group_size) {
402 case 4: dexps[j++] = prevexp;
403 dexps[j++] = prevexp;
404 case 2: dexps[j++] = prevexp;
405 case 1: dexps[j++] = prevexp;
412 * Generate transform coefficients for each coupled channel in the coupling
413 * range using the coupling coefficients and coupling coordinates.
414 * reference: Section 7.4.3 Coupling Coordinate Format
416 static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
420 bin = s->start_freq[CPL_CH];
421 for (band = 0; band < s->num_cpl_bands; band++) {
422 int band_start = bin;
423 int band_end = bin + s->cpl_band_sizes[band];
424 for (ch = 1; ch <= s->fbw_channels; ch++) {
425 if (s->channel_in_cpl[ch]) {
426 int cpl_coord = s->cpl_coords[ch][band] << 5;
427 for (bin = band_start; bin < band_end; bin++) {
428 s->fixed_coeffs[ch][bin] =
429 MULH(s->fixed_coeffs[CPL_CH][bin] << 4, cpl_coord);
431 if (ch == 2 && s->phase_flags[band]) {
432 for (bin = band_start; bin < band_end; bin++)
433 s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin];
442 * Grouped mantissas for 3-level 5-level and 11-level quantization
454 * Decode the transform coefficients for a particular channel
455 * reference: Section 7.3 Quantization and Decoding of Mantissas
457 static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
459 int start_freq = s->start_freq[ch_index];
460 int end_freq = s->end_freq[ch_index];
461 uint8_t *baps = s->bap[ch_index];
462 int8_t *exps = s->dexps[ch_index];
463 int32_t *coeffs = s->fixed_coeffs[ch_index];
464 int dither = (ch_index == CPL_CH) || s->dither_flag[ch_index];
465 GetBitContext *gbc = &s->gbc;
468 for (freq = start_freq; freq < end_freq; freq++) {
469 int bap = baps[freq];
473 /* random noise with approximate range of -0.707 to 0.707 */
475 mantissa = (av_lfg_get(&s->dith_state) / 362) - 5932275;
482 mantissa = m->b1_mant[m->b1];
484 int bits = get_bits(gbc, 5);
485 mantissa = b1_mantissas[bits][0];
486 m->b1_mant[1] = b1_mantissas[bits][1];
487 m->b1_mant[0] = b1_mantissas[bits][2];
494 mantissa = m->b2_mant[m->b2];
496 int bits = get_bits(gbc, 7);
497 mantissa = b2_mantissas[bits][0];
498 m->b2_mant[1] = b2_mantissas[bits][1];
499 m->b2_mant[0] = b2_mantissas[bits][2];
504 mantissa = b3_mantissas[get_bits(gbc, 3)];
509 mantissa = m->b4_mant;
511 int bits = get_bits(gbc, 7);
512 mantissa = b4_mantissas[bits][0];
513 m->b4_mant = b4_mantissas[bits][1];
518 mantissa = b5_mantissas[get_bits(gbc, 4)];
520 default: /* 6 to 15 */
521 /* Shift mantissa and sign-extend it. */
522 mantissa = get_sbits(gbc, quantization_tab[bap]);
523 mantissa <<= 24 - quantization_tab[bap];
526 coeffs[freq] = mantissa >> exps[freq];
531 * Remove random dithering from coupling range coefficients with zero-bit
532 * mantissas for coupled channels which do not use dithering.
533 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
535 static void remove_dithering(AC3DecodeContext *s) {
538 for (ch = 1; ch <= s->fbw_channels; ch++) {
539 if (!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
540 for (i = s->start_freq[CPL_CH]; i < s->end_freq[CPL_CH]; i++) {
541 if (!s->bap[CPL_CH][i])
542 s->fixed_coeffs[ch][i] = 0;
548 static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,
551 if (!s->channel_uses_aht[ch]) {
552 ac3_decode_transform_coeffs_ch(s, ch, m);
554 /* if AHT is used, mantissas for all blocks are encoded in the first
555 block of the frame. */
557 if (!blk && CONFIG_EAC3_DECODER)
558 ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
559 for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
560 s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
566 * Decode the transform coefficients.
568 static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
574 m.b1 = m.b2 = m.b4 = 0;
576 for (ch = 1; ch <= s->channels; ch++) {
577 /* transform coefficients for full-bandwidth channel */
578 decode_transform_coeffs_ch(s, blk, ch, &m);
579 /* transform coefficients for coupling channel come right after the
580 coefficients for the first coupled channel*/
581 if (s->channel_in_cpl[ch]) {
583 decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
584 calc_transform_coeffs_cpl(s);
587 end = s->end_freq[CPL_CH];
589 end = s->end_freq[ch];
592 s->fixed_coeffs[ch][end] = 0;
596 /* zero the dithered coefficients for appropriate channels */
601 * Stereo rematrixing.
602 * reference: Section 7.5.4 Rematrixing : Decoding Technique
604 static void do_rematrixing(AC3DecodeContext *s)
609 end = FFMIN(s->end_freq[1], s->end_freq[2]);
611 for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) {
612 if (s->rematrixing_flags[bnd]) {
613 bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd + 1]);
614 for (i = ff_ac3_rematrix_band_tab[bnd]; i < bndend; i++) {
615 int tmp0 = s->fixed_coeffs[1][i];
616 s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
617 s->fixed_coeffs[2][i] = tmp0 - s->fixed_coeffs[2][i];
624 * Inverse MDCT Transform.
625 * Convert frequency domain coefficients to time-domain audio samples.
626 * reference: Section 7.9.4 Transformation Equations
628 static inline void do_imdct(AC3DecodeContext *s, int channels)
632 for (ch = 1; ch <= channels; ch++) {
633 if (s->block_switch[ch]) {
635 float *x = s->tmp_output + 128;
636 for (i = 0; i < 128; i++)
637 x[i] = s->transform_coeffs[ch][2 * i];
638 s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
639 s->fdsp.vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
640 s->tmp_output, s->window, 128);
641 for (i = 0; i < 128; i++)
642 x[i] = s->transform_coeffs[ch][2 * i + 1];
643 s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch - 1], x);
645 s->imdct_512.imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
646 s->fdsp.vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
647 s->tmp_output, s->window, 128);
648 memcpy(s->delay[ch - 1], s->tmp_output + 128, 128 * sizeof(float));
654 * Upmix delay samples from stereo to original channel layout.
656 static void ac3_upmix_delay(AC3DecodeContext *s)
658 int channel_data_size = sizeof(s->delay[0]);
659 switch (s->channel_mode) {
660 case AC3_CHMODE_DUALMONO:
661 case AC3_CHMODE_STEREO:
662 /* upmix mono to stereo */
663 memcpy(s->delay[1], s->delay[0], channel_data_size);
665 case AC3_CHMODE_2F2R:
666 memset(s->delay[3], 0, channel_data_size);
667 case AC3_CHMODE_2F1R:
668 memset(s->delay[2], 0, channel_data_size);
670 case AC3_CHMODE_3F2R:
671 memset(s->delay[4], 0, channel_data_size);
672 case AC3_CHMODE_3F1R:
673 memset(s->delay[3], 0, channel_data_size);
675 memcpy(s->delay[2], s->delay[1], channel_data_size);
676 memset(s->delay[1], 0, channel_data_size);
682 * Decode band structure for coupling, spectral extension, or enhanced coupling.
683 * The band structure defines how many subbands are in each band. For each
684 * subband in the range, 1 means it is combined with the previous band, and 0
685 * means that it starts a new band.
687 * @param[in] gbc bit reader context
688 * @param[in] blk block number
689 * @param[in] eac3 flag to indicate E-AC-3
690 * @param[in] ecpl flag to indicate enhanced coupling
691 * @param[in] start_subband subband number for start of range
692 * @param[in] end_subband subband number for end of range
693 * @param[in] default_band_struct default band structure table
694 * @param[out] num_bands number of bands (optionally NULL)
695 * @param[out] band_sizes array containing the number of bins in each band (optionally NULL)
697 static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
698 int ecpl, int start_subband, int end_subband,
699 const uint8_t *default_band_struct,
700 int *num_bands, uint8_t *band_sizes)
702 int subbnd, bnd, n_subbands, n_bands=0;
704 uint8_t coded_band_struct[22];
705 const uint8_t *band_struct;
707 n_subbands = end_subband - start_subband;
709 /* decode band structure from bitstream or use default */
710 if (!eac3 || get_bits1(gbc)) {
711 for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
712 coded_band_struct[subbnd] = get_bits1(gbc);
714 band_struct = coded_band_struct;
716 band_struct = &default_band_struct[start_subband+1];
718 /* no change in band structure */
722 /* calculate number of bands and band sizes based on band structure.
723 note that the first 4 subbands in enhanced coupling span only 6 bins
725 if (num_bands || band_sizes ) {
726 n_bands = n_subbands;
727 bnd_sz[0] = ecpl ? 6 : 12;
728 for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
729 int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
730 if (band_struct[subbnd - 1]) {
732 bnd_sz[bnd] += subbnd_size;
734 bnd_sz[++bnd] = subbnd_size;
739 /* set optional output params */
741 *num_bands = n_bands;
743 memcpy(band_sizes, bnd_sz, n_bands);
747 * Decode a single audio block from the AC-3 bitstream.
749 static int decode_audio_block(AC3DecodeContext *s, int blk)
751 int fbw_channels = s->fbw_channels;
752 int channel_mode = s->channel_mode;
754 int different_transforms;
757 GetBitContext *gbc = &s->gbc;
758 uint8_t bit_alloc_stages[AC3_MAX_CHANNELS] = { 0 };
760 /* block switch flags */
761 different_transforms = 0;
762 if (s->block_switch_syntax) {
763 for (ch = 1; ch <= fbw_channels; ch++) {
764 s->block_switch[ch] = get_bits1(gbc);
765 if (ch > 1 && s->block_switch[ch] != s->block_switch[1])
766 different_transforms = 1;
770 /* dithering flags */
771 if (s->dither_flag_syntax) {
772 for (ch = 1; ch <= fbw_channels; ch++) {
773 s->dither_flag[ch] = get_bits1(gbc);
778 i = !s->channel_mode;
780 if (get_bits1(gbc)) {
781 /* Allow asymmetric application of DRC when drc_scale > 1.
782 Amplification of quiet sounds is enhanced */
783 float range = dynamic_range_tab[get_bits(gbc, 8)];
784 if (range > 1.0 || s->drc_scale <= 1.0)
785 s->dynamic_range[i] = powf(range, s->drc_scale);
787 s->dynamic_range[i] = range;
788 } else if (blk == 0) {
789 s->dynamic_range[i] = 1.0f;
793 /* spectral extension strategy */
794 if (s->eac3 && (!blk || get_bits1(gbc))) {
795 s->spx_in_use = get_bits1(gbc);
797 int dst_start_freq, dst_end_freq, src_start_freq,
798 start_subband, end_subband;
800 /* determine which channels use spx */
801 if (s->channel_mode == AC3_CHMODE_MONO) {
802 s->channel_uses_spx[1] = 1;
804 for (ch = 1; ch <= fbw_channels; ch++)
805 s->channel_uses_spx[ch] = get_bits1(gbc);
808 /* get the frequency bins of the spx copy region and the spx start
810 dst_start_freq = get_bits(gbc, 2);
811 start_subband = get_bits(gbc, 3) + 2;
812 if (start_subband > 7)
813 start_subband += start_subband - 7;
814 end_subband = get_bits(gbc, 3) + 5;
816 end_subband += end_subband - 7;
817 dst_start_freq = dst_start_freq * 12 + 25;
818 src_start_freq = start_subband * 12 + 25;
819 dst_end_freq = end_subband * 12 + 25;
821 /* check validity of spx ranges */
822 if (start_subband >= end_subband) {
823 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
824 "range (%d >= %d)\n", start_subband, end_subband);
825 return AVERROR_INVALIDDATA;
827 if (dst_start_freq >= src_start_freq) {
828 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
829 "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
830 return AVERROR_INVALIDDATA;
833 s->spx_dst_start_freq = dst_start_freq;
834 s->spx_src_start_freq = src_start_freq;
835 s->spx_dst_end_freq = dst_end_freq;
837 decode_band_structure(gbc, blk, s->eac3, 0,
838 start_subband, end_subband,
839 ff_eac3_default_spx_band_struct,
843 for (ch = 1; ch <= fbw_channels; ch++) {
844 s->channel_uses_spx[ch] = 0;
845 s->first_spx_coords[ch] = 1;
850 /* spectral extension coordinates */
852 for (ch = 1; ch <= fbw_channels; ch++) {
853 if (s->channel_uses_spx[ch]) {
854 if (s->first_spx_coords[ch] || get_bits1(gbc)) {
856 int bin, master_spx_coord;
858 s->first_spx_coords[ch] = 0;
859 spx_blend = get_bits(gbc, 5) * (1.0f/32);
860 master_spx_coord = get_bits(gbc, 2) * 3;
862 bin = s->spx_src_start_freq;
863 for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
865 int spx_coord_exp, spx_coord_mant;
866 float nratio, sblend, nblend, spx_coord;
868 /* calculate blending factors */
869 bandsize = s->spx_band_sizes[bnd];
870 nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
871 nratio = av_clipf(nratio, 0.0f, 1.0f);
872 nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
873 // to give unity variance
874 sblend = sqrtf(1.0f - nratio);
877 /* decode spx coordinates */
878 spx_coord_exp = get_bits(gbc, 4);
879 spx_coord_mant = get_bits(gbc, 2);
880 if (spx_coord_exp == 15) spx_coord_mant <<= 1;
881 else spx_coord_mant += 4;
882 spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
883 spx_coord = spx_coord_mant * (1.0f / (1 << 23));
885 /* multiply noise and signal blending factors by spx coordinate */
886 s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
887 s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
891 s->first_spx_coords[ch] = 1;
896 /* coupling strategy */
897 if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
898 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
900 s->cpl_in_use[blk] = get_bits1(gbc);
901 if (s->cpl_in_use[blk]) {
902 /* coupling in use */
903 int cpl_start_subband, cpl_end_subband;
905 if (channel_mode < AC3_CHMODE_STEREO) {
906 av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
907 return AVERROR_INVALIDDATA;
910 /* check for enhanced coupling */
911 if (s->eac3 && get_bits1(gbc)) {
912 /* TODO: parse enhanced coupling strategy info */
913 avpriv_request_sample(s->avctx, "Enhanced coupling");
914 return AVERROR_PATCHWELCOME;
917 /* determine which channels are coupled */
918 if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
919 s->channel_in_cpl[1] = 1;
920 s->channel_in_cpl[2] = 1;
922 for (ch = 1; ch <= fbw_channels; ch++)
923 s->channel_in_cpl[ch] = get_bits1(gbc);
926 /* phase flags in use */
927 if (channel_mode == AC3_CHMODE_STEREO)
928 s->phase_flags_in_use = get_bits1(gbc);
930 /* coupling frequency range */
931 cpl_start_subband = get_bits(gbc, 4);
932 cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
933 get_bits(gbc, 4) + 3;
934 if (cpl_start_subband >= cpl_end_subband) {
935 av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
936 cpl_start_subband, cpl_end_subband);
937 return AVERROR_INVALIDDATA;
939 s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
940 s->end_freq[CPL_CH] = cpl_end_subband * 12 + 37;
942 decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
944 ff_eac3_default_cpl_band_struct,
945 &s->num_cpl_bands, s->cpl_band_sizes);
947 /* coupling not in use */
948 for (ch = 1; ch <= fbw_channels; ch++) {
949 s->channel_in_cpl[ch] = 0;
950 s->first_cpl_coords[ch] = 1;
952 s->first_cpl_leak = s->eac3;
953 s->phase_flags_in_use = 0;
955 } else if (!s->eac3) {
957 av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "
958 "be present in block 0\n");
959 return AVERROR_INVALIDDATA;
961 s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
964 cpl_in_use = s->cpl_in_use[blk];
966 /* coupling coordinates */
968 int cpl_coords_exist = 0;
970 for (ch = 1; ch <= fbw_channels; ch++) {
971 if (s->channel_in_cpl[ch]) {
972 if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
973 int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
974 s->first_cpl_coords[ch] = 0;
975 cpl_coords_exist = 1;
976 master_cpl_coord = 3 * get_bits(gbc, 2);
977 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
978 cpl_coord_exp = get_bits(gbc, 4);
979 cpl_coord_mant = get_bits(gbc, 4);
980 if (cpl_coord_exp == 15)
981 s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
983 s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
984 s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
987 av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
988 "be present in block 0\n");
989 return AVERROR_INVALIDDATA;
992 /* channel not in coupling */
993 s->first_cpl_coords[ch] = 1;
997 if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
998 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
999 s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
1004 /* stereo rematrixing strategy and band structure */
1005 if (channel_mode == AC3_CHMODE_STEREO) {
1006 if ((s->eac3 && !blk) || get_bits1(gbc)) {
1007 s->num_rematrixing_bands = 4;
1008 if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
1009 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
1010 } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
1011 s->num_rematrixing_bands--;
1013 for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
1014 s->rematrixing_flags[bnd] = get_bits1(gbc);
1016 av_log(s->avctx, AV_LOG_WARNING, "Warning: "
1017 "new rematrixing strategy not present in block 0\n");
1018 s->num_rematrixing_bands = 0;
1022 /* exponent strategies for each channel */
1023 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1025 s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
1026 if (s->exp_strategy[blk][ch] != EXP_REUSE)
1027 bit_alloc_stages[ch] = 3;
1030 /* channel bandwidth */
1031 for (ch = 1; ch <= fbw_channels; ch++) {
1032 s->start_freq[ch] = 0;
1033 if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1035 int prev = s->end_freq[ch];
1036 if (s->channel_in_cpl[ch])
1037 s->end_freq[ch] = s->start_freq[CPL_CH];
1038 else if (s->channel_uses_spx[ch])
1039 s->end_freq[ch] = s->spx_src_start_freq;
1041 int bandwidth_code = get_bits(gbc, 6);
1042 if (bandwidth_code > 60) {
1043 av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1044 return AVERROR_INVALIDDATA;
1046 s->end_freq[ch] = bandwidth_code * 3 + 73;
1048 group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1049 s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
1050 if (blk > 0 && s->end_freq[ch] != prev)
1051 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1054 if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1055 s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
1056 (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1059 /* decode exponents for each channel */
1060 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1061 if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1062 s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1063 if (decode_exponents(gbc, s->exp_strategy[blk][ch],
1064 s->num_exp_groups[ch], s->dexps[ch][0],
1065 &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1066 av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
1067 return AVERROR_INVALIDDATA;
1069 if (ch != CPL_CH && ch != s->lfe_ch)
1070 skip_bits(gbc, 2); /* skip gainrng */
1074 /* bit allocation information */
1075 if (s->bit_allocation_syntax) {
1076 if (get_bits1(gbc)) {
1077 s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1078 s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1079 s->bit_alloc_params.slow_gain = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
1080 s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
1081 s->bit_alloc_params.floor = ff_ac3_floor_tab[get_bits(gbc, 3)];
1082 for (ch = !cpl_in_use; ch <= s->channels; ch++)
1083 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1085 av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must "
1086 "be present in block 0\n");
1087 return AVERROR_INVALIDDATA;
1091 /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1092 if (!s->eac3 || !blk) {
1093 if (s->snr_offset_strategy && get_bits1(gbc)) {
1096 csnr = (get_bits(gbc, 6) - 15) << 4;
1097 for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1099 if (ch == i || s->snr_offset_strategy == 2)
1100 snr = (csnr + get_bits(gbc, 4)) << 2;
1101 /* run at least last bit allocation stage if snr offset changes */
1102 if (blk && s->snr_offset[ch] != snr) {
1103 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1105 s->snr_offset[ch] = snr;
1107 /* fast gain (normal AC-3 only) */
1109 int prev = s->fast_gain[ch];
1110 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1111 /* run last 2 bit allocation stages if fast gain changes */
1112 if (blk && prev != s->fast_gain[ch])
1113 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1116 } else if (!s->eac3 && !blk) {
1117 av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1118 return AVERROR_INVALIDDATA;
1122 /* fast gain (E-AC-3 only) */
1123 if (s->fast_gain_syntax && get_bits1(gbc)) {
1124 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1125 int prev = s->fast_gain[ch];
1126 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1127 /* run last 2 bit allocation stages if fast gain changes */
1128 if (blk && prev != s->fast_gain[ch])
1129 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1131 } else if (s->eac3 && !blk) {
1132 for (ch = !cpl_in_use; ch <= s->channels; ch++)
1133 s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1136 /* E-AC-3 to AC-3 converter SNR offset */
1137 if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1138 skip_bits(gbc, 10); // skip converter snr offset
1141 /* coupling leak information */
1143 if (s->first_cpl_leak || get_bits1(gbc)) {
1144 int fl = get_bits(gbc, 3);
1145 int sl = get_bits(gbc, 3);
1146 /* run last 2 bit allocation stages for coupling channel if
1147 coupling leak changes */
1148 if (blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1149 sl != s->bit_alloc_params.cpl_slow_leak)) {
1150 bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1152 s->bit_alloc_params.cpl_fast_leak = fl;
1153 s->bit_alloc_params.cpl_slow_leak = sl;
1154 } else if (!s->eac3 && !blk) {
1155 av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must "
1156 "be present in block 0\n");
1157 return AVERROR_INVALIDDATA;
1159 s->first_cpl_leak = 0;
1162 /* delta bit allocation information */
1163 if (s->dba_syntax && get_bits1(gbc)) {
1164 /* delta bit allocation exists (strategy) */
1165 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1166 s->dba_mode[ch] = get_bits(gbc, 2);
1167 if (s->dba_mode[ch] == DBA_RESERVED) {
1168 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1169 return AVERROR_INVALIDDATA;
1171 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1173 /* channel delta offset, len and bit allocation */
1174 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1175 if (s->dba_mode[ch] == DBA_NEW) {
1176 s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;
1177 for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
1178 s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1179 s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1180 s->dba_values[ch][seg] = get_bits(gbc, 3);
1182 /* run last 2 bit allocation stages if new dba values */
1183 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1186 } else if (blk == 0) {
1187 for (ch = 0; ch <= s->channels; ch++) {
1188 s->dba_mode[ch] = DBA_NONE;
1192 /* Bit allocation */
1193 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1194 if (bit_alloc_stages[ch] > 2) {
1195 /* Exponent mapping into PSD and PSD integration */
1196 ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
1197 s->start_freq[ch], s->end_freq[ch],
1198 s->psd[ch], s->band_psd[ch]);
1200 if (bit_alloc_stages[ch] > 1) {
1201 /* Compute excitation function, Compute masking curve, and
1202 Apply delta bit allocation */
1203 if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1204 s->start_freq[ch], s->end_freq[ch],
1205 s->fast_gain[ch], (ch == s->lfe_ch),
1206 s->dba_mode[ch], s->dba_nsegs[ch],
1207 s->dba_offsets[ch], s->dba_lengths[ch],
1208 s->dba_values[ch], s->mask[ch])) {
1209 av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1210 return AVERROR_INVALIDDATA;
1213 if (bit_alloc_stages[ch] > 0) {
1214 /* Compute bit allocation */
1215 const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1216 ff_eac3_hebap_tab : ff_ac3_bap_tab;
1217 s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1218 s->start_freq[ch], s->end_freq[ch],
1220 s->bit_alloc_params.floor,
1221 bap_tab, s->bap[ch]);
1225 /* unused dummy data */
1226 if (s->skip_syntax && get_bits1(gbc)) {
1227 int skipl = get_bits(gbc, 9);
1232 /* unpack the transform coefficients
1233 this also uncouples channels if coupling is in use. */
1234 decode_transform_coeffs(s, blk);
1236 /* TODO: generate enhanced coupling coordinates and uncouple */
1238 /* recover coefficients if rematrixing is in use */
1239 if (s->channel_mode == AC3_CHMODE_STEREO)
1242 /* apply scaling to coefficients (headroom, dynrng) */
1243 for (ch = 1; ch <= s->channels; ch++) {
1244 float gain = 1.0 / 4194304.0f;
1245 if (s->channel_mode == AC3_CHMODE_DUALMONO) {
1246 gain *= s->dynamic_range[2 - ch];
1248 gain *= s->dynamic_range[0];
1250 s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch],
1251 s->fixed_coeffs[ch], gain, 256);
1254 /* apply spectral extension to high frequency bins */
1255 if (s->spx_in_use && CONFIG_EAC3_DECODER) {
1256 ff_eac3_apply_spectral_extension(s);
1259 /* downmix and MDCT. order depends on whether block switching is used for
1260 any channel in this block. this is because coefficients for the long
1261 and short transforms cannot be mixed. */
1262 downmix_output = s->channels != s->out_channels &&
1263 !((s->output_mode & AC3_OUTPUT_LFEON) &&
1264 s->fbw_channels == s->out_channels);
1265 if (different_transforms) {
1266 /* the delay samples have already been downmixed, so we upmix the delay
1267 samples in order to reconstruct all channels before downmixing. */
1273 do_imdct(s, s->channels);
1275 if (downmix_output) {
1276 s->ac3dsp.downmix(s->outptr, s->downmix_coeffs,
1277 s->out_channels, s->fbw_channels, 256);
1280 if (downmix_output) {
1281 s->ac3dsp.downmix(s->xcfptr + 1, s->downmix_coeffs,
1282 s->out_channels, s->fbw_channels, 256);
1285 if (downmix_output && !s->downmixed) {
1287 s->ac3dsp.downmix(s->dlyptr, s->downmix_coeffs, s->out_channels,
1288 s->fbw_channels, 128);
1291 do_imdct(s, s->out_channels);
1298 * Decode a single AC-3 frame.
1300 static int ac3_decode_frame(AVCodecContext * avctx, void *data,
1301 int *got_frame_ptr, AVPacket *avpkt)
1303 AVFrame *frame = data;
1304 const uint8_t *buf = avpkt->data;
1305 int buf_size = avpkt->size;
1306 AC3DecodeContext *s = avctx->priv_data;
1307 int blk, ch, err, ret;
1308 const uint8_t *channel_map;
1309 const float *output[AC3_MAX_CHANNELS];
1310 enum AVMatrixEncoding matrix_encoding;
1312 /* copy input buffer to decoder context to avoid reading past the end
1313 of the buffer, which can be caused by a damaged input stream. */
1314 if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
1315 // seems to be byte-swapped AC-3
1316 int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1317 s->dsp.bswap16_buf((uint16_t *)s->input_buffer, (const uint16_t *)buf, cnt);
1319 memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1320 buf = s->input_buffer;
1321 /* initialize the GetBitContext with the start of valid AC-3 Frame */
1322 init_get_bits(&s->gbc, buf, buf_size * 8);
1324 /* parse the syncinfo */
1325 err = parse_frame_header(s);
1329 case AAC_AC3_PARSE_ERROR_SYNC:
1330 av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1331 return AVERROR_INVALIDDATA;
1332 case AAC_AC3_PARSE_ERROR_BSID:
1333 av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1335 case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
1336 av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1338 case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
1339 av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1341 case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
1342 /* skip frame if CRC is ok. otherwise use error concealment. */
1343 /* TODO: add support for substreams and dependent frames */
1344 if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
1345 av_log(avctx, AV_LOG_WARNING, "unsupported frame type : "
1346 "skipping frame\n");
1350 av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1353 case AAC_AC3_PARSE_ERROR_CRC:
1354 case AAC_AC3_PARSE_ERROR_CHANNEL_CFG:
1356 default: // Normal AVERROR do not try to recover.
1361 /* check that reported frame size fits in input buffer */
1362 if (s->frame_size > buf_size) {
1363 av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1364 err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
1365 } else if (avctx->err_recognition & AV_EF_CRCCHECK) {
1366 /* check for crc mismatch */
1367 if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
1368 s->frame_size - 2)) {
1369 av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1370 if (avctx->err_recognition & AV_EF_EXPLODE)
1371 return AVERROR_INVALIDDATA;
1372 err = AAC_AC3_PARSE_ERROR_CRC;
1377 /* if frame is ok, set audio parameters */
1379 avctx->sample_rate = s->sample_rate;
1380 avctx->bit_rate = s->bit_rate;
1383 /* channel config */
1384 if (!err || (s->channels && s->out_channels != s->channels)) {
1385 s->out_channels = s->channels;
1386 s->output_mode = s->channel_mode;
1388 s->output_mode |= AC3_OUTPUT_LFEON;
1389 if (s->channels > 1 &&
1390 avctx->request_channel_layout == AV_CH_LAYOUT_MONO) {
1391 s->out_channels = 1;
1392 s->output_mode = AC3_CHMODE_MONO;
1393 } else if (s->channels > 2 &&
1394 avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
1395 s->out_channels = 2;
1396 s->output_mode = AC3_CHMODE_STEREO;
1399 /* set downmixing coefficients if needed */
1400 if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1401 s->fbw_channels == s->out_channels)) {
1402 set_downmix_coeffs(s);
1404 } else if (!s->channels) {
1405 av_log(avctx, AV_LOG_ERROR, "unable to determine channel mode\n");
1406 return AVERROR_INVALIDDATA;
1408 avctx->channels = s->out_channels;
1409 avctx->channel_layout = avpriv_ac3_channel_layout_tab[s->output_mode & ~AC3_OUTPUT_LFEON];
1410 if (s->output_mode & AC3_OUTPUT_LFEON)
1411 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1413 /* set audio service type based on bitstream mode for AC-3 */
1414 avctx->audio_service_type = s->bitstream_mode;
1415 if (s->bitstream_mode == 0x7 && s->channels > 1)
1416 avctx->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
1418 /* get output buffer */
1419 frame->nb_samples = s->num_blocks * AC3_BLOCK_SIZE;
1420 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
1421 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1425 /* decode the audio blocks */
1426 channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1427 for (ch = 0; ch < s->channels; ch++) {
1428 if (ch < s->out_channels)
1429 s->outptr[channel_map[ch]] = (float *)frame->data[ch];
1431 s->outptr[ch] = s->output[ch];
1432 output[ch] = s->output[ch];
1434 for (blk = 0; blk < s->num_blocks; blk++) {
1435 if (!err && decode_audio_block(s, blk)) {
1436 av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1440 for (ch = 0; ch < s->out_channels; ch++)
1441 memcpy(s->outptr[channel_map[ch]], output[ch], sizeof(**output) * AC3_BLOCK_SIZE);
1442 for (ch = 0; ch < s->out_channels; ch++)
1443 output[ch] = s->outptr[channel_map[ch]];
1444 for (ch = 0; ch < s->out_channels; ch++)
1445 s->outptr[ch] += AC3_BLOCK_SIZE;
1448 /* keep last block for error concealment in next frame */
1449 for (ch = 0; ch < s->out_channels; ch++)
1450 memcpy(s->output[ch], output[ch], sizeof(**output) * AC3_BLOCK_SIZE);
1455 * Check whether the input layout is compatible, and make sure we're not
1456 * downmixing (else the matrix encoding is no longer applicable).
1458 matrix_encoding = AV_MATRIX_ENCODING_NONE;
1459 if (s->channel_mode == AC3_CHMODE_STEREO &&
1460 s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1461 if (s->dolby_surround_mode == AC3_DSURMOD_ON)
1462 matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
1463 else if (s->dolby_headphone_mode == AC3_DHEADPHONMOD_ON)
1464 matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;
1465 } else if (s->channel_mode >= AC3_CHMODE_2F2R &&
1466 s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1467 switch (s->dolby_surround_ex_mode) {
1468 case AC3_DSUREXMOD_ON: // EX or PLIIx
1469 matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
1471 case AC3_DSUREXMOD_PLIIZ:
1472 matrix_encoding = AV_MATRIX_ENCODING_DPLIIZ;
1474 default: // not indicated or off
1478 if ((ret = ff_side_data_update_matrix_encoding(frame, matrix_encoding)) < 0)
1483 return FFMIN(buf_size, s->frame_size);
1487 * Uninitialize the AC-3 decoder.
1489 static av_cold int ac3_decode_end(AVCodecContext *avctx)
1491 AC3DecodeContext *s = avctx->priv_data;
1492 ff_mdct_end(&s->imdct_512);
1493 ff_mdct_end(&s->imdct_256);
1498 #define OFFSET(x) offsetof(AC3DecodeContext, x)
1499 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)
1500 static const AVOption options[] = {
1501 { "drc_scale", "percentage of dynamic range compression to apply", OFFSET(drc_scale), AV_OPT_TYPE_FLOAT, {.dbl = 1.0}, 0.0, 6.0, PAR },
1505 static const AVClass ac3_decoder_class = {
1506 .class_name = "AC3 decoder",
1507 .item_name = av_default_item_name,
1509 .version = LIBAVUTIL_VERSION_INT,
1512 AVCodec ff_ac3_decoder = {
1514 .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
1515 .type = AVMEDIA_TYPE_AUDIO,
1516 .id = AV_CODEC_ID_AC3,
1517 .priv_data_size = sizeof (AC3DecodeContext),
1518 .init = ac3_decode_init,
1519 .close = ac3_decode_end,
1520 .decode = ac3_decode_frame,
1521 .capabilities = CODEC_CAP_DR1,
1522 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1523 AV_SAMPLE_FMT_NONE },
1524 .priv_class = &ac3_decoder_class,
1527 #if CONFIG_EAC3_DECODER
1528 static const AVClass eac3_decoder_class = {
1529 .class_name = "E-AC3 decoder",
1530 .item_name = av_default_item_name,
1532 .version = LIBAVUTIL_VERSION_INT,
1535 AVCodec ff_eac3_decoder = {
1537 .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
1538 .type = AVMEDIA_TYPE_AUDIO,
1539 .id = AV_CODEC_ID_EAC3,
1540 .priv_data_size = sizeof (AC3DecodeContext),
1541 .init = ac3_decode_init,
1542 .close = ac3_decode_end,
1543 .decode = ac3_decode_frame,
1544 .capabilities = CODEC_CAP_DR1,
1545 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1546 AV_SAMPLE_FMT_NONE },
1547 .priv_class = &eac3_decoder_class,