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;
167 ff_ac3_common_init();
169 ff_mdct_init(&s->imdct_256, 8, 1, 1.0);
170 ff_mdct_init(&s->imdct_512, 9, 1, 1.0);
171 ff_kbd_window_init(s->window, 5.0, 256);
172 ff_dsputil_init(&s->dsp, avctx);
173 avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
174 ff_ac3dsp_init(&s->ac3dsp, avctx->flags & CODEC_FLAG_BITEXACT);
175 ff_fmt_convert_init(&s->fmt_conv, avctx);
176 av_lfg_init(&s->dith_state, 0);
178 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
180 /* allow downmixing to stereo or mono */
181 if (avctx->channels > 0 && avctx->request_channels > 0 &&
182 avctx->request_channels < avctx->channels &&
183 avctx->request_channels <= 2) {
184 avctx->channels = avctx->request_channels;
188 for (i = 0; i < AC3_MAX_CHANNELS; i++) {
189 s->xcfptr[i] = s->transform_coeffs[i];
190 s->dlyptr[i] = s->delay[i];
197 * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
198 * GetBitContext within AC3DecodeContext must point to
199 * the start of the synchronized AC-3 bitstream.
201 static int ac3_parse_header(AC3DecodeContext *s)
203 GetBitContext *gbc = &s->gbc;
206 /* read the rest of the bsi. read twice for dual mono mode. */
207 i = !s->channel_mode;
209 skip_bits(gbc, 5); // skip dialog normalization
211 skip_bits(gbc, 8); //skip compression
213 skip_bits(gbc, 8); //skip language code
215 skip_bits(gbc, 7); //skip audio production information
218 skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
220 /* skip the timecodes (or extra bitstream information for Alternate Syntax)
221 TODO: read & use the xbsi1 downmix levels */
223 skip_bits(gbc, 14); //skip timecode1 / xbsi1
225 skip_bits(gbc, 14); //skip timecode2 / xbsi2
227 /* skip additional bitstream info */
228 if (get_bits1(gbc)) {
229 i = get_bits(gbc, 6);
239 * Common function to parse AC-3 or E-AC-3 frame header
241 static int parse_frame_header(AC3DecodeContext *s)
246 err = avpriv_ac3_parse_header(&s->gbc, &hdr);
250 /* get decoding parameters from header info */
251 s->bit_alloc_params.sr_code = hdr.sr_code;
252 s->bitstream_mode = hdr.bitstream_mode;
253 s->channel_mode = hdr.channel_mode;
254 s->channel_layout = hdr.channel_layout;
255 s->lfe_on = hdr.lfe_on;
256 s->bit_alloc_params.sr_shift = hdr.sr_shift;
257 s->sample_rate = hdr.sample_rate;
258 s->bit_rate = hdr.bit_rate;
259 s->channels = hdr.channels;
260 s->fbw_channels = s->channels - s->lfe_on;
261 s->lfe_ch = s->fbw_channels + 1;
262 s->frame_size = hdr.frame_size;
263 s->center_mix_level = hdr.center_mix_level;
264 s->surround_mix_level = hdr.surround_mix_level;
265 s->num_blocks = hdr.num_blocks;
266 s->frame_type = hdr.frame_type;
267 s->substreamid = hdr.substreamid;
270 s->start_freq[s->lfe_ch] = 0;
271 s->end_freq[s->lfe_ch] = 7;
272 s->num_exp_groups[s->lfe_ch] = 2;
273 s->channel_in_cpl[s->lfe_ch] = 0;
276 if (hdr.bitstream_id <= 10) {
278 s->snr_offset_strategy = 2;
279 s->block_switch_syntax = 1;
280 s->dither_flag_syntax = 1;
281 s->bit_allocation_syntax = 1;
282 s->fast_gain_syntax = 0;
283 s->first_cpl_leak = 0;
286 memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
287 return ac3_parse_header(s);
288 } else if (CONFIG_EAC3_DECODER) {
290 return ff_eac3_parse_header(s);
292 av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n");
298 * Set stereo downmixing coefficients based on frame header info.
299 * reference: Section 7.8.2 Downmixing Into Two Channels
301 static void set_downmix_coeffs(AC3DecodeContext *s)
304 float cmix = gain_levels[s-> center_mix_level];
305 float smix = gain_levels[s->surround_mix_level];
308 for (i = 0; i < s->fbw_channels; i++) {
309 s->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
310 s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
312 if (s->channel_mode > 1 && s->channel_mode & 1) {
313 s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix;
315 if (s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
316 int nf = s->channel_mode - 2;
317 s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
319 if (s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
320 int nf = s->channel_mode - 4;
321 s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix;
326 for (i = 0; i < s->fbw_channels; i++) {
327 norm0 += s->downmix_coeffs[i][0];
328 norm1 += s->downmix_coeffs[i][1];
330 norm0 = 1.0f / norm0;
331 norm1 = 1.0f / norm1;
332 for (i = 0; i < s->fbw_channels; i++) {
333 s->downmix_coeffs[i][0] *= norm0;
334 s->downmix_coeffs[i][1] *= norm1;
337 if (s->output_mode == AC3_CHMODE_MONO) {
338 for (i = 0; i < s->fbw_channels; i++)
339 s->downmix_coeffs[i][0] = (s->downmix_coeffs[i][0] +
340 s->downmix_coeffs[i][1]) * LEVEL_MINUS_3DB;
345 * Decode the grouped exponents according to exponent strategy.
346 * reference: Section 7.1.3 Exponent Decoding
348 static int decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
349 uint8_t absexp, int8_t *dexps)
351 int i, j, grp, group_size;
356 group_size = exp_strategy + (exp_strategy == EXP_D45);
357 for (grp = 0, i = 0; grp < ngrps; grp++) {
358 expacc = get_bits(gbc, 7);
359 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
360 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
361 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
364 /* convert to absolute exps and expand groups */
366 for (i = 0, j = 0; i < ngrps * 3; i++) {
367 prevexp += dexp[i] - 2;
370 switch (group_size) {
371 case 4: dexps[j++] = prevexp;
372 dexps[j++] = prevexp;
373 case 2: dexps[j++] = prevexp;
374 case 1: dexps[j++] = prevexp;
381 * Generate transform coefficients for each coupled channel in the coupling
382 * range using the coupling coefficients and coupling coordinates.
383 * reference: Section 7.4.3 Coupling Coordinate Format
385 static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
389 bin = s->start_freq[CPL_CH];
390 for (band = 0; band < s->num_cpl_bands; band++) {
391 int band_start = bin;
392 int band_end = bin + s->cpl_band_sizes[band];
393 for (ch = 1; ch <= s->fbw_channels; ch++) {
394 if (s->channel_in_cpl[ch]) {
395 int cpl_coord = s->cpl_coords[ch][band] << 5;
396 for (bin = band_start; bin < band_end; bin++) {
397 s->fixed_coeffs[ch][bin] =
398 MULH(s->fixed_coeffs[CPL_CH][bin] << 4, cpl_coord);
400 if (ch == 2 && s->phase_flags[band]) {
401 for (bin = band_start; bin < band_end; bin++)
402 s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin];
411 * Grouped mantissas for 3-level 5-level and 11-level quantization
423 * Decode the transform coefficients for a particular channel
424 * reference: Section 7.3 Quantization and Decoding of Mantissas
426 static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
428 int start_freq = s->start_freq[ch_index];
429 int end_freq = s->end_freq[ch_index];
430 uint8_t *baps = s->bap[ch_index];
431 int8_t *exps = s->dexps[ch_index];
432 int *coeffs = s->fixed_coeffs[ch_index];
433 int dither = (ch_index == CPL_CH) || s->dither_flag[ch_index];
434 GetBitContext *gbc = &s->gbc;
437 for (freq = start_freq; freq < end_freq; freq++) {
438 int bap = baps[freq];
442 /* random noise with approximate range of -0.707 to 0.707 */
444 mantissa = (((av_lfg_get(&s->dith_state)>>8)*181)>>8) - 5931008;
451 mantissa = m->b1_mant[m->b1];
453 int bits = get_bits(gbc, 5);
454 mantissa = b1_mantissas[bits][0];
455 m->b1_mant[1] = b1_mantissas[bits][1];
456 m->b1_mant[0] = b1_mantissas[bits][2];
463 mantissa = m->b2_mant[m->b2];
465 int bits = get_bits(gbc, 7);
466 mantissa = b2_mantissas[bits][0];
467 m->b2_mant[1] = b2_mantissas[bits][1];
468 m->b2_mant[0] = b2_mantissas[bits][2];
473 mantissa = b3_mantissas[get_bits(gbc, 3)];
478 mantissa = m->b4_mant;
480 int bits = get_bits(gbc, 7);
481 mantissa = b4_mantissas[bits][0];
482 m->b4_mant = b4_mantissas[bits][1];
487 mantissa = b5_mantissas[get_bits(gbc, 4)];
489 default: /* 6 to 15 */
490 /* Shift mantissa and sign-extend it. */
491 mantissa = get_sbits(gbc, quantization_tab[bap]);
492 mantissa <<= 24 - quantization_tab[bap];
495 coeffs[freq] = mantissa >> exps[freq];
500 * Remove random dithering from coupling range coefficients with zero-bit
501 * mantissas for coupled channels which do not use dithering.
502 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
504 static void remove_dithering(AC3DecodeContext *s) {
507 for (ch = 1; ch <= s->fbw_channels; ch++) {
508 if (!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
509 for (i = s->start_freq[CPL_CH]; i < s->end_freq[CPL_CH]; i++) {
510 if (!s->bap[CPL_CH][i])
511 s->fixed_coeffs[ch][i] = 0;
517 static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,
520 if (!s->channel_uses_aht[ch]) {
521 ac3_decode_transform_coeffs_ch(s, ch, m);
523 /* if AHT is used, mantissas for all blocks are encoded in the first
524 block of the frame. */
526 if (!blk && CONFIG_EAC3_DECODER)
527 ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
528 for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
529 s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
535 * Decode the transform coefficients.
537 static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
543 m.b1 = m.b2 = m.b4 = 0;
545 for (ch = 1; ch <= s->channels; ch++) {
546 /* transform coefficients for full-bandwidth channel */
547 decode_transform_coeffs_ch(s, blk, ch, &m);
548 /* transform coefficients for coupling channel come right after the
549 coefficients for the first coupled channel*/
550 if (s->channel_in_cpl[ch]) {
552 decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
553 calc_transform_coeffs_cpl(s);
556 end = s->end_freq[CPL_CH];
558 end = s->end_freq[ch];
561 s->fixed_coeffs[ch][end] = 0;
565 /* zero the dithered coefficients for appropriate channels */
570 * Stereo rematrixing.
571 * reference: Section 7.5.4 Rematrixing : Decoding Technique
573 static void do_rematrixing(AC3DecodeContext *s)
578 end = FFMIN(s->end_freq[1], s->end_freq[2]);
580 for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) {
581 if (s->rematrixing_flags[bnd]) {
582 bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd + 1]);
583 for (i = ff_ac3_rematrix_band_tab[bnd]; i < bndend; i++) {
584 int tmp0 = s->fixed_coeffs[1][i];
585 s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
586 s->fixed_coeffs[2][i] = tmp0 - s->fixed_coeffs[2][i];
593 * Inverse MDCT Transform.
594 * Convert frequency domain coefficients to time-domain audio samples.
595 * reference: Section 7.9.4 Transformation Equations
597 static inline void do_imdct(AC3DecodeContext *s, int channels)
601 for (ch = 1; ch <= channels; ch++) {
602 if (s->block_switch[ch]) {
604 float *x = s->tmp_output + 128;
605 for (i = 0; i < 128; i++)
606 x[i] = s->transform_coeffs[ch][2 * i];
607 s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
608 s->fdsp.vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
609 s->tmp_output, s->window, 128);
610 for (i = 0; i < 128; i++)
611 x[i] = s->transform_coeffs[ch][2 * i + 1];
612 s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch - 1], x);
614 s->imdct_512.imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
615 s->fdsp.vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
616 s->tmp_output, s->window, 128);
617 memcpy(s->delay[ch - 1], s->tmp_output + 128, 128 * sizeof(float));
623 * Upmix delay samples from stereo to original channel layout.
625 static void ac3_upmix_delay(AC3DecodeContext *s)
627 int channel_data_size = sizeof(s->delay[0]);
628 switch (s->channel_mode) {
629 case AC3_CHMODE_DUALMONO:
630 case AC3_CHMODE_STEREO:
631 /* upmix mono to stereo */
632 memcpy(s->delay[1], s->delay[0], channel_data_size);
634 case AC3_CHMODE_2F2R:
635 memset(s->delay[3], 0, channel_data_size);
636 case AC3_CHMODE_2F1R:
637 memset(s->delay[2], 0, channel_data_size);
639 case AC3_CHMODE_3F2R:
640 memset(s->delay[4], 0, channel_data_size);
641 case AC3_CHMODE_3F1R:
642 memset(s->delay[3], 0, channel_data_size);
644 memcpy(s->delay[2], s->delay[1], channel_data_size);
645 memset(s->delay[1], 0, channel_data_size);
651 * Decode band structure for coupling, spectral extension, or enhanced coupling.
652 * The band structure defines how many subbands are in each band. For each
653 * subband in the range, 1 means it is combined with the previous band, and 0
654 * means that it starts a new band.
656 * @param[in] gbc bit reader context
657 * @param[in] blk block number
658 * @param[in] eac3 flag to indicate E-AC-3
659 * @param[in] ecpl flag to indicate enhanced coupling
660 * @param[in] start_subband subband number for start of range
661 * @param[in] end_subband subband number for end of range
662 * @param[in] default_band_struct default band structure table
663 * @param[out] num_bands number of bands (optionally NULL)
664 * @param[out] band_sizes array containing the number of bins in each band (optionally NULL)
666 static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
667 int ecpl, int start_subband, int end_subband,
668 const uint8_t *default_band_struct,
669 int *num_bands, uint8_t *band_sizes)
671 int subbnd, bnd, n_subbands, n_bands=0;
673 uint8_t coded_band_struct[22];
674 const uint8_t *band_struct;
676 n_subbands = end_subband - start_subband;
678 /* decode band structure from bitstream or use default */
679 if (!eac3 || get_bits1(gbc)) {
680 for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
681 coded_band_struct[subbnd] = get_bits1(gbc);
683 band_struct = coded_band_struct;
685 band_struct = &default_band_struct[start_subband+1];
687 /* no change in band structure */
691 /* calculate number of bands and band sizes based on band structure.
692 note that the first 4 subbands in enhanced coupling span only 6 bins
694 if (num_bands || band_sizes ) {
695 n_bands = n_subbands;
696 bnd_sz[0] = ecpl ? 6 : 12;
697 for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
698 int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
699 if (band_struct[subbnd - 1]) {
701 bnd_sz[bnd] += subbnd_size;
703 bnd_sz[++bnd] = subbnd_size;
708 /* set optional output params */
710 *num_bands = n_bands;
712 memcpy(band_sizes, bnd_sz, n_bands);
716 * Decode a single audio block from the AC-3 bitstream.
718 static int decode_audio_block(AC3DecodeContext *s, int blk)
720 int fbw_channels = s->fbw_channels;
721 int channel_mode = s->channel_mode;
723 int different_transforms;
726 GetBitContext *gbc = &s->gbc;
727 uint8_t bit_alloc_stages[AC3_MAX_CHANNELS] = { 0 };
729 /* block switch flags */
730 different_transforms = 0;
731 if (s->block_switch_syntax) {
732 for (ch = 1; ch <= fbw_channels; ch++) {
733 s->block_switch[ch] = get_bits1(gbc);
734 if (ch > 1 && s->block_switch[ch] != s->block_switch[1])
735 different_transforms = 1;
739 /* dithering flags */
740 if (s->dither_flag_syntax) {
741 for (ch = 1; ch <= fbw_channels; ch++) {
742 s->dither_flag[ch] = get_bits1(gbc);
747 i = !s->channel_mode;
749 if (get_bits1(gbc)) {
750 s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)] - 1.0) *
752 } else if (blk == 0) {
753 s->dynamic_range[i] = 1.0f;
757 /* spectral extension strategy */
758 if (s->eac3 && (!blk || get_bits1(gbc))) {
759 s->spx_in_use = get_bits1(gbc);
761 int dst_start_freq, dst_end_freq, src_start_freq,
762 start_subband, end_subband;
764 /* determine which channels use spx */
765 if (s->channel_mode == AC3_CHMODE_MONO) {
766 s->channel_uses_spx[1] = 1;
768 for (ch = 1; ch <= fbw_channels; ch++)
769 s->channel_uses_spx[ch] = get_bits1(gbc);
772 /* get the frequency bins of the spx copy region and the spx start
774 dst_start_freq = get_bits(gbc, 2);
775 start_subband = get_bits(gbc, 3) + 2;
776 if (start_subband > 7)
777 start_subband += start_subband - 7;
778 end_subband = get_bits(gbc, 3) + 5;
780 end_subband += end_subband - 7;
781 dst_start_freq = dst_start_freq * 12 + 25;
782 src_start_freq = start_subband * 12 + 25;
783 dst_end_freq = end_subband * 12 + 25;
785 /* check validity of spx ranges */
786 if (start_subband >= end_subband) {
787 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
788 "range (%d >= %d)\n", start_subband, end_subband);
791 if (dst_start_freq >= src_start_freq) {
792 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
793 "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
797 s->spx_dst_start_freq = dst_start_freq;
798 s->spx_src_start_freq = src_start_freq;
799 s->spx_dst_end_freq = dst_end_freq;
801 decode_band_structure(gbc, blk, s->eac3, 0,
802 start_subband, end_subband,
803 ff_eac3_default_spx_band_struct,
807 for (ch = 1; ch <= fbw_channels; ch++) {
808 s->channel_uses_spx[ch] = 0;
809 s->first_spx_coords[ch] = 1;
814 /* spectral extension coordinates */
816 for (ch = 1; ch <= fbw_channels; ch++) {
817 if (s->channel_uses_spx[ch]) {
818 if (s->first_spx_coords[ch] || get_bits1(gbc)) {
820 int bin, master_spx_coord;
822 s->first_spx_coords[ch] = 0;
823 spx_blend = get_bits(gbc, 5) * (1.0f/32);
824 master_spx_coord = get_bits(gbc, 2) * 3;
826 bin = s->spx_src_start_freq;
827 for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
829 int spx_coord_exp, spx_coord_mant;
830 float nratio, sblend, nblend, spx_coord;
832 /* calculate blending factors */
833 bandsize = s->spx_band_sizes[bnd];
834 nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
835 nratio = av_clipf(nratio, 0.0f, 1.0f);
836 nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
837 // to give unity variance
838 sblend = sqrtf(1.0f - nratio);
841 /* decode spx coordinates */
842 spx_coord_exp = get_bits(gbc, 4);
843 spx_coord_mant = get_bits(gbc, 2);
844 if (spx_coord_exp == 15) spx_coord_mant <<= 1;
845 else spx_coord_mant += 4;
846 spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
847 spx_coord = spx_coord_mant * (1.0f / (1 << 23));
849 /* multiply noise and signal blending factors by spx coordinate */
850 s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
851 s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
855 s->first_spx_coords[ch] = 1;
860 /* coupling strategy */
861 if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
862 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
864 s->cpl_in_use[blk] = get_bits1(gbc);
865 if (s->cpl_in_use[blk]) {
866 /* coupling in use */
867 int cpl_start_subband, cpl_end_subband;
869 if (channel_mode < AC3_CHMODE_STEREO) {
870 av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
874 /* check for enhanced coupling */
875 if (s->eac3 && get_bits1(gbc)) {
876 /* TODO: parse enhanced coupling strategy info */
877 avpriv_request_sample(s->avctx, "Enhanced coupling");
878 return AVERROR_PATCHWELCOME;
881 /* determine which channels are coupled */
882 if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
883 s->channel_in_cpl[1] = 1;
884 s->channel_in_cpl[2] = 1;
886 for (ch = 1; ch <= fbw_channels; ch++)
887 s->channel_in_cpl[ch] = get_bits1(gbc);
890 /* phase flags in use */
891 if (channel_mode == AC3_CHMODE_STEREO)
892 s->phase_flags_in_use = get_bits1(gbc);
894 /* coupling frequency range */
895 cpl_start_subband = get_bits(gbc, 4);
896 cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
897 get_bits(gbc, 4) + 3;
898 if (cpl_start_subband >= cpl_end_subband) {
899 av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
900 cpl_start_subband, cpl_end_subband);
903 s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
904 s->end_freq[CPL_CH] = cpl_end_subband * 12 + 37;
906 decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
908 ff_eac3_default_cpl_band_struct,
909 &s->num_cpl_bands, s->cpl_band_sizes);
911 /* coupling not in use */
912 for (ch = 1; ch <= fbw_channels; ch++) {
913 s->channel_in_cpl[ch] = 0;
914 s->first_cpl_coords[ch] = 1;
916 s->first_cpl_leak = s->eac3;
917 s->phase_flags_in_use = 0;
919 } else if (!s->eac3) {
921 av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "
922 "be present in block 0\n");
925 s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
928 cpl_in_use = s->cpl_in_use[blk];
930 /* coupling coordinates */
932 int cpl_coords_exist = 0;
934 for (ch = 1; ch <= fbw_channels; ch++) {
935 if (s->channel_in_cpl[ch]) {
936 if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
937 int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
938 s->first_cpl_coords[ch] = 0;
939 cpl_coords_exist = 1;
940 master_cpl_coord = 3 * get_bits(gbc, 2);
941 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
942 cpl_coord_exp = get_bits(gbc, 4);
943 cpl_coord_mant = get_bits(gbc, 4);
944 if (cpl_coord_exp == 15)
945 s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
947 s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
948 s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
951 av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
952 "be present in block 0\n");
956 /* channel not in coupling */
957 s->first_cpl_coords[ch] = 1;
961 if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
962 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
963 s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
968 /* stereo rematrixing strategy and band structure */
969 if (channel_mode == AC3_CHMODE_STEREO) {
970 if ((s->eac3 && !blk) || get_bits1(gbc)) {
971 s->num_rematrixing_bands = 4;
972 if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
973 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
974 } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
975 s->num_rematrixing_bands--;
977 for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
978 s->rematrixing_flags[bnd] = get_bits1(gbc);
980 av_log(s->avctx, AV_LOG_WARNING, "Warning: "
981 "new rematrixing strategy not present in block 0\n");
982 s->num_rematrixing_bands = 0;
986 /* exponent strategies for each channel */
987 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
989 s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
990 if (s->exp_strategy[blk][ch] != EXP_REUSE)
991 bit_alloc_stages[ch] = 3;
994 /* channel bandwidth */
995 for (ch = 1; ch <= fbw_channels; ch++) {
996 s->start_freq[ch] = 0;
997 if (s->exp_strategy[blk][ch] != EXP_REUSE) {
999 int prev = s->end_freq[ch];
1000 if (s->channel_in_cpl[ch])
1001 s->end_freq[ch] = s->start_freq[CPL_CH];
1002 else if (s->channel_uses_spx[ch])
1003 s->end_freq[ch] = s->spx_src_start_freq;
1005 int bandwidth_code = get_bits(gbc, 6);
1006 if (bandwidth_code > 60) {
1007 av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1010 s->end_freq[ch] = bandwidth_code * 3 + 73;
1012 group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1013 s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
1014 if (blk > 0 && s->end_freq[ch] != prev)
1015 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1018 if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1019 s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
1020 (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1023 /* decode exponents for each channel */
1024 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1025 if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1026 s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1027 if (decode_exponents(gbc, s->exp_strategy[blk][ch],
1028 s->num_exp_groups[ch], s->dexps[ch][0],
1029 &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1030 av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
1033 if (ch != CPL_CH && ch != s->lfe_ch)
1034 skip_bits(gbc, 2); /* skip gainrng */
1038 /* bit allocation information */
1039 if (s->bit_allocation_syntax) {
1040 if (get_bits1(gbc)) {
1041 s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1042 s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1043 s->bit_alloc_params.slow_gain = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
1044 s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
1045 s->bit_alloc_params.floor = ff_ac3_floor_tab[get_bits(gbc, 3)];
1046 for (ch = !cpl_in_use; ch <= s->channels; ch++)
1047 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1049 av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must "
1050 "be present in block 0\n");
1055 /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1056 if (!s->eac3 || !blk) {
1057 if (s->snr_offset_strategy && get_bits1(gbc)) {
1060 csnr = (get_bits(gbc, 6) - 15) << 4;
1061 for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1063 if (ch == i || s->snr_offset_strategy == 2)
1064 snr = (csnr + get_bits(gbc, 4)) << 2;
1065 /* run at least last bit allocation stage if snr offset changes */
1066 if (blk && s->snr_offset[ch] != snr) {
1067 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1069 s->snr_offset[ch] = snr;
1071 /* fast gain (normal AC-3 only) */
1073 int prev = s->fast_gain[ch];
1074 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1075 /* run last 2 bit allocation stages if fast gain changes */
1076 if (blk && prev != s->fast_gain[ch])
1077 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1080 } else if (!s->eac3 && !blk) {
1081 av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1086 /* fast gain (E-AC-3 only) */
1087 if (s->fast_gain_syntax && get_bits1(gbc)) {
1088 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1089 int prev = s->fast_gain[ch];
1090 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1091 /* run last 2 bit allocation stages if fast gain changes */
1092 if (blk && prev != s->fast_gain[ch])
1093 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1095 } else if (s->eac3 && !blk) {
1096 for (ch = !cpl_in_use; ch <= s->channels; ch++)
1097 s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1100 /* E-AC-3 to AC-3 converter SNR offset */
1101 if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1102 skip_bits(gbc, 10); // skip converter snr offset
1105 /* coupling leak information */
1107 if (s->first_cpl_leak || get_bits1(gbc)) {
1108 int fl = get_bits(gbc, 3);
1109 int sl = get_bits(gbc, 3);
1110 /* run last 2 bit allocation stages for coupling channel if
1111 coupling leak changes */
1112 if (blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1113 sl != s->bit_alloc_params.cpl_slow_leak)) {
1114 bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1116 s->bit_alloc_params.cpl_fast_leak = fl;
1117 s->bit_alloc_params.cpl_slow_leak = sl;
1118 } else if (!s->eac3 && !blk) {
1119 av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must "
1120 "be present in block 0\n");
1123 s->first_cpl_leak = 0;
1126 /* delta bit allocation information */
1127 if (s->dba_syntax && get_bits1(gbc)) {
1128 /* delta bit allocation exists (strategy) */
1129 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1130 s->dba_mode[ch] = get_bits(gbc, 2);
1131 if (s->dba_mode[ch] == DBA_RESERVED) {
1132 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1135 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1137 /* channel delta offset, len and bit allocation */
1138 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1139 if (s->dba_mode[ch] == DBA_NEW) {
1140 s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;
1141 for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
1142 s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1143 s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1144 s->dba_values[ch][seg] = get_bits(gbc, 3);
1146 /* run last 2 bit allocation stages if new dba values */
1147 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1150 } else if (blk == 0) {
1151 for (ch = 0; ch <= s->channels; ch++) {
1152 s->dba_mode[ch] = DBA_NONE;
1156 /* Bit allocation */
1157 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1158 if (bit_alloc_stages[ch] > 2) {
1159 /* Exponent mapping into PSD and PSD integration */
1160 ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
1161 s->start_freq[ch], s->end_freq[ch],
1162 s->psd[ch], s->band_psd[ch]);
1164 if (bit_alloc_stages[ch] > 1) {
1165 /* Compute excitation function, Compute masking curve, and
1166 Apply delta bit allocation */
1167 if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1168 s->start_freq[ch], s->end_freq[ch],
1169 s->fast_gain[ch], (ch == s->lfe_ch),
1170 s->dba_mode[ch], s->dba_nsegs[ch],
1171 s->dba_offsets[ch], s->dba_lengths[ch],
1172 s->dba_values[ch], s->mask[ch])) {
1173 av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1177 if (bit_alloc_stages[ch] > 0) {
1178 /* Compute bit allocation */
1179 const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1180 ff_eac3_hebap_tab : ff_ac3_bap_tab;
1181 s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1182 s->start_freq[ch], s->end_freq[ch],
1184 s->bit_alloc_params.floor,
1185 bap_tab, s->bap[ch]);
1189 /* unused dummy data */
1190 if (s->skip_syntax && get_bits1(gbc)) {
1191 int skipl = get_bits(gbc, 9);
1196 /* unpack the transform coefficients
1197 this also uncouples channels if coupling is in use. */
1198 decode_transform_coeffs(s, blk);
1200 /* TODO: generate enhanced coupling coordinates and uncouple */
1202 /* recover coefficients if rematrixing is in use */
1203 if (s->channel_mode == AC3_CHMODE_STEREO)
1206 /* apply scaling to coefficients (headroom, dynrng) */
1207 for (ch = 1; ch <= s->channels; ch++) {
1208 float gain = 1.0 / 4194304.0f;
1209 if (s->channel_mode == AC3_CHMODE_DUALMONO) {
1210 gain *= s->dynamic_range[2 - ch];
1212 gain *= s->dynamic_range[0];
1214 s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch],
1215 s->fixed_coeffs[ch], gain, 256);
1218 /* apply spectral extension to high frequency bins */
1219 if (s->spx_in_use && CONFIG_EAC3_DECODER) {
1220 ff_eac3_apply_spectral_extension(s);
1223 /* downmix and MDCT. order depends on whether block switching is used for
1224 any channel in this block. this is because coefficients for the long
1225 and short transforms cannot be mixed. */
1226 downmix_output = s->channels != s->out_channels &&
1227 !((s->output_mode & AC3_OUTPUT_LFEON) &&
1228 s->fbw_channels == s->out_channels);
1229 if (different_transforms) {
1230 /* the delay samples have already been downmixed, so we upmix the delay
1231 samples in order to reconstruct all channels before downmixing. */
1237 do_imdct(s, s->channels);
1239 if (downmix_output) {
1240 s->ac3dsp.downmix(s->outptr, s->downmix_coeffs,
1241 s->out_channels, s->fbw_channels, 256);
1244 if (downmix_output) {
1245 s->ac3dsp.downmix(s->xcfptr + 1, s->downmix_coeffs,
1246 s->out_channels, s->fbw_channels, 256);
1249 if (downmix_output && !s->downmixed) {
1251 s->ac3dsp.downmix(s->dlyptr, s->downmix_coeffs, s->out_channels,
1252 s->fbw_channels, 128);
1255 do_imdct(s, s->out_channels);
1262 * Decode a single AC-3 frame.
1264 static int ac3_decode_frame(AVCodecContext * avctx, void *data,
1265 int *got_frame_ptr, AVPacket *avpkt)
1267 AVFrame *frame = data;
1268 const uint8_t *buf = avpkt->data;
1269 int buf_size = avpkt->size;
1270 AC3DecodeContext *s = avctx->priv_data;
1271 int blk, ch, err, ret;
1272 const uint8_t *channel_map;
1273 const float *output[AC3_MAX_CHANNELS];
1275 /* copy input buffer to decoder context to avoid reading past the end
1276 of the buffer, which can be caused by a damaged input stream. */
1277 if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
1278 // seems to be byte-swapped AC-3
1279 int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1280 s->dsp.bswap16_buf((uint16_t *)s->input_buffer, (const uint16_t *)buf, cnt);
1282 memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1283 buf = s->input_buffer;
1284 /* initialize the GetBitContext with the start of valid AC-3 Frame */
1285 init_get_bits(&s->gbc, buf, buf_size * 8);
1287 /* parse the syncinfo */
1288 err = parse_frame_header(s);
1292 case AAC_AC3_PARSE_ERROR_SYNC:
1293 av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1295 case AAC_AC3_PARSE_ERROR_BSID:
1296 av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1298 case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
1299 av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1301 case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
1302 av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1304 case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
1305 /* skip frame if CRC is ok. otherwise use error concealment. */
1306 /* TODO: add support for substreams and dependent frames */
1307 if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
1308 av_log(avctx, AV_LOG_ERROR, "unsupported frame type : "
1309 "skipping frame\n");
1311 return s->frame_size;
1313 av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1317 av_log(avctx, AV_LOG_ERROR, "invalid header\n");
1321 /* check that reported frame size fits in input buffer */
1322 if (s->frame_size > buf_size) {
1323 av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1324 err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
1325 } else if (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL)) {
1326 /* check for crc mismatch */
1327 if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
1328 s->frame_size - 2)) {
1329 av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1330 err = AAC_AC3_PARSE_ERROR_CRC;
1335 /* if frame is ok, set audio parameters */
1337 avctx->sample_rate = s->sample_rate;
1338 avctx->bit_rate = s->bit_rate;
1341 /* channel config */
1342 if (!err || (s->channels && s->out_channels != s->channels)) {
1343 s->out_channels = s->channels;
1344 s->output_mode = s->channel_mode;
1346 s->output_mode |= AC3_OUTPUT_LFEON;
1347 if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&
1348 avctx->request_channels < s->channels) {
1349 s->out_channels = avctx->request_channels;
1350 s->output_mode = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1351 s->channel_layout = avpriv_ac3_channel_layout_tab[s->output_mode];
1353 avctx->channels = s->out_channels;
1354 avctx->channel_layout = s->channel_layout;
1356 s->loro_center_mix_level = gain_levels[s-> center_mix_level];
1357 s->loro_surround_mix_level = gain_levels[s->surround_mix_level];
1358 s->ltrt_center_mix_level = LEVEL_MINUS_3DB;
1359 s->ltrt_surround_mix_level = LEVEL_MINUS_3DB;
1360 /* set downmixing coefficients if needed */
1361 if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1362 s->fbw_channels == s->out_channels)) {
1363 set_downmix_coeffs(s);
1365 } else if (!s->channels) {
1366 av_log(avctx, AV_LOG_ERROR, "unable to determine channel mode\n");
1367 return AVERROR_INVALIDDATA;
1369 avctx->channels = s->out_channels;
1371 /* set audio service type based on bitstream mode for AC-3 */
1372 avctx->audio_service_type = s->bitstream_mode;
1373 if (s->bitstream_mode == 0x7 && s->channels > 1)
1374 avctx->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
1376 /* get output buffer */
1377 frame->nb_samples = s->num_blocks * 256;
1378 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1381 /* decode the audio blocks */
1382 channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1383 for (ch = 0; ch < AC3_MAX_CHANNELS; ch++) {
1384 output[ch] = s->output[ch];
1385 s->outptr[ch] = s->output[ch];
1387 for (ch = 0; ch < s->channels; ch++) {
1388 if (ch < s->out_channels)
1389 s->outptr[channel_map[ch]] = (float *)frame->data[ch];
1391 for (blk = 0; blk < s->num_blocks; blk++) {
1392 if (!err && decode_audio_block(s, blk)) {
1393 av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1397 for (ch = 0; ch < s->out_channels; ch++)
1398 memcpy(((float*)frame->data[ch]) + AC3_BLOCK_SIZE*blk, output[ch], 1024);
1399 for (ch = 0; ch < s->out_channels; ch++)
1400 output[ch] = s->outptr[channel_map[ch]];
1401 for (ch = 0; ch < s->out_channels; ch++) {
1402 if (!ch || channel_map[ch])
1403 s->outptr[channel_map[ch]] += AC3_BLOCK_SIZE;
1407 av_frame_set_decode_error_flags(frame, err ? FF_DECODE_ERROR_INVALID_BITSTREAM : 0);
1409 /* keep last block for error concealment in next frame */
1410 for (ch = 0; ch < s->out_channels; ch++)
1411 memcpy(s->output[ch], output[ch], 1024);
1415 return FFMIN(buf_size, s->frame_size);
1419 * Uninitialize the AC-3 decoder.
1421 static av_cold int ac3_decode_end(AVCodecContext *avctx)
1423 AC3DecodeContext *s = avctx->priv_data;
1424 ff_mdct_end(&s->imdct_512);
1425 ff_mdct_end(&s->imdct_256);
1430 #define OFFSET(x) offsetof(AC3DecodeContext, x)
1431 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)
1432 static const AVOption options[] = {
1433 { "drc_scale", "percentage of dynamic range compression to apply", OFFSET(drc_scale), AV_OPT_TYPE_FLOAT, {.dbl = 1.0}, 0.0, 1.0, PAR },
1435 {"dmix_mode", "Preferred Stereo Downmix Mode", OFFSET(preferred_stereo_downmix), AV_OPT_TYPE_INT, {.i64 = -1 }, -1, 2, 0, "dmix_mode"},
1436 {"ltrt_cmixlev", "Lt/Rt Center Mix Level", OFFSET(ltrt_center_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
1437 {"ltrt_surmixlev", "Lt/Rt Surround Mix Level", OFFSET(ltrt_surround_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
1438 {"loro_cmixlev", "Lo/Ro Center Mix Level", OFFSET(loro_center_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
1439 {"loro_surmixlev", "Lo/Ro Surround Mix Level", OFFSET(loro_surround_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
1444 static const AVClass ac3_decoder_class = {
1445 .class_name = "AC3 decoder",
1446 .item_name = av_default_item_name,
1448 .version = LIBAVUTIL_VERSION_INT,
1451 AVCodec ff_ac3_decoder = {
1453 .type = AVMEDIA_TYPE_AUDIO,
1454 .id = AV_CODEC_ID_AC3,
1455 .priv_data_size = sizeof (AC3DecodeContext),
1456 .init = ac3_decode_init,
1457 .close = ac3_decode_end,
1458 .decode = ac3_decode_frame,
1459 .capabilities = CODEC_CAP_DR1,
1460 .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
1461 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1462 AV_SAMPLE_FMT_NONE },
1463 .priv_class = &ac3_decoder_class,
1466 #if CONFIG_EAC3_DECODER
1467 static const AVClass eac3_decoder_class = {
1468 .class_name = "E-AC3 decoder",
1469 .item_name = av_default_item_name,
1471 .version = LIBAVUTIL_VERSION_INT,
1474 AVCodec ff_eac3_decoder = {
1476 .type = AVMEDIA_TYPE_AUDIO,
1477 .id = AV_CODEC_ID_EAC3,
1478 .priv_data_size = sizeof (AC3DecodeContext),
1479 .init = ac3_decode_init,
1480 .close = ac3_decode_end,
1481 .decode = ac3_decode_frame,
1482 .capabilities = CODEC_CAP_DR1,
1483 .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
1484 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1485 AV_SAMPLE_FMT_NONE },
1486 .priv_class = &eac3_decoder_class,