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