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 s->dynamic_range[i] = powf(dynamic_range_tab[get_bits(gbc, 8)],
787 } else if (blk == 0) {
788 s->dynamic_range[i] = 1.0f;
792 /* spectral extension strategy */
793 if (s->eac3 && (!blk || get_bits1(gbc))) {
794 s->spx_in_use = get_bits1(gbc);
796 int dst_start_freq, dst_end_freq, src_start_freq,
797 start_subband, end_subband;
799 /* determine which channels use spx */
800 if (s->channel_mode == AC3_CHMODE_MONO) {
801 s->channel_uses_spx[1] = 1;
803 for (ch = 1; ch <= fbw_channels; ch++)
804 s->channel_uses_spx[ch] = get_bits1(gbc);
807 /* get the frequency bins of the spx copy region and the spx start
809 dst_start_freq = get_bits(gbc, 2);
810 start_subband = get_bits(gbc, 3) + 2;
811 if (start_subband > 7)
812 start_subband += start_subband - 7;
813 end_subband = get_bits(gbc, 3) + 5;
815 end_subband += end_subband - 7;
816 dst_start_freq = dst_start_freq * 12 + 25;
817 src_start_freq = start_subband * 12 + 25;
818 dst_end_freq = end_subband * 12 + 25;
820 /* check validity of spx ranges */
821 if (start_subband >= end_subband) {
822 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
823 "range (%d >= %d)\n", start_subband, end_subband);
824 return AVERROR_INVALIDDATA;
826 if (dst_start_freq >= src_start_freq) {
827 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
828 "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
829 return AVERROR_INVALIDDATA;
832 s->spx_dst_start_freq = dst_start_freq;
833 s->spx_src_start_freq = src_start_freq;
834 s->spx_dst_end_freq = dst_end_freq;
836 decode_band_structure(gbc, blk, s->eac3, 0,
837 start_subband, end_subband,
838 ff_eac3_default_spx_band_struct,
842 for (ch = 1; ch <= fbw_channels; ch++) {
843 s->channel_uses_spx[ch] = 0;
844 s->first_spx_coords[ch] = 1;
849 /* spectral extension coordinates */
851 for (ch = 1; ch <= fbw_channels; ch++) {
852 if (s->channel_uses_spx[ch]) {
853 if (s->first_spx_coords[ch] || get_bits1(gbc)) {
855 int bin, master_spx_coord;
857 s->first_spx_coords[ch] = 0;
858 spx_blend = get_bits(gbc, 5) * (1.0f/32);
859 master_spx_coord = get_bits(gbc, 2) * 3;
861 bin = s->spx_src_start_freq;
862 for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
864 int spx_coord_exp, spx_coord_mant;
865 float nratio, sblend, nblend, spx_coord;
867 /* calculate blending factors */
868 bandsize = s->spx_band_sizes[bnd];
869 nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
870 nratio = av_clipf(nratio, 0.0f, 1.0f);
871 nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
872 // to give unity variance
873 sblend = sqrtf(1.0f - nratio);
876 /* decode spx coordinates */
877 spx_coord_exp = get_bits(gbc, 4);
878 spx_coord_mant = get_bits(gbc, 2);
879 if (spx_coord_exp == 15) spx_coord_mant <<= 1;
880 else spx_coord_mant += 4;
881 spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
882 spx_coord = spx_coord_mant * (1.0f / (1 << 23));
884 /* multiply noise and signal blending factors by spx coordinate */
885 s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
886 s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
890 s->first_spx_coords[ch] = 1;
895 /* coupling strategy */
896 if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
897 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
899 s->cpl_in_use[blk] = get_bits1(gbc);
900 if (s->cpl_in_use[blk]) {
901 /* coupling in use */
902 int cpl_start_subband, cpl_end_subband;
904 if (channel_mode < AC3_CHMODE_STEREO) {
905 av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
906 return AVERROR_INVALIDDATA;
909 /* check for enhanced coupling */
910 if (s->eac3 && get_bits1(gbc)) {
911 /* TODO: parse enhanced coupling strategy info */
912 avpriv_request_sample(s->avctx, "Enhanced coupling");
913 return AVERROR_PATCHWELCOME;
916 /* determine which channels are coupled */
917 if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
918 s->channel_in_cpl[1] = 1;
919 s->channel_in_cpl[2] = 1;
921 for (ch = 1; ch <= fbw_channels; ch++)
922 s->channel_in_cpl[ch] = get_bits1(gbc);
925 /* phase flags in use */
926 if (channel_mode == AC3_CHMODE_STEREO)
927 s->phase_flags_in_use = get_bits1(gbc);
929 /* coupling frequency range */
930 cpl_start_subband = get_bits(gbc, 4);
931 cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
932 get_bits(gbc, 4) + 3;
933 if (cpl_start_subband >= cpl_end_subband) {
934 av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
935 cpl_start_subband, cpl_end_subband);
936 return AVERROR_INVALIDDATA;
938 s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
939 s->end_freq[CPL_CH] = cpl_end_subband * 12 + 37;
941 decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
943 ff_eac3_default_cpl_band_struct,
944 &s->num_cpl_bands, s->cpl_band_sizes);
946 /* coupling not in use */
947 for (ch = 1; ch <= fbw_channels; ch++) {
948 s->channel_in_cpl[ch] = 0;
949 s->first_cpl_coords[ch] = 1;
951 s->first_cpl_leak = s->eac3;
952 s->phase_flags_in_use = 0;
954 } else if (!s->eac3) {
956 av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "
957 "be present in block 0\n");
958 return AVERROR_INVALIDDATA;
960 s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
963 cpl_in_use = s->cpl_in_use[blk];
965 /* coupling coordinates */
967 int cpl_coords_exist = 0;
969 for (ch = 1; ch <= fbw_channels; ch++) {
970 if (s->channel_in_cpl[ch]) {
971 if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
972 int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
973 s->first_cpl_coords[ch] = 0;
974 cpl_coords_exist = 1;
975 master_cpl_coord = 3 * get_bits(gbc, 2);
976 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
977 cpl_coord_exp = get_bits(gbc, 4);
978 cpl_coord_mant = get_bits(gbc, 4);
979 if (cpl_coord_exp == 15)
980 s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
982 s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
983 s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
986 av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
987 "be present in block 0\n");
988 return AVERROR_INVALIDDATA;
991 /* channel not in coupling */
992 s->first_cpl_coords[ch] = 1;
996 if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
997 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
998 s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
1003 /* stereo rematrixing strategy and band structure */
1004 if (channel_mode == AC3_CHMODE_STEREO) {
1005 if ((s->eac3 && !blk) || get_bits1(gbc)) {
1006 s->num_rematrixing_bands = 4;
1007 if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
1008 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
1009 } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
1010 s->num_rematrixing_bands--;
1012 for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
1013 s->rematrixing_flags[bnd] = get_bits1(gbc);
1015 av_log(s->avctx, AV_LOG_WARNING, "Warning: "
1016 "new rematrixing strategy not present in block 0\n");
1017 s->num_rematrixing_bands = 0;
1021 /* exponent strategies for each channel */
1022 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1024 s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
1025 if (s->exp_strategy[blk][ch] != EXP_REUSE)
1026 bit_alloc_stages[ch] = 3;
1029 /* channel bandwidth */
1030 for (ch = 1; ch <= fbw_channels; ch++) {
1031 s->start_freq[ch] = 0;
1032 if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1034 int prev = s->end_freq[ch];
1035 if (s->channel_in_cpl[ch])
1036 s->end_freq[ch] = s->start_freq[CPL_CH];
1037 else if (s->channel_uses_spx[ch])
1038 s->end_freq[ch] = s->spx_src_start_freq;
1040 int bandwidth_code = get_bits(gbc, 6);
1041 if (bandwidth_code > 60) {
1042 av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1043 return AVERROR_INVALIDDATA;
1045 s->end_freq[ch] = bandwidth_code * 3 + 73;
1047 group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1048 s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
1049 if (blk > 0 && s->end_freq[ch] != prev)
1050 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1053 if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1054 s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
1055 (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1058 /* decode exponents for each channel */
1059 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1060 if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1061 s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1062 if (decode_exponents(gbc, s->exp_strategy[blk][ch],
1063 s->num_exp_groups[ch], s->dexps[ch][0],
1064 &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1065 av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
1066 return AVERROR_INVALIDDATA;
1068 if (ch != CPL_CH && ch != s->lfe_ch)
1069 skip_bits(gbc, 2); /* skip gainrng */
1073 /* bit allocation information */
1074 if (s->bit_allocation_syntax) {
1075 if (get_bits1(gbc)) {
1076 s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1077 s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1078 s->bit_alloc_params.slow_gain = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
1079 s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
1080 s->bit_alloc_params.floor = ff_ac3_floor_tab[get_bits(gbc, 3)];
1081 for (ch = !cpl_in_use; ch <= s->channels; ch++)
1082 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1084 av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must "
1085 "be present in block 0\n");
1086 return AVERROR_INVALIDDATA;
1090 /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1091 if (!s->eac3 || !blk) {
1092 if (s->snr_offset_strategy && get_bits1(gbc)) {
1095 csnr = (get_bits(gbc, 6) - 15) << 4;
1096 for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1098 if (ch == i || s->snr_offset_strategy == 2)
1099 snr = (csnr + get_bits(gbc, 4)) << 2;
1100 /* run at least last bit allocation stage if snr offset changes */
1101 if (blk && s->snr_offset[ch] != snr) {
1102 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1104 s->snr_offset[ch] = snr;
1106 /* fast gain (normal AC-3 only) */
1108 int prev = s->fast_gain[ch];
1109 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1110 /* run last 2 bit allocation stages if fast gain changes */
1111 if (blk && prev != s->fast_gain[ch])
1112 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1115 } else if (!s->eac3 && !blk) {
1116 av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1117 return AVERROR_INVALIDDATA;
1121 /* fast gain (E-AC-3 only) */
1122 if (s->fast_gain_syntax && get_bits1(gbc)) {
1123 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1124 int prev = s->fast_gain[ch];
1125 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1126 /* run last 2 bit allocation stages if fast gain changes */
1127 if (blk && prev != s->fast_gain[ch])
1128 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1130 } else if (s->eac3 && !blk) {
1131 for (ch = !cpl_in_use; ch <= s->channels; ch++)
1132 s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1135 /* E-AC-3 to AC-3 converter SNR offset */
1136 if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1137 skip_bits(gbc, 10); // skip converter snr offset
1140 /* coupling leak information */
1142 if (s->first_cpl_leak || get_bits1(gbc)) {
1143 int fl = get_bits(gbc, 3);
1144 int sl = get_bits(gbc, 3);
1145 /* run last 2 bit allocation stages for coupling channel if
1146 coupling leak changes */
1147 if (blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1148 sl != s->bit_alloc_params.cpl_slow_leak)) {
1149 bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1151 s->bit_alloc_params.cpl_fast_leak = fl;
1152 s->bit_alloc_params.cpl_slow_leak = sl;
1153 } else if (!s->eac3 && !blk) {
1154 av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must "
1155 "be present in block 0\n");
1156 return AVERROR_INVALIDDATA;
1158 s->first_cpl_leak = 0;
1161 /* delta bit allocation information */
1162 if (s->dba_syntax && get_bits1(gbc)) {
1163 /* delta bit allocation exists (strategy) */
1164 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1165 s->dba_mode[ch] = get_bits(gbc, 2);
1166 if (s->dba_mode[ch] == DBA_RESERVED) {
1167 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1168 return AVERROR_INVALIDDATA;
1170 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1172 /* channel delta offset, len and bit allocation */
1173 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1174 if (s->dba_mode[ch] == DBA_NEW) {
1175 s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;
1176 for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
1177 s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1178 s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1179 s->dba_values[ch][seg] = get_bits(gbc, 3);
1181 /* run last 2 bit allocation stages if new dba values */
1182 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1185 } else if (blk == 0) {
1186 for (ch = 0; ch <= s->channels; ch++) {
1187 s->dba_mode[ch] = DBA_NONE;
1191 /* Bit allocation */
1192 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1193 if (bit_alloc_stages[ch] > 2) {
1194 /* Exponent mapping into PSD and PSD integration */
1195 ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
1196 s->start_freq[ch], s->end_freq[ch],
1197 s->psd[ch], s->band_psd[ch]);
1199 if (bit_alloc_stages[ch] > 1) {
1200 /* Compute excitation function, Compute masking curve, and
1201 Apply delta bit allocation */
1202 if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1203 s->start_freq[ch], s->end_freq[ch],
1204 s->fast_gain[ch], (ch == s->lfe_ch),
1205 s->dba_mode[ch], s->dba_nsegs[ch],
1206 s->dba_offsets[ch], s->dba_lengths[ch],
1207 s->dba_values[ch], s->mask[ch])) {
1208 av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1209 return AVERROR_INVALIDDATA;
1212 if (bit_alloc_stages[ch] > 0) {
1213 /* Compute bit allocation */
1214 const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1215 ff_eac3_hebap_tab : ff_ac3_bap_tab;
1216 s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1217 s->start_freq[ch], s->end_freq[ch],
1219 s->bit_alloc_params.floor,
1220 bap_tab, s->bap[ch]);
1224 /* unused dummy data */
1225 if (s->skip_syntax && get_bits1(gbc)) {
1226 int skipl = get_bits(gbc, 9);
1231 /* unpack the transform coefficients
1232 this also uncouples channels if coupling is in use. */
1233 decode_transform_coeffs(s, blk);
1235 /* TODO: generate enhanced coupling coordinates and uncouple */
1237 /* recover coefficients if rematrixing is in use */
1238 if (s->channel_mode == AC3_CHMODE_STEREO)
1241 /* apply scaling to coefficients (headroom, dynrng) */
1242 for (ch = 1; ch <= s->channels; ch++) {
1243 float gain = 1.0 / 4194304.0f;
1244 if (s->channel_mode == AC3_CHMODE_DUALMONO) {
1245 gain *= s->dynamic_range[2 - ch];
1247 gain *= s->dynamic_range[0];
1249 s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch],
1250 s->fixed_coeffs[ch], gain, 256);
1253 /* apply spectral extension to high frequency bins */
1254 if (s->spx_in_use && CONFIG_EAC3_DECODER) {
1255 ff_eac3_apply_spectral_extension(s);
1258 /* downmix and MDCT. order depends on whether block switching is used for
1259 any channel in this block. this is because coefficients for the long
1260 and short transforms cannot be mixed. */
1261 downmix_output = s->channels != s->out_channels &&
1262 !((s->output_mode & AC3_OUTPUT_LFEON) &&
1263 s->fbw_channels == s->out_channels);
1264 if (different_transforms) {
1265 /* the delay samples have already been downmixed, so we upmix the delay
1266 samples in order to reconstruct all channels before downmixing. */
1272 do_imdct(s, s->channels);
1274 if (downmix_output) {
1275 s->ac3dsp.downmix(s->outptr, s->downmix_coeffs,
1276 s->out_channels, s->fbw_channels, 256);
1279 if (downmix_output) {
1280 s->ac3dsp.downmix(s->xcfptr + 1, s->downmix_coeffs,
1281 s->out_channels, s->fbw_channels, 256);
1284 if (downmix_output && !s->downmixed) {
1286 s->ac3dsp.downmix(s->dlyptr, s->downmix_coeffs, s->out_channels,
1287 s->fbw_channels, 128);
1290 do_imdct(s, s->out_channels);
1297 * Decode a single AC-3 frame.
1299 static int ac3_decode_frame(AVCodecContext * avctx, void *data,
1300 int *got_frame_ptr, AVPacket *avpkt)
1302 AVFrame *frame = data;
1303 const uint8_t *buf = avpkt->data;
1304 int buf_size = avpkt->size;
1305 AC3DecodeContext *s = avctx->priv_data;
1306 int blk, ch, err, ret;
1307 const uint8_t *channel_map;
1308 const float *output[AC3_MAX_CHANNELS];
1309 enum AVMatrixEncoding matrix_encoding;
1311 /* copy input buffer to decoder context to avoid reading past the end
1312 of the buffer, which can be caused by a damaged input stream. */
1313 if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
1314 // seems to be byte-swapped AC-3
1315 int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1316 s->dsp.bswap16_buf((uint16_t *)s->input_buffer, (const uint16_t *)buf, cnt);
1318 memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1319 buf = s->input_buffer;
1320 /* initialize the GetBitContext with the start of valid AC-3 Frame */
1321 init_get_bits(&s->gbc, buf, buf_size * 8);
1323 /* parse the syncinfo */
1324 err = parse_frame_header(s);
1328 case AAC_AC3_PARSE_ERROR_SYNC:
1329 av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1330 return AVERROR_INVALIDDATA;
1331 case AAC_AC3_PARSE_ERROR_BSID:
1332 av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1334 case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
1335 av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1337 case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
1338 av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1340 case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
1341 /* skip frame if CRC is ok. otherwise use error concealment. */
1342 /* TODO: add support for substreams and dependent frames */
1343 if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
1344 av_log(avctx, AV_LOG_WARNING, "unsupported frame type : "
1345 "skipping frame\n");
1349 av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1352 case AAC_AC3_PARSE_ERROR_CRC:
1353 case AAC_AC3_PARSE_ERROR_CHANNEL_CFG:
1355 default: // Normal AVERROR do not try to recover.
1360 /* check that reported frame size fits in input buffer */
1361 if (s->frame_size > buf_size) {
1362 av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1363 err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
1364 } else if (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL)) {
1365 /* check for crc mismatch */
1366 if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
1367 s->frame_size - 2)) {
1368 av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1369 if (avctx->err_recognition & AV_EF_EXPLODE)
1370 return AVERROR_INVALIDDATA;
1371 err = AAC_AC3_PARSE_ERROR_CRC;
1376 /* if frame is ok, set audio parameters */
1378 avctx->sample_rate = s->sample_rate;
1379 avctx->bit_rate = s->bit_rate;
1382 /* channel config */
1383 if (!err || (s->channels && s->out_channels != s->channels)) {
1384 s->out_channels = s->channels;
1385 s->output_mode = s->channel_mode;
1387 s->output_mode |= AC3_OUTPUT_LFEON;
1388 if (s->channels > 1 &&
1389 avctx->request_channel_layout == AV_CH_LAYOUT_MONO) {
1390 s->out_channels = 1;
1391 s->output_mode = AC3_CHMODE_MONO;
1392 } else if (s->channels > 2 &&
1393 avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
1394 s->out_channels = 2;
1395 s->output_mode = AC3_CHMODE_STEREO;
1398 s->loro_center_mix_level = gain_levels[s-> center_mix_level];
1399 s->loro_surround_mix_level = gain_levels[s->surround_mix_level];
1400 s->ltrt_center_mix_level = LEVEL_MINUS_3DB;
1401 s->ltrt_surround_mix_level = LEVEL_MINUS_3DB;
1402 /* set downmixing coefficients if needed */
1403 if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1404 s->fbw_channels == s->out_channels)) {
1405 set_downmix_coeffs(s);
1407 } else if (!s->channels) {
1408 av_log(avctx, AV_LOG_ERROR, "unable to determine channel mode\n");
1409 return AVERROR_INVALIDDATA;
1411 avctx->channels = s->out_channels;
1412 avctx->channel_layout = avpriv_ac3_channel_layout_tab[s->output_mode & ~AC3_OUTPUT_LFEON];
1413 if (s->output_mode & AC3_OUTPUT_LFEON)
1414 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1416 /* set audio service type based on bitstream mode for AC-3 */
1417 avctx->audio_service_type = s->bitstream_mode;
1418 if (s->bitstream_mode == 0x7 && s->channels > 1)
1419 avctx->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
1421 /* get output buffer */
1422 frame->nb_samples = s->num_blocks * AC3_BLOCK_SIZE;
1423 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1426 /* decode the audio blocks */
1427 channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1428 for (ch = 0; ch < AC3_MAX_CHANNELS; ch++) {
1429 output[ch] = s->output[ch];
1430 s->outptr[ch] = s->output[ch];
1432 for (ch = 0; ch < s->channels; ch++) {
1433 if (ch < s->out_channels)
1434 s->outptr[channel_map[ch]] = (float *)frame->data[ch];
1436 for (blk = 0; blk < s->num_blocks; blk++) {
1437 if (!err && decode_audio_block(s, blk)) {
1438 av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1442 for (ch = 0; ch < s->out_channels; ch++)
1443 memcpy(((float*)frame->data[ch]) + AC3_BLOCK_SIZE*blk, output[ch], sizeof(**output) * AC3_BLOCK_SIZE);
1444 for (ch = 0; ch < s->out_channels; ch++)
1445 output[ch] = s->outptr[channel_map[ch]];
1446 for (ch = 0; ch < s->out_channels; ch++) {
1447 if (!ch || channel_map[ch])
1448 s->outptr[channel_map[ch]] += AC3_BLOCK_SIZE;
1452 av_frame_set_decode_error_flags(frame, err ? FF_DECODE_ERROR_INVALID_BITSTREAM : 0);
1454 /* keep last block for error concealment in next frame */
1455 for (ch = 0; ch < s->out_channels; ch++)
1456 memcpy(s->output[ch], output[ch], sizeof(**output) * AC3_BLOCK_SIZE);
1461 * Check whether the input layout is compatible, and make sure we're not
1462 * downmixing (else the matrix encoding is no longer applicable).
1464 matrix_encoding = AV_MATRIX_ENCODING_NONE;
1465 if (s->channel_mode == AC3_CHMODE_STEREO &&
1466 s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1467 if (s->dolby_surround_mode == AC3_DSURMOD_ON)
1468 matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
1469 else if (s->dolby_headphone_mode == AC3_DHEADPHONMOD_ON)
1470 matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;
1471 } else if (s->channel_mode >= AC3_CHMODE_2F2R &&
1472 s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1473 switch (s->dolby_surround_ex_mode) {
1474 case AC3_DSUREXMOD_ON: // EX or PLIIx
1475 matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
1477 case AC3_DSUREXMOD_PLIIZ:
1478 matrix_encoding = AV_MATRIX_ENCODING_DPLIIZ;
1480 default: // not indicated or off
1484 if ((ret = ff_side_data_update_matrix_encoding(frame, matrix_encoding)) < 0)
1489 return FFMIN(buf_size, s->frame_size);
1493 * Uninitialize the AC-3 decoder.
1495 static av_cold int ac3_decode_end(AVCodecContext *avctx)
1497 AC3DecodeContext *s = avctx->priv_data;
1498 ff_mdct_end(&s->imdct_512);
1499 ff_mdct_end(&s->imdct_256);
1504 #define OFFSET(x) offsetof(AC3DecodeContext, x)
1505 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)
1506 static const AVOption options[] = {
1507 { "drc_scale", "percentage of dynamic range compression to apply", OFFSET(drc_scale), AV_OPT_TYPE_FLOAT, {.dbl = 1.0}, 0.0, 1.0, PAR },
1509 {"dmix_mode", "Preferred Stereo Downmix Mode", OFFSET(preferred_stereo_downmix), AV_OPT_TYPE_INT, {.i64 = -1 }, -1, 2, 0, "dmix_mode"},
1510 {"ltrt_cmixlev", "Lt/Rt Center Mix Level", OFFSET(ltrt_center_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
1511 {"ltrt_surmixlev", "Lt/Rt Surround Mix Level", OFFSET(ltrt_surround_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
1512 {"loro_cmixlev", "Lo/Ro Center Mix Level", OFFSET(loro_center_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
1513 {"loro_surmixlev", "Lo/Ro Surround Mix Level", OFFSET(loro_surround_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
1518 static const AVClass ac3_decoder_class = {
1519 .class_name = "AC3 decoder",
1520 .item_name = av_default_item_name,
1522 .version = LIBAVUTIL_VERSION_INT,
1525 AVCodec ff_ac3_decoder = {
1527 .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
1528 .type = AVMEDIA_TYPE_AUDIO,
1529 .id = AV_CODEC_ID_AC3,
1530 .priv_data_size = sizeof (AC3DecodeContext),
1531 .init = ac3_decode_init,
1532 .close = ac3_decode_end,
1533 .decode = ac3_decode_frame,
1534 .capabilities = CODEC_CAP_DR1,
1535 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1536 AV_SAMPLE_FMT_NONE },
1537 .priv_class = &ac3_decoder_class,
1540 #if CONFIG_EAC3_DECODER
1541 static const AVClass eac3_decoder_class = {
1542 .class_name = "E-AC3 decoder",
1543 .item_name = av_default_item_name,
1545 .version = LIBAVUTIL_VERSION_INT,
1548 AVCodec ff_eac3_decoder = {
1550 .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
1551 .type = AVMEDIA_TYPE_AUDIO,
1552 .id = AV_CODEC_ID_EAC3,
1553 .priv_data_size = sizeof (AC3DecodeContext),
1554 .init = ac3_decode_init,
1555 .close = ac3_decode_end,
1556 .decode = ac3_decode_frame,
1557 .capabilities = CODEC_CAP_DR1,
1558 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1559 AV_SAMPLE_FMT_NONE },
1560 .priv_class = &eac3_decoder_class,