3 * This code was developed as part of Google Summer of Code 2006.
4 * E-AC-3 support was added as part of Google Summer of Code 2007.
6 * Copyright (c) 2006 Kartikey Mahendra BHATT (bhattkm at gmail dot com)
7 * Copyright (c) 2007-2008 Bartlomiej Wolowiec <bartek.wolowiec@gmail.com>
8 * Copyright (c) 2007 Justin Ruggles <justin.ruggles@gmail.com>
10 * This file is part of Libav.
12 * Libav is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU Lesser General Public
14 * License as published by the Free Software Foundation; either
15 * version 2.1 of the License, or (at your option) any later version.
17 * Libav is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * Lesser General Public License for more details.
22 * You should have received a copy of the GNU Lesser General Public
23 * License along with Libav; if not, write to the Free Software
24 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
32 #include "libavutil/channel_layout.h"
33 #include "libavutil/crc.h"
34 #include "libavutil/opt.h"
36 #include "aac_ac3_parser.h"
37 #include "ac3_parser.h"
39 #include "ac3dec_data.h"
43 * table for ungrouping 3 values in 7 bits.
44 * used for exponents and bap=2 mantissas
46 static uint8_t ungroup_3_in_7_bits_tab[128][3];
48 /** tables for ungrouping mantissas */
49 static int b1_mantissas[32][3];
50 static int b2_mantissas[128][3];
51 static int b3_mantissas[8];
52 static int b4_mantissas[128][2];
53 static int b5_mantissas[16];
56 * Quantization table: levels for symmetric. bits for asymmetric.
57 * reference: Table 7.18 Mapping of bap to Quantizer
59 static const uint8_t quantization_tab[16] = {
61 5, 6, 7, 8, 9, 10, 11, 12, 14, 16
64 /** dynamic range table. converts codes to scale factors. */
65 static float dynamic_range_tab[256];
67 /** Adjustments in dB gain */
68 static const float gain_levels[9] = {
72 LEVEL_MINUS_1POINT5DB,
74 LEVEL_MINUS_4POINT5DB,
81 * Table for default stereo downmixing coefficients
82 * reference: Section 7.8.2 Downmixing Into Two Channels
84 static const uint8_t ac3_default_coeffs[8][5][2] = {
85 { { 2, 7 }, { 7, 2 }, },
87 { { 2, 7 }, { 7, 2 }, },
88 { { 2, 7 }, { 5, 5 }, { 7, 2 }, },
89 { { 2, 7 }, { 7, 2 }, { 6, 6 }, },
90 { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 }, },
91 { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
92 { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
96 * Symmetrical Dequantization
97 * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization
101 symmetric_dequant(int code, int levels)
103 return ((code - (levels >> 1)) << 24) / levels;
107 * Initialize tables at runtime.
109 static av_cold void ac3_tables_init(void)
113 /* generate table for ungrouping 3 values in 7 bits
114 reference: Section 7.1.3 Exponent Decoding */
115 for (i = 0; i < 128; i++) {
116 ungroup_3_in_7_bits_tab[i][0] = i / 25;
117 ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5;
118 ungroup_3_in_7_bits_tab[i][2] = (i % 25) % 5;
121 /* generate grouped mantissa tables
122 reference: Section 7.3.5 Ungrouping of Mantissas */
123 for (i = 0; i < 32; i++) {
124 /* bap=1 mantissas */
125 b1_mantissas[i][0] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][0], 3);
126 b1_mantissas[i][1] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][1], 3);
127 b1_mantissas[i][2] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][2], 3);
129 for (i = 0; i < 128; i++) {
130 /* bap=2 mantissas */
131 b2_mantissas[i][0] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][0], 5);
132 b2_mantissas[i][1] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][1], 5);
133 b2_mantissas[i][2] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][2], 5);
135 /* bap=4 mantissas */
136 b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
137 b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
139 /* generate ungrouped mantissa tables
140 reference: Tables 7.21 and 7.23 */
141 for (i = 0; i < 7; i++) {
142 /* bap=3 mantissas */
143 b3_mantissas[i] = symmetric_dequant(i, 7);
145 for (i = 0; i < 15; i++) {
146 /* bap=5 mantissas */
147 b5_mantissas[i] = symmetric_dequant(i, 15);
150 /* generate dynamic range table
151 reference: Section 7.7.1 Dynamic Range Control */
152 for (i = 0; i < 256; i++) {
153 int v = (i >> 5) - ((i >> 7) << 3) - 5;
154 dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
159 * AVCodec initialization
161 static av_cold int ac3_decode_init(AVCodecContext *avctx)
163 AC3DecodeContext *s = avctx->priv_data;
168 ff_ac3_common_init();
170 ff_mdct_init(&s->imdct_256, 8, 1, 1.0);
171 ff_mdct_init(&s->imdct_512, 9, 1, 1.0);
172 ff_kbd_window_init(s->window, 5.0, 256);
173 ff_dsputil_init(&s->dsp, avctx);
174 avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
175 ff_ac3dsp_init(&s->ac3dsp, avctx->flags & CODEC_FLAG_BITEXACT);
176 ff_fmt_convert_init(&s->fmt_conv, avctx);
177 av_lfg_init(&s->dith_state, 0);
179 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
181 /* allow downmixing to stereo or mono */
182 #if FF_API_REQUEST_CHANNELS
183 FF_DISABLE_DEPRECATION_WARNINGS
184 if (avctx->request_channels == 1)
185 avctx->request_channel_layout = AV_CH_LAYOUT_MONO;
186 else if (avctx->request_channels == 2)
187 avctx->request_channel_layout = AV_CH_LAYOUT_STEREO;
188 FF_ENABLE_DEPRECATION_WARNINGS
190 if (avctx->channels > 1 &&
191 avctx->request_channel_layout == AV_CH_LAYOUT_MONO)
193 else if (avctx->channels > 2 &&
194 avctx->request_channel_layout == AV_CH_LAYOUT_STEREO)
198 for (i = 0; i < AC3_MAX_CHANNELS; i++) {
199 s->xcfptr[i] = s->transform_coeffs[i];
200 s->dlyptr[i] = s->delay[i];
207 * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
208 * GetBitContext within AC3DecodeContext must point to
209 * the start of the synchronized AC-3 bitstream.
211 static int ac3_parse_header(AC3DecodeContext *s)
213 GetBitContext *gbc = &s->gbc;
216 /* read the rest of the bsi. read twice for dual mono mode. */
217 i = !s->channel_mode;
219 skip_bits(gbc, 5); // skip dialog normalization
221 skip_bits(gbc, 8); //skip compression
223 skip_bits(gbc, 8); //skip language code
225 skip_bits(gbc, 7); //skip audio production information
228 skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
230 /* skip the timecodes (or extra bitstream information for Alternate Syntax)
231 TODO: read & use the xbsi1 downmix levels */
233 skip_bits(gbc, 14); //skip timecode1 / xbsi1
235 skip_bits(gbc, 14); //skip timecode2 / xbsi2
237 /* skip additional bitstream info */
238 if (get_bits1(gbc)) {
239 i = get_bits(gbc, 6);
249 * Common function to parse AC-3 or E-AC-3 frame header
251 static int parse_frame_header(AC3DecodeContext *s)
256 err = avpriv_ac3_parse_header(&s->gbc, &hdr);
260 /* get decoding parameters from header info */
261 s->bit_alloc_params.sr_code = hdr.sr_code;
262 s->bitstream_mode = hdr.bitstream_mode;
263 s->channel_mode = hdr.channel_mode;
264 s->lfe_on = hdr.lfe_on;
265 s->bit_alloc_params.sr_shift = hdr.sr_shift;
266 s->sample_rate = hdr.sample_rate;
267 s->bit_rate = hdr.bit_rate;
268 s->channels = hdr.channels;
269 s->fbw_channels = s->channels - s->lfe_on;
270 s->lfe_ch = s->fbw_channels + 1;
271 s->frame_size = hdr.frame_size;
272 s->center_mix_level = hdr.center_mix_level;
273 s->surround_mix_level = hdr.surround_mix_level;
274 s->num_blocks = hdr.num_blocks;
275 s->frame_type = hdr.frame_type;
276 s->substreamid = hdr.substreamid;
279 s->start_freq[s->lfe_ch] = 0;
280 s->end_freq[s->lfe_ch] = 7;
281 s->num_exp_groups[s->lfe_ch] = 2;
282 s->channel_in_cpl[s->lfe_ch] = 0;
285 if (hdr.bitstream_id <= 10) {
287 s->snr_offset_strategy = 2;
288 s->block_switch_syntax = 1;
289 s->dither_flag_syntax = 1;
290 s->bit_allocation_syntax = 1;
291 s->fast_gain_syntax = 0;
292 s->first_cpl_leak = 0;
295 memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
296 return ac3_parse_header(s);
297 } else if (CONFIG_EAC3_DECODER) {
299 return ff_eac3_parse_header(s);
301 av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n");
302 return AVERROR(ENOSYS);
307 * Set stereo downmixing coefficients based on frame header info.
308 * reference: Section 7.8.2 Downmixing Into Two Channels
310 static void set_downmix_coeffs(AC3DecodeContext *s)
313 float cmix = gain_levels[s-> center_mix_level];
314 float smix = gain_levels[s->surround_mix_level];
317 for (i = 0; i < s->fbw_channels; i++) {
318 s->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
319 s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
321 if (s->channel_mode > 1 && s->channel_mode & 1) {
322 s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix;
324 if (s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
325 int nf = s->channel_mode - 2;
326 s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
328 if (s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
329 int nf = s->channel_mode - 4;
330 s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix;
335 for (i = 0; i < s->fbw_channels; i++) {
336 norm0 += s->downmix_coeffs[i][0];
337 norm1 += s->downmix_coeffs[i][1];
339 norm0 = 1.0f / norm0;
340 norm1 = 1.0f / norm1;
341 for (i = 0; i < s->fbw_channels; i++) {
342 s->downmix_coeffs[i][0] *= norm0;
343 s->downmix_coeffs[i][1] *= norm1;
346 if (s->output_mode == AC3_CHMODE_MONO) {
347 for (i = 0; i < s->fbw_channels; i++)
348 s->downmix_coeffs[i][0] = (s->downmix_coeffs[i][0] +
349 s->downmix_coeffs[i][1]) * LEVEL_MINUS_3DB;
354 * Decode the grouped exponents according to exponent strategy.
355 * reference: Section 7.1.3 Exponent Decoding
357 static int decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
358 uint8_t absexp, int8_t *dexps)
360 int i, j, grp, group_size;
365 group_size = exp_strategy + (exp_strategy == EXP_D45);
366 for (grp = 0, i = 0; grp < ngrps; grp++) {
367 expacc = get_bits(gbc, 7);
368 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
369 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
370 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
373 /* convert to absolute exps and expand groups */
375 for (i = 0, j = 0; i < ngrps * 3; i++) {
376 prevexp += dexp[i] - 2;
379 switch (group_size) {
380 case 4: dexps[j++] = prevexp;
381 dexps[j++] = prevexp;
382 case 2: dexps[j++] = prevexp;
383 case 1: dexps[j++] = prevexp;
390 * Generate transform coefficients for each coupled channel in the coupling
391 * range using the coupling coefficients and coupling coordinates.
392 * reference: Section 7.4.3 Coupling Coordinate Format
394 static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
398 bin = s->start_freq[CPL_CH];
399 for (band = 0; band < s->num_cpl_bands; band++) {
400 int band_start = bin;
401 int band_end = bin + s->cpl_band_sizes[band];
402 for (ch = 1; ch <= s->fbw_channels; ch++) {
403 if (s->channel_in_cpl[ch]) {
404 int cpl_coord = s->cpl_coords[ch][band] << 5;
405 for (bin = band_start; bin < band_end; bin++) {
406 s->fixed_coeffs[ch][bin] =
407 MULH(s->fixed_coeffs[CPL_CH][bin] << 4, cpl_coord);
409 if (ch == 2 && s->phase_flags[band]) {
410 for (bin = band_start; bin < band_end; bin++)
411 s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin];
420 * Grouped mantissas for 3-level 5-level and 11-level quantization
432 * Decode the transform coefficients for a particular channel
433 * reference: Section 7.3 Quantization and Decoding of Mantissas
435 static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
437 int start_freq = s->start_freq[ch_index];
438 int end_freq = s->end_freq[ch_index];
439 uint8_t *baps = s->bap[ch_index];
440 int8_t *exps = s->dexps[ch_index];
441 int32_t *coeffs = s->fixed_coeffs[ch_index];
442 int dither = (ch_index == CPL_CH) || s->dither_flag[ch_index];
443 GetBitContext *gbc = &s->gbc;
446 for (freq = start_freq; freq < end_freq; freq++) {
447 int bap = baps[freq];
451 /* random noise with approximate range of -0.707 to 0.707 */
453 mantissa = (av_lfg_get(&s->dith_state) / 362) - 5932275;
460 mantissa = m->b1_mant[m->b1];
462 int bits = get_bits(gbc, 5);
463 mantissa = b1_mantissas[bits][0];
464 m->b1_mant[1] = b1_mantissas[bits][1];
465 m->b1_mant[0] = b1_mantissas[bits][2];
472 mantissa = m->b2_mant[m->b2];
474 int bits = get_bits(gbc, 7);
475 mantissa = b2_mantissas[bits][0];
476 m->b2_mant[1] = b2_mantissas[bits][1];
477 m->b2_mant[0] = b2_mantissas[bits][2];
482 mantissa = b3_mantissas[get_bits(gbc, 3)];
487 mantissa = m->b4_mant;
489 int bits = get_bits(gbc, 7);
490 mantissa = b4_mantissas[bits][0];
491 m->b4_mant = b4_mantissas[bits][1];
496 mantissa = b5_mantissas[get_bits(gbc, 4)];
498 default: /* 6 to 15 */
499 /* Shift mantissa and sign-extend it. */
500 mantissa = get_sbits(gbc, quantization_tab[bap]);
501 mantissa <<= 24 - quantization_tab[bap];
504 coeffs[freq] = mantissa >> exps[freq];
509 * Remove random dithering from coupling range coefficients with zero-bit
510 * mantissas for coupled channels which do not use dithering.
511 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
513 static void remove_dithering(AC3DecodeContext *s) {
516 for (ch = 1; ch <= s->fbw_channels; ch++) {
517 if (!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
518 for (i = s->start_freq[CPL_CH]; i < s->end_freq[CPL_CH]; i++) {
519 if (!s->bap[CPL_CH][i])
520 s->fixed_coeffs[ch][i] = 0;
526 static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,
529 if (!s->channel_uses_aht[ch]) {
530 ac3_decode_transform_coeffs_ch(s, ch, m);
532 /* if AHT is used, mantissas for all blocks are encoded in the first
533 block of the frame. */
535 if (!blk && CONFIG_EAC3_DECODER)
536 ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
537 for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
538 s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
544 * Decode the transform coefficients.
546 static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
552 m.b1 = m.b2 = m.b4 = 0;
554 for (ch = 1; ch <= s->channels; ch++) {
555 /* transform coefficients for full-bandwidth channel */
556 decode_transform_coeffs_ch(s, blk, ch, &m);
557 /* transform coefficients for coupling channel come right after the
558 coefficients for the first coupled channel*/
559 if (s->channel_in_cpl[ch]) {
561 decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
562 calc_transform_coeffs_cpl(s);
565 end = s->end_freq[CPL_CH];
567 end = s->end_freq[ch];
570 s->fixed_coeffs[ch][end] = 0;
574 /* zero the dithered coefficients for appropriate channels */
579 * Stereo rematrixing.
580 * reference: Section 7.5.4 Rematrixing : Decoding Technique
582 static void do_rematrixing(AC3DecodeContext *s)
587 end = FFMIN(s->end_freq[1], s->end_freq[2]);
589 for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) {
590 if (s->rematrixing_flags[bnd]) {
591 bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd + 1]);
592 for (i = ff_ac3_rematrix_band_tab[bnd]; i < bndend; i++) {
593 int tmp0 = s->fixed_coeffs[1][i];
594 s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
595 s->fixed_coeffs[2][i] = tmp0 - s->fixed_coeffs[2][i];
602 * Inverse MDCT Transform.
603 * Convert frequency domain coefficients to time-domain audio samples.
604 * reference: Section 7.9.4 Transformation Equations
606 static inline void do_imdct(AC3DecodeContext *s, int channels)
610 for (ch = 1; ch <= channels; ch++) {
611 if (s->block_switch[ch]) {
613 float *x = s->tmp_output + 128;
614 for (i = 0; i < 128; i++)
615 x[i] = s->transform_coeffs[ch][2 * i];
616 s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
617 s->fdsp.vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
618 s->tmp_output, s->window, 128);
619 for (i = 0; i < 128; i++)
620 x[i] = s->transform_coeffs[ch][2 * i + 1];
621 s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch - 1], x);
623 s->imdct_512.imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
624 s->fdsp.vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
625 s->tmp_output, s->window, 128);
626 memcpy(s->delay[ch - 1], s->tmp_output + 128, 128 * sizeof(float));
632 * Upmix delay samples from stereo to original channel layout.
634 static void ac3_upmix_delay(AC3DecodeContext *s)
636 int channel_data_size = sizeof(s->delay[0]);
637 switch (s->channel_mode) {
638 case AC3_CHMODE_DUALMONO:
639 case AC3_CHMODE_STEREO:
640 /* upmix mono to stereo */
641 memcpy(s->delay[1], s->delay[0], channel_data_size);
643 case AC3_CHMODE_2F2R:
644 memset(s->delay[3], 0, channel_data_size);
645 case AC3_CHMODE_2F1R:
646 memset(s->delay[2], 0, channel_data_size);
648 case AC3_CHMODE_3F2R:
649 memset(s->delay[4], 0, channel_data_size);
650 case AC3_CHMODE_3F1R:
651 memset(s->delay[3], 0, channel_data_size);
653 memcpy(s->delay[2], s->delay[1], channel_data_size);
654 memset(s->delay[1], 0, channel_data_size);
660 * Decode band structure for coupling, spectral extension, or enhanced coupling.
661 * The band structure defines how many subbands are in each band. For each
662 * subband in the range, 1 means it is combined with the previous band, and 0
663 * means that it starts a new band.
665 * @param[in] gbc bit reader context
666 * @param[in] blk block number
667 * @param[in] eac3 flag to indicate E-AC-3
668 * @param[in] ecpl flag to indicate enhanced coupling
669 * @param[in] start_subband subband number for start of range
670 * @param[in] end_subband subband number for end of range
671 * @param[in] default_band_struct default band structure table
672 * @param[out] num_bands number of bands (optionally NULL)
673 * @param[out] band_sizes array containing the number of bins in each band (optionally NULL)
675 static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
676 int ecpl, int start_subband, int end_subband,
677 const uint8_t *default_band_struct,
678 int *num_bands, uint8_t *band_sizes)
680 int subbnd, bnd, n_subbands, n_bands=0;
682 uint8_t coded_band_struct[22];
683 const uint8_t *band_struct;
685 n_subbands = end_subband - start_subband;
687 /* decode band structure from bitstream or use default */
688 if (!eac3 || get_bits1(gbc)) {
689 for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
690 coded_band_struct[subbnd] = get_bits1(gbc);
692 band_struct = coded_band_struct;
694 band_struct = &default_band_struct[start_subband+1];
696 /* no change in band structure */
700 /* calculate number of bands and band sizes based on band structure.
701 note that the first 4 subbands in enhanced coupling span only 6 bins
703 if (num_bands || band_sizes ) {
704 n_bands = n_subbands;
705 bnd_sz[0] = ecpl ? 6 : 12;
706 for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
707 int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
708 if (band_struct[subbnd - 1]) {
710 bnd_sz[bnd] += subbnd_size;
712 bnd_sz[++bnd] = subbnd_size;
717 /* set optional output params */
719 *num_bands = n_bands;
721 memcpy(band_sizes, bnd_sz, n_bands);
725 * Decode a single audio block from the AC-3 bitstream.
727 static int decode_audio_block(AC3DecodeContext *s, int blk)
729 int fbw_channels = s->fbw_channels;
730 int channel_mode = s->channel_mode;
732 int different_transforms;
735 GetBitContext *gbc = &s->gbc;
736 uint8_t bit_alloc_stages[AC3_MAX_CHANNELS] = { 0 };
738 /* block switch flags */
739 different_transforms = 0;
740 if (s->block_switch_syntax) {
741 for (ch = 1; ch <= fbw_channels; ch++) {
742 s->block_switch[ch] = get_bits1(gbc);
743 if (ch > 1 && s->block_switch[ch] != s->block_switch[1])
744 different_transforms = 1;
748 /* dithering flags */
749 if (s->dither_flag_syntax) {
750 for (ch = 1; ch <= fbw_channels; ch++) {
751 s->dither_flag[ch] = get_bits1(gbc);
756 i = !s->channel_mode;
758 if (get_bits1(gbc)) {
759 s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)] - 1.0) *
761 } else if (blk == 0) {
762 s->dynamic_range[i] = 1.0f;
766 /* spectral extension strategy */
767 if (s->eac3 && (!blk || get_bits1(gbc))) {
768 s->spx_in_use = get_bits1(gbc);
770 int dst_start_freq, dst_end_freq, src_start_freq,
771 start_subband, end_subband;
773 /* determine which channels use spx */
774 if (s->channel_mode == AC3_CHMODE_MONO) {
775 s->channel_uses_spx[1] = 1;
777 for (ch = 1; ch <= fbw_channels; ch++)
778 s->channel_uses_spx[ch] = get_bits1(gbc);
781 /* get the frequency bins of the spx copy region and the spx start
783 dst_start_freq = get_bits(gbc, 2);
784 start_subband = get_bits(gbc, 3) + 2;
785 if (start_subband > 7)
786 start_subband += start_subband - 7;
787 end_subband = get_bits(gbc, 3) + 5;
789 end_subband += end_subband - 7;
790 dst_start_freq = dst_start_freq * 12 + 25;
791 src_start_freq = start_subband * 12 + 25;
792 dst_end_freq = end_subband * 12 + 25;
794 /* check validity of spx ranges */
795 if (start_subband >= end_subband) {
796 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
797 "range (%d >= %d)\n", start_subband, end_subband);
798 return AVERROR_INVALIDDATA;
800 if (dst_start_freq >= src_start_freq) {
801 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
802 "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
803 return AVERROR_INVALIDDATA;
806 s->spx_dst_start_freq = dst_start_freq;
807 s->spx_src_start_freq = src_start_freq;
808 s->spx_dst_end_freq = dst_end_freq;
810 decode_band_structure(gbc, blk, s->eac3, 0,
811 start_subband, end_subband,
812 ff_eac3_default_spx_band_struct,
816 for (ch = 1; ch <= fbw_channels; ch++) {
817 s->channel_uses_spx[ch] = 0;
818 s->first_spx_coords[ch] = 1;
823 /* spectral extension coordinates */
825 for (ch = 1; ch <= fbw_channels; ch++) {
826 if (s->channel_uses_spx[ch]) {
827 if (s->first_spx_coords[ch] || get_bits1(gbc)) {
829 int bin, master_spx_coord;
831 s->first_spx_coords[ch] = 0;
832 spx_blend = get_bits(gbc, 5) * (1.0f/32);
833 master_spx_coord = get_bits(gbc, 2) * 3;
835 bin = s->spx_src_start_freq;
836 for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
838 int spx_coord_exp, spx_coord_mant;
839 float nratio, sblend, nblend, spx_coord;
841 /* calculate blending factors */
842 bandsize = s->spx_band_sizes[bnd];
843 nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
844 nratio = av_clipf(nratio, 0.0f, 1.0f);
845 nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
846 // to give unity variance
847 sblend = sqrtf(1.0f - nratio);
850 /* decode spx coordinates */
851 spx_coord_exp = get_bits(gbc, 4);
852 spx_coord_mant = get_bits(gbc, 2);
853 if (spx_coord_exp == 15) spx_coord_mant <<= 1;
854 else spx_coord_mant += 4;
855 spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
856 spx_coord = spx_coord_mant * (1.0f / (1 << 23));
858 /* multiply noise and signal blending factors by spx coordinate */
859 s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
860 s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
864 s->first_spx_coords[ch] = 1;
869 /* coupling strategy */
870 if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
871 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
873 s->cpl_in_use[blk] = get_bits1(gbc);
874 if (s->cpl_in_use[blk]) {
875 /* coupling in use */
876 int cpl_start_subband, cpl_end_subband;
878 if (channel_mode < AC3_CHMODE_STEREO) {
879 av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
880 return AVERROR_INVALIDDATA;
883 /* check for enhanced coupling */
884 if (s->eac3 && get_bits1(gbc)) {
885 /* TODO: parse enhanced coupling strategy info */
886 avpriv_request_sample(s->avctx, "Enhanced coupling");
887 return AVERROR_PATCHWELCOME;
890 /* determine which channels are coupled */
891 if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
892 s->channel_in_cpl[1] = 1;
893 s->channel_in_cpl[2] = 1;
895 for (ch = 1; ch <= fbw_channels; ch++)
896 s->channel_in_cpl[ch] = get_bits1(gbc);
899 /* phase flags in use */
900 if (channel_mode == AC3_CHMODE_STEREO)
901 s->phase_flags_in_use = get_bits1(gbc);
903 /* coupling frequency range */
904 cpl_start_subband = get_bits(gbc, 4);
905 cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
906 get_bits(gbc, 4) + 3;
907 if (cpl_start_subband >= cpl_end_subband) {
908 av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
909 cpl_start_subband, cpl_end_subband);
910 return AVERROR_INVALIDDATA;
912 s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
913 s->end_freq[CPL_CH] = cpl_end_subband * 12 + 37;
915 decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
917 ff_eac3_default_cpl_band_struct,
918 &s->num_cpl_bands, s->cpl_band_sizes);
920 /* coupling not in use */
921 for (ch = 1; ch <= fbw_channels; ch++) {
922 s->channel_in_cpl[ch] = 0;
923 s->first_cpl_coords[ch] = 1;
925 s->first_cpl_leak = s->eac3;
926 s->phase_flags_in_use = 0;
928 } else if (!s->eac3) {
930 av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "
931 "be present in block 0\n");
932 return AVERROR_INVALIDDATA;
934 s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
937 cpl_in_use = s->cpl_in_use[blk];
939 /* coupling coordinates */
941 int cpl_coords_exist = 0;
943 for (ch = 1; ch <= fbw_channels; ch++) {
944 if (s->channel_in_cpl[ch]) {
945 if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
946 int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
947 s->first_cpl_coords[ch] = 0;
948 cpl_coords_exist = 1;
949 master_cpl_coord = 3 * get_bits(gbc, 2);
950 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
951 cpl_coord_exp = get_bits(gbc, 4);
952 cpl_coord_mant = get_bits(gbc, 4);
953 if (cpl_coord_exp == 15)
954 s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
956 s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
957 s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
960 av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
961 "be present in block 0\n");
962 return AVERROR_INVALIDDATA;
965 /* channel not in coupling */
966 s->first_cpl_coords[ch] = 1;
970 if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
971 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
972 s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
977 /* stereo rematrixing strategy and band structure */
978 if (channel_mode == AC3_CHMODE_STEREO) {
979 if ((s->eac3 && !blk) || get_bits1(gbc)) {
980 s->num_rematrixing_bands = 4;
981 if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
982 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
983 } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
984 s->num_rematrixing_bands--;
986 for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
987 s->rematrixing_flags[bnd] = get_bits1(gbc);
989 av_log(s->avctx, AV_LOG_WARNING, "Warning: "
990 "new rematrixing strategy not present in block 0\n");
991 s->num_rematrixing_bands = 0;
995 /* exponent strategies for each channel */
996 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
998 s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
999 if (s->exp_strategy[blk][ch] != EXP_REUSE)
1000 bit_alloc_stages[ch] = 3;
1003 /* channel bandwidth */
1004 for (ch = 1; ch <= fbw_channels; ch++) {
1005 s->start_freq[ch] = 0;
1006 if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1008 int prev = s->end_freq[ch];
1009 if (s->channel_in_cpl[ch])
1010 s->end_freq[ch] = s->start_freq[CPL_CH];
1011 else if (s->channel_uses_spx[ch])
1012 s->end_freq[ch] = s->spx_src_start_freq;
1014 int bandwidth_code = get_bits(gbc, 6);
1015 if (bandwidth_code > 60) {
1016 av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1017 return AVERROR_INVALIDDATA;
1019 s->end_freq[ch] = bandwidth_code * 3 + 73;
1021 group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1022 s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
1023 if (blk > 0 && s->end_freq[ch] != prev)
1024 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1027 if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1028 s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
1029 (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1032 /* decode exponents for each channel */
1033 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1034 if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1035 s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1036 if (decode_exponents(gbc, s->exp_strategy[blk][ch],
1037 s->num_exp_groups[ch], s->dexps[ch][0],
1038 &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1039 av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
1040 return AVERROR_INVALIDDATA;
1042 if (ch != CPL_CH && ch != s->lfe_ch)
1043 skip_bits(gbc, 2); /* skip gainrng */
1047 /* bit allocation information */
1048 if (s->bit_allocation_syntax) {
1049 if (get_bits1(gbc)) {
1050 s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1051 s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1052 s->bit_alloc_params.slow_gain = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
1053 s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
1054 s->bit_alloc_params.floor = ff_ac3_floor_tab[get_bits(gbc, 3)];
1055 for (ch = !cpl_in_use; ch <= s->channels; ch++)
1056 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1058 av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must "
1059 "be present in block 0\n");
1060 return AVERROR_INVALIDDATA;
1064 /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1065 if (!s->eac3 || !blk) {
1066 if (s->snr_offset_strategy && get_bits1(gbc)) {
1069 csnr = (get_bits(gbc, 6) - 15) << 4;
1070 for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1072 if (ch == i || s->snr_offset_strategy == 2)
1073 snr = (csnr + get_bits(gbc, 4)) << 2;
1074 /* run at least last bit allocation stage if snr offset changes */
1075 if (blk && s->snr_offset[ch] != snr) {
1076 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1078 s->snr_offset[ch] = snr;
1080 /* fast gain (normal AC-3 only) */
1082 int prev = s->fast_gain[ch];
1083 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1084 /* run last 2 bit allocation stages if fast gain changes */
1085 if (blk && prev != s->fast_gain[ch])
1086 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1089 } else if (!s->eac3 && !blk) {
1090 av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1091 return AVERROR_INVALIDDATA;
1095 /* fast gain (E-AC-3 only) */
1096 if (s->fast_gain_syntax && get_bits1(gbc)) {
1097 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1098 int prev = s->fast_gain[ch];
1099 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1100 /* run last 2 bit allocation stages if fast gain changes */
1101 if (blk && prev != s->fast_gain[ch])
1102 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1104 } else if (s->eac3 && !blk) {
1105 for (ch = !cpl_in_use; ch <= s->channels; ch++)
1106 s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1109 /* E-AC-3 to AC-3 converter SNR offset */
1110 if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1111 skip_bits(gbc, 10); // skip converter snr offset
1114 /* coupling leak information */
1116 if (s->first_cpl_leak || get_bits1(gbc)) {
1117 int fl = get_bits(gbc, 3);
1118 int sl = get_bits(gbc, 3);
1119 /* run last 2 bit allocation stages for coupling channel if
1120 coupling leak changes */
1121 if (blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1122 sl != s->bit_alloc_params.cpl_slow_leak)) {
1123 bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1125 s->bit_alloc_params.cpl_fast_leak = fl;
1126 s->bit_alloc_params.cpl_slow_leak = sl;
1127 } else if (!s->eac3 && !blk) {
1128 av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must "
1129 "be present in block 0\n");
1130 return AVERROR_INVALIDDATA;
1132 s->first_cpl_leak = 0;
1135 /* delta bit allocation information */
1136 if (s->dba_syntax && get_bits1(gbc)) {
1137 /* delta bit allocation exists (strategy) */
1138 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1139 s->dba_mode[ch] = get_bits(gbc, 2);
1140 if (s->dba_mode[ch] == DBA_RESERVED) {
1141 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1142 return AVERROR_INVALIDDATA;
1144 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1146 /* channel delta offset, len and bit allocation */
1147 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1148 if (s->dba_mode[ch] == DBA_NEW) {
1149 s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;
1150 for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
1151 s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1152 s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1153 s->dba_values[ch][seg] = get_bits(gbc, 3);
1155 /* run last 2 bit allocation stages if new dba values */
1156 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1159 } else if (blk == 0) {
1160 for (ch = 0; ch <= s->channels; ch++) {
1161 s->dba_mode[ch] = DBA_NONE;
1165 /* Bit allocation */
1166 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1167 if (bit_alloc_stages[ch] > 2) {
1168 /* Exponent mapping into PSD and PSD integration */
1169 ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
1170 s->start_freq[ch], s->end_freq[ch],
1171 s->psd[ch], s->band_psd[ch]);
1173 if (bit_alloc_stages[ch] > 1) {
1174 /* Compute excitation function, Compute masking curve, and
1175 Apply delta bit allocation */
1176 if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1177 s->start_freq[ch], s->end_freq[ch],
1178 s->fast_gain[ch], (ch == s->lfe_ch),
1179 s->dba_mode[ch], s->dba_nsegs[ch],
1180 s->dba_offsets[ch], s->dba_lengths[ch],
1181 s->dba_values[ch], s->mask[ch])) {
1182 av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1183 return AVERROR_INVALIDDATA;
1186 if (bit_alloc_stages[ch] > 0) {
1187 /* Compute bit allocation */
1188 const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1189 ff_eac3_hebap_tab : ff_ac3_bap_tab;
1190 s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1191 s->start_freq[ch], s->end_freq[ch],
1193 s->bit_alloc_params.floor,
1194 bap_tab, s->bap[ch]);
1198 /* unused dummy data */
1199 if (s->skip_syntax && get_bits1(gbc)) {
1200 int skipl = get_bits(gbc, 9);
1205 /* unpack the transform coefficients
1206 this also uncouples channels if coupling is in use. */
1207 decode_transform_coeffs(s, blk);
1209 /* TODO: generate enhanced coupling coordinates and uncouple */
1211 /* recover coefficients if rematrixing is in use */
1212 if (s->channel_mode == AC3_CHMODE_STEREO)
1215 /* apply scaling to coefficients (headroom, dynrng) */
1216 for (ch = 1; ch <= s->channels; ch++) {
1217 float gain = 1.0 / 4194304.0f;
1218 if (s->channel_mode == AC3_CHMODE_DUALMONO) {
1219 gain *= s->dynamic_range[2 - ch];
1221 gain *= s->dynamic_range[0];
1223 s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch],
1224 s->fixed_coeffs[ch], gain, 256);
1227 /* apply spectral extension to high frequency bins */
1228 if (s->spx_in_use && CONFIG_EAC3_DECODER) {
1229 ff_eac3_apply_spectral_extension(s);
1232 /* downmix and MDCT. order depends on whether block switching is used for
1233 any channel in this block. this is because coefficients for the long
1234 and short transforms cannot be mixed. */
1235 downmix_output = s->channels != s->out_channels &&
1236 !((s->output_mode & AC3_OUTPUT_LFEON) &&
1237 s->fbw_channels == s->out_channels);
1238 if (different_transforms) {
1239 /* the delay samples have already been downmixed, so we upmix the delay
1240 samples in order to reconstruct all channels before downmixing. */
1246 do_imdct(s, s->channels);
1248 if (downmix_output) {
1249 s->ac3dsp.downmix(s->outptr, s->downmix_coeffs,
1250 s->out_channels, s->fbw_channels, 256);
1253 if (downmix_output) {
1254 s->ac3dsp.downmix(s->xcfptr + 1, s->downmix_coeffs,
1255 s->out_channels, s->fbw_channels, 256);
1258 if (downmix_output && !s->downmixed) {
1260 s->ac3dsp.downmix(s->dlyptr, s->downmix_coeffs, s->out_channels,
1261 s->fbw_channels, 128);
1264 do_imdct(s, s->out_channels);
1271 * Decode a single AC-3 frame.
1273 static int ac3_decode_frame(AVCodecContext * avctx, void *data,
1274 int *got_frame_ptr, AVPacket *avpkt)
1276 AVFrame *frame = data;
1277 const uint8_t *buf = avpkt->data;
1278 int buf_size = avpkt->size;
1279 AC3DecodeContext *s = avctx->priv_data;
1280 int blk, ch, err, ret;
1281 const uint8_t *channel_map;
1282 const float *output[AC3_MAX_CHANNELS];
1284 /* copy input buffer to decoder context to avoid reading past the end
1285 of the buffer, which can be caused by a damaged input stream. */
1286 if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
1287 // seems to be byte-swapped AC-3
1288 int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1289 s->dsp.bswap16_buf((uint16_t *)s->input_buffer, (const uint16_t *)buf, cnt);
1291 memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1292 buf = s->input_buffer;
1293 /* initialize the GetBitContext with the start of valid AC-3 Frame */
1294 init_get_bits(&s->gbc, buf, buf_size * 8);
1296 /* parse the syncinfo */
1297 err = parse_frame_header(s);
1301 case AAC_AC3_PARSE_ERROR_SYNC:
1302 av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1303 return AVERROR_INVALIDDATA;
1304 case AAC_AC3_PARSE_ERROR_BSID:
1305 av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1307 case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
1308 av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1310 case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
1311 av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1313 case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
1314 /* skip frame if CRC is ok. otherwise use error concealment. */
1315 /* TODO: add support for substreams and dependent frames */
1316 if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
1317 av_log(avctx, AV_LOG_WARNING, "unsupported frame type : "
1318 "skipping frame\n");
1322 av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1325 case AAC_AC3_PARSE_ERROR_CRC:
1326 case AAC_AC3_PARSE_ERROR_CHANNEL_CFG:
1328 default: // Normal AVERROR do not try to recover.
1333 /* check that reported frame size fits in input buffer */
1334 if (s->frame_size > buf_size) {
1335 av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1336 err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
1337 } else if (avctx->err_recognition & AV_EF_CRCCHECK) {
1338 /* check for crc mismatch */
1339 if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
1340 s->frame_size - 2)) {
1341 av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1342 if (avctx->err_recognition & AV_EF_EXPLODE)
1343 return AVERROR_INVALIDDATA;
1344 err = AAC_AC3_PARSE_ERROR_CRC;
1349 /* if frame is ok, set audio parameters */
1351 avctx->sample_rate = s->sample_rate;
1352 avctx->bit_rate = s->bit_rate;
1355 /* channel config */
1356 if (!err || (s->channels && s->out_channels != s->channels)) {
1357 s->out_channels = s->channels;
1358 s->output_mode = s->channel_mode;
1360 s->output_mode |= AC3_OUTPUT_LFEON;
1361 if (s->channels > 1 &&
1362 avctx->request_channel_layout == AV_CH_LAYOUT_MONO) {
1363 s->out_channels = 1;
1364 s->output_mode = AC3_CHMODE_MONO;
1365 } else if (s->channels > 2 &&
1366 avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
1367 s->out_channels = 2;
1368 s->output_mode = AC3_CHMODE_STEREO;
1371 /* set downmixing coefficients if needed */
1372 if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1373 s->fbw_channels == s->out_channels)) {
1374 set_downmix_coeffs(s);
1376 } else if (!s->channels) {
1377 av_log(avctx, AV_LOG_ERROR, "unable to determine channel mode\n");
1378 return AVERROR_INVALIDDATA;
1380 avctx->channels = s->out_channels;
1381 avctx->channel_layout = avpriv_ac3_channel_layout_tab[s->output_mode & ~AC3_OUTPUT_LFEON];
1382 if (s->output_mode & AC3_OUTPUT_LFEON)
1383 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1385 /* set audio service type based on bitstream mode for AC-3 */
1386 avctx->audio_service_type = s->bitstream_mode;
1387 if (s->bitstream_mode == 0x7 && s->channels > 1)
1388 avctx->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
1390 /* get output buffer */
1391 frame->nb_samples = s->num_blocks * AC3_BLOCK_SIZE;
1392 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
1393 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1397 /* decode the audio blocks */
1398 channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1399 for (ch = 0; ch < s->channels; ch++) {
1400 if (ch < s->out_channels)
1401 s->outptr[channel_map[ch]] = (float *)frame->data[ch];
1403 s->outptr[ch] = s->output[ch];
1404 output[ch] = s->output[ch];
1406 for (blk = 0; blk < s->num_blocks; blk++) {
1407 if (!err && decode_audio_block(s, blk)) {
1408 av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1412 for (ch = 0; ch < s->out_channels; ch++)
1413 memcpy(s->outptr[channel_map[ch]], output[ch], sizeof(**output) * AC3_BLOCK_SIZE);
1414 for (ch = 0; ch < s->out_channels; ch++)
1415 output[ch] = s->outptr[channel_map[ch]];
1416 for (ch = 0; ch < s->out_channels; ch++)
1417 s->outptr[ch] += AC3_BLOCK_SIZE;
1420 /* keep last block for error concealment in next frame */
1421 for (ch = 0; ch < s->out_channels; ch++)
1422 memcpy(s->output[ch], output[ch], sizeof(**output) * AC3_BLOCK_SIZE);
1426 return FFMIN(buf_size, s->frame_size);
1430 * Uninitialize the AC-3 decoder.
1432 static av_cold int ac3_decode_end(AVCodecContext *avctx)
1434 AC3DecodeContext *s = avctx->priv_data;
1435 ff_mdct_end(&s->imdct_512);
1436 ff_mdct_end(&s->imdct_256);
1441 #define OFFSET(x) offsetof(AC3DecodeContext, x)
1442 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)
1443 static const AVOption options[] = {
1444 { "drc_scale", "percentage of dynamic range compression to apply", OFFSET(drc_scale), AV_OPT_TYPE_FLOAT, {.dbl = 1.0}, 0.0, 1.0, PAR },
1448 static const AVClass ac3_decoder_class = {
1449 .class_name = "AC3 decoder",
1450 .item_name = av_default_item_name,
1452 .version = LIBAVUTIL_VERSION_INT,
1455 AVCodec ff_ac3_decoder = {
1457 .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
1458 .type = AVMEDIA_TYPE_AUDIO,
1459 .id = AV_CODEC_ID_AC3,
1460 .priv_data_size = sizeof (AC3DecodeContext),
1461 .init = ac3_decode_init,
1462 .close = ac3_decode_end,
1463 .decode = ac3_decode_frame,
1464 .capabilities = CODEC_CAP_DR1,
1465 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1466 AV_SAMPLE_FMT_NONE },
1467 .priv_class = &ac3_decoder_class,
1470 #if CONFIG_EAC3_DECODER
1471 static const AVClass eac3_decoder_class = {
1472 .class_name = "E-AC3 decoder",
1473 .item_name = av_default_item_name,
1475 .version = LIBAVUTIL_VERSION_INT,
1478 AVCodec ff_eac3_decoder = {
1480 .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
1481 .type = AVMEDIA_TYPE_AUDIO,
1482 .id = AV_CODEC_ID_EAC3,
1483 .priv_data_size = sizeof (AC3DecodeContext),
1484 .init = ac3_decode_init,
1485 .close = ac3_decode_end,
1486 .decode = ac3_decode_frame,
1487 .capabilities = CODEC_CAP_DR1,
1488 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1489 AV_SAMPLE_FMT_NONE },
1490 .priv_class = &eac3_decoder_class,