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/crc.h"
33 #include "libavutil/opt.h"
35 #include "aac_ac3_parser.h"
36 #include "ac3_parser.h"
38 #include "ac3dec_data.h"
42 * table for ungrouping 3 values in 7 bits.
43 * used for exponents and bap=2 mantissas
45 static uint8_t ungroup_3_in_7_bits_tab[128][3];
47 /** tables for ungrouping mantissas */
48 static int b1_mantissas[32][3];
49 static int b2_mantissas[128][3];
50 static int b3_mantissas[8];
51 static int b4_mantissas[128][2];
52 static int b5_mantissas[16];
55 * Quantization table: levels for symmetric. bits for asymmetric.
56 * reference: Table 7.18 Mapping of bap to Quantizer
58 static const uint8_t quantization_tab[16] = {
60 5, 6, 7, 8, 9, 10, 11, 12, 14, 16
63 /** dynamic range table. converts codes to scale factors. */
64 static float dynamic_range_tab[256];
66 /** Adjustments in dB gain */
67 static const float gain_levels[9] = {
71 LEVEL_MINUS_1POINT5DB,
73 LEVEL_MINUS_4POINT5DB,
80 * Table for default stereo downmixing coefficients
81 * reference: Section 7.8.2 Downmixing Into Two Channels
83 static const uint8_t ac3_default_coeffs[8][5][2] = {
84 { { 2, 7 }, { 7, 2 }, },
86 { { 2, 7 }, { 7, 2 }, },
87 { { 2, 7 }, { 5, 5 }, { 7, 2 }, },
88 { { 2, 7 }, { 7, 2 }, { 6, 6 }, },
89 { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 }, },
90 { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
91 { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
95 * Symmetrical Dequantization
96 * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization
100 symmetric_dequant(int code, int levels)
102 return ((code - (levels >> 1)) << 24) / levels;
106 * Initialize tables at runtime.
108 static av_cold void ac3_tables_init(void)
112 /* generate table for ungrouping 3 values in 7 bits
113 reference: Section 7.1.3 Exponent Decoding */
114 for (i = 0; i < 128; i++) {
115 ungroup_3_in_7_bits_tab[i][0] = i / 25;
116 ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5;
117 ungroup_3_in_7_bits_tab[i][2] = (i % 25) % 5;
120 /* generate grouped mantissa tables
121 reference: Section 7.3.5 Ungrouping of Mantissas */
122 for (i = 0; i < 32; i++) {
123 /* bap=1 mantissas */
124 b1_mantissas[i][0] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][0], 3);
125 b1_mantissas[i][1] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][1], 3);
126 b1_mantissas[i][2] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][2], 3);
128 for (i = 0; i < 128; i++) {
129 /* bap=2 mantissas */
130 b2_mantissas[i][0] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][0], 5);
131 b2_mantissas[i][1] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][1], 5);
132 b2_mantissas[i][2] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][2], 5);
134 /* bap=4 mantissas */
135 b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
136 b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
138 /* generate ungrouped mantissa tables
139 reference: Tables 7.21 and 7.23 */
140 for (i = 0; i < 7; i++) {
141 /* bap=3 mantissas */
142 b3_mantissas[i] = symmetric_dequant(i, 7);
144 for (i = 0; i < 15; i++) {
145 /* bap=5 mantissas */
146 b5_mantissas[i] = symmetric_dequant(i, 15);
149 /* generate dynamic range table
150 reference: Section 7.7.1 Dynamic Range Control */
151 for (i = 0; i < 256; i++) {
152 int v = (i >> 5) - ((i >> 7) << 3) - 5;
153 dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
158 * AVCodec initialization
160 static av_cold int ac3_decode_init(AVCodecContext *avctx)
162 AC3DecodeContext *s = avctx->priv_data;
166 if (avctx->drc_scale)
167 s->drc_scale = avctx->drc_scale;
170 ff_ac3_common_init();
172 ff_mdct_init(&s->imdct_256, 8, 1, 1.0);
173 ff_mdct_init(&s->imdct_512, 9, 1, 1.0);
174 ff_kbd_window_init(s->window, 5.0, 256);
175 dsputil_init(&s->dsp, avctx);
176 ff_ac3dsp_init(&s->ac3dsp, avctx->flags & CODEC_FLAG_BITEXACT);
177 ff_fmt_convert_init(&s->fmt_conv, avctx);
178 av_lfg_init(&s->dith_state, 0);
180 /* set scale value for float to int16 conversion */
181 if (avctx->request_sample_fmt == AV_SAMPLE_FMT_FLT) {
183 avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
185 s->mul_bias = 32767.0f;
186 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
189 /* allow downmixing to stereo or mono */
190 if (avctx->channels > 0 && avctx->request_channels > 0 &&
191 avctx->request_channels < avctx->channels &&
192 avctx->request_channels <= 2) {
193 avctx->channels = avctx->request_channels;
197 avcodec_get_frame_defaults(&s->frame);
198 avctx->coded_frame = &s->frame;
204 * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
205 * GetBitContext within AC3DecodeContext must point to
206 * the start of the synchronized AC-3 bitstream.
208 static int ac3_parse_header(AC3DecodeContext *s)
210 GetBitContext *gbc = &s->gbc;
213 /* read the rest of the bsi. read twice for dual mono mode. */
214 i = !s->channel_mode;
216 skip_bits(gbc, 5); // skip dialog normalization
218 skip_bits(gbc, 8); //skip compression
220 skip_bits(gbc, 8); //skip language code
222 skip_bits(gbc, 7); //skip audio production information
225 skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
227 /* skip the timecodes (or extra bitstream information for Alternate Syntax)
228 TODO: read & use the xbsi1 downmix levels */
230 skip_bits(gbc, 14); //skip timecode1 / xbsi1
232 skip_bits(gbc, 14); //skip timecode2 / xbsi2
234 /* skip additional bitstream info */
235 if (get_bits1(gbc)) {
236 i = get_bits(gbc, 6);
246 * Common function to parse AC-3 or E-AC-3 frame header
248 static int parse_frame_header(AC3DecodeContext *s)
253 err = avpriv_ac3_parse_header(&s->gbc, &hdr);
257 /* get decoding parameters from header info */
258 s->bit_alloc_params.sr_code = hdr.sr_code;
259 s->bitstream_mode = hdr.bitstream_mode;
260 s->channel_mode = hdr.channel_mode;
261 s->channel_layout = hdr.channel_layout;
262 s->lfe_on = hdr.lfe_on;
263 s->bit_alloc_params.sr_shift = hdr.sr_shift;
264 s->sample_rate = hdr.sample_rate;
265 s->bit_rate = hdr.bit_rate;
266 s->channels = hdr.channels;
267 s->fbw_channels = s->channels - s->lfe_on;
268 s->lfe_ch = s->fbw_channels + 1;
269 s->frame_size = hdr.frame_size;
270 s->center_mix_level = hdr.center_mix_level;
271 s->surround_mix_level = hdr.surround_mix_level;
272 s->num_blocks = hdr.num_blocks;
273 s->frame_type = hdr.frame_type;
274 s->substreamid = hdr.substreamid;
277 s->start_freq[s->lfe_ch] = 0;
278 s->end_freq[s->lfe_ch] = 7;
279 s->num_exp_groups[s->lfe_ch] = 2;
280 s->channel_in_cpl[s->lfe_ch] = 0;
283 if (hdr.bitstream_id <= 10) {
285 s->snr_offset_strategy = 2;
286 s->block_switch_syntax = 1;
287 s->dither_flag_syntax = 1;
288 s->bit_allocation_syntax = 1;
289 s->fast_gain_syntax = 0;
290 s->first_cpl_leak = 0;
293 memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
294 return ac3_parse_header(s);
295 } else if (CONFIG_EAC3_DECODER) {
297 return ff_eac3_parse_header(s);
299 av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n");
305 * Set stereo downmixing coefficients based on frame header info.
306 * reference: Section 7.8.2 Downmixing Into Two Channels
308 static void set_downmix_coeffs(AC3DecodeContext *s)
311 float cmix = gain_levels[s-> center_mix_level];
312 float smix = gain_levels[s->surround_mix_level];
315 for (i = 0; i < s->fbw_channels; i++) {
316 s->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
317 s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
319 if (s->channel_mode > 1 && s->channel_mode & 1) {
320 s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix;
322 if (s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
323 int nf = s->channel_mode - 2;
324 s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
326 if (s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
327 int nf = s->channel_mode - 4;
328 s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix;
333 for (i = 0; i < s->fbw_channels; i++) {
334 norm0 += s->downmix_coeffs[i][0];
335 norm1 += s->downmix_coeffs[i][1];
337 norm0 = 1.0f / norm0;
338 norm1 = 1.0f / norm1;
339 for (i = 0; i < s->fbw_channels; i++) {
340 s->downmix_coeffs[i][0] *= norm0;
341 s->downmix_coeffs[i][1] *= norm1;
344 if (s->output_mode == AC3_CHMODE_MONO) {
345 for (i = 0; i < s->fbw_channels; i++)
346 s->downmix_coeffs[i][0] = (s->downmix_coeffs[i][0] +
347 s->downmix_coeffs[i][1]) * LEVEL_MINUS_3DB;
352 * Decode the grouped exponents according to exponent strategy.
353 * reference: Section 7.1.3 Exponent Decoding
355 static int decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
356 uint8_t absexp, int8_t *dexps)
358 int i, j, grp, group_size;
363 group_size = exp_strategy + (exp_strategy == EXP_D45);
364 for (grp = 0, i = 0; grp < ngrps; grp++) {
365 expacc = get_bits(gbc, 7);
366 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
367 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
368 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
371 /* convert to absolute exps and expand groups */
373 for (i = 0, j = 0; i < ngrps * 3; i++) {
374 prevexp += dexp[i] - 2;
377 switch (group_size) {
378 case 4: dexps[j++] = prevexp;
379 dexps[j++] = prevexp;
380 case 2: dexps[j++] = prevexp;
381 case 1: dexps[j++] = prevexp;
388 * Generate transform coefficients for each coupled channel in the coupling
389 * range using the coupling coefficients and coupling coordinates.
390 * reference: Section 7.4.3 Coupling Coordinate Format
392 static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
396 bin = s->start_freq[CPL_CH];
397 for (band = 0; band < s->num_cpl_bands; band++) {
398 int band_start = bin;
399 int band_end = bin + s->cpl_band_sizes[band];
400 for (ch = 1; ch <= s->fbw_channels; ch++) {
401 if (s->channel_in_cpl[ch]) {
402 int cpl_coord = s->cpl_coords[ch][band] << 5;
403 for (bin = band_start; bin < band_end; bin++) {
404 s->fixed_coeffs[ch][bin] =
405 MULH(s->fixed_coeffs[CPL_CH][bin] << 4, cpl_coord);
407 if (ch == 2 && s->phase_flags[band]) {
408 for (bin = band_start; bin < band_end; bin++)
409 s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin];
418 * Grouped mantissas for 3-level 5-level and 11-level quantization
430 * Decode the transform coefficients for a particular channel
431 * reference: Section 7.3 Quantization and Decoding of Mantissas
433 static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
435 int start_freq = s->start_freq[ch_index];
436 int end_freq = s->end_freq[ch_index];
437 uint8_t *baps = s->bap[ch_index];
438 int8_t *exps = s->dexps[ch_index];
439 int *coeffs = s->fixed_coeffs[ch_index];
440 int dither = (ch_index == CPL_CH) || s->dither_flag[ch_index];
441 GetBitContext *gbc = &s->gbc;
444 for (freq = start_freq; freq < end_freq; freq++) {
445 int bap = baps[freq];
450 mantissa = (av_lfg_get(&s->dith_state) & 0x7FFFFF) - 0x400000;
457 mantissa = m->b1_mant[m->b1];
459 int bits = get_bits(gbc, 5);
460 mantissa = b1_mantissas[bits][0];
461 m->b1_mant[1] = b1_mantissas[bits][1];
462 m->b1_mant[0] = b1_mantissas[bits][2];
469 mantissa = m->b2_mant[m->b2];
471 int bits = get_bits(gbc, 7);
472 mantissa = b2_mantissas[bits][0];
473 m->b2_mant[1] = b2_mantissas[bits][1];
474 m->b2_mant[0] = b2_mantissas[bits][2];
479 mantissa = b3_mantissas[get_bits(gbc, 3)];
484 mantissa = m->b4_mant;
486 int bits = get_bits(gbc, 7);
487 mantissa = b4_mantissas[bits][0];
488 m->b4_mant = b4_mantissas[bits][1];
493 mantissa = b5_mantissas[get_bits(gbc, 4)];
495 default: /* 6 to 15 */
496 /* Shift mantissa and sign-extend it. */
497 mantissa = get_sbits(gbc, quantization_tab[bap]);
498 mantissa <<= 24 - quantization_tab[bap];
501 coeffs[freq] = mantissa >> exps[freq];
506 * Remove random dithering from coupling range coefficients with zero-bit
507 * mantissas for coupled channels which do not use dithering.
508 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
510 static void remove_dithering(AC3DecodeContext *s) {
513 for (ch = 1; ch <= s->fbw_channels; ch++) {
514 if (!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
515 for (i = s->start_freq[CPL_CH]; i < s->end_freq[CPL_CH]; i++) {
516 if (!s->bap[CPL_CH][i])
517 s->fixed_coeffs[ch][i] = 0;
523 static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,
526 if (!s->channel_uses_aht[ch]) {
527 ac3_decode_transform_coeffs_ch(s, ch, m);
529 /* if AHT is used, mantissas for all blocks are encoded in the first
530 block of the frame. */
532 if (!blk && CONFIG_EAC3_DECODER)
533 ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
534 for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
535 s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
541 * Decode the transform coefficients.
543 static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
549 m.b1 = m.b2 = m.b4 = 0;
551 for (ch = 1; ch <= s->channels; ch++) {
552 /* transform coefficients for full-bandwidth channel */
553 decode_transform_coeffs_ch(s, blk, ch, &m);
554 /* tranform coefficients for coupling channel come right after the
555 coefficients for the first coupled channel*/
556 if (s->channel_in_cpl[ch]) {
558 decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
559 calc_transform_coeffs_cpl(s);
562 end = s->end_freq[CPL_CH];
564 end = s->end_freq[ch];
567 s->fixed_coeffs[ch][end] = 0;
571 /* zero the dithered coefficients for appropriate channels */
576 * Stereo rematrixing.
577 * reference: Section 7.5.4 Rematrixing : Decoding Technique
579 static void do_rematrixing(AC3DecodeContext *s)
584 end = FFMIN(s->end_freq[1], s->end_freq[2]);
586 for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) {
587 if (s->rematrixing_flags[bnd]) {
588 bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd + 1]);
589 for (i = ff_ac3_rematrix_band_tab[bnd]; i < bndend; i++) {
590 int tmp0 = s->fixed_coeffs[1][i];
591 s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
592 s->fixed_coeffs[2][i] = tmp0 - s->fixed_coeffs[2][i];
599 * Inverse MDCT Transform.
600 * Convert frequency domain coefficients to time-domain audio samples.
601 * reference: Section 7.9.4 Transformation Equations
603 static inline void do_imdct(AC3DecodeContext *s, int channels)
607 for (ch = 1; ch <= channels; ch++) {
608 if (s->block_switch[ch]) {
610 float *x = s->tmp_output + 128;
611 for (i = 0; i < 128; i++)
612 x[i] = s->transform_coeffs[ch][2 * i];
613 s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
614 s->dsp.vector_fmul_window(s->output[ch - 1], s->delay[ch - 1],
615 s->tmp_output, s->window, 128);
616 for (i = 0; i < 128; i++)
617 x[i] = s->transform_coeffs[ch][2 * i + 1];
618 s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch - 1], x);
620 s->imdct_512.imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
621 s->dsp.vector_fmul_window(s->output[ch - 1], s->delay[ch - 1],
622 s->tmp_output, s->window, 128);
623 memcpy(s->delay[ch - 1], s->tmp_output + 128, 128 * sizeof(float));
629 * Downmix the output to mono or stereo.
631 void ff_ac3_downmix_c(float (*samples)[256], float (*matrix)[2],
632 int out_ch, int in_ch, int len)
637 for (i = 0; i < len; i++) {
639 for (j = 0; j < in_ch; j++) {
640 v0 += samples[j][i] * matrix[j][0];
641 v1 += samples[j][i] * matrix[j][1];
646 } else if (out_ch == 1) {
647 for (i = 0; i < len; i++) {
649 for (j = 0; j < in_ch; j++)
650 v0 += samples[j][i] * matrix[j][0];
657 * Upmix delay samples from stereo to original channel layout.
659 static void ac3_upmix_delay(AC3DecodeContext *s)
661 int channel_data_size = sizeof(s->delay[0]);
662 switch (s->channel_mode) {
663 case AC3_CHMODE_DUALMONO:
664 case AC3_CHMODE_STEREO:
665 /* upmix mono to stereo */
666 memcpy(s->delay[1], s->delay[0], channel_data_size);
668 case AC3_CHMODE_2F2R:
669 memset(s->delay[3], 0, channel_data_size);
670 case AC3_CHMODE_2F1R:
671 memset(s->delay[2], 0, channel_data_size);
673 case AC3_CHMODE_3F2R:
674 memset(s->delay[4], 0, channel_data_size);
675 case AC3_CHMODE_3F1R:
676 memset(s->delay[3], 0, channel_data_size);
678 memcpy(s->delay[2], s->delay[1], channel_data_size);
679 memset(s->delay[1], 0, channel_data_size);
685 * Decode band structure for coupling, spectral extension, or enhanced coupling.
686 * The band structure defines how many subbands are in each band. For each
687 * subband in the range, 1 means it is combined with the previous band, and 0
688 * means that it starts a new band.
690 * @param[in] gbc bit reader context
691 * @param[in] blk block number
692 * @param[in] eac3 flag to indicate E-AC-3
693 * @param[in] ecpl flag to indicate enhanced coupling
694 * @param[in] start_subband subband number for start of range
695 * @param[in] end_subband subband number for end of range
696 * @param[in] default_band_struct default band structure table
697 * @param[out] num_bands number of bands (optionally NULL)
698 * @param[out] band_sizes array containing the number of bins in each band (optionally NULL)
700 static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
701 int ecpl, int start_subband, int end_subband,
702 const uint8_t *default_band_struct,
703 int *num_bands, uint8_t *band_sizes)
705 int subbnd, bnd, n_subbands, n_bands=0;
707 uint8_t coded_band_struct[22];
708 const uint8_t *band_struct;
710 n_subbands = end_subband - start_subband;
712 /* decode band structure from bitstream or use default */
713 if (!eac3 || get_bits1(gbc)) {
714 for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
715 coded_band_struct[subbnd] = get_bits1(gbc);
717 band_struct = coded_band_struct;
719 band_struct = &default_band_struct[start_subband+1];
721 /* no change in band structure */
725 /* calculate number of bands and band sizes based on band structure.
726 note that the first 4 subbands in enhanced coupling span only 6 bins
728 if (num_bands || band_sizes ) {
729 n_bands = n_subbands;
730 bnd_sz[0] = ecpl ? 6 : 12;
731 for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
732 int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
733 if (band_struct[subbnd - 1]) {
735 bnd_sz[bnd] += subbnd_size;
737 bnd_sz[++bnd] = subbnd_size;
742 /* set optional output params */
744 *num_bands = n_bands;
746 memcpy(band_sizes, bnd_sz, n_bands);
750 * Decode a single audio block from the AC-3 bitstream.
752 static int decode_audio_block(AC3DecodeContext *s, int blk)
754 int fbw_channels = s->fbw_channels;
755 int channel_mode = s->channel_mode;
757 int different_transforms;
760 GetBitContext *gbc = &s->gbc;
761 uint8_t bit_alloc_stages[AC3_MAX_CHANNELS];
763 memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);
765 /* block switch flags */
766 different_transforms = 0;
767 if (s->block_switch_syntax) {
768 for (ch = 1; ch <= fbw_channels; ch++) {
769 s->block_switch[ch] = get_bits1(gbc);
770 if (ch > 1 && s->block_switch[ch] != s->block_switch[1])
771 different_transforms = 1;
775 /* dithering flags */
776 if (s->dither_flag_syntax) {
777 for (ch = 1; ch <= fbw_channels; ch++) {
778 s->dither_flag[ch] = get_bits1(gbc);
783 i = !s->channel_mode;
785 if (get_bits1(gbc)) {
786 s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)] - 1.0) *
788 } else if (blk == 0) {
789 s->dynamic_range[i] = 1.0f;
793 /* spectral extension strategy */
794 if (s->eac3 && (!blk || get_bits1(gbc))) {
795 s->spx_in_use = get_bits1(gbc);
797 int dst_start_freq, dst_end_freq, src_start_freq,
798 start_subband, end_subband;
800 /* determine which channels use spx */
801 if (s->channel_mode == AC3_CHMODE_MONO) {
802 s->channel_uses_spx[1] = 1;
804 for (ch = 1; ch <= fbw_channels; ch++)
805 s->channel_uses_spx[ch] = get_bits1(gbc);
808 /* get the frequency bins of the spx copy region and the spx start
810 dst_start_freq = get_bits(gbc, 2);
811 start_subband = get_bits(gbc, 3) + 2;
812 if (start_subband > 7)
813 start_subband += start_subband - 7;
814 end_subband = get_bits(gbc, 3) + 5;
816 end_subband += end_subband - 7;
817 dst_start_freq = dst_start_freq * 12 + 25;
818 src_start_freq = start_subband * 12 + 25;
819 dst_end_freq = end_subband * 12 + 25;
821 /* check validity of spx ranges */
822 if (start_subband >= end_subband) {
823 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
824 "range (%d >= %d)\n", start_subband, end_subband);
827 if (dst_start_freq >= src_start_freq) {
828 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
829 "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
833 s->spx_dst_start_freq = dst_start_freq;
834 s->spx_src_start_freq = src_start_freq;
835 s->spx_dst_end_freq = dst_end_freq;
837 decode_band_structure(gbc, blk, s->eac3, 0,
838 start_subband, end_subband,
839 ff_eac3_default_spx_band_struct,
843 for (ch = 1; ch <= fbw_channels; ch++) {
844 s->channel_uses_spx[ch] = 0;
845 s->first_spx_coords[ch] = 1;
850 /* spectral extension coordinates */
852 for (ch = 1; ch <= fbw_channels; ch++) {
853 if (s->channel_uses_spx[ch]) {
854 if (s->first_spx_coords[ch] || get_bits1(gbc)) {
856 int bin, master_spx_coord;
858 s->first_spx_coords[ch] = 0;
859 spx_blend = get_bits(gbc, 5) * (1.0f/32);
860 master_spx_coord = get_bits(gbc, 2) * 3;
862 bin = s->spx_src_start_freq;
863 for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
865 int spx_coord_exp, spx_coord_mant;
866 float nratio, sblend, nblend, spx_coord;
868 /* calculate blending factors */
869 bandsize = s->spx_band_sizes[bnd];
870 nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
871 nratio = av_clipf(nratio, 0.0f, 1.0f);
872 nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
873 // to give unity variance
874 sblend = sqrtf(1.0f - nratio);
877 /* decode spx coordinates */
878 spx_coord_exp = get_bits(gbc, 4);
879 spx_coord_mant = get_bits(gbc, 2);
880 if (spx_coord_exp == 15) spx_coord_mant <<= 1;
881 else spx_coord_mant += 4;
882 spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
883 spx_coord = spx_coord_mant * (1.0f / (1 << 23));
885 /* multiply noise and signal blending factors by spx coordinate */
886 s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
887 s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
891 s->first_spx_coords[ch] = 1;
896 /* coupling strategy */
897 if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
898 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
900 s->cpl_in_use[blk] = get_bits1(gbc);
901 if (s->cpl_in_use[blk]) {
902 /* coupling in use */
903 int cpl_start_subband, cpl_end_subband;
905 if (channel_mode < AC3_CHMODE_STEREO) {
906 av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
910 /* check for enhanced coupling */
911 if (s->eac3 && get_bits1(gbc)) {
912 /* TODO: parse enhanced coupling strategy info */
913 av_log_missing_feature(s->avctx, "Enhanced coupling", 1);
917 /* determine which channels are coupled */
918 if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
919 s->channel_in_cpl[1] = 1;
920 s->channel_in_cpl[2] = 1;
922 for (ch = 1; ch <= fbw_channels; ch++)
923 s->channel_in_cpl[ch] = get_bits1(gbc);
926 /* phase flags in use */
927 if (channel_mode == AC3_CHMODE_STEREO)
928 s->phase_flags_in_use = get_bits1(gbc);
930 /* coupling frequency range */
931 cpl_start_subband = get_bits(gbc, 4);
932 cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
933 get_bits(gbc, 4) + 3;
934 if (cpl_start_subband >= cpl_end_subband) {
935 av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
936 cpl_start_subband, cpl_end_subband);
939 s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
940 s->end_freq[CPL_CH] = cpl_end_subband * 12 + 37;
942 decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
944 ff_eac3_default_cpl_band_struct,
945 &s->num_cpl_bands, s->cpl_band_sizes);
947 /* coupling not in use */
948 for (ch = 1; ch <= fbw_channels; ch++) {
949 s->channel_in_cpl[ch] = 0;
950 s->first_cpl_coords[ch] = 1;
952 s->first_cpl_leak = s->eac3;
953 s->phase_flags_in_use = 0;
955 } else if (!s->eac3) {
957 av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "
958 "be present in block 0\n");
961 s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
964 cpl_in_use = s->cpl_in_use[blk];
966 /* coupling coordinates */
968 int cpl_coords_exist = 0;
970 for (ch = 1; ch <= fbw_channels; ch++) {
971 if (s->channel_in_cpl[ch]) {
972 if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
973 int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
974 s->first_cpl_coords[ch] = 0;
975 cpl_coords_exist = 1;
976 master_cpl_coord = 3 * get_bits(gbc, 2);
977 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
978 cpl_coord_exp = get_bits(gbc, 4);
979 cpl_coord_mant = get_bits(gbc, 4);
980 if (cpl_coord_exp == 15)
981 s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
983 s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
984 s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
987 av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
988 "be present in block 0\n");
992 /* channel not in coupling */
993 s->first_cpl_coords[ch] = 1;
997 if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
998 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
999 s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
1004 /* stereo rematrixing strategy and band structure */
1005 if (channel_mode == AC3_CHMODE_STEREO) {
1006 if ((s->eac3 && !blk) || get_bits1(gbc)) {
1007 s->num_rematrixing_bands = 4;
1008 if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
1009 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
1010 } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
1011 s->num_rematrixing_bands--;
1013 for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
1014 s->rematrixing_flags[bnd] = get_bits1(gbc);
1016 av_log(s->avctx, AV_LOG_WARNING, "Warning: "
1017 "new rematrixing strategy not present in block 0\n");
1018 s->num_rematrixing_bands = 0;
1022 /* exponent strategies for each channel */
1023 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1025 s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
1026 if (s->exp_strategy[blk][ch] != EXP_REUSE)
1027 bit_alloc_stages[ch] = 3;
1030 /* channel bandwidth */
1031 for (ch = 1; ch <= fbw_channels; ch++) {
1032 s->start_freq[ch] = 0;
1033 if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1035 int prev = s->end_freq[ch];
1036 if (s->channel_in_cpl[ch])
1037 s->end_freq[ch] = s->start_freq[CPL_CH];
1038 else if (s->channel_uses_spx[ch])
1039 s->end_freq[ch] = s->spx_src_start_freq;
1041 int bandwidth_code = get_bits(gbc, 6);
1042 if (bandwidth_code > 60) {
1043 av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1046 s->end_freq[ch] = bandwidth_code * 3 + 73;
1048 group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1049 s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
1050 if (blk > 0 && s->end_freq[ch] != prev)
1051 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1054 if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1055 s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
1056 (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1059 /* decode exponents for each channel */
1060 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1061 if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1062 s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1063 if (decode_exponents(gbc, s->exp_strategy[blk][ch],
1064 s->num_exp_groups[ch], s->dexps[ch][0],
1065 &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1066 av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
1069 if (ch != CPL_CH && ch != s->lfe_ch)
1070 skip_bits(gbc, 2); /* skip gainrng */
1074 /* bit allocation information */
1075 if (s->bit_allocation_syntax) {
1076 if (get_bits1(gbc)) {
1077 s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1078 s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1079 s->bit_alloc_params.slow_gain = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
1080 s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
1081 s->bit_alloc_params.floor = ff_ac3_floor_tab[get_bits(gbc, 3)];
1082 for (ch = !cpl_in_use; ch <= s->channels; ch++)
1083 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1085 av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must "
1086 "be present in block 0\n");
1091 /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1092 if (!s->eac3 || !blk) {
1093 if (s->snr_offset_strategy && get_bits1(gbc)) {
1096 csnr = (get_bits(gbc, 6) - 15) << 4;
1097 for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1099 if (ch == i || s->snr_offset_strategy == 2)
1100 snr = (csnr + get_bits(gbc, 4)) << 2;
1101 /* run at least last bit allocation stage if snr offset changes */
1102 if (blk && s->snr_offset[ch] != snr) {
1103 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1105 s->snr_offset[ch] = snr;
1107 /* fast gain (normal AC-3 only) */
1109 int prev = s->fast_gain[ch];
1110 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1111 /* run last 2 bit allocation stages if fast gain changes */
1112 if (blk && prev != s->fast_gain[ch])
1113 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1116 } else if (!s->eac3 && !blk) {
1117 av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1122 /* fast gain (E-AC-3 only) */
1123 if (s->fast_gain_syntax && get_bits1(gbc)) {
1124 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1125 int prev = s->fast_gain[ch];
1126 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1127 /* run last 2 bit allocation stages if fast gain changes */
1128 if (blk && prev != s->fast_gain[ch])
1129 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1131 } else if (s->eac3 && !blk) {
1132 for (ch = !cpl_in_use; ch <= s->channels; ch++)
1133 s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1136 /* E-AC-3 to AC-3 converter SNR offset */
1137 if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1138 skip_bits(gbc, 10); // skip converter snr offset
1141 /* coupling leak information */
1143 if (s->first_cpl_leak || get_bits1(gbc)) {
1144 int fl = get_bits(gbc, 3);
1145 int sl = get_bits(gbc, 3);
1146 /* run last 2 bit allocation stages for coupling channel if
1147 coupling leak changes */
1148 if (blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1149 sl != s->bit_alloc_params.cpl_slow_leak)) {
1150 bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1152 s->bit_alloc_params.cpl_fast_leak = fl;
1153 s->bit_alloc_params.cpl_slow_leak = sl;
1154 } else if (!s->eac3 && !blk) {
1155 av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must "
1156 "be present in block 0\n");
1159 s->first_cpl_leak = 0;
1162 /* delta bit allocation information */
1163 if (s->dba_syntax && get_bits1(gbc)) {
1164 /* delta bit allocation exists (strategy) */
1165 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1166 s->dba_mode[ch] = get_bits(gbc, 2);
1167 if (s->dba_mode[ch] == DBA_RESERVED) {
1168 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1171 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1173 /* channel delta offset, len and bit allocation */
1174 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1175 if (s->dba_mode[ch] == DBA_NEW) {
1176 s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;
1177 for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
1178 s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1179 s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1180 s->dba_values[ch][seg] = get_bits(gbc, 3);
1182 /* run last 2 bit allocation stages if new dba values */
1183 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1186 } else if (blk == 0) {
1187 for (ch = 0; ch <= s->channels; ch++) {
1188 s->dba_mode[ch] = DBA_NONE;
1192 /* Bit allocation */
1193 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1194 if (bit_alloc_stages[ch] > 2) {
1195 /* Exponent mapping into PSD and PSD integration */
1196 ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
1197 s->start_freq[ch], s->end_freq[ch],
1198 s->psd[ch], s->band_psd[ch]);
1200 if (bit_alloc_stages[ch] > 1) {
1201 /* Compute excitation function, Compute masking curve, and
1202 Apply delta bit allocation */
1203 if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1204 s->start_freq[ch], s->end_freq[ch],
1205 s->fast_gain[ch], (ch == s->lfe_ch),
1206 s->dba_mode[ch], s->dba_nsegs[ch],
1207 s->dba_offsets[ch], s->dba_lengths[ch],
1208 s->dba_values[ch], s->mask[ch])) {
1209 av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1213 if (bit_alloc_stages[ch] > 0) {
1214 /* Compute bit allocation */
1215 const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1216 ff_eac3_hebap_tab : ff_ac3_bap_tab;
1217 s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1218 s->start_freq[ch], s->end_freq[ch],
1220 s->bit_alloc_params.floor,
1221 bap_tab, s->bap[ch]);
1225 /* unused dummy data */
1226 if (s->skip_syntax && get_bits1(gbc)) {
1227 int skipl = get_bits(gbc, 9);
1232 /* unpack the transform coefficients
1233 this also uncouples channels if coupling is in use. */
1234 decode_transform_coeffs(s, blk);
1236 /* TODO: generate enhanced coupling coordinates and uncouple */
1238 /* recover coefficients if rematrixing is in use */
1239 if (s->channel_mode == AC3_CHMODE_STEREO)
1242 /* apply scaling to coefficients (headroom, dynrng) */
1243 for (ch = 1; ch <= s->channels; ch++) {
1244 float gain = s->mul_bias / 4194304.0f;
1245 if (s->channel_mode == AC3_CHMODE_DUALMONO) {
1246 gain *= s->dynamic_range[2 - ch];
1248 gain *= s->dynamic_range[0];
1250 s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch],
1251 s->fixed_coeffs[ch], gain, 256);
1254 /* apply spectral extension to high frequency bins */
1255 if (s->spx_in_use && CONFIG_EAC3_DECODER) {
1256 ff_eac3_apply_spectral_extension(s);
1259 /* downmix and MDCT. order depends on whether block switching is used for
1260 any channel in this block. this is because coefficients for the long
1261 and short transforms cannot be mixed. */
1262 downmix_output = s->channels != s->out_channels &&
1263 !((s->output_mode & AC3_OUTPUT_LFEON) &&
1264 s->fbw_channels == s->out_channels);
1265 if (different_transforms) {
1266 /* the delay samples have already been downmixed, so we upmix the delay
1267 samples in order to reconstruct all channels before downmixing. */
1273 do_imdct(s, s->channels);
1275 if (downmix_output) {
1276 s->dsp.ac3_downmix(s->output, s->downmix_coeffs,
1277 s->out_channels, s->fbw_channels, 256);
1280 if (downmix_output) {
1281 s->dsp.ac3_downmix(s->transform_coeffs + 1, s->downmix_coeffs,
1282 s->out_channels, s->fbw_channels, 256);
1285 if (downmix_output && !s->downmixed) {
1287 s->dsp.ac3_downmix(s->delay, s->downmix_coeffs, s->out_channels,
1288 s->fbw_channels, 128);
1291 do_imdct(s, s->out_channels);
1298 * Decode a single AC-3 frame.
1300 static int ac3_decode_frame(AVCodecContext * avctx, void *data,
1301 int *got_frame_ptr, AVPacket *avpkt)
1303 const uint8_t *buf = avpkt->data;
1304 int buf_size = avpkt->size;
1305 AC3DecodeContext *s = avctx->priv_data;
1306 float *out_samples_flt;
1307 int16_t *out_samples_s16;
1308 int blk, ch, err, ret;
1309 const uint8_t *channel_map;
1310 const float *output[AC3_MAX_CHANNELS];
1312 /* copy input buffer to decoder context to avoid reading past the end
1313 of the buffer, which can be caused by a damaged input stream. */
1314 if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
1315 // seems to be byte-swapped AC-3
1316 int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1317 s->dsp.bswap16_buf((uint16_t *)s->input_buffer, (const uint16_t *)buf, cnt);
1319 memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1320 buf = s->input_buffer;
1321 /* initialize the GetBitContext with the start of valid AC-3 Frame */
1322 init_get_bits(&s->gbc, buf, buf_size * 8);
1324 /* parse the syncinfo */
1325 err = parse_frame_header(s);
1329 case AAC_AC3_PARSE_ERROR_SYNC:
1330 av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1332 case AAC_AC3_PARSE_ERROR_BSID:
1333 av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1335 case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
1336 av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1338 case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
1339 av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1341 case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
1342 /* skip frame if CRC is ok. otherwise use error concealment. */
1343 /* TODO: add support for substreams and dependent frames */
1344 if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
1345 av_log(avctx, AV_LOG_ERROR, "unsupported frame type : "
1346 "skipping frame\n");
1348 return s->frame_size;
1350 av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1354 av_log(avctx, AV_LOG_ERROR, "invalid header\n");
1358 /* check that reported frame size fits in input buffer */
1359 if (s->frame_size > buf_size) {
1360 av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1361 err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
1362 } else if (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL)) {
1363 /* check for crc mismatch */
1364 if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
1365 s->frame_size - 2)) {
1366 av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1367 err = AAC_AC3_PARSE_ERROR_CRC;
1372 /* if frame is ok, set audio parameters */
1374 avctx->sample_rate = s->sample_rate;
1375 avctx->bit_rate = s->bit_rate;
1377 /* channel config */
1378 s->out_channels = s->channels;
1379 s->output_mode = s->channel_mode;
1381 s->output_mode |= AC3_OUTPUT_LFEON;
1382 if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&
1383 avctx->request_channels < s->channels) {
1384 s->out_channels = avctx->request_channels;
1385 s->output_mode = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1386 s->channel_layout = ff_ac3_channel_layout_tab[s->output_mode];
1388 avctx->channels = s->out_channels;
1389 avctx->channel_layout = s->channel_layout;
1391 s->loro_center_mix_level = gain_levels[s-> center_mix_level];
1392 s->loro_surround_mix_level = gain_levels[s->surround_mix_level];
1393 s->ltrt_center_mix_level = LEVEL_MINUS_3DB;
1394 s->ltrt_surround_mix_level = LEVEL_MINUS_3DB;
1395 /* set downmixing coefficients if needed */
1396 if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1397 s->fbw_channels == s->out_channels)) {
1398 set_downmix_coeffs(s);
1400 } else if (!s->out_channels) {
1401 s->out_channels = avctx->channels;
1402 if (s->out_channels < s->channels)
1403 s->output_mode = s->out_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1405 /* set audio service type based on bitstream mode for AC-3 */
1406 avctx->audio_service_type = s->bitstream_mode;
1407 if (s->bitstream_mode == 0x7 && s->channels > 1)
1408 avctx->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
1410 /* get output buffer */
1411 s->frame.nb_samples = s->num_blocks * 256;
1412 if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
1413 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1416 out_samples_flt = (float *)s->frame.data[0];
1417 out_samples_s16 = (int16_t *)s->frame.data[0];
1419 /* decode the audio blocks */
1420 channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1421 for (ch = 0; ch < s->out_channels; ch++)
1422 output[ch] = s->output[channel_map[ch]];
1423 for (blk = 0; blk < s->num_blocks; blk++) {
1424 if (!err && decode_audio_block(s, blk)) {
1425 av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1428 if (avctx->sample_fmt == AV_SAMPLE_FMT_FLT) {
1429 s->fmt_conv.float_interleave(out_samples_flt, output, 256,
1431 out_samples_flt += 256 * s->out_channels;
1433 s->fmt_conv.float_to_int16_interleave(out_samples_s16, output, 256,
1435 out_samples_s16 += 256 * s->out_channels;
1440 *(AVFrame *)data = s->frame;
1442 return FFMIN(buf_size, s->frame_size);
1446 * Uninitialize the AC-3 decoder.
1448 static av_cold int ac3_decode_end(AVCodecContext *avctx)
1450 AC3DecodeContext *s = avctx->priv_data;
1451 ff_mdct_end(&s->imdct_512);
1452 ff_mdct_end(&s->imdct_256);
1457 #define OFFSET(x) offsetof(AC3DecodeContext, x)
1458 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)
1459 static const AVOption options[] = {
1460 { "drc_scale", "percentage of dynamic range compression to apply", OFFSET(drc_scale), AV_OPT_TYPE_FLOAT, {1.0}, 0.0, 1.0, PAR },
1462 {"dmix_mode", "Preferred Stereo Downmix Mode", OFFSET(preferred_stereo_downmix), AV_OPT_TYPE_INT, {.dbl = -1 }, -1, 2, 0, "dmix_mode"},
1463 {"ltrt_cmixlev", "Lt/Rt Center Mix Level", OFFSET(ltrt_center_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
1464 {"ltrt_surmixlev", "Lt/Rt Surround Mix Level", OFFSET(ltrt_surround_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
1465 {"loro_cmixlev", "Lo/Ro Center Mix Level", OFFSET(loro_center_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
1466 {"loro_surmixlev", "Lo/Ro Surround Mix Level", OFFSET(loro_surround_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
1471 static const AVClass ac3_decoder_class = {
1472 .class_name = "AC3 decoder",
1473 .item_name = av_default_item_name,
1475 .version = LIBAVUTIL_VERSION_INT,
1478 AVCodec ff_ac3_decoder = {
1480 .type = AVMEDIA_TYPE_AUDIO,
1482 .priv_data_size = sizeof (AC3DecodeContext),
1483 .init = ac3_decode_init,
1484 .close = ac3_decode_end,
1485 .decode = ac3_decode_frame,
1486 .capabilities = CODEC_CAP_DR1,
1487 .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
1488 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLT,
1490 AV_SAMPLE_FMT_NONE },
1491 .priv_class = &ac3_decoder_class,
1494 #if CONFIG_EAC3_DECODER
1495 static const AVClass eac3_decoder_class = {
1496 .class_name = "E-AC3 decoder",
1497 .item_name = av_default_item_name,
1499 .version = LIBAVUTIL_VERSION_INT,
1502 AVCodec ff_eac3_decoder = {
1504 .type = AVMEDIA_TYPE_AUDIO,
1505 .id = CODEC_ID_EAC3,
1506 .priv_data_size = sizeof (AC3DecodeContext),
1507 .init = ac3_decode_init,
1508 .close = ac3_decode_end,
1509 .decode = ac3_decode_frame,
1510 .capabilities = CODEC_CAP_DR1,
1511 .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
1512 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLT,
1514 AV_SAMPLE_FMT_NONE },
1515 .priv_class = &eac3_decoder_class,