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/crc.h"
33 #include "libavutil/opt.h"
35 #include "aac_ac3_parser.h"
36 #include "ac3_parser.h"
38 #include "ac3dec_data.h"
41 /** Large enough for maximum possible frame size when the specification limit is ignored */
42 #define AC3_FRAME_BUFFER_SIZE 32768
45 * table for ungrouping 3 values in 7 bits.
46 * used for exponents and bap=2 mantissas
48 static uint8_t ungroup_3_in_7_bits_tab[128][3];
51 /** tables for ungrouping mantissas */
52 static int b1_mantissas[32][3];
53 static int b2_mantissas[128][3];
54 static int b3_mantissas[8];
55 static int b4_mantissas[128][2];
56 static int b5_mantissas[16];
59 * Quantization table: levels for symmetric. bits for asymmetric.
60 * reference: Table 7.18 Mapping of bap to Quantizer
62 static const uint8_t quantization_tab[16] = {
64 5, 6, 7, 8, 9, 10, 11, 12, 14, 16
67 /** dynamic range table. converts codes to scale factors. */
68 static float dynamic_range_tab[256];
70 /** Adjustments in dB gain */
71 static const float gain_levels[9] = {
75 LEVEL_MINUS_1POINT5DB,
77 LEVEL_MINUS_4POINT5DB,
84 * Table for center mix levels
85 * reference: Section 5.4.2.4 cmixlev
87 static const uint8_t center_levels[4] = { 4, 5, 6, 5 };
90 * Table for surround mix levels
91 * reference: Section 5.4.2.5 surmixlev
93 static const uint8_t surround_levels[4] = { 4, 6, 7, 6 };
96 * Table for default stereo downmixing coefficients
97 * reference: Section 7.8.2 Downmixing Into Two Channels
99 static const uint8_t ac3_default_coeffs[8][5][2] = {
100 { { 2, 7 }, { 7, 2 }, },
102 { { 2, 7 }, { 7, 2 }, },
103 { { 2, 7 }, { 5, 5 }, { 7, 2 }, },
104 { { 2, 7 }, { 7, 2 }, { 6, 6 }, },
105 { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 }, },
106 { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
107 { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
111 * Symmetrical Dequantization
112 * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization
113 * Tables 7.19 to 7.23
116 symmetric_dequant(int code, int levels)
118 return ((code - (levels >> 1)) << 24) / levels;
122 * Initialize tables at runtime.
124 static av_cold void ac3_tables_init(void)
128 /* generate table for ungrouping 3 values in 7 bits
129 reference: Section 7.1.3 Exponent Decoding */
130 for(i=0; i<128; i++) {
131 ungroup_3_in_7_bits_tab[i][0] = i / 25;
132 ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5;
133 ungroup_3_in_7_bits_tab[i][2] = (i % 25) % 5;
136 /* generate grouped mantissa tables
137 reference: Section 7.3.5 Ungrouping of Mantissas */
138 for(i=0; i<32; i++) {
139 /* bap=1 mantissas */
140 b1_mantissas[i][0] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][0], 3);
141 b1_mantissas[i][1] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][1], 3);
142 b1_mantissas[i][2] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][2], 3);
144 for(i=0; i<128; i++) {
145 /* bap=2 mantissas */
146 b2_mantissas[i][0] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][0], 5);
147 b2_mantissas[i][1] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][1], 5);
148 b2_mantissas[i][2] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][2], 5);
150 /* bap=4 mantissas */
151 b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
152 b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
154 /* generate ungrouped mantissa tables
155 reference: Tables 7.21 and 7.23 */
157 /* bap=3 mantissas */
158 b3_mantissas[i] = symmetric_dequant(i, 7);
160 for(i=0; i<15; i++) {
161 /* bap=5 mantissas */
162 b5_mantissas[i] = symmetric_dequant(i, 15);
165 /* generate dynamic range table
166 reference: Section 7.7.1 Dynamic Range Control */
167 for(i=0; i<256; i++) {
168 int v = (i >> 5) - ((i >> 7) << 3) - 5;
169 dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
175 * AVCodec initialization
177 static av_cold int ac3_decode_init(AVCodecContext *avctx)
179 AC3DecodeContext *s = avctx->priv_data;
182 ff_ac3_common_init();
184 ff_mdct_init(&s->imdct_256, 8, 1, 1.0);
185 ff_mdct_init(&s->imdct_512, 9, 1, 1.0);
186 ff_kbd_window_init(s->window, 5.0, 256);
187 dsputil_init(&s->dsp, avctx);
188 ff_ac3dsp_init(&s->ac3dsp, avctx->flags & CODEC_FLAG_BITEXACT);
189 ff_fmt_convert_init(&s->fmt_conv, avctx);
190 av_lfg_init(&s->dith_state, 0);
192 /* set scale value for float to int16 conversion */
193 if (avctx->request_sample_fmt == AV_SAMPLE_FMT_FLT) {
195 avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
197 s->mul_bias = 32767.0f;
198 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
201 /* allow downmixing to stereo or mono */
202 if (avctx->channels > 0 && avctx->request_channels > 0 &&
203 avctx->request_channels < avctx->channels &&
204 avctx->request_channels <= 2) {
205 avctx->channels = avctx->request_channels;
209 /* allocate context input buffer */
210 s->input_buffer = av_mallocz(AC3_FRAME_BUFFER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);
211 if (!s->input_buffer)
212 return AVERROR(ENOMEM);
218 * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
219 * GetBitContext within AC3DecodeContext must point to
220 * the start of the synchronized AC-3 bitstream.
222 static int ac3_parse_header(AC3DecodeContext *s)
224 GetBitContext *gbc = &s->gbc;
227 /* read the rest of the bsi. read twice for dual mono mode. */
228 i = !(s->channel_mode);
230 skip_bits(gbc, 5); // skip dialog normalization
232 skip_bits(gbc, 8); //skip compression
234 skip_bits(gbc, 8); //skip language code
236 skip_bits(gbc, 7); //skip audio production information
239 skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
241 /* skip the timecodes (or extra bitstream information for Alternate Syntax)
242 TODO: read & use the xbsi1 downmix levels */
244 skip_bits(gbc, 14); //skip timecode1 / xbsi1
246 skip_bits(gbc, 14); //skip timecode2 / xbsi2
248 /* skip additional bitstream info */
249 if (get_bits1(gbc)) {
250 i = get_bits(gbc, 6);
260 * Common function to parse AC-3 or E-AC-3 frame header
262 static int parse_frame_header(AC3DecodeContext *s)
267 err = ff_ac3_parse_header(&s->gbc, &hdr);
271 /* get decoding parameters from header info */
272 s->bit_alloc_params.sr_code = hdr.sr_code;
273 s->bitstream_mode = hdr.bitstream_mode;
274 s->channel_mode = hdr.channel_mode;
275 s->channel_layout = hdr.channel_layout;
276 s->lfe_on = hdr.lfe_on;
277 s->bit_alloc_params.sr_shift = hdr.sr_shift;
278 s->sample_rate = hdr.sample_rate;
279 s->bit_rate = hdr.bit_rate;
280 s->channels = hdr.channels;
281 s->fbw_channels = s->channels - s->lfe_on;
282 s->lfe_ch = s->fbw_channels + 1;
283 s->frame_size = hdr.frame_size;
284 s->center_mix_level = hdr.center_mix_level;
285 s->surround_mix_level = hdr.surround_mix_level;
286 s->num_blocks = hdr.num_blocks;
287 s->frame_type = hdr.frame_type;
288 s->substreamid = hdr.substreamid;
291 s->start_freq[s->lfe_ch] = 0;
292 s->end_freq[s->lfe_ch] = 7;
293 s->num_exp_groups[s->lfe_ch] = 2;
294 s->channel_in_cpl[s->lfe_ch] = 0;
297 if (hdr.bitstream_id <= 10) {
299 s->snr_offset_strategy = 2;
300 s->block_switch_syntax = 1;
301 s->dither_flag_syntax = 1;
302 s->bit_allocation_syntax = 1;
303 s->fast_gain_syntax = 0;
304 s->first_cpl_leak = 0;
307 memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
308 return ac3_parse_header(s);
309 } else if (CONFIG_EAC3_DECODER) {
311 return ff_eac3_parse_header(s);
313 av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n");
319 * Set stereo downmixing coefficients based on frame header info.
320 * reference: Section 7.8.2 Downmixing Into Two Channels
322 static void set_downmix_coeffs(AC3DecodeContext *s)
325 float cmix = gain_levels[center_levels[s->center_mix_level]];
326 float smix = gain_levels[surround_levels[s->surround_mix_level]];
329 for(i=0; i<s->fbw_channels; i++) {
330 s->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
331 s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
333 if(s->channel_mode > 1 && s->channel_mode & 1) {
334 s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix;
336 if(s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
337 int nf = s->channel_mode - 2;
338 s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
340 if(s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
341 int nf = s->channel_mode - 4;
342 s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix;
347 for(i=0; i<s->fbw_channels; i++) {
348 norm0 += s->downmix_coeffs[i][0];
349 norm1 += s->downmix_coeffs[i][1];
351 norm0 = 1.0f / norm0;
352 norm1 = 1.0f / norm1;
353 for(i=0; i<s->fbw_channels; i++) {
354 s->downmix_coeffs[i][0] *= norm0;
355 s->downmix_coeffs[i][1] *= norm1;
358 if(s->output_mode == AC3_CHMODE_MONO) {
359 for(i=0; i<s->fbw_channels; i++)
360 s->downmix_coeffs[i][0] = (s->downmix_coeffs[i][0] + s->downmix_coeffs[i][1]) * LEVEL_MINUS_3DB;
365 * Decode the grouped exponents according to exponent strategy.
366 * reference: Section 7.1.3 Exponent Decoding
368 static int decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
369 uint8_t absexp, int8_t *dexps)
371 int i, j, grp, group_size;
376 group_size = exp_strategy + (exp_strategy == EXP_D45);
377 for(grp=0,i=0; grp<ngrps; grp++) {
378 expacc = get_bits(gbc, 7);
379 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
380 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
381 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
384 /* convert to absolute exps and expand groups */
386 for(i=0,j=0; i<ngrps*3; i++) {
387 prevexp += dexp[i] - 2;
390 switch (group_size) {
391 case 4: dexps[j++] = prevexp;
392 dexps[j++] = prevexp;
393 case 2: dexps[j++] = prevexp;
394 case 1: dexps[j++] = prevexp;
401 * Generate transform coefficients for each coupled channel in the coupling
402 * range using the coupling coefficients and coupling coordinates.
403 * reference: Section 7.4.3 Coupling Coordinate Format
405 static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
409 bin = s->start_freq[CPL_CH];
410 for (band = 0; band < s->num_cpl_bands; band++) {
411 int band_start = bin;
412 int band_end = bin + s->cpl_band_sizes[band];
413 for (ch = 1; ch <= s->fbw_channels; ch++) {
414 if (s->channel_in_cpl[ch]) {
415 int cpl_coord = s->cpl_coords[ch][band] << 5;
416 for (bin = band_start; bin < band_end; bin++) {
417 s->fixed_coeffs[ch][bin] = MULH(s->fixed_coeffs[CPL_CH][bin] << 4, cpl_coord);
419 if (ch == 2 && s->phase_flags[band]) {
420 for (bin = band_start; bin < band_end; bin++)
421 s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin];
430 * Grouped mantissas for 3-level 5-level and 11-level quantization
442 * Decode the transform coefficients for a particular channel
443 * reference: Section 7.3 Quantization and Decoding of Mantissas
445 static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
447 int start_freq = s->start_freq[ch_index];
448 int end_freq = s->end_freq[ch_index];
449 uint8_t *baps = s->bap[ch_index];
450 int8_t *exps = s->dexps[ch_index];
451 int *coeffs = s->fixed_coeffs[ch_index];
452 int dither = (ch_index == CPL_CH) || s->dither_flag[ch_index];
453 GetBitContext *gbc = &s->gbc;
456 for(freq = start_freq; freq < end_freq; freq++){
457 int bap = baps[freq];
462 mantissa = (av_lfg_get(&s->dith_state) & 0x7FFFFF) - 0x400000;
469 mantissa = m->b1_mant[m->b1];
472 int bits = get_bits(gbc, 5);
473 mantissa = b1_mantissas[bits][0];
474 m->b1_mant[1] = b1_mantissas[bits][1];
475 m->b1_mant[0] = b1_mantissas[bits][2];
482 mantissa = m->b2_mant[m->b2];
485 int bits = get_bits(gbc, 7);
486 mantissa = b2_mantissas[bits][0];
487 m->b2_mant[1] = b2_mantissas[bits][1];
488 m->b2_mant[0] = b2_mantissas[bits][2];
493 mantissa = b3_mantissas[get_bits(gbc, 3)];
498 mantissa = m->b4_mant;
501 int bits = get_bits(gbc, 7);
502 mantissa = b4_mantissas[bits][0];
503 m->b4_mant = b4_mantissas[bits][1];
508 mantissa = b5_mantissas[get_bits(gbc, 4)];
510 default: /* 6 to 15 */
511 mantissa = get_bits(gbc, quantization_tab[bap]);
512 /* Shift mantissa and sign-extend it. */
513 mantissa = (mantissa << (32-quantization_tab[bap]))>>8;
516 coeffs[freq] = mantissa >> exps[freq];
521 * Remove random dithering from coupling range coefficients with zero-bit
522 * mantissas for coupled channels which do not use dithering.
523 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
525 static void remove_dithering(AC3DecodeContext *s) {
528 for(ch=1; ch<=s->fbw_channels; ch++) {
529 if(!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
530 for(i = s->start_freq[CPL_CH]; i<s->end_freq[CPL_CH]; i++) {
531 if(!s->bap[CPL_CH][i])
532 s->fixed_coeffs[ch][i] = 0;
538 static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,
541 if (!s->channel_uses_aht[ch]) {
542 ac3_decode_transform_coeffs_ch(s, ch, m);
544 /* if AHT is used, mantissas for all blocks are encoded in the first
545 block of the frame. */
547 if (!blk && CONFIG_EAC3_DECODER)
548 ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
549 for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
550 s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
556 * Decode the transform coefficients.
558 static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
564 m.b1 = m.b2 = m.b4 = 0;
566 for (ch = 1; ch <= s->channels; ch++) {
567 /* transform coefficients for full-bandwidth channel */
568 decode_transform_coeffs_ch(s, blk, ch, &m);
569 /* tranform coefficients for coupling channel come right after the
570 coefficients for the first coupled channel*/
571 if (s->channel_in_cpl[ch]) {
573 decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
574 calc_transform_coeffs_cpl(s);
577 end = s->end_freq[CPL_CH];
579 end = s->end_freq[ch];
582 s->fixed_coeffs[ch][end] = 0;
586 /* zero the dithered coefficients for appropriate channels */
591 * Stereo rematrixing.
592 * reference: Section 7.5.4 Rematrixing : Decoding Technique
594 static void do_rematrixing(AC3DecodeContext *s)
599 end = FFMIN(s->end_freq[1], s->end_freq[2]);
601 for(bnd=0; bnd<s->num_rematrixing_bands; bnd++) {
602 if(s->rematrixing_flags[bnd]) {
603 bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd+1]);
604 for(i=ff_ac3_rematrix_band_tab[bnd]; i<bndend; i++) {
605 int tmp0 = s->fixed_coeffs[1][i];
606 s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
607 s->fixed_coeffs[2][i] = tmp0 - s->fixed_coeffs[2][i];
614 * Inverse MDCT Transform.
615 * Convert frequency domain coefficients to time-domain audio samples.
616 * reference: Section 7.9.4 Transformation Equations
618 static inline void do_imdct(AC3DecodeContext *s, int channels)
622 for (ch=1; ch<=channels; ch++) {
623 if (s->block_switch[ch]) {
625 float *x = s->tmp_output+128;
627 x[i] = s->transform_coeffs[ch][2*i];
628 s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
629 s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, 128);
631 x[i] = s->transform_coeffs[ch][2*i+1];
632 s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch-1], x);
634 s->imdct_512.imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
635 s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, 128);
636 memcpy(s->delay[ch-1], s->tmp_output+128, 128*sizeof(float));
642 * Downmix the output to mono or stereo.
644 void ff_ac3_downmix_c(float (*samples)[256], float (*matrix)[2], int out_ch, int in_ch, int len)
649 for(i=0; i<len; i++) {
651 for(j=0; j<in_ch; j++) {
652 v0 += samples[j][i] * matrix[j][0];
653 v1 += samples[j][i] * matrix[j][1];
658 } else if(out_ch == 1) {
659 for(i=0; i<len; i++) {
661 for(j=0; j<in_ch; j++)
662 v0 += samples[j][i] * matrix[j][0];
669 * Upmix delay samples from stereo to original channel layout.
671 static void ac3_upmix_delay(AC3DecodeContext *s)
673 int channel_data_size = sizeof(s->delay[0]);
674 switch(s->channel_mode) {
675 case AC3_CHMODE_DUALMONO:
676 case AC3_CHMODE_STEREO:
677 /* upmix mono to stereo */
678 memcpy(s->delay[1], s->delay[0], channel_data_size);
680 case AC3_CHMODE_2F2R:
681 memset(s->delay[3], 0, channel_data_size);
682 case AC3_CHMODE_2F1R:
683 memset(s->delay[2], 0, channel_data_size);
685 case AC3_CHMODE_3F2R:
686 memset(s->delay[4], 0, channel_data_size);
687 case AC3_CHMODE_3F1R:
688 memset(s->delay[3], 0, channel_data_size);
690 memcpy(s->delay[2], s->delay[1], channel_data_size);
691 memset(s->delay[1], 0, channel_data_size);
697 * Decode band structure for coupling, spectral extension, or enhanced coupling.
698 * The band structure defines how many subbands are in each band. For each
699 * subband in the range, 1 means it is combined with the previous band, and 0
700 * means that it starts a new band.
702 * @param[in] gbc bit reader context
703 * @param[in] blk block number
704 * @param[in] eac3 flag to indicate E-AC-3
705 * @param[in] ecpl flag to indicate enhanced coupling
706 * @param[in] start_subband subband number for start of range
707 * @param[in] end_subband subband number for end of range
708 * @param[in] default_band_struct default band structure table
709 * @param[out] num_bands number of bands (optionally NULL)
710 * @param[out] band_sizes array containing the number of bins in each band (optionally NULL)
712 static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
713 int ecpl, int start_subband, int end_subband,
714 const uint8_t *default_band_struct,
715 int *num_bands, uint8_t *band_sizes)
717 int subbnd, bnd, n_subbands, n_bands=0;
719 uint8_t coded_band_struct[22];
720 const uint8_t *band_struct;
722 n_subbands = end_subband - start_subband;
724 /* decode band structure from bitstream or use default */
725 if (!eac3 || get_bits1(gbc)) {
726 for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
727 coded_band_struct[subbnd] = get_bits1(gbc);
729 band_struct = coded_band_struct;
731 band_struct = &default_band_struct[start_subband+1];
733 /* no change in band structure */
737 /* calculate number of bands and band sizes based on band structure.
738 note that the first 4 subbands in enhanced coupling span only 6 bins
740 if (num_bands || band_sizes ) {
741 n_bands = n_subbands;
742 bnd_sz[0] = ecpl ? 6 : 12;
743 for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
744 int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
745 if (band_struct[subbnd-1]) {
747 bnd_sz[bnd] += subbnd_size;
749 bnd_sz[++bnd] = subbnd_size;
754 /* set optional output params */
756 *num_bands = n_bands;
758 memcpy(band_sizes, bnd_sz, n_bands);
762 * Decode a single audio block from the AC-3 bitstream.
764 static int decode_audio_block(AC3DecodeContext *s, int blk)
766 int fbw_channels = s->fbw_channels;
767 int channel_mode = s->channel_mode;
769 int different_transforms;
772 GetBitContext *gbc = &s->gbc;
773 uint8_t bit_alloc_stages[AC3_MAX_CHANNELS];
775 memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);
777 /* block switch flags */
778 different_transforms = 0;
779 if (s->block_switch_syntax) {
780 for (ch = 1; ch <= fbw_channels; ch++) {
781 s->block_switch[ch] = get_bits1(gbc);
782 if(ch > 1 && s->block_switch[ch] != s->block_switch[1])
783 different_transforms = 1;
787 /* dithering flags */
788 if (s->dither_flag_syntax) {
789 for (ch = 1; ch <= fbw_channels; ch++) {
790 s->dither_flag[ch] = get_bits1(gbc);
795 i = !(s->channel_mode);
798 s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)]-1.0) *
799 s->avctx->drc_scale)+1.0;
800 } else if(blk == 0) {
801 s->dynamic_range[i] = 1.0f;
805 /* spectral extension strategy */
806 if (s->eac3 && (!blk || get_bits1(gbc))) {
807 s->spx_in_use = get_bits1(gbc);
809 int dst_start_freq, dst_end_freq, src_start_freq,
810 start_subband, end_subband;
812 /* determine which channels use spx */
813 if (s->channel_mode == AC3_CHMODE_MONO) {
814 s->channel_uses_spx[1] = 1;
816 for (ch = 1; ch <= fbw_channels; ch++)
817 s->channel_uses_spx[ch] = get_bits1(gbc);
820 /* get the frequency bins of the spx copy region and the spx start
822 dst_start_freq = get_bits(gbc, 2);
823 start_subband = get_bits(gbc, 3) + 2;
824 if (start_subband > 7)
825 start_subband += start_subband - 7;
826 end_subband = get_bits(gbc, 3) + 5;
828 end_subband += end_subband - 7;
829 dst_start_freq = dst_start_freq * 12 + 25;
830 src_start_freq = start_subband * 12 + 25;
831 dst_end_freq = end_subband * 12 + 25;
833 /* check validity of spx ranges */
834 if (start_subband >= end_subband) {
835 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
836 "range (%d >= %d)\n", start_subband, end_subband);
839 if (dst_start_freq >= src_start_freq) {
840 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
841 "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
845 s->spx_dst_start_freq = dst_start_freq;
846 s->spx_src_start_freq = src_start_freq;
847 s->spx_dst_end_freq = dst_end_freq;
849 decode_band_structure(gbc, blk, s->eac3, 0,
850 start_subband, end_subband,
851 ff_eac3_default_spx_band_struct,
855 for (ch = 1; ch <= fbw_channels; ch++) {
856 s->channel_uses_spx[ch] = 0;
857 s->first_spx_coords[ch] = 1;
862 /* spectral extension coordinates */
864 for (ch = 1; ch <= fbw_channels; ch++) {
865 if (s->channel_uses_spx[ch]) {
866 if (s->first_spx_coords[ch] || get_bits1(gbc)) {
868 int bin, master_spx_coord;
870 s->first_spx_coords[ch] = 0;
871 spx_blend = get_bits(gbc, 5) * (1.0f/32);
872 master_spx_coord = get_bits(gbc, 2) * 3;
874 bin = s->spx_src_start_freq;
875 for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
877 int spx_coord_exp, spx_coord_mant;
878 float nratio, sblend, nblend, spx_coord;
880 /* calculate blending factors */
881 bandsize = s->spx_band_sizes[bnd];
882 nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
883 nratio = av_clipf(nratio, 0.0f, 1.0f);
884 nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3) to give unity variance
885 sblend = sqrtf(1.0f - nratio);
888 /* decode spx coordinates */
889 spx_coord_exp = get_bits(gbc, 4);
890 spx_coord_mant = get_bits(gbc, 2);
891 if (spx_coord_exp == 15) spx_coord_mant <<= 1;
892 else spx_coord_mant += 4;
893 spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
894 spx_coord = spx_coord_mant * (1.0f/(1<<23));
896 /* multiply noise and signal blending factors by spx coordinate */
897 s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
898 s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
902 s->first_spx_coords[ch] = 1;
907 /* coupling strategy */
908 if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
909 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
911 s->cpl_in_use[blk] = get_bits1(gbc);
912 if (s->cpl_in_use[blk]) {
913 /* coupling in use */
914 int cpl_start_subband, cpl_end_subband;
916 if (channel_mode < AC3_CHMODE_STEREO) {
917 av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
921 /* check for enhanced coupling */
922 if (s->eac3 && get_bits1(gbc)) {
923 /* TODO: parse enhanced coupling strategy info */
924 av_log_missing_feature(s->avctx, "Enhanced coupling", 1);
928 /* determine which channels are coupled */
929 if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
930 s->channel_in_cpl[1] = 1;
931 s->channel_in_cpl[2] = 1;
933 for (ch = 1; ch <= fbw_channels; ch++)
934 s->channel_in_cpl[ch] = get_bits1(gbc);
937 /* phase flags in use */
938 if (channel_mode == AC3_CHMODE_STEREO)
939 s->phase_flags_in_use = get_bits1(gbc);
941 /* coupling frequency range */
942 cpl_start_subband = get_bits(gbc, 4);
943 cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
944 get_bits(gbc, 4) + 3;
945 if (cpl_start_subband >= cpl_end_subband) {
946 av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
947 cpl_start_subband, cpl_end_subband);
950 s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
951 s->end_freq[CPL_CH] = cpl_end_subband * 12 + 37;
953 decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
955 ff_eac3_default_cpl_band_struct,
956 &s->num_cpl_bands, s->cpl_band_sizes);
958 /* coupling not in use */
959 for (ch = 1; ch <= fbw_channels; ch++) {
960 s->channel_in_cpl[ch] = 0;
961 s->first_cpl_coords[ch] = 1;
963 s->first_cpl_leak = s->eac3;
964 s->phase_flags_in_use = 0;
966 } else if (!s->eac3) {
968 av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must be present in block 0\n");
971 s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
974 cpl_in_use = s->cpl_in_use[blk];
976 /* coupling coordinates */
978 int cpl_coords_exist = 0;
980 for (ch = 1; ch <= fbw_channels; ch++) {
981 if (s->channel_in_cpl[ch]) {
982 if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
983 int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
984 s->first_cpl_coords[ch] = 0;
985 cpl_coords_exist = 1;
986 master_cpl_coord = 3 * get_bits(gbc, 2);
987 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
988 cpl_coord_exp = get_bits(gbc, 4);
989 cpl_coord_mant = get_bits(gbc, 4);
990 if (cpl_coord_exp == 15)
991 s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
993 s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
994 s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
997 av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must be present in block 0\n");
1001 /* channel not in coupling */
1002 s->first_cpl_coords[ch] = 1;
1006 if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
1007 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1008 s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
1013 /* stereo rematrixing strategy and band structure */
1014 if (channel_mode == AC3_CHMODE_STEREO) {
1015 if ((s->eac3 && !blk) || get_bits1(gbc)) {
1016 s->num_rematrixing_bands = 4;
1017 if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
1018 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
1019 } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
1020 s->num_rematrixing_bands--;
1022 for(bnd=0; bnd<s->num_rematrixing_bands; bnd++)
1023 s->rematrixing_flags[bnd] = get_bits1(gbc);
1025 av_log(s->avctx, AV_LOG_WARNING, "Warning: new rematrixing strategy not present in block 0\n");
1026 s->num_rematrixing_bands = 0;
1030 /* exponent strategies for each channel */
1031 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1033 s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
1034 if(s->exp_strategy[blk][ch] != EXP_REUSE)
1035 bit_alloc_stages[ch] = 3;
1038 /* channel bandwidth */
1039 for (ch = 1; ch <= fbw_channels; ch++) {
1040 s->start_freq[ch] = 0;
1041 if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1043 int prev = s->end_freq[ch];
1044 if (s->channel_in_cpl[ch])
1045 s->end_freq[ch] = s->start_freq[CPL_CH];
1046 else if (s->channel_uses_spx[ch])
1047 s->end_freq[ch] = s->spx_src_start_freq;
1049 int bandwidth_code = get_bits(gbc, 6);
1050 if (bandwidth_code > 60) {
1051 av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1054 s->end_freq[ch] = bandwidth_code * 3 + 73;
1056 group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1057 s->num_exp_groups[ch] = (s->end_freq[ch]+group_size-4) / group_size;
1058 if(blk > 0 && s->end_freq[ch] != prev)
1059 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1062 if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1063 s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
1064 (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1067 /* decode exponents for each channel */
1068 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1069 if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1070 s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1071 if (decode_exponents(gbc, s->exp_strategy[blk][ch],
1072 s->num_exp_groups[ch], s->dexps[ch][0],
1073 &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1074 av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
1077 if(ch != CPL_CH && ch != s->lfe_ch)
1078 skip_bits(gbc, 2); /* skip gainrng */
1082 /* bit allocation information */
1083 if (s->bit_allocation_syntax) {
1084 if (get_bits1(gbc)) {
1085 s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1086 s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1087 s->bit_alloc_params.slow_gain = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
1088 s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
1089 s->bit_alloc_params.floor = ff_ac3_floor_tab[get_bits(gbc, 3)];
1090 for(ch=!cpl_in_use; ch<=s->channels; ch++)
1091 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1093 av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must be present in block 0\n");
1098 /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1099 if(!s->eac3 || !blk){
1100 if(s->snr_offset_strategy && get_bits1(gbc)) {
1103 csnr = (get_bits(gbc, 6) - 15) << 4;
1104 for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1106 if (ch == i || s->snr_offset_strategy == 2)
1107 snr = (csnr + get_bits(gbc, 4)) << 2;
1108 /* run at least last bit allocation stage if snr offset changes */
1109 if(blk && s->snr_offset[ch] != snr) {
1110 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1112 s->snr_offset[ch] = snr;
1114 /* fast gain (normal AC-3 only) */
1116 int prev = s->fast_gain[ch];
1117 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1118 /* run last 2 bit allocation stages if fast gain changes */
1119 if(blk && prev != s->fast_gain[ch])
1120 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1123 } else if (!s->eac3 && !blk) {
1124 av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1129 /* fast gain (E-AC-3 only) */
1130 if (s->fast_gain_syntax && get_bits1(gbc)) {
1131 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1132 int prev = s->fast_gain[ch];
1133 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1134 /* run last 2 bit allocation stages if fast gain changes */
1135 if(blk && prev != s->fast_gain[ch])
1136 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1138 } else if (s->eac3 && !blk) {
1139 for (ch = !cpl_in_use; ch <= s->channels; ch++)
1140 s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1143 /* E-AC-3 to AC-3 converter SNR offset */
1144 if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1145 skip_bits(gbc, 10); // skip converter snr offset
1148 /* coupling leak information */
1150 if (s->first_cpl_leak || get_bits1(gbc)) {
1151 int fl = get_bits(gbc, 3);
1152 int sl = get_bits(gbc, 3);
1153 /* run last 2 bit allocation stages for coupling channel if
1154 coupling leak changes */
1155 if(blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1156 sl != s->bit_alloc_params.cpl_slow_leak)) {
1157 bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1159 s->bit_alloc_params.cpl_fast_leak = fl;
1160 s->bit_alloc_params.cpl_slow_leak = sl;
1161 } else if (!s->eac3 && !blk) {
1162 av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must be present in block 0\n");
1165 s->first_cpl_leak = 0;
1168 /* delta bit allocation information */
1169 if (s->dba_syntax && get_bits1(gbc)) {
1170 /* delta bit allocation exists (strategy) */
1171 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1172 s->dba_mode[ch] = get_bits(gbc, 2);
1173 if (s->dba_mode[ch] == DBA_RESERVED) {
1174 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1177 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1179 /* channel delta offset, len and bit allocation */
1180 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1181 if (s->dba_mode[ch] == DBA_NEW) {
1182 s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;
1183 for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
1184 s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1185 s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1186 s->dba_values[ch][seg] = get_bits(gbc, 3);
1188 /* run last 2 bit allocation stages if new dba values */
1189 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1192 } else if(blk == 0) {
1193 for(ch=0; ch<=s->channels; ch++) {
1194 s->dba_mode[ch] = DBA_NONE;
1198 /* Bit allocation */
1199 for(ch=!cpl_in_use; ch<=s->channels; ch++) {
1200 if(bit_alloc_stages[ch] > 2) {
1201 /* Exponent mapping into PSD and PSD integration */
1202 ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
1203 s->start_freq[ch], s->end_freq[ch],
1204 s->psd[ch], s->band_psd[ch]);
1206 if(bit_alloc_stages[ch] > 1) {
1207 /* Compute excitation function, Compute masking curve, and
1208 Apply delta bit allocation */
1209 if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1210 s->start_freq[ch], s->end_freq[ch],
1211 s->fast_gain[ch], (ch == s->lfe_ch),
1212 s->dba_mode[ch], s->dba_nsegs[ch],
1213 s->dba_offsets[ch], s->dba_lengths[ch],
1214 s->dba_values[ch], s->mask[ch])) {
1215 av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1219 if(bit_alloc_stages[ch] > 0) {
1220 /* Compute bit allocation */
1221 const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1222 ff_eac3_hebap_tab : ff_ac3_bap_tab;
1223 s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1224 s->start_freq[ch], s->end_freq[ch],
1226 s->bit_alloc_params.floor,
1227 bap_tab, s->bap[ch]);
1231 /* unused dummy data */
1232 if (s->skip_syntax && get_bits1(gbc)) {
1233 int skipl = get_bits(gbc, 9);
1238 /* unpack the transform coefficients
1239 this also uncouples channels if coupling is in use. */
1240 decode_transform_coeffs(s, blk);
1242 /* TODO: generate enhanced coupling coordinates and uncouple */
1244 /* recover coefficients if rematrixing is in use */
1245 if(s->channel_mode == AC3_CHMODE_STEREO)
1248 /* apply scaling to coefficients (headroom, dynrng) */
1249 for(ch=1; ch<=s->channels; ch++) {
1250 float gain = s->mul_bias / 4194304.0f;
1251 if(s->channel_mode == AC3_CHMODE_DUALMONO) {
1252 gain *= s->dynamic_range[2-ch];
1254 gain *= s->dynamic_range[0];
1256 s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch], s->fixed_coeffs[ch], gain, 256);
1259 /* apply spectral extension to high frequency bins */
1260 if (s->spx_in_use && CONFIG_EAC3_DECODER) {
1261 ff_eac3_apply_spectral_extension(s);
1264 /* downmix and MDCT. order depends on whether block switching is used for
1265 any channel in this block. this is because coefficients for the long
1266 and short transforms cannot be mixed. */
1267 downmix_output = s->channels != s->out_channels &&
1268 !((s->output_mode & AC3_OUTPUT_LFEON) &&
1269 s->fbw_channels == s->out_channels);
1270 if(different_transforms) {
1271 /* the delay samples have already been downmixed, so we upmix the delay
1272 samples in order to reconstruct all channels before downmixing. */
1278 do_imdct(s, s->channels);
1280 if(downmix_output) {
1281 s->dsp.ac3_downmix(s->output, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
1284 if(downmix_output) {
1285 s->dsp.ac3_downmix(s->transform_coeffs+1, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
1288 if(downmix_output && !s->downmixed) {
1290 s->dsp.ac3_downmix(s->delay, s->downmix_coeffs, s->out_channels, s->fbw_channels, 128);
1293 do_imdct(s, s->out_channels);
1300 * Decode a single AC-3 frame.
1302 static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size,
1305 const uint8_t *buf = avpkt->data;
1306 int buf_size = avpkt->size;
1307 AC3DecodeContext *s = avctx->priv_data;
1308 float *out_samples_flt = data;
1309 int16_t *out_samples_s16 = data;
1311 const uint8_t *channel_map;
1312 const float *output[AC3_MAX_CHANNELS];
1314 /* copy input buffer to decoder context to avoid reading past the end
1315 of the buffer, which can be caused by a damaged input stream. */
1316 if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
1317 // seems to be byte-swapped AC-3
1318 int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1319 s->dsp.bswap16_buf((uint16_t *)s->input_buffer, (const uint16_t *)buf, cnt);
1321 memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1322 buf = s->input_buffer;
1323 /* initialize the GetBitContext with the start of valid AC-3 Frame */
1324 init_get_bits(&s->gbc, buf, buf_size * 8);
1326 /* parse the syncinfo */
1328 err = parse_frame_header(s);
1332 case AAC_AC3_PARSE_ERROR_SYNC:
1333 av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1335 case AAC_AC3_PARSE_ERROR_BSID:
1336 av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1338 case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
1339 av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1341 case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
1342 av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1344 case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
1345 /* skip frame if CRC is ok. otherwise use error concealment. */
1346 /* TODO: add support for substreams and dependent frames */
1347 if(s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
1348 av_log(avctx, AV_LOG_ERROR, "unsupported frame type : skipping frame\n");
1349 return s->frame_size;
1351 av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1355 av_log(avctx, AV_LOG_ERROR, "invalid header\n");
1359 /* check that reported frame size fits in input buffer */
1360 if (s->frame_size > buf_size) {
1361 av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1362 err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
1363 } else if (avctx->error_recognition >= FF_ER_CAREFUL) {
1364 /* check for crc mismatch */
1365 if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2], 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 /* set downmixing coefficients if needed */
1392 if(s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1393 s->fbw_channels == s->out_channels)) {
1394 set_downmix_coeffs(s);
1396 } else if (!s->out_channels) {
1397 s->out_channels = avctx->channels;
1398 if(s->out_channels < s->channels)
1399 s->output_mode = s->out_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1401 /* set audio service type based on bitstream mode for AC-3 */
1402 avctx->audio_service_type = s->bitstream_mode;
1403 if (s->bitstream_mode == 0x7 && s->channels > 1)
1404 avctx->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
1406 /* decode the audio blocks */
1407 channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1408 for (ch = 0; ch < s->out_channels; ch++)
1409 output[ch] = s->output[channel_map[ch]];
1410 for (blk = 0; blk < s->num_blocks; blk++) {
1411 if (!err && decode_audio_block(s, blk)) {
1412 av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1415 if (avctx->sample_fmt == AV_SAMPLE_FMT_FLT) {
1416 s->fmt_conv.float_interleave(out_samples_flt, output, 256,
1418 out_samples_flt += 256 * s->out_channels;
1420 s->fmt_conv.float_to_int16_interleave(out_samples_s16, output, 256,
1422 out_samples_s16 += 256 * s->out_channels;
1425 *data_size = s->num_blocks * 256 * avctx->channels *
1426 av_get_bytes_per_sample(avctx->sample_fmt);
1427 return FFMIN(buf_size, s->frame_size);
1431 * Uninitialize the AC-3 decoder.
1433 static av_cold int ac3_decode_end(AVCodecContext *avctx)
1435 AC3DecodeContext *s = avctx->priv_data;
1436 ff_mdct_end(&s->imdct_512);
1437 ff_mdct_end(&s->imdct_256);
1439 av_freep(&s->input_buffer);
1444 #define OFFSET(x) offsetof(AC3DecodeContext, x)
1445 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)
1446 static const AVOption options[] = {
1447 { "drc_scale", "percentage of dynamic range compression to apply", OFFSET(drc_scale), FF_OPT_TYPE_FLOAT, {1.0}, 0.0, 1.0, PAR },
1451 static const AVClass ac3_decoder_class = {
1452 .class_name = "(E-)AC3 decoder",
1453 .item_name = av_default_item_name,
1455 .version = LIBAVUTIL_VERSION_INT,
1458 AVCodec ff_ac3_decoder = {
1460 .type = AVMEDIA_TYPE_AUDIO,
1462 .priv_data_size = sizeof (AC3DecodeContext),
1463 .init = ac3_decode_init,
1464 .close = ac3_decode_end,
1465 .decode = ac3_decode_frame,
1466 .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
1467 .sample_fmts = (const enum AVSampleFormat[]) {
1468 AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE
1470 .priv_class = &ac3_decoder_class,
1473 #if CONFIG_EAC3_DECODER
1474 AVCodec ff_eac3_decoder = {
1476 .type = AVMEDIA_TYPE_AUDIO,
1477 .id = 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 .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
1483 .sample_fmts = (const enum AVSampleFormat[]) {
1484 AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE
1486 .priv_class = &ac3_decoder_class,