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