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/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)>>8)*181)>>8) - 5931008;
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. */
523 av_log(s->avctx, AV_LOG_ERROR, "bap %d is invalid in plain AC-3\n", bap);
526 mantissa = get_sbits(gbc, quantization_tab[bap]);
527 mantissa <<= 24 - quantization_tab[bap];
530 coeffs[freq] = mantissa >> exps[freq];
535 * Remove random dithering from coupling range coefficients with zero-bit
536 * mantissas for coupled channels which do not use dithering.
537 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
539 static void remove_dithering(AC3DecodeContext *s) {
542 for (ch = 1; ch <= s->fbw_channels; ch++) {
543 if (!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
544 for (i = s->start_freq[CPL_CH]; i < s->end_freq[CPL_CH]; i++) {
545 if (!s->bap[CPL_CH][i])
546 s->fixed_coeffs[ch][i] = 0;
552 static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,
555 if (!s->channel_uses_aht[ch]) {
556 ac3_decode_transform_coeffs_ch(s, ch, m);
558 /* if AHT is used, mantissas for all blocks are encoded in the first
559 block of the frame. */
561 if (!blk && CONFIG_EAC3_DECODER)
562 ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
563 for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
564 s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
570 * Decode the transform coefficients.
572 static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
578 m.b1 = m.b2 = m.b4 = 0;
580 for (ch = 1; ch <= s->channels; ch++) {
581 /* transform coefficients for full-bandwidth channel */
582 decode_transform_coeffs_ch(s, blk, ch, &m);
583 /* transform coefficients for coupling channel come right after the
584 coefficients for the first coupled channel*/
585 if (s->channel_in_cpl[ch]) {
587 decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
588 calc_transform_coeffs_cpl(s);
591 end = s->end_freq[CPL_CH];
593 end = s->end_freq[ch];
596 s->fixed_coeffs[ch][end] = 0;
600 /* zero the dithered coefficients for appropriate channels */
605 * Stereo rematrixing.
606 * reference: Section 7.5.4 Rematrixing : Decoding Technique
608 static void do_rematrixing(AC3DecodeContext *s)
613 end = FFMIN(s->end_freq[1], s->end_freq[2]);
615 for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) {
616 if (s->rematrixing_flags[bnd]) {
617 bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd + 1]);
618 for (i = ff_ac3_rematrix_band_tab[bnd]; i < bndend; i++) {
619 int tmp0 = s->fixed_coeffs[1][i];
620 s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
621 s->fixed_coeffs[2][i] = tmp0 - s->fixed_coeffs[2][i];
628 * Inverse MDCT Transform.
629 * Convert frequency domain coefficients to time-domain audio samples.
630 * reference: Section 7.9.4 Transformation Equations
632 static inline void do_imdct(AC3DecodeContext *s, int channels)
636 for (ch = 1; ch <= channels; ch++) {
637 if (s->block_switch[ch]) {
639 float *x = s->tmp_output + 128;
640 for (i = 0; i < 128; i++)
641 x[i] = s->transform_coeffs[ch][2 * i];
642 s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
643 s->fdsp.vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
644 s->tmp_output, s->window, 128);
645 for (i = 0; i < 128; i++)
646 x[i] = s->transform_coeffs[ch][2 * i + 1];
647 s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch - 1], x);
649 s->imdct_512.imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
650 s->fdsp.vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
651 s->tmp_output, s->window, 128);
652 memcpy(s->delay[ch - 1], s->tmp_output + 128, 128 * sizeof(float));
658 * Upmix delay samples from stereo to original channel layout.
660 static void ac3_upmix_delay(AC3DecodeContext *s)
662 int channel_data_size = sizeof(s->delay[0]);
663 switch (s->channel_mode) {
664 case AC3_CHMODE_DUALMONO:
665 case AC3_CHMODE_STEREO:
666 /* upmix mono to stereo */
667 memcpy(s->delay[1], s->delay[0], channel_data_size);
669 case AC3_CHMODE_2F2R:
670 memset(s->delay[3], 0, channel_data_size);
671 case AC3_CHMODE_2F1R:
672 memset(s->delay[2], 0, channel_data_size);
674 case AC3_CHMODE_3F2R:
675 memset(s->delay[4], 0, channel_data_size);
676 case AC3_CHMODE_3F1R:
677 memset(s->delay[3], 0, channel_data_size);
679 memcpy(s->delay[2], s->delay[1], channel_data_size);
680 memset(s->delay[1], 0, channel_data_size);
686 * Decode band structure for coupling, spectral extension, or enhanced coupling.
687 * The band structure defines how many subbands are in each band. For each
688 * subband in the range, 1 means it is combined with the previous band, and 0
689 * means that it starts a new band.
691 * @param[in] gbc bit reader context
692 * @param[in] blk block number
693 * @param[in] eac3 flag to indicate E-AC-3
694 * @param[in] ecpl flag to indicate enhanced coupling
695 * @param[in] start_subband subband number for start of range
696 * @param[in] end_subband subband number for end of range
697 * @param[in] default_band_struct default band structure table
698 * @param[out] num_bands number of bands (optionally NULL)
699 * @param[out] band_sizes array containing the number of bins in each band (optionally NULL)
701 static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
702 int ecpl, int start_subband, int end_subband,
703 const uint8_t *default_band_struct,
704 int *num_bands, uint8_t *band_sizes)
706 int subbnd, bnd, n_subbands, n_bands=0;
708 uint8_t coded_band_struct[22];
709 const uint8_t *band_struct;
711 n_subbands = end_subband - start_subband;
713 /* decode band structure from bitstream or use default */
714 if (!eac3 || get_bits1(gbc)) {
715 for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
716 coded_band_struct[subbnd] = get_bits1(gbc);
718 band_struct = coded_band_struct;
720 band_struct = &default_band_struct[start_subband+1];
722 /* no change in band structure */
726 /* calculate number of bands and band sizes based on band structure.
727 note that the first 4 subbands in enhanced coupling span only 6 bins
729 if (num_bands || band_sizes ) {
730 n_bands = n_subbands;
731 bnd_sz[0] = ecpl ? 6 : 12;
732 for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
733 int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
734 if (band_struct[subbnd - 1]) {
736 bnd_sz[bnd] += subbnd_size;
738 bnd_sz[++bnd] = subbnd_size;
743 /* set optional output params */
745 *num_bands = n_bands;
747 memcpy(band_sizes, bnd_sz, n_bands);
751 * Decode a single audio block from the AC-3 bitstream.
753 static int decode_audio_block(AC3DecodeContext *s, int blk)
755 int fbw_channels = s->fbw_channels;
756 int channel_mode = s->channel_mode;
758 int different_transforms;
761 GetBitContext *gbc = &s->gbc;
762 uint8_t bit_alloc_stages[AC3_MAX_CHANNELS] = { 0 };
764 /* block switch flags */
765 different_transforms = 0;
766 if (s->block_switch_syntax) {
767 for (ch = 1; ch <= fbw_channels; ch++) {
768 s->block_switch[ch] = get_bits1(gbc);
769 if (ch > 1 && s->block_switch[ch] != s->block_switch[1])
770 different_transforms = 1;
774 /* dithering flags */
775 if (s->dither_flag_syntax) {
776 for (ch = 1; ch <= fbw_channels; ch++) {
777 s->dither_flag[ch] = get_bits1(gbc);
782 i = !s->channel_mode;
784 if (get_bits1(gbc)) {
785 /* Allow asymmetric application of DRC when drc_scale > 1.
786 Amplification of quiet sounds is enhanced */
787 float range = dynamic_range_tab[get_bits(gbc, 8)];
788 if (range > 1.0 || s->drc_scale <= 1.0)
789 s->dynamic_range[i] = powf(range, s->drc_scale);
791 s->dynamic_range[i] = range;
792 } else if (blk == 0) {
793 s->dynamic_range[i] = 1.0f;
797 /* spectral extension strategy */
798 if (s->eac3 && (!blk || get_bits1(gbc))) {
799 s->spx_in_use = get_bits1(gbc);
801 int dst_start_freq, dst_end_freq, src_start_freq,
802 start_subband, end_subband;
804 /* determine which channels use spx */
805 if (s->channel_mode == AC3_CHMODE_MONO) {
806 s->channel_uses_spx[1] = 1;
808 for (ch = 1; ch <= fbw_channels; ch++)
809 s->channel_uses_spx[ch] = get_bits1(gbc);
812 /* get the frequency bins of the spx copy region and the spx start
814 dst_start_freq = get_bits(gbc, 2);
815 start_subband = get_bits(gbc, 3) + 2;
816 if (start_subband > 7)
817 start_subband += start_subband - 7;
818 end_subband = get_bits(gbc, 3) + 5;
820 end_subband += end_subband - 7;
821 dst_start_freq = dst_start_freq * 12 + 25;
822 src_start_freq = start_subband * 12 + 25;
823 dst_end_freq = end_subband * 12 + 25;
825 /* check validity of spx ranges */
826 if (start_subband >= end_subband) {
827 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
828 "range (%d >= %d)\n", start_subband, end_subband);
829 return AVERROR_INVALIDDATA;
831 if (dst_start_freq >= src_start_freq) {
832 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
833 "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
834 return AVERROR_INVALIDDATA;
837 s->spx_dst_start_freq = dst_start_freq;
838 s->spx_src_start_freq = src_start_freq;
839 s->spx_dst_end_freq = dst_end_freq;
841 decode_band_structure(gbc, blk, s->eac3, 0,
842 start_subband, end_subband,
843 ff_eac3_default_spx_band_struct,
847 for (ch = 1; ch <= fbw_channels; ch++) {
848 s->channel_uses_spx[ch] = 0;
849 s->first_spx_coords[ch] = 1;
854 /* spectral extension coordinates */
856 for (ch = 1; ch <= fbw_channels; ch++) {
857 if (s->channel_uses_spx[ch]) {
858 if (s->first_spx_coords[ch] || get_bits1(gbc)) {
860 int bin, master_spx_coord;
862 s->first_spx_coords[ch] = 0;
863 spx_blend = get_bits(gbc, 5) * (1.0f/32);
864 master_spx_coord = get_bits(gbc, 2) * 3;
866 bin = s->spx_src_start_freq;
867 for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
869 int spx_coord_exp, spx_coord_mant;
870 float nratio, sblend, nblend, spx_coord;
872 /* calculate blending factors */
873 bandsize = s->spx_band_sizes[bnd];
874 nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
875 nratio = av_clipf(nratio, 0.0f, 1.0f);
876 nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
877 // to give unity variance
878 sblend = sqrtf(1.0f - nratio);
881 /* decode spx coordinates */
882 spx_coord_exp = get_bits(gbc, 4);
883 spx_coord_mant = get_bits(gbc, 2);
884 if (spx_coord_exp == 15) spx_coord_mant <<= 1;
885 else spx_coord_mant += 4;
886 spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
887 spx_coord = spx_coord_mant * (1.0f / (1 << 23));
889 /* multiply noise and signal blending factors by spx coordinate */
890 s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
891 s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
895 s->first_spx_coords[ch] = 1;
900 /* coupling strategy */
901 if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
902 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
904 s->cpl_in_use[blk] = get_bits1(gbc);
905 if (s->cpl_in_use[blk]) {
906 /* coupling in use */
907 int cpl_start_subband, cpl_end_subband;
909 if (channel_mode < AC3_CHMODE_STEREO) {
910 av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
911 return AVERROR_INVALIDDATA;
914 /* check for enhanced coupling */
915 if (s->eac3 && get_bits1(gbc)) {
916 /* TODO: parse enhanced coupling strategy info */
917 avpriv_request_sample(s->avctx, "Enhanced coupling");
918 return AVERROR_PATCHWELCOME;
921 /* determine which channels are coupled */
922 if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
923 s->channel_in_cpl[1] = 1;
924 s->channel_in_cpl[2] = 1;
926 for (ch = 1; ch <= fbw_channels; ch++)
927 s->channel_in_cpl[ch] = get_bits1(gbc);
930 /* phase flags in use */
931 if (channel_mode == AC3_CHMODE_STEREO)
932 s->phase_flags_in_use = get_bits1(gbc);
934 /* coupling frequency range */
935 cpl_start_subband = get_bits(gbc, 4);
936 cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
937 get_bits(gbc, 4) + 3;
938 if (cpl_start_subband >= cpl_end_subband) {
939 av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
940 cpl_start_subband, cpl_end_subband);
941 return AVERROR_INVALIDDATA;
943 s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
944 s->end_freq[CPL_CH] = cpl_end_subband * 12 + 37;
946 decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
948 ff_eac3_default_cpl_band_struct,
949 &s->num_cpl_bands, s->cpl_band_sizes);
951 /* coupling not in use */
952 for (ch = 1; ch <= fbw_channels; ch++) {
953 s->channel_in_cpl[ch] = 0;
954 s->first_cpl_coords[ch] = 1;
956 s->first_cpl_leak = s->eac3;
957 s->phase_flags_in_use = 0;
959 } else if (!s->eac3) {
961 av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "
962 "be present in block 0\n");
963 return AVERROR_INVALIDDATA;
965 s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
968 cpl_in_use = s->cpl_in_use[blk];
970 /* coupling coordinates */
972 int cpl_coords_exist = 0;
974 for (ch = 1; ch <= fbw_channels; ch++) {
975 if (s->channel_in_cpl[ch]) {
976 if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
977 int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
978 s->first_cpl_coords[ch] = 0;
979 cpl_coords_exist = 1;
980 master_cpl_coord = 3 * get_bits(gbc, 2);
981 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
982 cpl_coord_exp = get_bits(gbc, 4);
983 cpl_coord_mant = get_bits(gbc, 4);
984 if (cpl_coord_exp == 15)
985 s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
987 s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
988 s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
991 av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
992 "be present in block 0\n");
993 return AVERROR_INVALIDDATA;
996 /* channel not in coupling */
997 s->first_cpl_coords[ch] = 1;
1001 if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
1002 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1003 s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
1008 /* stereo rematrixing strategy and band structure */
1009 if (channel_mode == AC3_CHMODE_STEREO) {
1010 if ((s->eac3 && !blk) || get_bits1(gbc)) {
1011 s->num_rematrixing_bands = 4;
1012 if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
1013 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
1014 } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
1015 s->num_rematrixing_bands--;
1017 for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
1018 s->rematrixing_flags[bnd] = get_bits1(gbc);
1020 av_log(s->avctx, AV_LOG_WARNING, "Warning: "
1021 "new rematrixing strategy not present in block 0\n");
1022 s->num_rematrixing_bands = 0;
1026 /* exponent strategies for each channel */
1027 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1029 s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
1030 if (s->exp_strategy[blk][ch] != EXP_REUSE)
1031 bit_alloc_stages[ch] = 3;
1034 /* channel bandwidth */
1035 for (ch = 1; ch <= fbw_channels; ch++) {
1036 s->start_freq[ch] = 0;
1037 if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1039 int prev = s->end_freq[ch];
1040 if (s->channel_in_cpl[ch])
1041 s->end_freq[ch] = s->start_freq[CPL_CH];
1042 else if (s->channel_uses_spx[ch])
1043 s->end_freq[ch] = s->spx_src_start_freq;
1045 int bandwidth_code = get_bits(gbc, 6);
1046 if (bandwidth_code > 60) {
1047 av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1048 return AVERROR_INVALIDDATA;
1050 s->end_freq[ch] = bandwidth_code * 3 + 73;
1052 group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1053 s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
1054 if (blk > 0 && s->end_freq[ch] != prev)
1055 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1058 if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1059 s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
1060 (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1063 /* decode exponents for each channel */
1064 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1065 if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1066 s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1067 if (decode_exponents(gbc, s->exp_strategy[blk][ch],
1068 s->num_exp_groups[ch], s->dexps[ch][0],
1069 &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1070 av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
1071 return AVERROR_INVALIDDATA;
1073 if (ch != CPL_CH && ch != s->lfe_ch)
1074 skip_bits(gbc, 2); /* skip gainrng */
1078 /* bit allocation information */
1079 if (s->bit_allocation_syntax) {
1080 if (get_bits1(gbc)) {
1081 s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1082 s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1083 s->bit_alloc_params.slow_gain = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
1084 s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
1085 s->bit_alloc_params.floor = ff_ac3_floor_tab[get_bits(gbc, 3)];
1086 for (ch = !cpl_in_use; ch <= s->channels; ch++)
1087 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1089 av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must "
1090 "be present in block 0\n");
1091 return AVERROR_INVALIDDATA;
1095 /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1096 if (!s->eac3 || !blk) {
1097 if (s->snr_offset_strategy && get_bits1(gbc)) {
1100 csnr = (get_bits(gbc, 6) - 15) << 4;
1101 for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1103 if (ch == i || s->snr_offset_strategy == 2)
1104 snr = (csnr + get_bits(gbc, 4)) << 2;
1105 /* run at least last bit allocation stage if snr offset changes */
1106 if (blk && s->snr_offset[ch] != snr) {
1107 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1109 s->snr_offset[ch] = snr;
1111 /* fast gain (normal AC-3 only) */
1113 int prev = s->fast_gain[ch];
1114 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1115 /* run last 2 bit allocation stages if fast gain changes */
1116 if (blk && prev != s->fast_gain[ch])
1117 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1120 } else if (!s->eac3 && !blk) {
1121 av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1122 return AVERROR_INVALIDDATA;
1126 /* fast gain (E-AC-3 only) */
1127 if (s->fast_gain_syntax && get_bits1(gbc)) {
1128 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1129 int prev = s->fast_gain[ch];
1130 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1131 /* run last 2 bit allocation stages if fast gain changes */
1132 if (blk && prev != s->fast_gain[ch])
1133 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1135 } else if (s->eac3 && !blk) {
1136 for (ch = !cpl_in_use; ch <= s->channels; ch++)
1137 s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1140 /* E-AC-3 to AC-3 converter SNR offset */
1141 if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1142 skip_bits(gbc, 10); // skip converter snr offset
1145 /* coupling leak information */
1147 if (s->first_cpl_leak || get_bits1(gbc)) {
1148 int fl = get_bits(gbc, 3);
1149 int sl = get_bits(gbc, 3);
1150 /* run last 2 bit allocation stages for coupling channel if
1151 coupling leak changes */
1152 if (blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1153 sl != s->bit_alloc_params.cpl_slow_leak)) {
1154 bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1156 s->bit_alloc_params.cpl_fast_leak = fl;
1157 s->bit_alloc_params.cpl_slow_leak = sl;
1158 } else if (!s->eac3 && !blk) {
1159 av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must "
1160 "be present in block 0\n");
1161 return AVERROR_INVALIDDATA;
1163 s->first_cpl_leak = 0;
1166 /* delta bit allocation information */
1167 if (s->dba_syntax && get_bits1(gbc)) {
1168 /* delta bit allocation exists (strategy) */
1169 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1170 s->dba_mode[ch] = get_bits(gbc, 2);
1171 if (s->dba_mode[ch] == DBA_RESERVED) {
1172 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1173 return AVERROR_INVALIDDATA;
1175 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1177 /* channel delta offset, len and bit allocation */
1178 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1179 if (s->dba_mode[ch] == DBA_NEW) {
1180 s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;
1181 for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
1182 s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1183 s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1184 s->dba_values[ch][seg] = get_bits(gbc, 3);
1186 /* run last 2 bit allocation stages if new dba values */
1187 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1190 } else if (blk == 0) {
1191 for (ch = 0; ch <= s->channels; ch++) {
1192 s->dba_mode[ch] = DBA_NONE;
1196 /* Bit allocation */
1197 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1198 if (bit_alloc_stages[ch] > 2) {
1199 /* Exponent mapping into PSD and PSD integration */
1200 ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
1201 s->start_freq[ch], s->end_freq[ch],
1202 s->psd[ch], s->band_psd[ch]);
1204 if (bit_alloc_stages[ch] > 1) {
1205 /* Compute excitation function, Compute masking curve, and
1206 Apply delta bit allocation */
1207 if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1208 s->start_freq[ch], s->end_freq[ch],
1209 s->fast_gain[ch], (ch == s->lfe_ch),
1210 s->dba_mode[ch], s->dba_nsegs[ch],
1211 s->dba_offsets[ch], s->dba_lengths[ch],
1212 s->dba_values[ch], s->mask[ch])) {
1213 av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1214 return AVERROR_INVALIDDATA;
1217 if (bit_alloc_stages[ch] > 0) {
1218 /* Compute bit allocation */
1219 const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1220 ff_eac3_hebap_tab : ff_ac3_bap_tab;
1221 s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1222 s->start_freq[ch], s->end_freq[ch],
1224 s->bit_alloc_params.floor,
1225 bap_tab, s->bap[ch]);
1229 /* unused dummy data */
1230 if (s->skip_syntax && get_bits1(gbc)) {
1231 int skipl = get_bits(gbc, 9);
1236 /* unpack the transform coefficients
1237 this also uncouples channels if coupling is in use. */
1238 decode_transform_coeffs(s, blk);
1240 /* TODO: generate enhanced coupling coordinates and uncouple */
1242 /* recover coefficients if rematrixing is in use */
1243 if (s->channel_mode == AC3_CHMODE_STEREO)
1246 /* apply scaling to coefficients (headroom, dynrng) */
1247 for (ch = 1; ch <= s->channels; ch++) {
1248 float gain = 1.0 / 4194304.0f;
1249 if (s->channel_mode == AC3_CHMODE_DUALMONO) {
1250 gain *= s->dynamic_range[2 - ch];
1252 gain *= s->dynamic_range[0];
1254 s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch],
1255 s->fixed_coeffs[ch], gain, 256);
1258 /* apply spectral extension to high frequency bins */
1259 if (s->spx_in_use && CONFIG_EAC3_DECODER) {
1260 ff_eac3_apply_spectral_extension(s);
1263 /* downmix and MDCT. order depends on whether block switching is used for
1264 any channel in this block. this is because coefficients for the long
1265 and short transforms cannot be mixed. */
1266 downmix_output = s->channels != s->out_channels &&
1267 !((s->output_mode & AC3_OUTPUT_LFEON) &&
1268 s->fbw_channels == s->out_channels);
1269 if (different_transforms) {
1270 /* the delay samples have already been downmixed, so we upmix the delay
1271 samples in order to reconstruct all channels before downmixing. */
1277 do_imdct(s, s->channels);
1279 if (downmix_output) {
1280 s->ac3dsp.downmix(s->outptr, s->downmix_coeffs,
1281 s->out_channels, s->fbw_channels, 256);
1284 if (downmix_output) {
1285 s->ac3dsp.downmix(s->xcfptr + 1, s->downmix_coeffs,
1286 s->out_channels, s->fbw_channels, 256);
1289 if (downmix_output && !s->downmixed) {
1291 s->ac3dsp.downmix(s->dlyptr, s->downmix_coeffs, s->out_channels,
1292 s->fbw_channels, 128);
1295 do_imdct(s, s->out_channels);
1302 * Decode a single AC-3 frame.
1304 static int ac3_decode_frame(AVCodecContext * avctx, void *data,
1305 int *got_frame_ptr, AVPacket *avpkt)
1307 AVFrame *frame = data;
1308 const uint8_t *buf = avpkt->data;
1309 int buf_size = avpkt->size;
1310 AC3DecodeContext *s = avctx->priv_data;
1311 int blk, ch, err, ret;
1312 const uint8_t *channel_map;
1313 const float *output[AC3_MAX_CHANNELS];
1314 enum AVMatrixEncoding matrix_encoding;
1316 /* copy input buffer to decoder context to avoid reading past the end
1317 of the buffer, which can be caused by a damaged input stream. */
1318 if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
1319 // seems to be byte-swapped AC-3
1320 int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1321 s->dsp.bswap16_buf((uint16_t *)s->input_buffer, (const uint16_t *)buf, cnt);
1323 memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1324 buf = s->input_buffer;
1325 /* initialize the GetBitContext with the start of valid AC-3 Frame */
1326 init_get_bits(&s->gbc, buf, buf_size * 8);
1328 /* parse the syncinfo */
1329 err = parse_frame_header(s);
1333 case AAC_AC3_PARSE_ERROR_SYNC:
1334 av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1335 return AVERROR_INVALIDDATA;
1336 case AAC_AC3_PARSE_ERROR_BSID:
1337 av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1339 case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
1340 av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1342 case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
1343 av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1345 case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
1346 /* skip frame if CRC is ok. otherwise use error concealment. */
1347 /* TODO: add support for substreams and dependent frames */
1348 if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
1349 av_log(avctx, AV_LOG_WARNING, "unsupported frame type : "
1350 "skipping frame\n");
1354 av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1357 case AAC_AC3_PARSE_ERROR_CRC:
1358 case AAC_AC3_PARSE_ERROR_CHANNEL_CFG:
1360 default: // Normal AVERROR do not try to recover.
1365 /* check that reported frame size fits in input buffer */
1366 if (s->frame_size > buf_size) {
1367 av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1368 err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
1369 } else if (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL)) {
1370 /* check for crc mismatch */
1371 if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
1372 s->frame_size - 2)) {
1373 av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1374 if (avctx->err_recognition & AV_EF_EXPLODE)
1375 return AVERROR_INVALIDDATA;
1376 err = AAC_AC3_PARSE_ERROR_CRC;
1381 /* if frame is ok, set audio parameters */
1383 avctx->sample_rate = s->sample_rate;
1384 avctx->bit_rate = s->bit_rate;
1387 /* channel config */
1388 if (!err || (s->channels && s->out_channels != s->channels)) {
1389 s->out_channels = s->channels;
1390 s->output_mode = s->channel_mode;
1392 s->output_mode |= AC3_OUTPUT_LFEON;
1393 if (s->channels > 1 &&
1394 avctx->request_channel_layout == AV_CH_LAYOUT_MONO) {
1395 s->out_channels = 1;
1396 s->output_mode = AC3_CHMODE_MONO;
1397 } else if (s->channels > 2 &&
1398 avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
1399 s->out_channels = 2;
1400 s->output_mode = AC3_CHMODE_STEREO;
1403 s->loro_center_mix_level = gain_levels[s-> center_mix_level];
1404 s->loro_surround_mix_level = gain_levels[s->surround_mix_level];
1405 s->ltrt_center_mix_level = LEVEL_MINUS_3DB;
1406 s->ltrt_surround_mix_level = LEVEL_MINUS_3DB;
1407 /* set downmixing coefficients if needed */
1408 if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1409 s->fbw_channels == s->out_channels)) {
1410 set_downmix_coeffs(s);
1412 } else if (!s->channels) {
1413 av_log(avctx, AV_LOG_ERROR, "unable to determine channel mode\n");
1414 return AVERROR_INVALIDDATA;
1416 avctx->channels = s->out_channels;
1417 avctx->channel_layout = avpriv_ac3_channel_layout_tab[s->output_mode & ~AC3_OUTPUT_LFEON];
1418 if (s->output_mode & AC3_OUTPUT_LFEON)
1419 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1421 /* set audio service type based on bitstream mode for AC-3 */
1422 avctx->audio_service_type = s->bitstream_mode;
1423 if (s->bitstream_mode == 0x7 && s->channels > 1)
1424 avctx->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
1426 /* get output buffer */
1427 frame->nb_samples = s->num_blocks * AC3_BLOCK_SIZE;
1428 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1431 /* decode the audio blocks */
1432 channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1433 for (ch = 0; ch < AC3_MAX_CHANNELS; ch++) {
1434 output[ch] = s->output[ch];
1435 s->outptr[ch] = s->output[ch];
1437 for (ch = 0; ch < s->channels; ch++) {
1438 if (ch < s->out_channels)
1439 s->outptr[channel_map[ch]] = (float *)frame->data[ch];
1441 for (blk = 0; blk < s->num_blocks; blk++) {
1442 if (!err && decode_audio_block(s, blk)) {
1443 av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1447 for (ch = 0; ch < s->out_channels; ch++)
1448 memcpy(((float*)frame->data[ch]) + AC3_BLOCK_SIZE*blk, output[ch], sizeof(**output) * AC3_BLOCK_SIZE);
1449 for (ch = 0; ch < s->out_channels; ch++)
1450 output[ch] = s->outptr[channel_map[ch]];
1451 for (ch = 0; ch < s->out_channels; ch++) {
1452 if (!ch || channel_map[ch])
1453 s->outptr[channel_map[ch]] += AC3_BLOCK_SIZE;
1457 av_frame_set_decode_error_flags(frame, err ? FF_DECODE_ERROR_INVALID_BITSTREAM : 0);
1459 /* keep last block for error concealment in next frame */
1460 for (ch = 0; ch < s->out_channels; ch++)
1461 memcpy(s->output[ch], output[ch], sizeof(**output) * AC3_BLOCK_SIZE);
1466 * Check whether the input layout is compatible, and make sure we're not
1467 * downmixing (else the matrix encoding is no longer applicable).
1469 matrix_encoding = AV_MATRIX_ENCODING_NONE;
1470 if (s->channel_mode == AC3_CHMODE_STEREO &&
1471 s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1472 if (s->dolby_surround_mode == AC3_DSURMOD_ON)
1473 matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
1474 else if (s->dolby_headphone_mode == AC3_DHEADPHONMOD_ON)
1475 matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;
1476 } else if (s->channel_mode >= AC3_CHMODE_2F2R &&
1477 s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1478 switch (s->dolby_surround_ex_mode) {
1479 case AC3_DSUREXMOD_ON: // EX or PLIIx
1480 matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
1482 case AC3_DSUREXMOD_PLIIZ:
1483 matrix_encoding = AV_MATRIX_ENCODING_DPLIIZ;
1485 default: // not indicated or off
1489 if ((ret = ff_side_data_update_matrix_encoding(frame, matrix_encoding)) < 0)
1494 return FFMIN(buf_size, s->frame_size);
1498 * Uninitialize the AC-3 decoder.
1500 static av_cold int ac3_decode_end(AVCodecContext *avctx)
1502 AC3DecodeContext *s = avctx->priv_data;
1503 ff_mdct_end(&s->imdct_512);
1504 ff_mdct_end(&s->imdct_256);
1509 #define OFFSET(x) offsetof(AC3DecodeContext, x)
1510 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)
1511 static const AVOption options[] = {
1512 { "drc_scale", "percentage of dynamic range compression to apply", OFFSET(drc_scale), AV_OPT_TYPE_FLOAT, {.dbl = 1.0}, 0.0, 6.0, PAR },
1514 {"dmix_mode", "Preferred Stereo Downmix Mode", OFFSET(preferred_stereo_downmix), AV_OPT_TYPE_INT, {.i64 = -1 }, -1, 2, 0, "dmix_mode"},
1515 {"ltrt_cmixlev", "Lt/Rt Center Mix Level", OFFSET(ltrt_center_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
1516 {"ltrt_surmixlev", "Lt/Rt Surround Mix Level", OFFSET(ltrt_surround_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
1517 {"loro_cmixlev", "Lo/Ro Center Mix Level", OFFSET(loro_center_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
1518 {"loro_surmixlev", "Lo/Ro Surround Mix Level", OFFSET(loro_surround_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
1523 static const AVClass ac3_decoder_class = {
1524 .class_name = "AC3 decoder",
1525 .item_name = av_default_item_name,
1527 .version = LIBAVUTIL_VERSION_INT,
1530 AVCodec ff_ac3_decoder = {
1532 .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
1533 .type = AVMEDIA_TYPE_AUDIO,
1534 .id = AV_CODEC_ID_AC3,
1535 .priv_data_size = sizeof (AC3DecodeContext),
1536 .init = ac3_decode_init,
1537 .close = ac3_decode_end,
1538 .decode = ac3_decode_frame,
1539 .capabilities = CODEC_CAP_DR1,
1540 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1541 AV_SAMPLE_FMT_NONE },
1542 .priv_class = &ac3_decoder_class,
1545 #if CONFIG_EAC3_DECODER
1546 static const AVClass eac3_decoder_class = {
1547 .class_name = "E-AC3 decoder",
1548 .item_name = av_default_item_name,
1550 .version = LIBAVUTIL_VERSION_INT,
1553 AVCodec ff_eac3_decoder = {
1555 .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
1556 .type = AVMEDIA_TYPE_AUDIO,
1557 .id = AV_CODEC_ID_EAC3,
1558 .priv_data_size = sizeof (AC3DecodeContext),
1559 .init = ac3_decode_init,
1560 .close = ac3_decode_end,
1561 .decode = ac3_decode_frame,
1562 .capabilities = CODEC_CAP_DR1,
1563 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1564 AV_SAMPLE_FMT_NONE },
1565 .priv_class = &eac3_decoder_class,