398224753f99e28a3eeb8fcc89c95fa3a649206f
[ffmpeg.git] / libavcodec / ac3dec.c
1 /*
2  * AC-3 Audio Decoder
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.
5  *
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>
9  *
10  * This file is part of FFmpeg.
11  *
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.
16  *
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.
21  *
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
25  */
26
27 #include <stdio.h>
28 #include <stddef.h>
29 #include <math.h>
30 #include <string.h>
31
32 #include "libavutil/channel_layout.h"
33 #include "libavutil/crc.h"
34 #include "libavutil/downmix_info.h"
35 #include "libavutil/opt.h"
36 #include "bswapdsp.h"
37 #include "internal.h"
38 #include "aac_ac3_parser.h"
39 #include "ac3_parser.h"
40 #include "ac3dec.h"
41 #include "ac3dec_data.h"
42 #include "kbdwin.h"
43
44 /**
45  * table for ungrouping 3 values in 7 bits.
46  * used for exponents and bap=2 mantissas
47  */
48 static uint8_t ungroup_3_in_7_bits_tab[128][3];
49
50 /** tables for ungrouping mantissas */
51 static int b1_mantissas[32][3];
52 static int b2_mantissas[128][3];
53 static int b3_mantissas[8];
54 static int b4_mantissas[128][2];
55 static int b5_mantissas[16];
56
57 /**
58  * Quantization table: levels for symmetric. bits for asymmetric.
59  * reference: Table 7.18 Mapping of bap to Quantizer
60  */
61 static const uint8_t quantization_tab[16] = {
62     0, 3, 5, 7, 11, 15,
63     5, 6, 7, 8, 9, 10, 11, 12, 14, 16
64 };
65
66 /** dynamic range table. converts codes to scale factors. */
67 static float dynamic_range_tab[256];
68 static float heavy_dynamic_range_tab[256];
69
70 /** Adjustments in dB gain */
71 static const float gain_levels[9] = {
72     LEVEL_PLUS_3DB,
73     LEVEL_PLUS_1POINT5DB,
74     LEVEL_ONE,
75     LEVEL_MINUS_1POINT5DB,
76     LEVEL_MINUS_3DB,
77     LEVEL_MINUS_4POINT5DB,
78     LEVEL_MINUS_6DB,
79     LEVEL_ZERO,
80     LEVEL_MINUS_9DB
81 };
82
83 /** Adjustments in dB gain (LFE, +10 to -21 dB) */
84 static const float gain_levels_lfe[32] = {
85     3.162275, 2.818382, 2.511886, 2.238719, 1.995261, 1.778278, 1.584893,
86     1.412536, 1.258924, 1.122018, 1.000000, 0.891251, 0.794328, 0.707946,
87     0.630957, 0.562341, 0.501187, 0.446683, 0.398107, 0.354813, 0.316227,
88     0.281838, 0.251188, 0.223872, 0.199526, 0.177828, 0.158489, 0.141253,
89     0.125892, 0.112201, 0.100000, 0.089125
90 };
91
92 /**
93  * Table for default stereo downmixing coefficients
94  * reference: Section 7.8.2 Downmixing Into Two Channels
95  */
96 static const uint8_t ac3_default_coeffs[8][5][2] = {
97     { { 2, 7 }, { 7, 2 },                               },
98     { { 4, 4 },                                         },
99     { { 2, 7 }, { 7, 2 },                               },
100     { { 2, 7 }, { 5, 5 }, { 7, 2 },                     },
101     { { 2, 7 }, { 7, 2 }, { 6, 6 },                     },
102     { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 },           },
103     { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 },           },
104     { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
105 };
106
107 /**
108  * Symmetrical Dequantization
109  * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization
110  *            Tables 7.19 to 7.23
111  */
112 static inline int
113 symmetric_dequant(int code, int levels)
114 {
115     return ((code - (levels >> 1)) * (1 << 24)) / levels;
116 }
117
118 /*
119  * Initialize tables at runtime.
120  */
121 static av_cold void ac3_tables_init(void)
122 {
123     int i;
124
125     /* generate table for ungrouping 3 values in 7 bits
126        reference: Section 7.1.3 Exponent Decoding */
127     for (i = 0; i < 128; i++) {
128         ungroup_3_in_7_bits_tab[i][0] =  i / 25;
129         ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5;
130         ungroup_3_in_7_bits_tab[i][2] = (i % 25) % 5;
131     }
132
133     /* generate grouped mantissa tables
134        reference: Section 7.3.5 Ungrouping of Mantissas */
135     for (i = 0; i < 32; i++) {
136         /* bap=1 mantissas */
137         b1_mantissas[i][0] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][0], 3);
138         b1_mantissas[i][1] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][1], 3);
139         b1_mantissas[i][2] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][2], 3);
140     }
141     for (i = 0; i < 128; i++) {
142         /* bap=2 mantissas */
143         b2_mantissas[i][0] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][0], 5);
144         b2_mantissas[i][1] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][1], 5);
145         b2_mantissas[i][2] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][2], 5);
146
147         /* bap=4 mantissas */
148         b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
149         b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
150     }
151     /* generate ungrouped mantissa tables
152        reference: Tables 7.21 and 7.23 */
153     for (i = 0; i < 7; i++) {
154         /* bap=3 mantissas */
155         b3_mantissas[i] = symmetric_dequant(i, 7);
156     }
157     for (i = 0; i < 15; i++) {
158         /* bap=5 mantissas */
159         b5_mantissas[i] = symmetric_dequant(i, 15);
160     }
161
162     /* generate dynamic range table
163        reference: Section 7.7.1 Dynamic Range Control */
164     for (i = 0; i < 256; i++) {
165         int v = (i >> 5) - ((i >> 7) << 3) - 5;
166         dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
167     }
168
169     /* generate compr dynamic range table
170        reference: Section 7.7.2 Heavy Compression */
171     for (i = 0; i < 256; i++) {
172         int v = (i >> 4) - ((i >> 7) << 4) - 4;
173         heavy_dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0xF) | 0x10);
174     }
175
176 }
177
178 /**
179  * AVCodec initialization
180  */
181 static av_cold int ac3_decode_init(AVCodecContext *avctx)
182 {
183     AC3DecodeContext *s = avctx->priv_data;
184     int i;
185
186     s->avctx = avctx;
187
188     ff_ac3_common_init();
189     ac3_tables_init();
190     ff_mdct_init(&s->imdct_256, 8, 1, 1.0);
191     ff_mdct_init(&s->imdct_512, 9, 1, 1.0);
192     AC3_RENAME(ff_kbd_window_init)(s->window, 5.0, 256);
193     ff_bswapdsp_init(&s->bdsp);
194
195 #if (USE_FIXED)
196     s->fdsp = avpriv_alloc_fixed_dsp(avctx->flags & AV_CODEC_FLAG_BITEXACT);
197 #else
198     s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
199     ff_fmt_convert_init(&s->fmt_conv, avctx);
200 #endif
201
202     ff_ac3dsp_init(&s->ac3dsp, avctx->flags & AV_CODEC_FLAG_BITEXACT);
203     av_lfg_init(&s->dith_state, 0);
204
205     if (USE_FIXED)
206         avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
207     else
208         avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
209
210     /* allow downmixing to stereo or mono */
211 #if FF_API_REQUEST_CHANNELS
212 FF_DISABLE_DEPRECATION_WARNINGS
213     if (avctx->request_channels == 1)
214         avctx->request_channel_layout = AV_CH_LAYOUT_MONO;
215     else if (avctx->request_channels == 2)
216         avctx->request_channel_layout = AV_CH_LAYOUT_STEREO;
217 FF_ENABLE_DEPRECATION_WARNINGS
218 #endif
219     if (avctx->channels > 1 &&
220         avctx->request_channel_layout == AV_CH_LAYOUT_MONO)
221         avctx->channels = 1;
222     else if (avctx->channels > 2 &&
223              avctx->request_channel_layout == AV_CH_LAYOUT_STEREO)
224         avctx->channels = 2;
225     s->downmixed = 1;
226
227     for (i = 0; i < AC3_MAX_CHANNELS; i++) {
228         s->xcfptr[i] = s->transform_coeffs[i];
229         s->dlyptr[i] = s->delay[i];
230     }
231
232     return 0;
233 }
234
235 /**
236  * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
237  * GetBitContext within AC3DecodeContext must point to
238  * the start of the synchronized AC-3 bitstream.
239  */
240 static int ac3_parse_header(AC3DecodeContext *s)
241 {
242     GetBitContext *gbc = &s->gbc;
243     int i;
244
245     /* read the rest of the bsi. read twice for dual mono mode. */
246     i = !s->channel_mode;
247     do {
248         s->dialog_normalization[(!s->channel_mode)-i] = -get_bits(gbc, 5);
249         if (s->dialog_normalization[(!s->channel_mode)-i] == 0) {
250             s->dialog_normalization[(!s->channel_mode)-i] = -31;
251         }
252         if (s->target_level != 0) {
253             s->level_gain[(!s->channel_mode)-i] = powf(2.0f,
254                 (float)(s->target_level -
255                 s->dialog_normalization[(!s->channel_mode)-i])/6.0f);
256         }
257         if (s->compression_exists[(!s->channel_mode)-i] = get_bits1(gbc)) {
258             s->heavy_dynamic_range[(!s->channel_mode)-i] =
259                 AC3_HEAVY_RANGE(get_bits(gbc, 8));
260         }
261         if (get_bits1(gbc))
262             skip_bits(gbc, 8); //skip language code
263         if (get_bits1(gbc))
264             skip_bits(gbc, 7); //skip audio production information
265     } while (i--);
266
267     skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
268
269     /* skip the timecodes or parse the Alternate Bit Stream Syntax */
270     if (s->bitstream_id != 6) {
271         if (get_bits1(gbc))
272             skip_bits(gbc, 14); //skip timecode1
273         if (get_bits1(gbc))
274             skip_bits(gbc, 14); //skip timecode2
275     } else {
276         if (get_bits1(gbc)) {
277             s->preferred_downmix       = get_bits(gbc, 2);
278             s->center_mix_level_ltrt   = get_bits(gbc, 3);
279             s->surround_mix_level_ltrt = av_clip(get_bits(gbc, 3), 3, 7);
280             s->center_mix_level        = get_bits(gbc, 3);
281             s->surround_mix_level      = av_clip(get_bits(gbc, 3), 3, 7);
282         }
283         if (get_bits1(gbc)) {
284             s->dolby_surround_ex_mode = get_bits(gbc, 2);
285             s->dolby_headphone_mode   = get_bits(gbc, 2);
286             skip_bits(gbc, 10); // skip adconvtyp (1), xbsi2 (8), encinfo (1)
287         }
288     }
289
290     /* skip additional bitstream info */
291     if (get_bits1(gbc)) {
292         i = get_bits(gbc, 6);
293         do {
294             skip_bits(gbc, 8);
295         } while (i--);
296     }
297
298     return 0;
299 }
300
301 /**
302  * Common function to parse AC-3 or E-AC-3 frame header
303  */
304 static int parse_frame_header(AC3DecodeContext *s)
305 {
306     AC3HeaderInfo hdr, *phdr=&hdr;
307     int err;
308
309     err = avpriv_ac3_parse_header2(&s->gbc, &phdr);
310     if (err)
311         return err;
312
313     /* get decoding parameters from header info */
314     s->bit_alloc_params.sr_code     = hdr.sr_code;
315     s->bitstream_id                 = hdr.bitstream_id;
316     s->bitstream_mode               = hdr.bitstream_mode;
317     s->channel_mode                 = hdr.channel_mode;
318     s->lfe_on                       = hdr.lfe_on;
319     s->bit_alloc_params.sr_shift    = hdr.sr_shift;
320     s->sample_rate                  = hdr.sample_rate;
321     s->bit_rate                     = hdr.bit_rate;
322     s->channels                     = hdr.channels;
323     s->fbw_channels                 = s->channels - s->lfe_on;
324     s->lfe_ch                       = s->fbw_channels + 1;
325     s->frame_size                   = hdr.frame_size;
326     s->preferred_downmix            = AC3_DMIXMOD_NOTINDICATED;
327     s->center_mix_level             = hdr.center_mix_level;
328     s->center_mix_level_ltrt        = 4; // -3.0dB
329     s->surround_mix_level           = hdr.surround_mix_level;
330     s->surround_mix_level_ltrt      = 4; // -3.0dB
331     s->lfe_mix_level_exists         = 0;
332     s->num_blocks                   = hdr.num_blocks;
333     s->frame_type                   = hdr.frame_type;
334     s->substreamid                  = hdr.substreamid;
335     s->dolby_surround_mode          = hdr.dolby_surround_mode;
336     s->dolby_surround_ex_mode       = AC3_DSUREXMOD_NOTINDICATED;
337     s->dolby_headphone_mode         = AC3_DHEADPHONMOD_NOTINDICATED;
338
339     if (s->lfe_on) {
340         s->start_freq[s->lfe_ch]     = 0;
341         s->end_freq[s->lfe_ch]       = 7;
342         s->num_exp_groups[s->lfe_ch] = 2;
343         s->channel_in_cpl[s->lfe_ch] = 0;
344     }
345
346     if (s->bitstream_id <= 10) {
347         s->eac3                  = 0;
348         s->snr_offset_strategy   = 2;
349         s->block_switch_syntax   = 1;
350         s->dither_flag_syntax    = 1;
351         s->bit_allocation_syntax = 1;
352         s->fast_gain_syntax      = 0;
353         s->first_cpl_leak        = 0;
354         s->dba_syntax            = 1;
355         s->skip_syntax           = 1;
356         memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
357         return ac3_parse_header(s);
358     } else if (CONFIG_EAC3_DECODER) {
359         s->eac3 = 1;
360         return ff_eac3_parse_header(s);
361     } else {
362         av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n");
363         return AVERROR(ENOSYS);
364     }
365 }
366
367 /**
368  * Set stereo downmixing coefficients based on frame header info.
369  * reference: Section 7.8.2 Downmixing Into Two Channels
370  */
371 static void set_downmix_coeffs(AC3DecodeContext *s)
372 {
373     int i;
374     float cmix = gain_levels[s->  center_mix_level];
375     float smix = gain_levels[s->surround_mix_level];
376     float norm0, norm1;
377     float downmix_coeffs[AC3_MAX_CHANNELS][2];
378
379     for (i = 0; i < s->fbw_channels; i++) {
380         downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
381         downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
382     }
383     if (s->channel_mode > 1 && s->channel_mode & 1) {
384         downmix_coeffs[1][0] = downmix_coeffs[1][1] = cmix;
385     }
386     if (s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
387         int nf = s->channel_mode - 2;
388         downmix_coeffs[nf][0] = downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
389     }
390     if (s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
391         int nf = s->channel_mode - 4;
392         downmix_coeffs[nf][0] = downmix_coeffs[nf+1][1] = smix;
393     }
394
395     /* renormalize */
396     norm0 = norm1 = 0.0;
397     for (i = 0; i < s->fbw_channels; i++) {
398         norm0 += downmix_coeffs[i][0];
399         norm1 += downmix_coeffs[i][1];
400     }
401     norm0 = 1.0f / norm0;
402     norm1 = 1.0f / norm1;
403     for (i = 0; i < s->fbw_channels; i++) {
404         downmix_coeffs[i][0] *= norm0;
405         downmix_coeffs[i][1] *= norm1;
406     }
407
408     if (s->output_mode == AC3_CHMODE_MONO) {
409         for (i = 0; i < s->fbw_channels; i++)
410             downmix_coeffs[i][0] = (downmix_coeffs[i][0] +
411                                     downmix_coeffs[i][1]) * LEVEL_MINUS_3DB;
412     }
413     for (i = 0; i < s->fbw_channels; i++) {
414         s->downmix_coeffs[i][0] = FIXR12(downmix_coeffs[i][0]);
415         s->downmix_coeffs[i][1] = FIXR12(downmix_coeffs[i][1]);
416     }
417 }
418
419 /**
420  * Decode the grouped exponents according to exponent strategy.
421  * reference: Section 7.1.3 Exponent Decoding
422  */
423 static int decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
424                             uint8_t absexp, int8_t *dexps)
425 {
426     int i, j, grp, group_size;
427     int dexp[256];
428     int expacc, prevexp;
429
430     /* unpack groups */
431     group_size = exp_strategy + (exp_strategy == EXP_D45);
432     for (grp = 0, i = 0; grp < ngrps; grp++) {
433         expacc = get_bits(gbc, 7);
434         dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
435         dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
436         dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
437     }
438
439     /* convert to absolute exps and expand groups */
440     prevexp = absexp;
441     for (i = 0, j = 0; i < ngrps * 3; i++) {
442         prevexp += dexp[i] - 2;
443         if (prevexp > 24U)
444             return -1;
445         switch (group_size) {
446         case 4: dexps[j++] = prevexp;
447                 dexps[j++] = prevexp;
448         case 2: dexps[j++] = prevexp;
449         case 1: dexps[j++] = prevexp;
450         }
451     }
452     return 0;
453 }
454
455 /**
456  * Generate transform coefficients for each coupled channel in the coupling
457  * range using the coupling coefficients and coupling coordinates.
458  * reference: Section 7.4.3 Coupling Coordinate Format
459  */
460 static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
461 {
462     int bin, band, ch;
463
464     bin = s->start_freq[CPL_CH];
465     for (band = 0; band < s->num_cpl_bands; band++) {
466         int band_start = bin;
467         int band_end = bin + s->cpl_band_sizes[band];
468         for (ch = 1; ch <= s->fbw_channels; ch++) {
469             if (s->channel_in_cpl[ch]) {
470                 int cpl_coord = s->cpl_coords[ch][band] << 5;
471                 for (bin = band_start; bin < band_end; bin++) {
472                     s->fixed_coeffs[ch][bin] =
473                         MULH(s->fixed_coeffs[CPL_CH][bin] * (1 << 4), cpl_coord);
474                 }
475                 if (ch == 2 && s->phase_flags[band]) {
476                     for (bin = band_start; bin < band_end; bin++)
477                         s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin];
478                 }
479             }
480         }
481         bin = band_end;
482     }
483 }
484
485 /**
486  * Grouped mantissas for 3-level 5-level and 11-level quantization
487  */
488 typedef struct mant_groups {
489     int b1_mant[2];
490     int b2_mant[2];
491     int b4_mant;
492     int b1;
493     int b2;
494     int b4;
495 } mant_groups;
496
497 /**
498  * Decode the transform coefficients for a particular channel
499  * reference: Section 7.3 Quantization and Decoding of Mantissas
500  */
501 static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
502 {
503     int start_freq = s->start_freq[ch_index];
504     int end_freq   = s->end_freq[ch_index];
505     uint8_t *baps  = s->bap[ch_index];
506     int8_t *exps   = s->dexps[ch_index];
507     int32_t *coeffs = s->fixed_coeffs[ch_index];
508     int dither     = (ch_index == CPL_CH) || s->dither_flag[ch_index];
509     GetBitContext *gbc = &s->gbc;
510     int freq;
511
512     for (freq = start_freq; freq < end_freq; freq++) {
513         int bap = baps[freq];
514         int mantissa;
515         switch (bap) {
516         case 0:
517             /* random noise with approximate range of -0.707 to 0.707 */
518             if (dither)
519                 mantissa = (((av_lfg_get(&s->dith_state)>>8)*181)>>8) - 5931008;
520             else
521                 mantissa = 0;
522             break;
523         case 1:
524             if (m->b1) {
525                 m->b1--;
526                 mantissa = m->b1_mant[m->b1];
527             } else {
528                 int bits      = get_bits(gbc, 5);
529                 mantissa      = b1_mantissas[bits][0];
530                 m->b1_mant[1] = b1_mantissas[bits][1];
531                 m->b1_mant[0] = b1_mantissas[bits][2];
532                 m->b1         = 2;
533             }
534             break;
535         case 2:
536             if (m->b2) {
537                 m->b2--;
538                 mantissa = m->b2_mant[m->b2];
539             } else {
540                 int bits      = get_bits(gbc, 7);
541                 mantissa      = b2_mantissas[bits][0];
542                 m->b2_mant[1] = b2_mantissas[bits][1];
543                 m->b2_mant[0] = b2_mantissas[bits][2];
544                 m->b2         = 2;
545             }
546             break;
547         case 3:
548             mantissa = b3_mantissas[get_bits(gbc, 3)];
549             break;
550         case 4:
551             if (m->b4) {
552                 m->b4 = 0;
553                 mantissa = m->b4_mant;
554             } else {
555                 int bits   = get_bits(gbc, 7);
556                 mantissa   = b4_mantissas[bits][0];
557                 m->b4_mant = b4_mantissas[bits][1];
558                 m->b4      = 1;
559             }
560             break;
561         case 5:
562             mantissa = b5_mantissas[get_bits(gbc, 4)];
563             break;
564         default: /* 6 to 15 */
565             /* Shift mantissa and sign-extend it. */
566             if (bap > 15) {
567                 av_log(s->avctx, AV_LOG_ERROR, "bap %d is invalid in plain AC-3\n", bap);
568                 bap = 15;
569             }
570             mantissa = (unsigned)get_sbits(gbc, quantization_tab[bap]) << (24 - quantization_tab[bap]);
571             break;
572         }
573         coeffs[freq] = mantissa >> exps[freq];
574     }
575 }
576
577 /**
578  * Remove random dithering from coupling range coefficients with zero-bit
579  * mantissas for coupled channels which do not use dithering.
580  * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
581  */
582 static void remove_dithering(AC3DecodeContext *s) {
583     int ch, i;
584
585     for (ch = 1; ch <= s->fbw_channels; ch++) {
586         if (!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
587             for (i = s->start_freq[CPL_CH]; i < s->end_freq[CPL_CH]; i++) {
588                 if (!s->bap[CPL_CH][i])
589                     s->fixed_coeffs[ch][i] = 0;
590             }
591         }
592     }
593 }
594
595 static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,
596                                        mant_groups *m)
597 {
598     if (!s->channel_uses_aht[ch]) {
599         ac3_decode_transform_coeffs_ch(s, ch, m);
600     } else {
601         /* if AHT is used, mantissas for all blocks are encoded in the first
602            block of the frame. */
603         int bin;
604         if (CONFIG_EAC3_DECODER && !blk)
605             ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
606         for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
607             s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
608         }
609     }
610 }
611
612 /**
613  * Decode the transform coefficients.
614  */
615 static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
616 {
617     int ch, end;
618     int got_cplchan = 0;
619     mant_groups m;
620
621     m.b1 = m.b2 = m.b4 = 0;
622
623     for (ch = 1; ch <= s->channels; ch++) {
624         /* transform coefficients for full-bandwidth channel */
625         decode_transform_coeffs_ch(s, blk, ch, &m);
626         /* transform coefficients for coupling channel come right after the
627            coefficients for the first coupled channel*/
628         if (s->channel_in_cpl[ch])  {
629             if (!got_cplchan) {
630                 decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
631                 calc_transform_coeffs_cpl(s);
632                 got_cplchan = 1;
633             }
634             end = s->end_freq[CPL_CH];
635         } else {
636             end = s->end_freq[ch];
637         }
638         do
639             s->fixed_coeffs[ch][end] = 0;
640         while (++end < 256);
641     }
642
643     /* zero the dithered coefficients for appropriate channels */
644     remove_dithering(s);
645 }
646
647 /**
648  * Stereo rematrixing.
649  * reference: Section 7.5.4 Rematrixing : Decoding Technique
650  */
651 static void do_rematrixing(AC3DecodeContext *s)
652 {
653     int bnd, i;
654     int end, bndend;
655
656     end = FFMIN(s->end_freq[1], s->end_freq[2]);
657
658     for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) {
659         if (s->rematrixing_flags[bnd]) {
660             bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd + 1]);
661             for (i = ff_ac3_rematrix_band_tab[bnd]; i < bndend; i++) {
662                 int tmp0 = s->fixed_coeffs[1][i];
663                 s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
664                 s->fixed_coeffs[2][i]  = tmp0 - s->fixed_coeffs[2][i];
665             }
666         }
667     }
668 }
669
670 /**
671  * Inverse MDCT Transform.
672  * Convert frequency domain coefficients to time-domain audio samples.
673  * reference: Section 7.9.4 Transformation Equations
674  */
675 static inline void do_imdct(AC3DecodeContext *s, int channels)
676 {
677     int ch;
678
679     for (ch = 1; ch <= channels; ch++) {
680         if (s->block_switch[ch]) {
681             int i;
682             FFTSample *x = s->tmp_output + 128;
683             for (i = 0; i < 128; i++)
684                 x[i] = s->transform_coeffs[ch][2 * i];
685             s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
686 #if USE_FIXED
687             s->fdsp->vector_fmul_window_scaled(s->outptr[ch - 1], s->delay[ch - 1],
688                                        s->tmp_output, s->window, 128, 8);
689 #else
690             s->fdsp->vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
691                                        s->tmp_output, s->window, 128);
692 #endif
693             for (i = 0; i < 128; i++)
694                 x[i] = s->transform_coeffs[ch][2 * i + 1];
695             s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch - 1], x);
696         } else {
697             s->imdct_512.imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
698 #if USE_FIXED
699             s->fdsp->vector_fmul_window_scaled(s->outptr[ch - 1], s->delay[ch - 1],
700                                        s->tmp_output, s->window, 128, 8);
701 #else
702             s->fdsp->vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
703                                        s->tmp_output, s->window, 128);
704 #endif
705             memcpy(s->delay[ch - 1], s->tmp_output + 128, 128 * sizeof(FFTSample));
706         }
707     }
708 }
709
710 /**
711  * Upmix delay samples from stereo to original channel layout.
712  */
713 static void ac3_upmix_delay(AC3DecodeContext *s)
714 {
715     int channel_data_size = sizeof(s->delay[0]);
716     switch (s->channel_mode) {
717     case AC3_CHMODE_DUALMONO:
718     case AC3_CHMODE_STEREO:
719         /* upmix mono to stereo */
720         memcpy(s->delay[1], s->delay[0], channel_data_size);
721         break;
722     case AC3_CHMODE_2F2R:
723         memset(s->delay[3], 0, channel_data_size);
724     case AC3_CHMODE_2F1R:
725         memset(s->delay[2], 0, channel_data_size);
726         break;
727     case AC3_CHMODE_3F2R:
728         memset(s->delay[4], 0, channel_data_size);
729     case AC3_CHMODE_3F1R:
730         memset(s->delay[3], 0, channel_data_size);
731     case AC3_CHMODE_3F:
732         memcpy(s->delay[2], s->delay[1], channel_data_size);
733         memset(s->delay[1], 0, channel_data_size);
734         break;
735     }
736 }
737
738 /**
739  * Decode band structure for coupling, spectral extension, or enhanced coupling.
740  * The band structure defines how many subbands are in each band.  For each
741  * subband in the range, 1 means it is combined with the previous band, and 0
742  * means that it starts a new band.
743  *
744  * @param[in] gbc bit reader context
745  * @param[in] blk block number
746  * @param[in] eac3 flag to indicate E-AC-3
747  * @param[in] ecpl flag to indicate enhanced coupling
748  * @param[in] start_subband subband number for start of range
749  * @param[in] end_subband subband number for end of range
750  * @param[in] default_band_struct default band structure table
751  * @param[out] num_bands number of bands (optionally NULL)
752  * @param[out] band_sizes array containing the number of bins in each band (optionally NULL)
753  */
754 static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
755                                   int ecpl, int start_subband, int end_subband,
756                                   const uint8_t *default_band_struct,
757                                   int *num_bands, uint8_t *band_sizes)
758 {
759     int subbnd, bnd, n_subbands, n_bands=0;
760     uint8_t bnd_sz[22];
761     uint8_t coded_band_struct[22];
762     const uint8_t *band_struct;
763
764     n_subbands = end_subband - start_subband;
765
766     /* decode band structure from bitstream or use default */
767     if (!eac3 || get_bits1(gbc)) {
768         for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
769             coded_band_struct[subbnd] = get_bits1(gbc);
770         }
771         band_struct = coded_band_struct;
772     } else if (!blk) {
773         band_struct = &default_band_struct[start_subband+1];
774     } else {
775         /* no change in band structure */
776         return;
777     }
778
779     /* calculate number of bands and band sizes based on band structure.
780        note that the first 4 subbands in enhanced coupling span only 6 bins
781        instead of 12. */
782     if (num_bands || band_sizes ) {
783         n_bands = n_subbands;
784         bnd_sz[0] = ecpl ? 6 : 12;
785         for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
786             int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
787             if (band_struct[subbnd - 1]) {
788                 n_bands--;
789                 bnd_sz[bnd] += subbnd_size;
790             } else {
791                 bnd_sz[++bnd] = subbnd_size;
792             }
793         }
794     }
795
796     /* set optional output params */
797     if (num_bands)
798         *num_bands = n_bands;
799     if (band_sizes)
800         memcpy(band_sizes, bnd_sz, n_bands);
801 }
802
803 /**
804  * Decode a single audio block from the AC-3 bitstream.
805  */
806 static int decode_audio_block(AC3DecodeContext *s, int blk)
807 {
808     int fbw_channels = s->fbw_channels;
809     int channel_mode = s->channel_mode;
810     int i, bnd, seg, ch;
811     int different_transforms;
812     int downmix_output;
813     int cpl_in_use;
814     GetBitContext *gbc = &s->gbc;
815     uint8_t bit_alloc_stages[AC3_MAX_CHANNELS] = { 0 };
816
817     /* block switch flags */
818     different_transforms = 0;
819     if (s->block_switch_syntax) {
820         for (ch = 1; ch <= fbw_channels; ch++) {
821             s->block_switch[ch] = get_bits1(gbc);
822             if (ch > 1 && s->block_switch[ch] != s->block_switch[1])
823                 different_transforms = 1;
824         }
825     }
826
827     /* dithering flags */
828     if (s->dither_flag_syntax) {
829         for (ch = 1; ch <= fbw_channels; ch++) {
830             s->dither_flag[ch] = get_bits1(gbc);
831         }
832     }
833
834     /* dynamic range */
835     i = !s->channel_mode;
836     do {
837         if (get_bits1(gbc)) {
838             /* Allow asymmetric application of DRC when drc_scale > 1.
839                Amplification of quiet sounds is enhanced */
840             int range_bits = get_bits(gbc, 8);
841             INTFLOAT range = AC3_RANGE(range_bits);
842             if (range_bits <= 127 || s->drc_scale <= 1.0)
843                 s->dynamic_range[i] = AC3_DYNAMIC_RANGE(range);
844             else
845                 s->dynamic_range[i] = range;
846         } else if (blk == 0) {
847             s->dynamic_range[i] = AC3_DYNAMIC_RANGE1;
848         }
849     } while (i--);
850
851     /* spectral extension strategy */
852     if (s->eac3 && (!blk || get_bits1(gbc))) {
853         s->spx_in_use = get_bits1(gbc);
854         if (s->spx_in_use) {
855             int dst_start_freq, dst_end_freq, src_start_freq,
856                 start_subband, end_subband;
857
858             /* determine which channels use spx */
859             if (s->channel_mode == AC3_CHMODE_MONO) {
860                 s->channel_uses_spx[1] = 1;
861             } else {
862                 for (ch = 1; ch <= fbw_channels; ch++)
863                     s->channel_uses_spx[ch] = get_bits1(gbc);
864             }
865
866             /* get the frequency bins of the spx copy region and the spx start
867                and end subbands */
868             dst_start_freq = get_bits(gbc, 2);
869             start_subband  = get_bits(gbc, 3) + 2;
870             if (start_subband > 7)
871                 start_subband += start_subband - 7;
872             end_subband    = get_bits(gbc, 3) + 5;
873 #if USE_FIXED
874             s->spx_dst_end_freq = end_freq_inv_tab[end_subband-5];
875 #endif
876             if (end_subband   > 7)
877                 end_subband   += end_subband   - 7;
878             dst_start_freq = dst_start_freq * 12 + 25;
879             src_start_freq = start_subband  * 12 + 25;
880             dst_end_freq   = end_subband    * 12 + 25;
881
882             /* check validity of spx ranges */
883             if (start_subband >= end_subband) {
884                 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
885                        "range (%d >= %d)\n", start_subband, end_subband);
886                 return AVERROR_INVALIDDATA;
887             }
888             if (dst_start_freq >= src_start_freq) {
889                 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
890                        "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
891                 return AVERROR_INVALIDDATA;
892             }
893
894             s->spx_dst_start_freq = dst_start_freq;
895             s->spx_src_start_freq = src_start_freq;
896             if (!USE_FIXED)
897                 s->spx_dst_end_freq   = dst_end_freq;
898
899             decode_band_structure(gbc, blk, s->eac3, 0,
900                                   start_subband, end_subband,
901                                   ff_eac3_default_spx_band_struct,
902                                   &s->num_spx_bands,
903                                   s->spx_band_sizes);
904         } else {
905             for (ch = 1; ch <= fbw_channels; ch++) {
906                 s->channel_uses_spx[ch] = 0;
907                 s->first_spx_coords[ch] = 1;
908             }
909         }
910     }
911
912     /* spectral extension coordinates */
913     if (s->spx_in_use) {
914         for (ch = 1; ch <= fbw_channels; ch++) {
915             if (s->channel_uses_spx[ch]) {
916                 if (s->first_spx_coords[ch] || get_bits1(gbc)) {
917                     INTFLOAT spx_blend;
918                     int bin, master_spx_coord;
919
920                     s->first_spx_coords[ch] = 0;
921                     spx_blend = AC3_SPX_BLEND(get_bits(gbc, 5));
922                     master_spx_coord = get_bits(gbc, 2) * 3;
923
924                     bin = s->spx_src_start_freq;
925                     for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
926                         int bandsize = s->spx_band_sizes[bnd];
927                         int spx_coord_exp, spx_coord_mant;
928                         INTFLOAT nratio, sblend, nblend;
929 #if USE_FIXED
930                         /* calculate blending factors */
931                         int64_t accu = ((bin << 23) + (bandsize << 22))
932                                      * (int64_t)s->spx_dst_end_freq;
933                         nratio = (int)(accu >> 32);
934                         nratio -= spx_blend << 18;
935
936                         if (nratio < 0) {
937                             nblend = 0;
938                             sblend = 0x800000;
939                         } else if (nratio > 0x7fffff) {
940                             nblend = 14529495; // sqrt(3) in FP.23
941                             sblend = 0;
942                         } else {
943                             nblend = fixed_sqrt(nratio, 23);
944                             accu = (int64_t)nblend * 1859775393;
945                             nblend = (int)((accu + (1<<29)) >> 30);
946                             sblend = fixed_sqrt(0x800000 - nratio, 23);
947                         }
948 #else
949                         float spx_coord;
950
951                         /* calculate blending factors */
952                         nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
953                         nratio = av_clipf(nratio, 0.0f, 1.0f);
954                         nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
955                                                        // to give unity variance
956                         sblend = sqrtf(1.0f - nratio);
957 #endif
958                         bin += bandsize;
959
960                         /* decode spx coordinates */
961                         spx_coord_exp  = get_bits(gbc, 4);
962                         spx_coord_mant = get_bits(gbc, 2);
963                         if (spx_coord_exp == 15) spx_coord_mant <<= 1;
964                         else                     spx_coord_mant += 4;
965                         spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
966
967                         /* multiply noise and signal blending factors by spx coordinate */
968 #if USE_FIXED
969                         accu = (int64_t)nblend * spx_coord_mant;
970                         s->spx_noise_blend[ch][bnd]  = (int)((accu + (1<<22)) >> 23);
971                         accu = (int64_t)sblend * spx_coord_mant;
972                         s->spx_signal_blend[ch][bnd] = (int)((accu + (1<<22)) >> 23);
973 #else
974                         spx_coord = spx_coord_mant * (1.0f / (1 << 23));
975                         s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
976                         s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
977 #endif
978                     }
979                 }
980             } else {
981                 s->first_spx_coords[ch] = 1;
982             }
983         }
984     }
985
986     /* coupling strategy */
987     if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
988         memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
989         if (!s->eac3)
990             s->cpl_in_use[blk] = get_bits1(gbc);
991         if (s->cpl_in_use[blk]) {
992             /* coupling in use */
993             int cpl_start_subband, cpl_end_subband;
994
995             if (channel_mode < AC3_CHMODE_STEREO) {
996                 av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
997                 return AVERROR_INVALIDDATA;
998             }
999
1000             /* check for enhanced coupling */
1001             if (s->eac3 && get_bits1(gbc)) {
1002                 /* TODO: parse enhanced coupling strategy info */
1003                 avpriv_request_sample(s->avctx, "Enhanced coupling");
1004                 return AVERROR_PATCHWELCOME;
1005             }
1006
1007             /* determine which channels are coupled */
1008             if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
1009                 s->channel_in_cpl[1] = 1;
1010                 s->channel_in_cpl[2] = 1;
1011             } else {
1012                 for (ch = 1; ch <= fbw_channels; ch++)
1013                     s->channel_in_cpl[ch] = get_bits1(gbc);
1014             }
1015
1016             /* phase flags in use */
1017             if (channel_mode == AC3_CHMODE_STEREO)
1018                 s->phase_flags_in_use = get_bits1(gbc);
1019
1020             /* coupling frequency range */
1021             cpl_start_subband = get_bits(gbc, 4);
1022             cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
1023                                               get_bits(gbc, 4) + 3;
1024             if (cpl_start_subband >= cpl_end_subband) {
1025                 av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
1026                        cpl_start_subband, cpl_end_subband);
1027                 return AVERROR_INVALIDDATA;
1028             }
1029             s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
1030             s->end_freq[CPL_CH]   = cpl_end_subband   * 12 + 37;
1031
1032             decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
1033                                   cpl_end_subband,
1034                                   ff_eac3_default_cpl_band_struct,
1035                                   &s->num_cpl_bands, s->cpl_band_sizes);
1036         } else {
1037             /* coupling not in use */
1038             for (ch = 1; ch <= fbw_channels; ch++) {
1039                 s->channel_in_cpl[ch] = 0;
1040                 s->first_cpl_coords[ch] = 1;
1041             }
1042             s->first_cpl_leak = s->eac3;
1043             s->phase_flags_in_use = 0;
1044         }
1045     } else if (!s->eac3) {
1046         if (!blk) {
1047             av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "
1048                    "be present in block 0\n");
1049             return AVERROR_INVALIDDATA;
1050         } else {
1051             s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
1052         }
1053     }
1054     cpl_in_use = s->cpl_in_use[blk];
1055
1056     /* coupling coordinates */
1057     if (cpl_in_use) {
1058         int cpl_coords_exist = 0;
1059
1060         for (ch = 1; ch <= fbw_channels; ch++) {
1061             if (s->channel_in_cpl[ch]) {
1062                 if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
1063                     int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
1064                     s->first_cpl_coords[ch] = 0;
1065                     cpl_coords_exist = 1;
1066                     master_cpl_coord = 3 * get_bits(gbc, 2);
1067                     for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1068                         cpl_coord_exp = get_bits(gbc, 4);
1069                         cpl_coord_mant = get_bits(gbc, 4);
1070                         if (cpl_coord_exp == 15)
1071                             s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
1072                         else
1073                             s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
1074                         s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
1075                     }
1076                 } else if (!blk) {
1077                     av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
1078                            "be present in block 0\n");
1079                     return AVERROR_INVALIDDATA;
1080                 }
1081             } else {
1082                 /* channel not in coupling */
1083                 s->first_cpl_coords[ch] = 1;
1084             }
1085         }
1086         /* phase flags */
1087         if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
1088             for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1089                 s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
1090             }
1091         }
1092     }
1093
1094     /* stereo rematrixing strategy and band structure */
1095     if (channel_mode == AC3_CHMODE_STEREO) {
1096         if ((s->eac3 && !blk) || get_bits1(gbc)) {
1097             s->num_rematrixing_bands = 4;
1098             if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
1099                 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
1100             } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
1101                 s->num_rematrixing_bands--;
1102             }
1103             for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
1104                 s->rematrixing_flags[bnd] = get_bits1(gbc);
1105         } else if (!blk) {
1106             av_log(s->avctx, AV_LOG_WARNING, "Warning: "
1107                    "new rematrixing strategy not present in block 0\n");
1108             s->num_rematrixing_bands = 0;
1109         }
1110     }
1111
1112     /* exponent strategies for each channel */
1113     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1114         if (!s->eac3)
1115             s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
1116         if (s->exp_strategy[blk][ch] != EXP_REUSE)
1117             bit_alloc_stages[ch] = 3;
1118     }
1119
1120     /* channel bandwidth */
1121     for (ch = 1; ch <= fbw_channels; ch++) {
1122         s->start_freq[ch] = 0;
1123         if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1124             int group_size;
1125             int prev = s->end_freq[ch];
1126             if (s->channel_in_cpl[ch])
1127                 s->end_freq[ch] = s->start_freq[CPL_CH];
1128             else if (s->channel_uses_spx[ch])
1129                 s->end_freq[ch] = s->spx_src_start_freq;
1130             else {
1131                 int bandwidth_code = get_bits(gbc, 6);
1132                 if (bandwidth_code > 60) {
1133                     av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1134                     return AVERROR_INVALIDDATA;
1135                 }
1136                 s->end_freq[ch] = bandwidth_code * 3 + 73;
1137             }
1138             group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1139             s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
1140             if (blk > 0 && s->end_freq[ch] != prev)
1141                 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1142         }
1143     }
1144     if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1145         s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
1146                                     (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1147     }
1148
1149     /* decode exponents for each channel */
1150     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1151         if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1152             s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1153             if (decode_exponents(gbc, s->exp_strategy[blk][ch],
1154                                  s->num_exp_groups[ch], s->dexps[ch][0],
1155                                  &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1156                 av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
1157                 return AVERROR_INVALIDDATA;
1158             }
1159             if (ch != CPL_CH && ch != s->lfe_ch)
1160                 skip_bits(gbc, 2); /* skip gainrng */
1161         }
1162     }
1163
1164     /* bit allocation information */
1165     if (s->bit_allocation_syntax) {
1166         if (get_bits1(gbc)) {
1167             s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1168             s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1169             s->bit_alloc_params.slow_gain  = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
1170             s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
1171             s->bit_alloc_params.floor  = ff_ac3_floor_tab[get_bits(gbc, 3)];
1172             for (ch = !cpl_in_use; ch <= s->channels; ch++)
1173                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1174         } else if (!blk) {
1175             av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must "
1176                    "be present in block 0\n");
1177             return AVERROR_INVALIDDATA;
1178         }
1179     }
1180
1181     /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1182     if (!s->eac3 || !blk) {
1183         if (s->snr_offset_strategy && get_bits1(gbc)) {
1184             int snr = 0;
1185             int csnr;
1186             csnr = (get_bits(gbc, 6) - 15) << 4;
1187             for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1188                 /* snr offset */
1189                 if (ch == i || s->snr_offset_strategy == 2)
1190                     snr = (csnr + get_bits(gbc, 4)) << 2;
1191                 /* run at least last bit allocation stage if snr offset changes */
1192                 if (blk && s->snr_offset[ch] != snr) {
1193                     bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1194                 }
1195                 s->snr_offset[ch] = snr;
1196
1197                 /* fast gain (normal AC-3 only) */
1198                 if (!s->eac3) {
1199                     int prev = s->fast_gain[ch];
1200                     s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1201                     /* run last 2 bit allocation stages if fast gain changes */
1202                     if (blk && prev != s->fast_gain[ch])
1203                         bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1204                 }
1205             }
1206         } else if (!s->eac3 && !blk) {
1207             av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1208             return AVERROR_INVALIDDATA;
1209         }
1210     }
1211
1212     /* fast gain (E-AC-3 only) */
1213     if (s->fast_gain_syntax && get_bits1(gbc)) {
1214         for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1215             int prev = s->fast_gain[ch];
1216             s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1217             /* run last 2 bit allocation stages if fast gain changes */
1218             if (blk && prev != s->fast_gain[ch])
1219                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1220         }
1221     } else if (s->eac3 && !blk) {
1222         for (ch = !cpl_in_use; ch <= s->channels; ch++)
1223             s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1224     }
1225
1226     /* E-AC-3 to AC-3 converter SNR offset */
1227     if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1228         skip_bits(gbc, 10); // skip converter snr offset
1229     }
1230
1231     /* coupling leak information */
1232     if (cpl_in_use) {
1233         if (s->first_cpl_leak || get_bits1(gbc)) {
1234             int fl = get_bits(gbc, 3);
1235             int sl = get_bits(gbc, 3);
1236             /* run last 2 bit allocation stages for coupling channel if
1237                coupling leak changes */
1238             if (blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1239                 sl != s->bit_alloc_params.cpl_slow_leak)) {
1240                 bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1241             }
1242             s->bit_alloc_params.cpl_fast_leak = fl;
1243             s->bit_alloc_params.cpl_slow_leak = sl;
1244         } else if (!s->eac3 && !blk) {
1245             av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must "
1246                    "be present in block 0\n");
1247             return AVERROR_INVALIDDATA;
1248         }
1249         s->first_cpl_leak = 0;
1250     }
1251
1252     /* delta bit allocation information */
1253     if (s->dba_syntax && get_bits1(gbc)) {
1254         /* delta bit allocation exists (strategy) */
1255         for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1256             s->dba_mode[ch] = get_bits(gbc, 2);
1257             if (s->dba_mode[ch] == DBA_RESERVED) {
1258                 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1259                 return AVERROR_INVALIDDATA;
1260             }
1261             bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1262         }
1263         /* channel delta offset, len and bit allocation */
1264         for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1265             if (s->dba_mode[ch] == DBA_NEW) {
1266                 s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;
1267                 for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
1268                     s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1269                     s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1270                     s->dba_values[ch][seg]  = get_bits(gbc, 3);
1271                 }
1272                 /* run last 2 bit allocation stages if new dba values */
1273                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1274             }
1275         }
1276     } else if (blk == 0) {
1277         for (ch = 0; ch <= s->channels; ch++) {
1278             s->dba_mode[ch] = DBA_NONE;
1279         }
1280     }
1281
1282     /* Bit allocation */
1283     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1284         if (bit_alloc_stages[ch] > 2) {
1285             /* Exponent mapping into PSD and PSD integration */
1286             ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
1287                                       s->start_freq[ch], s->end_freq[ch],
1288                                       s->psd[ch], s->band_psd[ch]);
1289         }
1290         if (bit_alloc_stages[ch] > 1) {
1291             /* Compute excitation function, Compute masking curve, and
1292                Apply delta bit allocation */
1293             if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1294                                            s->start_freq[ch],  s->end_freq[ch],
1295                                            s->fast_gain[ch],   (ch == s->lfe_ch),
1296                                            s->dba_mode[ch],    s->dba_nsegs[ch],
1297                                            s->dba_offsets[ch], s->dba_lengths[ch],
1298                                            s->dba_values[ch],  s->mask[ch])) {
1299                 av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1300                 return AVERROR_INVALIDDATA;
1301             }
1302         }
1303         if (bit_alloc_stages[ch] > 0) {
1304             /* Compute bit allocation */
1305             const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1306                                      ff_eac3_hebap_tab : ff_ac3_bap_tab;
1307             s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1308                                       s->start_freq[ch], s->end_freq[ch],
1309                                       s->snr_offset[ch],
1310                                       s->bit_alloc_params.floor,
1311                                       bap_tab, s->bap[ch]);
1312         }
1313     }
1314
1315     /* unused dummy data */
1316     if (s->skip_syntax && get_bits1(gbc)) {
1317         int skipl = get_bits(gbc, 9);
1318         while (skipl--)
1319             skip_bits(gbc, 8);
1320     }
1321
1322     /* unpack the transform coefficients
1323        this also uncouples channels if coupling is in use. */
1324     decode_transform_coeffs(s, blk);
1325
1326     /* TODO: generate enhanced coupling coordinates and uncouple */
1327
1328     /* recover coefficients if rematrixing is in use */
1329     if (s->channel_mode == AC3_CHMODE_STEREO)
1330         do_rematrixing(s);
1331
1332     /* apply scaling to coefficients (headroom, dynrng) */
1333     for (ch = 1; ch <= s->channels; ch++) {
1334         int audio_channel = 0;
1335         INTFLOAT gain;
1336         if (s->channel_mode == AC3_CHMODE_DUALMONO)
1337             audio_channel = 2-ch;
1338         if (s->heavy_compression && s->compression_exists[audio_channel])
1339             gain = s->heavy_dynamic_range[audio_channel];
1340         else
1341             gain = s->dynamic_range[audio_channel];
1342
1343 #if USE_FIXED
1344         scale_coefs(s->transform_coeffs[ch], s->fixed_coeffs[ch], gain, 256);
1345 #else
1346         if (s->target_level != 0)
1347           gain = gain * s->level_gain[audio_channel];
1348         gain *= 1.0 / 4194304.0f;
1349         s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch],
1350                                                s->fixed_coeffs[ch], gain, 256);
1351 #endif
1352     }
1353
1354     /* apply spectral extension to high frequency bins */
1355     if (CONFIG_EAC3_DECODER && s->spx_in_use) {
1356         ff_eac3_apply_spectral_extension(s);
1357     }
1358
1359     /* downmix and MDCT. order depends on whether block switching is used for
1360        any channel in this block. this is because coefficients for the long
1361        and short transforms cannot be mixed. */
1362     downmix_output = s->channels != s->out_channels &&
1363                      !((s->output_mode & AC3_OUTPUT_LFEON) &&
1364                      s->fbw_channels == s->out_channels);
1365     if (different_transforms) {
1366         /* the delay samples have already been downmixed, so we upmix the delay
1367            samples in order to reconstruct all channels before downmixing. */
1368         if (s->downmixed) {
1369             s->downmixed = 0;
1370             ac3_upmix_delay(s);
1371         }
1372
1373         do_imdct(s, s->channels);
1374
1375         if (downmix_output) {
1376 #if USE_FIXED
1377             ac3_downmix_c_fixed16(s->outptr, s->downmix_coeffs,
1378                               s->out_channels, s->fbw_channels, 256);
1379 #else
1380             s->ac3dsp.downmix(s->outptr, s->downmix_coeffs,
1381                               s->out_channels, s->fbw_channels, 256);
1382 #endif
1383         }
1384     } else {
1385         if (downmix_output) {
1386             s->ac3dsp.AC3_RENAME(downmix)(s->xcfptr + 1, s->downmix_coeffs,
1387                                           s->out_channels, s->fbw_channels, 256);
1388         }
1389
1390         if (downmix_output && !s->downmixed) {
1391             s->downmixed = 1;
1392             s->ac3dsp.AC3_RENAME(downmix)(s->dlyptr, s->downmix_coeffs,
1393                                           s->out_channels, s->fbw_channels, 128);
1394         }
1395
1396         do_imdct(s, s->out_channels);
1397     }
1398
1399     return 0;
1400 }
1401
1402 /**
1403  * Decode a single AC-3 frame.
1404  */
1405 static int ac3_decode_frame(AVCodecContext * avctx, void *data,
1406                             int *got_frame_ptr, AVPacket *avpkt)
1407 {
1408     AVFrame *frame     = data;
1409     const uint8_t *buf = avpkt->data;
1410     int buf_size = avpkt->size;
1411     AC3DecodeContext *s = avctx->priv_data;
1412     int blk, ch, err, ret;
1413     const uint8_t *channel_map;
1414     const SHORTFLOAT *output[AC3_MAX_CHANNELS];
1415     enum AVMatrixEncoding matrix_encoding;
1416     AVDownmixInfo *downmix_info;
1417
1418     /* copy input buffer to decoder context to avoid reading past the end
1419        of the buffer, which can be caused by a damaged input stream. */
1420     if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
1421         // seems to be byte-swapped AC-3
1422         int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1423         s->bdsp.bswap16_buf((uint16_t *) s->input_buffer,
1424                             (const uint16_t *) buf, cnt);
1425     } else
1426         memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1427     buf = s->input_buffer;
1428     /* initialize the GetBitContext with the start of valid AC-3 Frame */
1429     if ((ret = init_get_bits8(&s->gbc, buf, buf_size)) < 0)
1430         return ret;
1431
1432     /* parse the syncinfo */
1433     err = parse_frame_header(s);
1434
1435     if (err) {
1436         switch (err) {
1437         case AAC_AC3_PARSE_ERROR_SYNC:
1438             av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1439             return AVERROR_INVALIDDATA;
1440         case AAC_AC3_PARSE_ERROR_BSID:
1441             av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1442             break;
1443         case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
1444             av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1445             break;
1446         case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
1447             av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1448             break;
1449         case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
1450             /* skip frame if CRC is ok. otherwise use error concealment. */
1451             /* TODO: add support for substreams and dependent frames */
1452             if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
1453                 av_log(avctx, AV_LOG_WARNING, "unsupported frame type : "
1454                        "skipping frame\n");
1455                 *got_frame_ptr = 0;
1456                 return buf_size;
1457             } else {
1458                 av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1459             }
1460             break;
1461         case AAC_AC3_PARSE_ERROR_CRC:
1462         case AAC_AC3_PARSE_ERROR_CHANNEL_CFG:
1463             break;
1464         default: // Normal AVERROR do not try to recover.
1465             *got_frame_ptr = 0;
1466             return err;
1467         }
1468     } else {
1469         /* check that reported frame size fits in input buffer */
1470         if (s->frame_size > buf_size) {
1471             av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1472             err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
1473         } else if (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL)) {
1474             /* check for crc mismatch */
1475             if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
1476                        s->frame_size - 2)) {
1477                 av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1478                 if (avctx->err_recognition & AV_EF_EXPLODE)
1479                     return AVERROR_INVALIDDATA;
1480                 err = AAC_AC3_PARSE_ERROR_CRC;
1481             }
1482         }
1483     }
1484
1485     /* if frame is ok, set audio parameters */
1486     if (!err) {
1487         avctx->sample_rate = s->sample_rate;
1488         avctx->bit_rate    = s->bit_rate;
1489     }
1490
1491     /* channel config */
1492     if (!err || (s->channels && s->out_channels != s->channels)) {
1493         s->out_channels = s->channels;
1494         s->output_mode  = s->channel_mode;
1495         if (s->lfe_on)
1496             s->output_mode |= AC3_OUTPUT_LFEON;
1497         if (s->channels > 1 &&
1498             avctx->request_channel_layout == AV_CH_LAYOUT_MONO) {
1499             s->out_channels = 1;
1500             s->output_mode  = AC3_CHMODE_MONO;
1501         } else if (s->channels > 2 &&
1502                    avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
1503             s->out_channels = 2;
1504             s->output_mode  = AC3_CHMODE_STEREO;
1505         }
1506
1507         s->loro_center_mix_level   = gain_levels[s->  center_mix_level];
1508         s->loro_surround_mix_level = gain_levels[s->surround_mix_level];
1509         s->ltrt_center_mix_level   = LEVEL_MINUS_3DB;
1510         s->ltrt_surround_mix_level = LEVEL_MINUS_3DB;
1511         /* set downmixing coefficients if needed */
1512         if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1513                 s->fbw_channels == s->out_channels)) {
1514             set_downmix_coeffs(s);
1515         }
1516     } else if (!s->channels) {
1517         av_log(avctx, AV_LOG_ERROR, "unable to determine channel mode\n");
1518         return AVERROR_INVALIDDATA;
1519     }
1520     avctx->channels = s->out_channels;
1521     avctx->channel_layout = avpriv_ac3_channel_layout_tab[s->output_mode & ~AC3_OUTPUT_LFEON];
1522     if (s->output_mode & AC3_OUTPUT_LFEON)
1523         avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1524
1525     /* set audio service type based on bitstream mode for AC-3 */
1526     avctx->audio_service_type = s->bitstream_mode;
1527     if (s->bitstream_mode == 0x7 && s->channels > 1)
1528         avctx->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
1529
1530     /* get output buffer */
1531     frame->nb_samples = s->num_blocks * AC3_BLOCK_SIZE;
1532     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1533         return ret;
1534
1535     /* decode the audio blocks */
1536     channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1537     for (ch = 0; ch < AC3_MAX_CHANNELS; ch++) {
1538         output[ch] = s->output[ch];
1539         s->outptr[ch] = s->output[ch];
1540     }
1541     for (ch = 0; ch < s->channels; ch++) {
1542         if (ch < s->out_channels)
1543             s->outptr[channel_map[ch]] = (SHORTFLOAT *)frame->data[ch];
1544     }
1545     for (blk = 0; blk < s->num_blocks; blk++) {
1546         if (!err && decode_audio_block(s, blk)) {
1547             av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1548             err = 1;
1549         }
1550         if (err)
1551             for (ch = 0; ch < s->out_channels; ch++)
1552                 memcpy(((SHORTFLOAT*)frame->data[ch]) + AC3_BLOCK_SIZE*blk, output[ch], AC3_BLOCK_SIZE*sizeof(SHORTFLOAT));
1553         for (ch = 0; ch < s->out_channels; ch++)
1554             output[ch] = s->outptr[channel_map[ch]];
1555         for (ch = 0; ch < s->out_channels; ch++) {
1556             if (!ch || channel_map[ch])
1557                 s->outptr[channel_map[ch]] += AC3_BLOCK_SIZE;
1558         }
1559     }
1560
1561     av_frame_set_decode_error_flags(frame, err ? FF_DECODE_ERROR_INVALID_BITSTREAM : 0);
1562
1563     /* keep last block for error concealment in next frame */
1564     for (ch = 0; ch < s->out_channels; ch++)
1565         memcpy(s->output[ch], output[ch], AC3_BLOCK_SIZE*sizeof(SHORTFLOAT));
1566
1567     /*
1568      * AVMatrixEncoding
1569      *
1570      * Check whether the input layout is compatible, and make sure we're not
1571      * downmixing (else the matrix encoding is no longer applicable).
1572      */
1573     matrix_encoding = AV_MATRIX_ENCODING_NONE;
1574     if (s->channel_mode == AC3_CHMODE_STEREO &&
1575         s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1576         if (s->dolby_surround_mode == AC3_DSURMOD_ON)
1577             matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
1578         else if (s->dolby_headphone_mode == AC3_DHEADPHONMOD_ON)
1579             matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;
1580     } else if (s->channel_mode >= AC3_CHMODE_2F2R &&
1581                s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1582         switch (s->dolby_surround_ex_mode) {
1583         case AC3_DSUREXMOD_ON: // EX or PLIIx
1584             matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
1585             break;
1586         case AC3_DSUREXMOD_PLIIZ:
1587             matrix_encoding = AV_MATRIX_ENCODING_DPLIIZ;
1588             break;
1589         default: // not indicated or off
1590             break;
1591         }
1592     }
1593     if ((ret = ff_side_data_update_matrix_encoding(frame, matrix_encoding)) < 0)
1594         return ret;
1595
1596     /* AVDownmixInfo */
1597     if ((downmix_info = av_downmix_info_update_side_data(frame))) {
1598         switch (s->preferred_downmix) {
1599         case AC3_DMIXMOD_LTRT:
1600             downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_LTRT;
1601             break;
1602         case AC3_DMIXMOD_LORO:
1603             downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_LORO;
1604             break;
1605         case AC3_DMIXMOD_DPLII:
1606             downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_DPLII;
1607             break;
1608         default:
1609             downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_UNKNOWN;
1610             break;
1611         }
1612         downmix_info->center_mix_level        = gain_levels[s->       center_mix_level];
1613         downmix_info->center_mix_level_ltrt   = gain_levels[s->  center_mix_level_ltrt];
1614         downmix_info->surround_mix_level      = gain_levels[s->     surround_mix_level];
1615         downmix_info->surround_mix_level_ltrt = gain_levels[s->surround_mix_level_ltrt];
1616         if (s->lfe_mix_level_exists)
1617             downmix_info->lfe_mix_level       = gain_levels_lfe[s->lfe_mix_level];
1618         else
1619             downmix_info->lfe_mix_level       = 0.0; // -inf dB
1620     } else
1621         return AVERROR(ENOMEM);
1622
1623     *got_frame_ptr = 1;
1624
1625     return FFMIN(buf_size, s->frame_size);
1626 }
1627
1628 /**
1629  * Uninitialize the AC-3 decoder.
1630  */
1631 static av_cold int ac3_decode_end(AVCodecContext *avctx)
1632 {
1633     AC3DecodeContext *s = avctx->priv_data;
1634     ff_mdct_end(&s->imdct_512);
1635     ff_mdct_end(&s->imdct_256);
1636     av_freep(&s->fdsp);
1637
1638     return 0;
1639 }
1640
1641 #define OFFSET(x) offsetof(AC3DecodeContext, x)
1642 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)