avcodec/ac3dec: use init_get_bits8()
[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)) << 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 & CODEC_FLAG_BITEXACT);
197 #else
198     s->fdsp = avpriv_float_dsp_alloc(avctx->flags & CODEC_FLAG_BITEXACT);
199 #endif
200
201     ff_ac3dsp_init(&s->ac3dsp, avctx->flags & CODEC_FLAG_BITEXACT);
202     ff_fmt_convert_init(&s->fmt_conv, avctx);
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] << 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 {
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 = get_sbits(gbc, quantization_tab[bap]);
571             mantissa <<= 24 - quantization_tab[bap];
572             break;
573         }
574         coeffs[freq] = mantissa >> exps[freq];
575     }
576 }
577
578 /**
579  * Remove random dithering from coupling range coefficients with zero-bit
580  * mantissas for coupled channels which do not use dithering.
581  * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
582  */
583 static void remove_dithering(AC3DecodeContext *s) {
584     int ch, i;
585
586     for (ch = 1; ch <= s->fbw_channels; ch++) {
587         if (!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
588             for (i = s->start_freq[CPL_CH]; i < s->end_freq[CPL_CH]; i++) {
589                 if (!s->bap[CPL_CH][i])
590                     s->fixed_coeffs[ch][i] = 0;
591             }
592         }
593     }
594 }
595
596 static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,
597                                        mant_groups *m)
598 {
599     if (!s->channel_uses_aht[ch]) {
600         ac3_decode_transform_coeffs_ch(s, ch, m);
601     } else {
602         /* if AHT is used, mantissas for all blocks are encoded in the first
603            block of the frame. */
604         int bin;
605         if (!blk && CONFIG_EAC3_DECODER)
606             ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
607         for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
608             s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
609         }
610     }
611 }
612
613 /**
614  * Decode the transform coefficients.
615  */
616 static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
617 {
618     int ch, end;
619     int got_cplchan = 0;
620     mant_groups m;
621
622     m.b1 = m.b2 = m.b4 = 0;
623
624     for (ch = 1; ch <= s->channels; ch++) {
625         /* transform coefficients for full-bandwidth channel */
626         decode_transform_coeffs_ch(s, blk, ch, &m);
627         /* transform coefficients for coupling channel come right after the
628            coefficients for the first coupled channel*/
629         if (s->channel_in_cpl[ch])  {
630             if (!got_cplchan) {
631                 decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
632                 calc_transform_coeffs_cpl(s);
633                 got_cplchan = 1;
634             }
635             end = s->end_freq[CPL_CH];
636         } else {
637             end = s->end_freq[ch];
638         }
639         do
640             s->fixed_coeffs[ch][end] = 0;
641         while (++end < 256);
642     }
643
644     /* zero the dithered coefficients for appropriate channels */
645     remove_dithering(s);
646 }
647
648 /**
649  * Stereo rematrixing.
650  * reference: Section 7.5.4 Rematrixing : Decoding Technique
651  */
652 static void do_rematrixing(AC3DecodeContext *s)
653 {
654     int bnd, i;
655     int end, bndend;
656
657     end = FFMIN(s->end_freq[1], s->end_freq[2]);
658
659     for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) {
660         if (s->rematrixing_flags[bnd]) {
661             bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd + 1]);
662             for (i = ff_ac3_rematrix_band_tab[bnd]; i < bndend; i++) {
663                 int tmp0 = s->fixed_coeffs[1][i];
664                 s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
665                 s->fixed_coeffs[2][i]  = tmp0 - s->fixed_coeffs[2][i];
666             }
667         }
668     }
669 }
670
671 /**
672  * Inverse MDCT Transform.
673  * Convert frequency domain coefficients to time-domain audio samples.
674  * reference: Section 7.9.4 Transformation Equations
675  */
676 static inline void do_imdct(AC3DecodeContext *s, int channels)
677 {
678     int ch;
679
680     for (ch = 1; ch <= channels; ch++) {
681         if (s->block_switch[ch]) {
682             int i;
683             FFTSample *x = s->tmp_output + 128;
684             for (i = 0; i < 128; i++)
685                 x[i] = s->transform_coeffs[ch][2 * i];
686             s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
687 #if USE_FIXED
688             s->fdsp->vector_fmul_window_scaled(s->outptr[ch - 1], s->delay[ch - 1],
689                                        s->tmp_output, s->window, 128, 8);
690 #else
691             s->fdsp->vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
692                                        s->tmp_output, s->window, 128);
693 #endif
694             for (i = 0; i < 128; i++)
695                 x[i] = s->transform_coeffs[ch][2 * i + 1];
696             s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch - 1], x);
697         } else {
698             s->imdct_512.imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
699 #if USE_FIXED
700             s->fdsp->vector_fmul_window_scaled(s->outptr[ch - 1], s->delay[ch - 1],
701                                        s->tmp_output, s->window, 128, 8);
702 #else
703             s->fdsp->vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
704                                        s->tmp_output, s->window, 128);
705 #endif
706             memcpy(s->delay[ch - 1], s->tmp_output + 128, 128 * sizeof(FFTSample));
707         }
708     }
709 }
710
711 /**
712  * Upmix delay samples from stereo to original channel layout.
713  */
714 static void ac3_upmix_delay(AC3DecodeContext *s)
715 {
716     int channel_data_size = sizeof(s->delay[0]);
717     switch (s->channel_mode) {
718     case AC3_CHMODE_DUALMONO:
719     case AC3_CHMODE_STEREO:
720         /* upmix mono to stereo */
721         memcpy(s->delay[1], s->delay[0], channel_data_size);
722         break;
723     case AC3_CHMODE_2F2R:
724         memset(s->delay[3], 0, channel_data_size);
725     case AC3_CHMODE_2F1R:
726         memset(s->delay[2], 0, channel_data_size);
727         break;
728     case AC3_CHMODE_3F2R:
729         memset(s->delay[4], 0, channel_data_size);
730     case AC3_CHMODE_3F1R:
731         memset(s->delay[3], 0, channel_data_size);
732     case AC3_CHMODE_3F:
733         memcpy(s->delay[2], s->delay[1], channel_data_size);
734         memset(s->delay[1], 0, channel_data_size);
735         break;
736     }
737 }
738
739 /**
740  * Decode band structure for coupling, spectral extension, or enhanced coupling.
741  * The band structure defines how many subbands are in each band.  For each
742  * subband in the range, 1 means it is combined with the previous band, and 0
743  * means that it starts a new band.
744  *
745  * @param[in] gbc bit reader context
746  * @param[in] blk block number
747  * @param[in] eac3 flag to indicate E-AC-3
748  * @param[in] ecpl flag to indicate enhanced coupling
749  * @param[in] start_subband subband number for start of range
750  * @param[in] end_subband subband number for end of range
751  * @param[in] default_band_struct default band structure table
752  * @param[out] num_bands number of bands (optionally NULL)
753  * @param[out] band_sizes array containing the number of bins in each band (optionally NULL)
754  */
755 static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
756                                   int ecpl, int start_subband, int end_subband,
757                                   const uint8_t *default_band_struct,
758                                   int *num_bands, uint8_t *band_sizes)
759 {
760     int subbnd, bnd, n_subbands, n_bands=0;
761     uint8_t bnd_sz[22];
762     uint8_t coded_band_struct[22];
763     const uint8_t *band_struct;
764
765     n_subbands = end_subband - start_subband;
766
767     /* decode band structure from bitstream or use default */
768     if (!eac3 || get_bits1(gbc)) {
769         for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
770             coded_band_struct[subbnd] = get_bits1(gbc);
771         }
772         band_struct = coded_band_struct;
773     } else if (!blk) {
774         band_struct = &default_band_struct[start_subband+1];
775     } else {
776         /* no change in band structure */
777         return;
778     }
779
780     /* calculate number of bands and band sizes based on band structure.
781        note that the first 4 subbands in enhanced coupling span only 6 bins
782        instead of 12. */
783     if (num_bands || band_sizes ) {
784         n_bands = n_subbands;
785         bnd_sz[0] = ecpl ? 6 : 12;
786         for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
787             int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
788             if (band_struct[subbnd - 1]) {
789                 n_bands--;
790                 bnd_sz[bnd] += subbnd_size;
791             } else {
792                 bnd_sz[++bnd] = subbnd_size;
793             }
794         }
795     }
796
797     /* set optional output params */
798     if (num_bands)
799         *num_bands = n_bands;
800     if (band_sizes)
801         memcpy(band_sizes, bnd_sz, n_bands);
802 }
803
804 /**
805  * Decode a single audio block from the AC-3 bitstream.
806  */
807 static int decode_audio_block(AC3DecodeContext *s, int blk)
808 {
809     int fbw_channels = s->fbw_channels;
810     int channel_mode = s->channel_mode;
811     int i, bnd, seg, ch;
812     int different_transforms;
813     int downmix_output;
814     int cpl_in_use;
815     GetBitContext *gbc = &s->gbc;
816     uint8_t bit_alloc_stages[AC3_MAX_CHANNELS] = { 0 };
817
818     /* block switch flags */
819     different_transforms = 0;
820     if (s->block_switch_syntax) {
821         for (ch = 1; ch <= fbw_channels; ch++) {
822             s->block_switch[ch] = get_bits1(gbc);
823             if (ch > 1 && s->block_switch[ch] != s->block_switch[1])
824                 different_transforms = 1;
825         }
826     }
827
828     /* dithering flags */
829     if (s->dither_flag_syntax) {
830         for (ch = 1; ch <= fbw_channels; ch++) {
831             s->dither_flag[ch] = get_bits1(gbc);
832         }
833     }
834
835     /* dynamic range */
836     i = !s->channel_mode;
837     do {
838         if (get_bits1(gbc)) {
839             /* Allow asymmetric application of DRC when drc_scale > 1.
840                Amplification of quiet sounds is enhanced */
841             int range_bits = get_bits(gbc, 8);
842             INTFLOAT range = AC3_RANGE(range_bits);
843             if (range_bits <= 127 || s->drc_scale <= 1.0)
844                 s->dynamic_range[i] = AC3_DYNAMIC_RANGE(range);
845             else
846                 s->dynamic_range[i] = range;
847         } else if (blk == 0) {
848             s->dynamic_range[i] = AC3_DYNAMIC_RANGE1;
849         }
850     } while (i--);
851
852     /* spectral extension strategy */
853     if (s->eac3 && (!blk || get_bits1(gbc))) {
854         s->spx_in_use = get_bits1(gbc);
855         if (s->spx_in_use) {
856             int dst_start_freq, dst_end_freq, src_start_freq,
857                 start_subband, end_subband;
858
859             /* determine which channels use spx */
860             if (s->channel_mode == AC3_CHMODE_MONO) {
861                 s->channel_uses_spx[1] = 1;
862             } else {
863                 for (ch = 1; ch <= fbw_channels; ch++)
864                     s->channel_uses_spx[ch] = get_bits1(gbc);
865             }
866
867             /* get the frequency bins of the spx copy region and the spx start
868                and end subbands */
869             dst_start_freq = get_bits(gbc, 2);
870             start_subband  = get_bits(gbc, 3) + 2;
871             if (start_subband > 7)
872                 start_subband += start_subband - 7;
873             end_subband    = get_bits(gbc, 3) + 5;
874 #if USE_FIXED
875             s->spx_dst_end_freq = end_freq_inv_tab[end_subband];
876 #endif
877             if (end_subband   > 7)
878                 end_subband   += end_subband   - 7;
879             dst_start_freq = dst_start_freq * 12 + 25;
880             src_start_freq = start_subband  * 12 + 25;
881             dst_end_freq   = end_subband    * 12 + 25;
882
883             /* check validity of spx ranges */
884             if (start_subband >= end_subband) {
885                 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
886                        "range (%d >= %d)\n", start_subband, end_subband);
887                 return AVERROR_INVALIDDATA;
888             }
889             if (dst_start_freq >= src_start_freq) {
890                 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
891                        "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
892                 return AVERROR_INVALIDDATA;
893             }
894
895             s->spx_dst_start_freq = dst_start_freq;
896             s->spx_src_start_freq = src_start_freq;
897             if (!USE_FIXED)
898                 s->spx_dst_end_freq   = dst_end_freq;
899
900             decode_band_structure(gbc, blk, s->eac3, 0,
901                                   start_subband, end_subband,
902                                   ff_eac3_default_spx_band_struct,
903                                   &s->num_spx_bands,
904                                   s->spx_band_sizes);
905         } else {
906             for (ch = 1; ch <= fbw_channels; ch++) {
907                 s->channel_uses_spx[ch] = 0;
908                 s->first_spx_coords[ch] = 1;
909             }
910         }
911     }
912
913     /* spectral extension coordinates */
914     if (s->spx_in_use) {
915         for (ch = 1; ch <= fbw_channels; ch++) {
916             if (s->channel_uses_spx[ch]) {
917                 if (s->first_spx_coords[ch] || get_bits1(gbc)) {
918                     INTFLOAT spx_blend;
919                     int bin, master_spx_coord;
920
921                     s->first_spx_coords[ch] = 0;
922                     spx_blend = AC3_SPX_BLEND(get_bits(gbc, 5));
923                     master_spx_coord = get_bits(gbc, 2) * 3;
924
925                     bin = s->spx_src_start_freq;
926                     for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
927                         int bandsize;
928                         int spx_coord_exp, spx_coord_mant;
929                         INTFLOAT nratio, sblend, nblend;
930 #if USE_FIXED
931                         int64_t accu;
932                         /* calculate blending factors */
933                         bandsize = s->spx_band_sizes[bnd];
934                         accu = (int64_t)((bin << 23) + (bandsize << 22)) * s->spx_dst_end_freq;
935                         nratio = (int)(accu >> 32);
936                         nratio -= spx_blend << 18;
937
938                         if (nratio < 0) {
939                             nblend = 0;
940                             sblend = 0x800000;
941                         } else if (nratio > 0x7fffff) {
942                             nblend = 0x800000;
943                             sblend = 0;
944                         } else {
945                             nblend = fixed_sqrt(nratio, 23);
946                             accu = (int64_t)nblend * 1859775393;
947                             nblend = (int)((accu + (1<<29)) >> 30);
948                             sblend = fixed_sqrt(0x800000 - nratio, 23);
949                         }
950 #else
951                         float spx_coord;
952
953                         /* calculate blending factors */
954                         bandsize = s->spx_band_sizes[bnd];
955                         nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
956                         nratio = av_clipf(nratio, 0.0f, 1.0f);
957                         nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
958                                                        // to give unity variance
959                         sblend = sqrtf(1.0f - nratio);
960 #endif
961                         bin += bandsize;
962
963                         /* decode spx coordinates */
964                         spx_coord_exp  = get_bits(gbc, 4);
965                         spx_coord_mant = get_bits(gbc, 2);
966                         if (spx_coord_exp == 15) spx_coord_mant <<= 1;
967                         else                     spx_coord_mant += 4;
968                         spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
969
970                         /* multiply noise and signal blending factors by spx coordinate */
971 #if USE_FIXED
972                         accu = (int64_t)nblend * spx_coord_mant;
973                         s->spx_noise_blend[ch][bnd]  = (int)((accu + (1<<22)) >> 23);
974                         accu = (int64_t)sblend * spx_coord_mant;
975                         s->spx_signal_blend[ch][bnd] = (int)((accu + (1<<22)) >> 23);
976 #else
977                         spx_coord = spx_coord_mant * (1.0f / (1 << 23));
978                         s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
979                         s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
980 #endif
981                     }
982                 }
983             } else {
984                 s->first_spx_coords[ch] = 1;
985             }
986         }
987     }
988
989     /* coupling strategy */
990     if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
991         memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
992         if (!s->eac3)
993             s->cpl_in_use[blk] = get_bits1(gbc);
994         if (s->cpl_in_use[blk]) {
995             /* coupling in use */
996             int cpl_start_subband, cpl_end_subband;
997
998             if (channel_mode < AC3_CHMODE_STEREO) {
999                 av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
1000                 return AVERROR_INVALIDDATA;
1001             }
1002
1003             /* check for enhanced coupling */
1004             if (s->eac3 && get_bits1(gbc)) {
1005                 /* TODO: parse enhanced coupling strategy info */
1006                 avpriv_request_sample(s->avctx, "Enhanced coupling");
1007                 return AVERROR_PATCHWELCOME;
1008             }
1009
1010             /* determine which channels are coupled */
1011             if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
1012                 s->channel_in_cpl[1] = 1;
1013                 s->channel_in_cpl[2] = 1;
1014             } else {
1015                 for (ch = 1; ch <= fbw_channels; ch++)
1016                     s->channel_in_cpl[ch] = get_bits1(gbc);
1017             }
1018
1019             /* phase flags in use */
1020             if (channel_mode == AC3_CHMODE_STEREO)
1021                 s->phase_flags_in_use = get_bits1(gbc);
1022
1023             /* coupling frequency range */
1024             cpl_start_subband = get_bits(gbc, 4);
1025             cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
1026                                               get_bits(gbc, 4) + 3;
1027             if (cpl_start_subband >= cpl_end_subband) {
1028                 av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
1029                        cpl_start_subband, cpl_end_subband);
1030                 return AVERROR_INVALIDDATA;
1031             }
1032             s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
1033             s->end_freq[CPL_CH]   = cpl_end_subband   * 12 + 37;
1034
1035             decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
1036                                   cpl_end_subband,
1037                                   ff_eac3_default_cpl_band_struct,
1038                                   &s->num_cpl_bands, s->cpl_band_sizes);
1039         } else {
1040             /* coupling not in use */
1041             for (ch = 1; ch <= fbw_channels; ch++) {
1042                 s->channel_in_cpl[ch] = 0;
1043                 s->first_cpl_coords[ch] = 1;
1044             }
1045             s->first_cpl_leak = s->eac3;
1046             s->phase_flags_in_use = 0;
1047         }
1048     } else if (!s->eac3) {
1049         if (!blk) {
1050             av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "
1051                    "be present in block 0\n");
1052             return AVERROR_INVALIDDATA;
1053         } else {
1054             s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
1055         }
1056     }
1057     cpl_in_use = s->cpl_in_use[blk];
1058
1059     /* coupling coordinates */
1060     if (cpl_in_use) {
1061         int cpl_coords_exist = 0;
1062
1063         for (ch = 1; ch <= fbw_channels; ch++) {
1064             if (s->channel_in_cpl[ch]) {
1065                 if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
1066                     int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
1067                     s->first_cpl_coords[ch] = 0;
1068                     cpl_coords_exist = 1;
1069                     master_cpl_coord = 3 * get_bits(gbc, 2);
1070                     for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1071                         cpl_coord_exp = get_bits(gbc, 4);
1072                         cpl_coord_mant = get_bits(gbc, 4);
1073                         if (cpl_coord_exp == 15)
1074                             s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
1075                         else
1076                             s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
1077                         s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
1078                     }
1079                 } else if (!blk) {
1080                     av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
1081                            "be present in block 0\n");
1082                     return AVERROR_INVALIDDATA;
1083                 }
1084             } else {
1085                 /* channel not in coupling */
1086                 s->first_cpl_coords[ch] = 1;
1087             }
1088         }
1089         /* phase flags */
1090         if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
1091             for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1092                 s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
1093             }
1094         }
1095     }
1096
1097     /* stereo rematrixing strategy and band structure */
1098     if (channel_mode == AC3_CHMODE_STEREO) {
1099         if ((s->eac3 && !blk) || get_bits1(gbc)) {
1100             s->num_rematrixing_bands = 4;
1101             if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
1102                 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
1103             } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
1104                 s->num_rematrixing_bands--;
1105             }
1106             for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
1107                 s->rematrixing_flags[bnd] = get_bits1(gbc);
1108         } else if (!blk) {
1109             av_log(s->avctx, AV_LOG_WARNING, "Warning: "
1110                    "new rematrixing strategy not present in block 0\n");
1111             s->num_rematrixing_bands = 0;
1112         }
1113     }
1114
1115     /* exponent strategies for each channel */
1116     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1117         if (!s->eac3)
1118             s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
1119         if (s->exp_strategy[blk][ch] != EXP_REUSE)
1120             bit_alloc_stages[ch] = 3;
1121     }
1122
1123     /* channel bandwidth */
1124     for (ch = 1; ch <= fbw_channels; ch++) {
1125         s->start_freq[ch] = 0;
1126         if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1127             int group_size;
1128             int prev = s->end_freq[ch];
1129             if (s->channel_in_cpl[ch])
1130                 s->end_freq[ch] = s->start_freq[CPL_CH];
1131             else if (s->channel_uses_spx[ch])
1132                 s->end_freq[ch] = s->spx_src_start_freq;
1133             else {
1134                 int bandwidth_code = get_bits(gbc, 6);
1135                 if (bandwidth_code > 60) {
1136                     av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1137                     return AVERROR_INVALIDDATA;
1138                 }
1139                 s->end_freq[ch] = bandwidth_code * 3 + 73;
1140             }
1141             group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1142             s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
1143             if (blk > 0 && s->end_freq[ch] != prev)
1144                 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1145         }
1146     }
1147     if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1148         s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
1149                                     (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1150     }
1151
1152     /* decode exponents for each channel */
1153     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1154         if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1155             s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1156             if (decode_exponents(gbc, s->exp_strategy[blk][ch],
1157                                  s->num_exp_groups[ch], s->dexps[ch][0],
1158                                  &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1159                 av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
1160                 return AVERROR_INVALIDDATA;
1161             }
1162             if (ch != CPL_CH && ch != s->lfe_ch)
1163                 skip_bits(gbc, 2); /* skip gainrng */
1164         }
1165     }
1166
1167     /* bit allocation information */
1168     if (s->bit_allocation_syntax) {
1169         if (get_bits1(gbc)) {
1170             s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1171             s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1172             s->bit_alloc_params.slow_gain  = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
1173             s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
1174             s->bit_alloc_params.floor  = ff_ac3_floor_tab[get_bits(gbc, 3)];
1175             for (ch = !cpl_in_use; ch <= s->channels; ch++)
1176                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1177         } else if (!blk) {
1178             av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must "
1179                    "be present in block 0\n");
1180             return AVERROR_INVALIDDATA;
1181         }
1182     }
1183
1184     /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1185     if (!s->eac3 || !blk) {
1186         if (s->snr_offset_strategy && get_bits1(gbc)) {
1187             int snr = 0;
1188             int csnr;
1189             csnr = (get_bits(gbc, 6) - 15) << 4;
1190             for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1191                 /* snr offset */
1192                 if (ch == i || s->snr_offset_strategy == 2)
1193                     snr = (csnr + get_bits(gbc, 4)) << 2;
1194                 /* run at least last bit allocation stage if snr offset changes */
1195                 if (blk && s->snr_offset[ch] != snr) {
1196                     bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1197                 }
1198                 s->snr_offset[ch] = snr;
1199
1200                 /* fast gain (normal AC-3 only) */
1201                 if (!s->eac3) {
1202                     int prev = s->fast_gain[ch];
1203                     s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1204                     /* run last 2 bit allocation stages if fast gain changes */
1205                     if (blk && prev != s->fast_gain[ch])
1206                         bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1207                 }
1208             }
1209         } else if (!s->eac3 && !blk) {
1210             av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1211             return AVERROR_INVALIDDATA;
1212         }
1213     }
1214
1215     /* fast gain (E-AC-3 only) */
1216     if (s->fast_gain_syntax && get_bits1(gbc)) {
1217         for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1218             int prev = s->fast_gain[ch];
1219             s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1220             /* run last 2 bit allocation stages if fast gain changes */
1221             if (blk && prev != s->fast_gain[ch])
1222                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1223         }
1224     } else if (s->eac3 && !blk) {
1225         for (ch = !cpl_in_use; ch <= s->channels; ch++)
1226             s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1227     }
1228
1229     /* E-AC-3 to AC-3 converter SNR offset */
1230     if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1231         skip_bits(gbc, 10); // skip converter snr offset
1232     }
1233
1234     /* coupling leak information */
1235     if (cpl_in_use) {
1236         if (s->first_cpl_leak || get_bits1(gbc)) {
1237             int fl = get_bits(gbc, 3);
1238             int sl = get_bits(gbc, 3);
1239             /* run last 2 bit allocation stages for coupling channel if
1240                coupling leak changes */
1241             if (blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1242                 sl != s->bit_alloc_params.cpl_slow_leak)) {
1243                 bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1244             }
1245             s->bit_alloc_params.cpl_fast_leak = fl;
1246             s->bit_alloc_params.cpl_slow_leak = sl;
1247         } else if (!s->eac3 && !blk) {
1248             av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must "
1249                    "be present in block 0\n");
1250             return AVERROR_INVALIDDATA;
1251         }
1252         s->first_cpl_leak = 0;
1253     }
1254
1255     /* delta bit allocation information */
1256     if (s->dba_syntax && get_bits1(gbc)) {
1257         /* delta bit allocation exists (strategy) */
1258         for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1259             s->dba_mode[ch] = get_bits(gbc, 2);
1260             if (s->dba_mode[ch] == DBA_RESERVED) {
1261                 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1262                 return AVERROR_INVALIDDATA;
1263             }
1264             bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1265         }
1266         /* channel delta offset, len and bit allocation */
1267         for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1268             if (s->dba_mode[ch] == DBA_NEW) {
1269                 s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;
1270                 for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
1271                     s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1272                     s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1273                     s->dba_values[ch][seg]  = get_bits(gbc, 3);
1274                 }
1275                 /* run last 2 bit allocation stages if new dba values */
1276                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1277             }
1278         }
1279     } else if (blk == 0) {
1280         for (ch = 0; ch <= s->channels; ch++) {
1281             s->dba_mode[ch] = DBA_NONE;
1282         }
1283     }
1284
1285     /* Bit allocation */
1286     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1287         if (bit_alloc_stages[ch] > 2) {
1288             /* Exponent mapping into PSD and PSD integration */
1289             ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
1290                                       s->start_freq[ch], s->end_freq[ch],
1291                                       s->psd[ch], s->band_psd[ch]);
1292         }
1293         if (bit_alloc_stages[ch] > 1) {
1294             /* Compute excitation function, Compute masking curve, and
1295                Apply delta bit allocation */
1296             if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1297                                            s->start_freq[ch],  s->end_freq[ch],
1298                                            s->fast_gain[ch],   (ch == s->lfe_ch),
1299                                            s->dba_mode[ch],    s->dba_nsegs[ch],
1300                                            s->dba_offsets[ch], s->dba_lengths[ch],
1301                                            s->dba_values[ch],  s->mask[ch])) {
1302                 av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1303                 return AVERROR_INVALIDDATA;
1304             }
1305         }
1306         if (bit_alloc_stages[ch] > 0) {
1307             /* Compute bit allocation */
1308             const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1309                                      ff_eac3_hebap_tab : ff_ac3_bap_tab;
1310             s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1311                                       s->start_freq[ch], s->end_freq[ch],
1312                                       s->snr_offset[ch],
1313                                       s->bit_alloc_params.floor,
1314                                       bap_tab, s->bap[ch]);
1315         }
1316     }
1317
1318     /* unused dummy data */
1319     if (s->skip_syntax && get_bits1(gbc)) {
1320         int skipl = get_bits(gbc, 9);
1321         while (skipl--)
1322             skip_bits(gbc, 8);
1323     }
1324
1325     /* unpack the transform coefficients
1326        this also uncouples channels if coupling is in use. */
1327     decode_transform_coeffs(s, blk);
1328
1329     /* TODO: generate enhanced coupling coordinates and uncouple */
1330
1331     /* recover coefficients if rematrixing is in use */
1332     if (s->channel_mode == AC3_CHMODE_STEREO)
1333         do_rematrixing(s);
1334
1335     /* apply scaling to coefficients (headroom, dynrng) */
1336     for (ch = 1; ch <= s->channels; ch++) {
1337         int audio_channel = 0;
1338         INTFLOAT gain;
1339         if (s->channel_mode == AC3_CHMODE_DUALMONO)
1340             audio_channel = 2-ch;
1341         if (s->heavy_compression && s->compression_exists[audio_channel])
1342             gain = s->heavy_dynamic_range[audio_channel];
1343         else
1344             gain = s->dynamic_range[audio_channel];
1345
1346 #if USE_FIXED
1347         scale_coefs(s->transform_coeffs[ch], s->fixed_coeffs[ch], gain, 256);
1348 #else
1349         if (s->target_level != 0)
1350           gain = gain * s->level_gain[audio_channel];
1351         gain *= 1.0 / 4194304.0f;
1352         s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch],
1353                                                s->fixed_coeffs[ch], gain, 256);
1354 #endif
1355     }
1356
1357     /* apply spectral extension to high frequency bins */
1358     if (s->spx_in_use && CONFIG_EAC3_DECODER) {
1359         ff_eac3_apply_spectral_extension(s);
1360     }
1361
1362     /* downmix and MDCT. order depends on whether block switching is used for
1363        any channel in this block. this is because coefficients for the long
1364        and short transforms cannot be mixed. */
1365     downmix_output = s->channels != s->out_channels &&
1366                      !((s->output_mode & AC3_OUTPUT_LFEON) &&
1367                      s->fbw_channels == s->out_channels);
1368     if (different_transforms) {
1369         /* the delay samples have already been downmixed, so we upmix the delay
1370            samples in order to reconstruct all channels before downmixing. */
1371         if (s->downmixed) {
1372             s->downmixed = 0;
1373             ac3_upmix_delay(s);
1374         }
1375
1376         do_imdct(s, s->channels);
1377
1378         if (downmix_output) {
1379 #if USE_FIXED
1380             ac3_downmix_c_fixed16(s->outptr, s->downmix_coeffs,
1381                               s->out_channels, s->fbw_channels, 256);
1382 #else
1383             s->ac3dsp.downmix(s->outptr, s->downmix_coeffs,
1384                               s->out_channels, s->fbw_channels, 256);
1385 #endif
1386         }
1387     } else {
1388         if (downmix_output) {
1389             s->ac3dsp.AC3_RENAME(downmix)(s->xcfptr + 1, s->downmix_coeffs,
1390                                           s->out_channels, s->fbw_channels, 256);
1391         }
1392
1393         if (downmix_output && !s->downmixed) {
1394             s->downmixed = 1;
1395             s->ac3dsp.AC3_RENAME(downmix)(s->dlyptr, s->downmix_coeffs,
1396                                           s->out_channels, s->fbw_channels, 128);
1397         }
1398
1399         do_imdct(s, s->out_channels);
1400     }
1401
1402     return 0;
1403 }
1404
1405 /**
1406  * Decode a single AC-3 frame.
1407  */
1408 static int ac3_decode_frame(AVCodecContext * avctx, void *data,
1409                             int *got_frame_ptr, AVPacket *avpkt)
1410 {
1411     AVFrame *frame     = data;
1412     const uint8_t *buf = avpkt->data;
1413     int buf_size = avpkt->size;
1414     AC3DecodeContext *s = avctx->priv_data;
1415     int blk, ch, err, ret;
1416     const uint8_t *channel_map;
1417     const SHORTFLOAT *output[AC3_MAX_CHANNELS];
1418     enum AVMatrixEncoding matrix_encoding;
1419     AVDownmixInfo *downmix_info;
1420
1421     /* copy input buffer to decoder context to avoid reading past the end
1422        of the buffer, which can be caused by a damaged input stream. */
1423     if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
1424         // seems to be byte-swapped AC-3
1425         int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1426         s->bdsp.bswap16_buf((uint16_t *) s->input_buffer,
1427                             (const uint16_t *) buf, cnt);
1428     } else
1429         memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1430     buf = s->input_buffer;
1431     /* initialize the GetBitContext with the start of valid AC-3 Frame */
1432     if ((ret = init_get_bits8(&s->gbc, buf, buf_size)) < 0)
1433         return ret;
1434
1435     /* parse the syncinfo */
1436     err = parse_frame_header(s);
1437
1438     if (err) {
1439         switch (err) {
1440         case AAC_AC3_PARSE_ERROR_SYNC:
1441             av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1442             return AVERROR_INVALIDDATA;
1443         case AAC_AC3_PARSE_ERROR_BSID:
1444             av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1445             break;
1446         case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
1447             av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1448             break;
1449         case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
1450             av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1451             break;
1452         case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
1453             /* skip frame if CRC is ok. otherwise use error concealment. */
1454             /* TODO: add support for substreams and dependent frames */
1455             if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
1456                 av_log(avctx, AV_LOG_WARNING, "unsupported frame type : "
1457                        "skipping frame\n");
1458                 *got_frame_ptr = 0;
1459                 return buf_size;
1460             } else {
1461                 av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1462             }
1463             break;
1464         case AAC_AC3_PARSE_ERROR_CRC:
1465         case AAC_AC3_PARSE_ERROR_CHANNEL_CFG:
1466             break;
1467         default: // Normal AVERROR do not try to recover.
1468             *got_frame_ptr = 0;
1469             return err;
1470         }
1471     } else {
1472         /* check that reported frame size fits in input buffer */
1473         if (s->frame_size > buf_size) {
1474             av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1475             err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
1476         } else if (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL)) {
1477             /* check for crc mismatch */
1478             if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
1479                        s->frame_size - 2)) {
1480                 av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1481                 if (avctx->err_recognition & AV_EF_EXPLODE)
1482                     return AVERROR_INVALIDDATA;
1483                 err = AAC_AC3_PARSE_ERROR_CRC;
1484             }
1485         }
1486     }
1487
1488     /* if frame is ok, set audio parameters */
1489     if (!err) {
1490         avctx->sample_rate = s->sample_rate;
1491         avctx->bit_rate    = s->bit_rate;
1492     }
1493
1494     /* channel config */
1495     if (!err || (s->channels && s->out_channels != s->channels)) {
1496         s->out_channels = s->channels;
1497         s->output_mode  = s->channel_mode;
1498         if (s->lfe_on)
1499             s->output_mode |= AC3_OUTPUT_LFEON;
1500         if (s->channels > 1 &&
1501             avctx->request_channel_layout == AV_CH_LAYOUT_MONO) {
1502             s->out_channels = 1;
1503             s->output_mode  = AC3_CHMODE_MONO;
1504         } else if (s->channels > 2 &&
1505                    avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
1506             s->out_channels = 2;
1507             s->output_mode  = AC3_CHMODE_STEREO;
1508         }
1509
1510         s->loro_center_mix_level   = gain_levels[s->  center_mix_level];
1511         s->loro_surround_mix_level = gain_levels[s->surround_mix_level];
1512         s->ltrt_center_mix_level   = LEVEL_MINUS_3DB;
1513         s->ltrt_surround_mix_level = LEVEL_MINUS_3DB;
1514         /* set downmixing coefficients if needed */
1515         if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1516                 s->fbw_channels == s->out_channels)) {
1517             set_downmix_coeffs(s);
1518         }
1519     } else if (!s->channels) {
1520         av_log(avctx, AV_LOG_ERROR, "unable to determine channel mode\n");
1521         return AVERROR_INVALIDDATA;
1522     }
1523     avctx->channels = s->out_channels;
1524     avctx->channel_layout = avpriv_ac3_channel_layout_tab[s->output_mode & ~AC3_OUTPUT_LFEON];
1525     if (s->output_mode & AC3_OUTPUT_LFEON)
1526         avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1527
1528     /* set audio service type based on bitstream mode for AC-3 */
1529     avctx->audio_service_type = s->bitstream_mode;
1530     if (s->bitstream_mode == 0x7 && s->channels > 1)
1531         avctx->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
1532
1533     /* get output buffer */
1534     frame->nb_samples = s->num_blocks * AC3_BLOCK_SIZE;
1535     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1536         return ret;
1537
1538     /* decode the audio blocks */
1539     channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1540     for (ch = 0; ch < AC3_MAX_CHANNELS; ch++) {
1541         output[ch] = s->output[ch];
1542         s->outptr[ch] = s->output[ch];
1543     }
1544     for (ch = 0; ch < s->channels; ch++) {
1545         if (ch < s->out_channels)
1546             s->outptr[channel_map[ch]] = (SHORTFLOAT *)frame->data[ch];
1547     }
1548     for (blk = 0; blk < s->num_blocks; blk++) {
1549         if (!err && decode_audio_block(s, blk)) {
1550             av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1551             err = 1;
1552         }
1553         if (err)
1554             for (ch = 0; ch < s->out_channels; ch++)
1555                 memcpy(((SHORTFLOAT*)frame->data[ch]) + AC3_BLOCK_SIZE*blk, output[ch], AC3_BLOCK_SIZE*sizeof(SHORTFLOAT));
1556         for (ch = 0; ch < s->out_channels; ch++)
1557             output[ch] = s->outptr[channel_map[ch]];
1558         for (ch = 0; ch < s->out_channels; ch++) {
1559             if (!ch || channel_map[ch])
1560                 s->outptr[channel_map[ch]] += AC3_BLOCK_SIZE;
1561         }
1562     }
1563
1564     av_frame_set_decode_error_flags(frame, err ? FF_DECODE_ERROR_INVALID_BITSTREAM : 0);
1565
1566     /* keep last block for error concealment in next frame */
1567     for (ch = 0; ch < s->out_channels; ch++)
1568         memcpy(s->output[ch], output[ch], AC3_BLOCK_SIZE*sizeof(SHORTFLOAT));
1569
1570     /*
1571      * AVMatrixEncoding
1572      *
1573      * Check whether the input layout is compatible, and make sure we're not
1574      * downmixing (else the matrix encoding is no longer applicable).
1575      */
1576     matrix_encoding = AV_MATRIX_ENCODING_NONE;
1577     if (s->channel_mode == AC3_CHMODE_STEREO &&
1578         s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1579         if (s->dolby_surround_mode == AC3_DSURMOD_ON)
1580             matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
1581         else if (s->dolby_headphone_mode == AC3_DHEADPHONMOD_ON)
1582             matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;
1583     } else if (s->channel_mode >= AC3_CHMODE_2F2R &&
1584                s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1585         switch (s->dolby_surround_ex_mode) {
1586         case AC3_DSUREXMOD_ON: // EX or PLIIx
1587             matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
1588             break;
1589         case AC3_DSUREXMOD_PLIIZ:
1590             matrix_encoding = AV_MATRIX_ENCODING_DPLIIZ;
1591             break;
1592         default: // not indicated or off
1593             break;
1594         }
1595     }
1596     if ((ret = ff_side_data_update_matrix_encoding(frame, matrix_encoding)) < 0)
1597         return ret;
1598
1599     /* AVDownmixInfo */
1600     if ((downmix_info = av_downmix_info_update_side_data(frame))) {
1601         switch (s->preferred_downmix) {
1602         case AC3_DMIXMOD_LTRT:
1603             downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_LTRT;
1604             break;
1605         case AC3_DMIXMOD_LORO:
1606             downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_LORO;
1607             break;
1608         case AC3_DMIXMOD_DPLII:
1609             downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_DPLII;
1610             break;
1611         default:
1612             downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_UNKNOWN;
1613             break;
1614         }
1615         downmix_info->center_mix_level        = gain_levels[s->       center_mix_level];
1616         downmix_info->center_mix_level_ltrt   = gain_levels[s->  center_mix_level_ltrt];
1617         downmix_info->surround_mix_level      = gain_levels[s->     surround_mix_level];
1618         downmix_info->surround_mix_level_ltrt = gain_levels[s->surround_mix_level_ltrt];
1619         if (s->lfe_mix_level_exists)
1620             downmix_info->lfe_mix_level       = gain_levels_lfe[s->lfe_mix_level];
1621         else
1622             downmix_info->lfe_mix_level       = 0.0; // -inf dB
1623     } else
1624         return AVERROR(ENOMEM);
1625
1626     *got_frame_ptr = 1;
1627
1628     return FFMIN(buf_size, s->frame_size);
1629 }
1630
1631 /**
1632  * Uninitialize the AC-3 decoder.
1633  */
1634 static av_cold int ac3_decode_end(AVCodecContext *avctx)
1635 {
1636     AC3DecodeContext *s = avctx->priv_data;
1637     ff_mdct_end(&s->imdct_512);
1638     ff_mdct_end(&s->imdct_256);
1639     av_freep(&s->fdsp);
1640
1641     return 0;
1642 }
1643
1644 #define OFFSET(x) offsetof(AC3DecodeContext, x)
1645 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)