ac3dec: Split coupling-specific code from decode_audio_block()
[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 void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,
552                                        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 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         while (skipl--)
1275             skip_bits(gbc, 8);
1276     }
1277
1278     /* unpack the transform coefficients
1279        this also uncouples channels if coupling is in use. */
1280     decode_transform_coeffs(s, blk);
1281
1282     /* TODO: generate enhanced coupling coordinates and uncouple */
1283
1284     /* recover coefficients if rematrixing is in use */
1285     if (s->channel_mode == AC3_CHMODE_STEREO)
1286         do_rematrixing(s);
1287
1288     /* apply scaling to coefficients (headroom, dynrng) */
1289     for (ch = 1; ch <= s->channels; ch++) {
1290         float gain = 1.0 / 4194304.0f;
1291         if (s->channel_mode == AC3_CHMODE_DUALMONO) {
1292             gain *= s->dynamic_range[2 - ch];
1293         } else {
1294             gain *= s->dynamic_range[0];
1295         }
1296         s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch],
1297                                                s->fixed_coeffs[ch], gain, 256);
1298     }
1299
1300     /* apply spectral extension to high frequency bins */
1301     if (s->spx_in_use && CONFIG_EAC3_DECODER) {
1302         ff_eac3_apply_spectral_extension(s);
1303     }
1304
1305     /* downmix and MDCT. order depends on whether block switching is used for
1306        any channel in this block. this is because coefficients for the long
1307        and short transforms cannot be mixed. */
1308     downmix_output = s->channels != s->out_channels &&
1309                      !((s->output_mode & AC3_OUTPUT_LFEON) &&
1310                      s->fbw_channels == s->out_channels);
1311     if (different_transforms) {
1312         /* the delay samples have already been downmixed, so we upmix the delay
1313            samples in order to reconstruct all channels before downmixing. */
1314         if (s->downmixed) {
1315             s->downmixed = 0;
1316             ac3_upmix_delay(s);
1317         }
1318
1319         do_imdct(s, s->channels);
1320
1321         if (downmix_output) {
1322             s->ac3dsp.downmix(s->outptr, s->downmix_coeffs,
1323                               s->out_channels, s->fbw_channels, 256);
1324         }
1325     } else {
1326         if (downmix_output) {
1327             s->ac3dsp.downmix(s->xcfptr + 1, s->downmix_coeffs,
1328                               s->out_channels, s->fbw_channels, 256);
1329         }
1330
1331         if (downmix_output && !s->downmixed) {
1332             s->downmixed = 1;
1333             s->ac3dsp.downmix(s->dlyptr, s->downmix_coeffs, s->out_channels,
1334                               s->fbw_channels, 128);
1335         }
1336
1337         do_imdct(s, s->out_channels);
1338     }
1339
1340     return 0;
1341 }
1342
1343 /**
1344  * Decode a single AC-3 frame.
1345  */
1346 static int ac3_decode_frame(AVCodecContext * avctx, void *data,
1347                             int *got_frame_ptr, AVPacket *avpkt)
1348 {
1349     AVFrame *frame     = data;
1350     const uint8_t *buf = avpkt->data;
1351     int buf_size = avpkt->size;
1352     AC3DecodeContext *s = avctx->priv_data;
1353     int blk, ch, err, ret;
1354     const uint8_t *channel_map;
1355     const float *output[AC3_MAX_CHANNELS];
1356     enum AVMatrixEncoding matrix_encoding;
1357     AVDownmixInfo *downmix_info;
1358
1359     /* copy input buffer to decoder context to avoid reading past the end
1360        of the buffer, which can be caused by a damaged input stream. */
1361     if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
1362         // seems to be byte-swapped AC-3
1363         int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1364         s->bdsp.bswap16_buf((uint16_t *) s->input_buffer,
1365                             (const uint16_t *) buf, cnt);
1366     } else
1367         memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1368     buf = s->input_buffer;
1369     /* initialize the GetBitContext with the start of valid AC-3 Frame */
1370     init_get_bits(&s->gbc, buf, buf_size * 8);
1371
1372     /* parse the syncinfo */
1373     err = parse_frame_header(s);
1374
1375     if (err) {
1376         switch (err) {
1377         case AAC_AC3_PARSE_ERROR_SYNC:
1378             av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1379             return AVERROR_INVALIDDATA;
1380         case AAC_AC3_PARSE_ERROR_BSID:
1381             av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1382             break;
1383         case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
1384             av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1385             break;
1386         case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
1387             av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1388             break;
1389         case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
1390             /* skip frame if CRC is ok. otherwise use error concealment. */
1391             /* TODO: add support for substreams and dependent frames */
1392             if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
1393                 av_log(avctx, AV_LOG_DEBUG,
1394                        "unsupported frame type %d: skipping frame\n",
1395                        s->frame_type);
1396                 *got_frame_ptr = 0;
1397                 return buf_size;
1398             } else {
1399                 av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1400             }
1401             break;
1402         case AAC_AC3_PARSE_ERROR_CRC:
1403         case AAC_AC3_PARSE_ERROR_CHANNEL_CFG:
1404             break;
1405         default: // Normal AVERROR do not try to recover.
1406             *got_frame_ptr = 0;
1407             return err;
1408         }
1409     } else {
1410         /* check that reported frame size fits in input buffer */
1411         if (s->frame_size > buf_size) {
1412             av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1413             err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
1414         } else if (avctx->err_recognition & AV_EF_CRCCHECK) {
1415             /* check for crc mismatch */
1416             if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
1417                        s->frame_size - 2)) {
1418                 av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1419                 if (avctx->err_recognition & AV_EF_EXPLODE)
1420                     return AVERROR_INVALIDDATA;
1421                 err = AAC_AC3_PARSE_ERROR_CRC;
1422             }
1423         }
1424     }
1425
1426     /* if frame is ok, set audio parameters */
1427     if (!err) {
1428         avctx->sample_rate = s->sample_rate;
1429         avctx->bit_rate    = s->bit_rate;
1430     }
1431
1432     /* channel config */
1433     if (!err || (s->channels && s->out_channels != s->channels)) {
1434         s->out_channels = s->channels;
1435         s->output_mode  = s->channel_mode;
1436         if (s->lfe_on)
1437             s->output_mode |= AC3_OUTPUT_LFEON;
1438         if (s->channels > 1 &&
1439             avctx->request_channel_layout == AV_CH_LAYOUT_MONO) {
1440             s->out_channels = 1;
1441             s->output_mode  = AC3_CHMODE_MONO;
1442         } else if (s->channels > 2 &&
1443                    avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
1444             s->out_channels = 2;
1445             s->output_mode  = AC3_CHMODE_STEREO;
1446         }
1447
1448         /* set downmixing coefficients if needed */
1449         if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1450                 s->fbw_channels == s->out_channels)) {
1451             set_downmix_coeffs(s);
1452         }
1453     } else if (!s->channels) {
1454         av_log(avctx, AV_LOG_ERROR, "unable to determine channel mode\n");
1455         return AVERROR_INVALIDDATA;
1456     }
1457     avctx->channels = s->out_channels;
1458     avctx->channel_layout = avpriv_ac3_channel_layout_tab[s->output_mode & ~AC3_OUTPUT_LFEON];
1459     if (s->output_mode & AC3_OUTPUT_LFEON)
1460         avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1461
1462     /* set audio service type based on bitstream mode for AC-3 */
1463     avctx->audio_service_type = s->bitstream_mode;
1464     if (s->bitstream_mode == 0x7 && s->channels > 1)
1465         avctx->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
1466
1467     /* get output buffer */
1468     frame->nb_samples = s->num_blocks * AC3_BLOCK_SIZE;
1469     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
1470         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1471         return ret;
1472     }
1473
1474     /* decode the audio blocks */
1475     channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1476     for (ch = 0; ch < s->channels; ch++) {
1477         if (ch < s->out_channels)
1478             s->outptr[channel_map[ch]] = (float *)frame->data[ch];
1479         else
1480             s->outptr[ch] = s->output[ch];
1481         output[ch] = s->output[ch];
1482     }
1483     for (blk = 0; blk < s->num_blocks; blk++) {
1484         if (!err && decode_audio_block(s, blk)) {
1485             av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1486             err = 1;
1487         }
1488         if (err)
1489             for (ch = 0; ch < s->out_channels; ch++)
1490                 memcpy(s->outptr[channel_map[ch]], output[ch], sizeof(**output) * AC3_BLOCK_SIZE);
1491         for (ch = 0; ch < s->out_channels; ch++)
1492             output[ch] = s->outptr[channel_map[ch]];
1493         for (ch = 0; ch < s->out_channels; ch++)
1494             s->outptr[ch] += AC3_BLOCK_SIZE;
1495     }
1496
1497     /* keep last block for error concealment in next frame */
1498     for (ch = 0; ch < s->out_channels; ch++)
1499         memcpy(s->output[ch], output[ch], sizeof(**output) * AC3_BLOCK_SIZE);
1500
1501     /*
1502      * AVMatrixEncoding
1503      *
1504      * Check whether the input layout is compatible, and make sure we're not
1505      * downmixing (else the matrix encoding is no longer applicable).
1506      */
1507     matrix_encoding = AV_MATRIX_ENCODING_NONE;
1508     if (s->channel_mode == AC3_CHMODE_STEREO &&
1509         s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1510         if (s->dolby_surround_mode == AC3_DSURMOD_ON)
1511             matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
1512         else if (s->dolby_headphone_mode == AC3_DHEADPHONMOD_ON)
1513             matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;
1514     } else if (s->channel_mode >= AC3_CHMODE_2F2R &&
1515                s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1516         switch (s->dolby_surround_ex_mode) {
1517         case AC3_DSUREXMOD_ON: // EX or PLIIx
1518             matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
1519             break;
1520         case AC3_DSUREXMOD_PLIIZ:
1521             matrix_encoding = AV_MATRIX_ENCODING_DPLIIZ;
1522             break;
1523         default: // not indicated or off
1524             break;
1525         }
1526     }
1527     if ((ret = ff_side_data_update_matrix_encoding(frame, matrix_encoding)) < 0)
1528         return ret;
1529
1530     /* AVDownmixInfo */
1531     if ((downmix_info = av_downmix_info_update_side_data(frame))) {
1532         switch (s->preferred_downmix) {
1533         case AC3_DMIXMOD_LTRT:
1534             downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_LTRT;
1535             break;
1536         case AC3_DMIXMOD_LORO:
1537             downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_LORO;
1538             break;
1539         case AC3_DMIXMOD_DPLII:
1540             downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_DPLII;
1541             break;
1542         default:
1543             downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_UNKNOWN;
1544             break;
1545         }
1546         downmix_info->center_mix_level        = gain_levels[s->       center_mix_level];
1547         downmix_info->center_mix_level_ltrt   = gain_levels[s->  center_mix_level_ltrt];
1548         downmix_info->surround_mix_level      = gain_levels[s->     surround_mix_level];
1549         downmix_info->surround_mix_level_ltrt = gain_levels[s->surround_mix_level_ltrt];
1550         if (s->lfe_mix_level_exists)
1551             downmix_info->lfe_mix_level       = gain_levels_lfe[s->lfe_mix_level];
1552         else
1553             downmix_info->lfe_mix_level       = 0.0; // -inf dB
1554     } else
1555         return AVERROR(ENOMEM);
1556
1557     *got_frame_ptr = 1;
1558
1559     return FFMIN(buf_size, s->frame_size);
1560 }
1561
1562 /**
1563  * Uninitialize the AC-3 decoder.
1564  */
1565 static av_cold int ac3_decode_end(AVCodecContext *avctx)
1566 {
1567     AC3DecodeContext *s = avctx->priv_data;
1568     ff_mdct_end(&s->imdct_512);
1569     ff_mdct_end(&s->imdct_256);
1570
1571     return 0;
1572 }
1573
1574 #define OFFSET(x) offsetof(AC3DecodeContext, x)
1575 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)
1576 static const AVOption options[] = {
1577     { "drc_scale", "percentage of dynamic range compression to apply", OFFSET(drc_scale), AV_OPT_TYPE_FLOAT, {.dbl = 1.0}, 0.0, 6.0, PAR },
1578     { NULL},
1579 };
1580
1581 static const AVClass ac3_decoder_class = {
1582     .class_name = "AC3 decoder",
1583     .item_name  = av_default_item_name,
1584     .option     = options,
1585     .version    = LIBAVUTIL_VERSION_INT,
1586 };
1587
1588 AVCodec ff_ac3_decoder = {
1589     .name           = "ac3",
1590     .long_name      = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
1591     .type           = AVMEDIA_TYPE_AUDIO,
1592     .id             = AV_CODEC_ID_AC3,
1593     .priv_data_size = sizeof (AC3DecodeContext),
1594     .init           = ac3_decode_init,
1595     .close          = ac3_decode_end,
1596     .decode         = ac3_decode_frame,
1597     .capabilities   = AV_CODEC_CAP_DR1,
1598     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1599                                                       AV_SAMPLE_FMT_NONE },
1600     .priv_class     = &ac3_decoder_class,
1601 };
1602
1603 #if CONFIG_EAC3_DECODER
1604 static const AVClass eac3_decoder_class = {
1605     .class_name = "E-AC3 decoder",
1606     .item_name  = av_default_item_name,
1607     .option     = options,
1608     .version    = LIBAVUTIL_VERSION_INT,
1609 };
1610
1611 AVCodec ff_eac3_decoder = {
1612     .name           = "eac3",
1613     .long_name      = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
1614     .type           = AVMEDIA_TYPE_AUDIO,
1615     .id             = AV_CODEC_ID_EAC3,
1616     .priv_data_size = sizeof (AC3DecodeContext),
1617     .init           = ac3_decode_init,
1618     .close          = ac3_decode_end,
1619     .decode         = ac3_decode_frame,
1620     .capabilities   = AV_CODEC_CAP_DR1,
1621     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1622                                                       AV_SAMPLE_FMT_NONE },
1623     .priv_class     = &eac3_decoder_class,
1624 };
1625 #endif