h264: switch to h2645_parse for NAL parsing
[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 /**
750  * Decode a single audio block from the AC-3 bitstream.
751  */
752 static int decode_audio_block(AC3DecodeContext *s, int blk)
753 {
754     int fbw_channels = s->fbw_channels;
755     int channel_mode = s->channel_mode;
756     int i, bnd, seg, ch;
757     int different_transforms;
758     int downmix_output;
759     int cpl_in_use;
760     GetBitContext *gbc = &s->gbc;
761     uint8_t bit_alloc_stages[AC3_MAX_CHANNELS] = { 0 };
762
763     /* block switch flags */
764     different_transforms = 0;
765     if (s->block_switch_syntax) {
766         for (ch = 1; ch <= fbw_channels; ch++) {
767             s->block_switch[ch] = get_bits1(gbc);
768             if (ch > 1 && s->block_switch[ch] != s->block_switch[1])
769                 different_transforms = 1;
770         }
771     }
772
773     /* dithering flags */
774     if (s->dither_flag_syntax) {
775         for (ch = 1; ch <= fbw_channels; ch++) {
776             s->dither_flag[ch] = get_bits1(gbc);
777         }
778     }
779
780     /* dynamic range */
781     i = !s->channel_mode;
782     do {
783         if (get_bits1(gbc)) {
784             /* Allow asymmetric application of DRC when drc_scale > 1.
785                Amplification of quiet sounds is enhanced */
786             float range = dynamic_range_tab[get_bits(gbc, 8)];
787             if (range > 1.0 || s->drc_scale <= 1.0)
788                 s->dynamic_range[i] = powf(range, s->drc_scale);
789             else
790                 s->dynamic_range[i] = range;
791         } else if (blk == 0) {
792             s->dynamic_range[i] = 1.0f;
793         }
794     } while (i--);
795
796     /* spectral extension strategy */
797     if (s->eac3 && (!blk || get_bits1(gbc))) {
798         s->spx_in_use = get_bits1(gbc);
799         if (s->spx_in_use) {
800             int dst_start_freq, dst_end_freq, src_start_freq,
801                 start_subband, end_subband;
802
803             /* determine which channels use spx */
804             if (s->channel_mode == AC3_CHMODE_MONO) {
805                 s->channel_uses_spx[1] = 1;
806             } else {
807                 for (ch = 1; ch <= fbw_channels; ch++)
808                     s->channel_uses_spx[ch] = get_bits1(gbc);
809             }
810
811             /* get the frequency bins of the spx copy region and the spx start
812                and end subbands */
813             dst_start_freq = get_bits(gbc, 2);
814             start_subband  = get_bits(gbc, 3) + 2;
815             if (start_subband > 7)
816                 start_subband += start_subband - 7;
817             end_subband    = get_bits(gbc, 3) + 5;
818             if (end_subband   > 7)
819                 end_subband   += end_subband   - 7;
820             dst_start_freq = dst_start_freq * 12 + 25;
821             src_start_freq = start_subband  * 12 + 25;
822             dst_end_freq   = end_subband    * 12 + 25;
823
824             /* check validity of spx ranges */
825             if (start_subband >= end_subband) {
826                 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
827                        "range (%d >= %d)\n", start_subband, end_subband);
828                 return AVERROR_INVALIDDATA;
829             }
830             if (dst_start_freq >= src_start_freq) {
831                 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
832                        "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
833                 return AVERROR_INVALIDDATA;
834             }
835
836             s->spx_dst_start_freq = dst_start_freq;
837             s->spx_src_start_freq = src_start_freq;
838             s->spx_dst_end_freq   = dst_end_freq;
839
840             decode_band_structure(gbc, blk, s->eac3, 0,
841                                   start_subband, end_subband,
842                                   ff_eac3_default_spx_band_struct,
843                                   &s->num_spx_bands,
844                                   s->spx_band_sizes);
845         } else {
846             for (ch = 1; ch <= fbw_channels; ch++) {
847                 s->channel_uses_spx[ch] = 0;
848                 s->first_spx_coords[ch] = 1;
849             }
850         }
851     }
852
853     /* spectral extension coordinates */
854     if (s->spx_in_use) {
855         for (ch = 1; ch <= fbw_channels; ch++) {
856             if (s->channel_uses_spx[ch]) {
857                 if (s->first_spx_coords[ch] || get_bits1(gbc)) {
858                     float spx_blend;
859                     int bin, master_spx_coord;
860
861                     s->first_spx_coords[ch] = 0;
862                     spx_blend = get_bits(gbc, 5) * (1.0f/32);
863                     master_spx_coord = get_bits(gbc, 2) * 3;
864
865                     bin = s->spx_src_start_freq;
866                     for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
867                         int bandsize;
868                         int spx_coord_exp, spx_coord_mant;
869                         float nratio, sblend, nblend, spx_coord;
870
871                         /* calculate blending factors */
872                         bandsize = s->spx_band_sizes[bnd];
873                         nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
874                         nratio = av_clipf(nratio, 0.0f, 1.0f);
875                         nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
876                                                        // to give unity variance
877                         sblend = sqrtf(1.0f - nratio);
878                         bin += bandsize;
879
880                         /* decode spx coordinates */
881                         spx_coord_exp  = get_bits(gbc, 4);
882                         spx_coord_mant = get_bits(gbc, 2);
883                         if (spx_coord_exp == 15) spx_coord_mant <<= 1;
884                         else                     spx_coord_mant += 4;
885                         spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
886                         spx_coord = spx_coord_mant * (1.0f / (1 << 23));
887
888                         /* multiply noise and signal blending factors by spx coordinate */
889                         s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
890                         s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
891                     }
892                 }
893             } else {
894                 s->first_spx_coords[ch] = 1;
895             }
896         }
897     }
898
899     /* coupling strategy */
900     if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
901         memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
902         if (!s->eac3)
903             s->cpl_in_use[blk] = get_bits1(gbc);
904         if (s->cpl_in_use[blk]) {
905             /* coupling in use */
906             int cpl_start_subband, cpl_end_subband;
907
908             if (channel_mode < AC3_CHMODE_STEREO) {
909                 av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
910                 return AVERROR_INVALIDDATA;
911             }
912
913             /* check for enhanced coupling */
914             if (s->eac3 && get_bits1(gbc)) {
915                 /* TODO: parse enhanced coupling strategy info */
916                 avpriv_request_sample(s->avctx, "Enhanced coupling");
917                 return AVERROR_PATCHWELCOME;
918             }
919
920             /* determine which channels are coupled */
921             if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
922                 s->channel_in_cpl[1] = 1;
923                 s->channel_in_cpl[2] = 1;
924             } else {
925                 for (ch = 1; ch <= fbw_channels; ch++)
926                     s->channel_in_cpl[ch] = get_bits1(gbc);
927             }
928
929             /* phase flags in use */
930             if (channel_mode == AC3_CHMODE_STEREO)
931                 s->phase_flags_in_use = get_bits1(gbc);
932
933             /* coupling frequency range */
934             cpl_start_subband = get_bits(gbc, 4);
935             cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
936                                               get_bits(gbc, 4) + 3;
937             if (cpl_start_subband >= cpl_end_subband) {
938                 av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
939                        cpl_start_subband, cpl_end_subband);
940                 return AVERROR_INVALIDDATA;
941             }
942             s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
943             s->end_freq[CPL_CH]   = cpl_end_subband   * 12 + 37;
944
945             decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
946                                   cpl_end_subband,
947                                   ff_eac3_default_cpl_band_struct,
948                                   &s->num_cpl_bands, s->cpl_band_sizes);
949         } else {
950             /* coupling not in use */
951             for (ch = 1; ch <= fbw_channels; ch++) {
952                 s->channel_in_cpl[ch] = 0;
953                 s->first_cpl_coords[ch] = 1;
954             }
955             s->first_cpl_leak = s->eac3;
956             s->phase_flags_in_use = 0;
957         }
958     } else if (!s->eac3) {
959         if (!blk) {
960             av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "
961                    "be present in block 0\n");
962             return AVERROR_INVALIDDATA;
963         } else {
964             s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
965         }
966     }
967     cpl_in_use = s->cpl_in_use[blk];
968
969     /* coupling coordinates */
970     if (cpl_in_use) {
971         int cpl_coords_exist = 0;
972
973         for (ch = 1; ch <= fbw_channels; ch++) {
974             if (s->channel_in_cpl[ch]) {
975                 if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
976                     int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
977                     s->first_cpl_coords[ch] = 0;
978                     cpl_coords_exist = 1;
979                     master_cpl_coord = 3 * get_bits(gbc, 2);
980                     for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
981                         cpl_coord_exp = get_bits(gbc, 4);
982                         cpl_coord_mant = get_bits(gbc, 4);
983                         if (cpl_coord_exp == 15)
984                             s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
985                         else
986                             s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
987                         s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
988                     }
989                 } else if (!blk) {
990                     av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
991                            "be present in block 0\n");
992                     return AVERROR_INVALIDDATA;
993                 }
994             } else {
995                 /* channel not in coupling */
996                 s->first_cpl_coords[ch] = 1;
997             }
998         }
999         /* phase flags */
1000         if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
1001             for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1002                 s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
1003             }
1004         }
1005     }
1006
1007     /* stereo rematrixing strategy and band structure */
1008     if (channel_mode == AC3_CHMODE_STEREO) {
1009         if ((s->eac3 && !blk) || get_bits1(gbc)) {
1010             s->num_rematrixing_bands = 4;
1011             if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
1012                 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
1013             } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
1014                 s->num_rematrixing_bands--;
1015             }
1016             for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
1017                 s->rematrixing_flags[bnd] = get_bits1(gbc);
1018         } else if (!blk) {
1019             av_log(s->avctx, AV_LOG_WARNING, "Warning: "
1020                    "new rematrixing strategy not present in block 0\n");
1021             s->num_rematrixing_bands = 0;
1022         }
1023     }
1024
1025     /* exponent strategies for each channel */
1026     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1027         if (!s->eac3)
1028             s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
1029         if (s->exp_strategy[blk][ch] != EXP_REUSE)
1030             bit_alloc_stages[ch] = 3;
1031     }
1032
1033     /* channel bandwidth */
1034     for (ch = 1; ch <= fbw_channels; ch++) {
1035         s->start_freq[ch] = 0;
1036         if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1037             int group_size;
1038             int prev = s->end_freq[ch];
1039             if (s->channel_in_cpl[ch])
1040                 s->end_freq[ch] = s->start_freq[CPL_CH];
1041             else if (s->channel_uses_spx[ch])
1042                 s->end_freq[ch] = s->spx_src_start_freq;
1043             else {
1044                 int bandwidth_code = get_bits(gbc, 6);
1045                 if (bandwidth_code > 60) {
1046                     av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1047                     return AVERROR_INVALIDDATA;
1048                 }
1049                 s->end_freq[ch] = bandwidth_code * 3 + 73;
1050             }
1051             group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1052             s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
1053             if (blk > 0 && s->end_freq[ch] != prev)
1054                 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1055         }
1056     }
1057     if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1058         s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
1059                                     (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1060     }
1061
1062     /* decode exponents for each channel */
1063     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1064         if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1065             s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1066             if (decode_exponents(gbc, s->exp_strategy[blk][ch],
1067                                  s->num_exp_groups[ch], s->dexps[ch][0],
1068                                  &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1069                 av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
1070                 return AVERROR_INVALIDDATA;
1071             }
1072             if (ch != CPL_CH && ch != s->lfe_ch)
1073                 skip_bits(gbc, 2); /* skip gainrng */
1074         }
1075     }
1076
1077     /* bit allocation information */
1078     if (s->bit_allocation_syntax) {
1079         if (get_bits1(gbc)) {
1080             s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1081             s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1082             s->bit_alloc_params.slow_gain  = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
1083             s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
1084             s->bit_alloc_params.floor  = ff_ac3_floor_tab[get_bits(gbc, 3)];
1085             for (ch = !cpl_in_use; ch <= s->channels; ch++)
1086                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1087         } else if (!blk) {
1088             av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must "
1089                    "be present in block 0\n");
1090             return AVERROR_INVALIDDATA;
1091         }
1092     }
1093
1094     /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1095     if (!s->eac3 || !blk) {
1096         if (s->snr_offset_strategy && get_bits1(gbc)) {
1097             int snr = 0;
1098             int csnr;
1099             csnr = (get_bits(gbc, 6) - 15) << 4;
1100             for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1101                 /* snr offset */
1102                 if (ch == i || s->snr_offset_strategy == 2)
1103                     snr = (csnr + get_bits(gbc, 4)) << 2;
1104                 /* run at least last bit allocation stage if snr offset changes */
1105                 if (blk && s->snr_offset[ch] != snr) {
1106                     bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1107                 }
1108                 s->snr_offset[ch] = snr;
1109
1110                 /* fast gain (normal AC-3 only) */
1111                 if (!s->eac3) {
1112                     int prev = s->fast_gain[ch];
1113                     s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1114                     /* run last 2 bit allocation stages if fast gain changes */
1115                     if (blk && prev != s->fast_gain[ch])
1116                         bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1117                 }
1118             }
1119         } else if (!s->eac3 && !blk) {
1120             av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1121             return AVERROR_INVALIDDATA;
1122         }
1123     }
1124
1125     /* fast gain (E-AC-3 only) */
1126     if (s->fast_gain_syntax && get_bits1(gbc)) {
1127         for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1128             int prev = s->fast_gain[ch];
1129             s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1130             /* run last 2 bit allocation stages if fast gain changes */
1131             if (blk && prev != s->fast_gain[ch])
1132                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1133         }
1134     } else if (s->eac3 && !blk) {
1135         for (ch = !cpl_in_use; ch <= s->channels; ch++)
1136             s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1137     }
1138
1139     /* E-AC-3 to AC-3 converter SNR offset */
1140     if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1141         skip_bits(gbc, 10); // skip converter snr offset
1142     }
1143
1144     /* coupling leak information */
1145     if (cpl_in_use) {
1146         if (s->first_cpl_leak || get_bits1(gbc)) {
1147             int fl = get_bits(gbc, 3);
1148             int sl = get_bits(gbc, 3);
1149             /* run last 2 bit allocation stages for coupling channel if
1150                coupling leak changes */
1151             if (blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1152                 sl != s->bit_alloc_params.cpl_slow_leak)) {
1153                 bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1154             }
1155             s->bit_alloc_params.cpl_fast_leak = fl;
1156             s->bit_alloc_params.cpl_slow_leak = sl;
1157         } else if (!s->eac3 && !blk) {
1158             av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must "
1159                    "be present in block 0\n");
1160             return AVERROR_INVALIDDATA;
1161         }
1162         s->first_cpl_leak = 0;
1163     }
1164
1165     /* delta bit allocation information */
1166     if (s->dba_syntax && get_bits1(gbc)) {
1167         /* delta bit allocation exists (strategy) */
1168         for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1169             s->dba_mode[ch] = get_bits(gbc, 2);
1170             if (s->dba_mode[ch] == DBA_RESERVED) {
1171                 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1172                 return AVERROR_INVALIDDATA;
1173             }
1174             bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1175         }
1176         /* channel delta offset, len and bit allocation */
1177         for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1178             if (s->dba_mode[ch] == DBA_NEW) {
1179                 s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;
1180                 for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
1181                     s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1182                     s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1183                     s->dba_values[ch][seg]  = get_bits(gbc, 3);
1184                 }
1185                 /* run last 2 bit allocation stages if new dba values */
1186                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1187             }
1188         }
1189     } else if (blk == 0) {
1190         for (ch = 0; ch <= s->channels; ch++) {
1191             s->dba_mode[ch] = DBA_NONE;
1192         }
1193     }
1194
1195     /* Bit allocation */
1196     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1197         if (bit_alloc_stages[ch] > 2) {
1198             /* Exponent mapping into PSD and PSD integration */
1199             ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
1200                                       s->start_freq[ch], s->end_freq[ch],
1201                                       s->psd[ch], s->band_psd[ch]);
1202         }
1203         if (bit_alloc_stages[ch] > 1) {
1204             /* Compute excitation function, Compute masking curve, and
1205                Apply delta bit allocation */
1206             if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1207                                            s->start_freq[ch],  s->end_freq[ch],
1208                                            s->fast_gain[ch],   (ch == s->lfe_ch),
1209                                            s->dba_mode[ch],    s->dba_nsegs[ch],
1210                                            s->dba_offsets[ch], s->dba_lengths[ch],
1211                                            s->dba_values[ch],  s->mask[ch])) {
1212                 av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1213                 return AVERROR_INVALIDDATA;
1214             }
1215         }
1216         if (bit_alloc_stages[ch] > 0) {
1217             /* Compute bit allocation */
1218             const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1219                                      ff_eac3_hebap_tab : ff_ac3_bap_tab;
1220             s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1221                                       s->start_freq[ch], s->end_freq[ch],
1222                                       s->snr_offset[ch],
1223                                       s->bit_alloc_params.floor,
1224                                       bap_tab, s->bap[ch]);
1225         }
1226     }
1227
1228     /* unused dummy data */
1229     if (s->skip_syntax && get_bits1(gbc)) {
1230         int skipl = get_bits(gbc, 9);
1231         while (skipl--)
1232             skip_bits(gbc, 8);
1233     }
1234
1235     /* unpack the transform coefficients
1236        this also uncouples channels if coupling is in use. */
1237     decode_transform_coeffs(s, blk);
1238
1239     /* TODO: generate enhanced coupling coordinates and uncouple */
1240
1241     /* recover coefficients if rematrixing is in use */
1242     if (s->channel_mode == AC3_CHMODE_STEREO)
1243         do_rematrixing(s);
1244
1245     /* apply scaling to coefficients (headroom, dynrng) */
1246     for (ch = 1; ch <= s->channels; ch++) {
1247         float gain = 1.0 / 4194304.0f;
1248         if (s->channel_mode == AC3_CHMODE_DUALMONO) {
1249             gain *= s->dynamic_range[2 - ch];
1250         } else {
1251             gain *= s->dynamic_range[0];
1252         }
1253         s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch],
1254                                                s->fixed_coeffs[ch], gain, 256);
1255     }
1256
1257     /* apply spectral extension to high frequency bins */
1258     if (s->spx_in_use && CONFIG_EAC3_DECODER) {
1259         ff_eac3_apply_spectral_extension(s);
1260     }
1261
1262     /* downmix and MDCT. order depends on whether block switching is used for
1263        any channel in this block. this is because coefficients for the long
1264        and short transforms cannot be mixed. */
1265     downmix_output = s->channels != s->out_channels &&
1266                      !((s->output_mode & AC3_OUTPUT_LFEON) &&
1267                      s->fbw_channels == s->out_channels);
1268     if (different_transforms) {
1269         /* the delay samples have already been downmixed, so we upmix the delay
1270            samples in order to reconstruct all channels before downmixing. */
1271         if (s->downmixed) {
1272             s->downmixed = 0;
1273             ac3_upmix_delay(s);
1274         }
1275
1276         do_imdct(s, s->channels);
1277
1278         if (downmix_output) {
1279             s->ac3dsp.downmix(s->outptr, s->downmix_coeffs,
1280                               s->out_channels, s->fbw_channels, 256);
1281         }
1282     } else {
1283         if (downmix_output) {
1284             s->ac3dsp.downmix(s->xcfptr + 1, s->downmix_coeffs,
1285                               s->out_channels, s->fbw_channels, 256);
1286         }
1287
1288         if (downmix_output && !s->downmixed) {
1289             s->downmixed = 1;
1290             s->ac3dsp.downmix(s->dlyptr, s->downmix_coeffs, s->out_channels,
1291                               s->fbw_channels, 128);
1292         }
1293
1294         do_imdct(s, s->out_channels);
1295     }
1296
1297     return 0;
1298 }
1299
1300 /**
1301  * Decode a single AC-3 frame.
1302  */
1303 static int ac3_decode_frame(AVCodecContext * avctx, void *data,
1304                             int *got_frame_ptr, AVPacket *avpkt)
1305 {
1306     AVFrame *frame     = data;
1307     const uint8_t *buf = avpkt->data;
1308     int buf_size = avpkt->size;
1309     AC3DecodeContext *s = avctx->priv_data;
1310     int blk, ch, err, ret;
1311     const uint8_t *channel_map;
1312     const float *output[AC3_MAX_CHANNELS];
1313     enum AVMatrixEncoding matrix_encoding;
1314     AVDownmixInfo *downmix_info;
1315
1316     /* copy input buffer to decoder context to avoid reading past the end
1317        of the buffer, which can be caused by a damaged input stream. */
1318     if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
1319         // seems to be byte-swapped AC-3
1320         int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1321         s->bdsp.bswap16_buf((uint16_t *) s->input_buffer,
1322                             (const uint16_t *) buf, cnt);
1323     } else
1324         memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1325     buf = s->input_buffer;
1326     /* initialize the GetBitContext with the start of valid AC-3 Frame */
1327     init_get_bits(&s->gbc, buf, buf_size * 8);
1328
1329     /* parse the syncinfo */
1330     err = parse_frame_header(s);
1331
1332     if (err) {
1333         switch (err) {
1334         case AAC_AC3_PARSE_ERROR_SYNC:
1335             av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1336             return AVERROR_INVALIDDATA;
1337         case AAC_AC3_PARSE_ERROR_BSID:
1338             av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1339             break;
1340         case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
1341             av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1342             break;
1343         case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
1344             av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1345             break;
1346         case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
1347             /* skip frame if CRC is ok. otherwise use error concealment. */
1348             /* TODO: add support for substreams and dependent frames */
1349             if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
1350                 av_log(avctx, AV_LOG_WARNING, "unsupported frame type : "
1351                        "skipping frame\n");
1352                 *got_frame_ptr = 0;
1353                 return buf_size;
1354             } else {
1355                 av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1356             }
1357             break;
1358         case AAC_AC3_PARSE_ERROR_CRC:
1359         case AAC_AC3_PARSE_ERROR_CHANNEL_CFG:
1360             break;
1361         default: // Normal AVERROR do not try to recover.
1362             *got_frame_ptr = 0;
1363             return err;
1364         }
1365     } else {
1366         /* check that reported frame size fits in input buffer */
1367         if (s->frame_size > buf_size) {
1368             av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1369             err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
1370         } else if (avctx->err_recognition & AV_EF_CRCCHECK) {
1371             /* check for crc mismatch */
1372             if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
1373                        s->frame_size - 2)) {
1374                 av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1375                 if (avctx->err_recognition & AV_EF_EXPLODE)
1376                     return AVERROR_INVALIDDATA;
1377                 err = AAC_AC3_PARSE_ERROR_CRC;
1378             }
1379         }
1380     }
1381
1382     /* if frame is ok, set audio parameters */
1383     if (!err) {
1384         avctx->sample_rate = s->sample_rate;
1385         avctx->bit_rate    = s->bit_rate;
1386     }
1387
1388     /* channel config */
1389     if (!err || (s->channels && s->out_channels != s->channels)) {
1390         s->out_channels = s->channels;
1391         s->output_mode  = s->channel_mode;
1392         if (s->lfe_on)
1393             s->output_mode |= AC3_OUTPUT_LFEON;
1394         if (s->channels > 1 &&
1395             avctx->request_channel_layout == AV_CH_LAYOUT_MONO) {
1396             s->out_channels = 1;
1397             s->output_mode  = AC3_CHMODE_MONO;
1398         } else if (s->channels > 2 &&
1399                    avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
1400             s->out_channels = 2;
1401             s->output_mode  = AC3_CHMODE_STEREO;
1402         }
1403
1404         /* set downmixing coefficients if needed */
1405         if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1406                 s->fbw_channels == s->out_channels)) {
1407             set_downmix_coeffs(s);
1408         }
1409     } else if (!s->channels) {
1410         av_log(avctx, AV_LOG_ERROR, "unable to determine channel mode\n");
1411         return AVERROR_INVALIDDATA;
1412     }
1413     avctx->channels = s->out_channels;
1414     avctx->channel_layout = avpriv_ac3_channel_layout_tab[s->output_mode & ~AC3_OUTPUT_LFEON];
1415     if (s->output_mode & AC3_OUTPUT_LFEON)
1416         avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1417
1418     /* set audio service type based on bitstream mode for AC-3 */
1419     avctx->audio_service_type = s->bitstream_mode;
1420     if (s->bitstream_mode == 0x7 && s->channels > 1)
1421         avctx->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
1422
1423     /* get output buffer */
1424     frame->nb_samples = s->num_blocks * AC3_BLOCK_SIZE;
1425     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
1426         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1427         return ret;
1428     }
1429
1430     /* decode the audio blocks */
1431     channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1432     for (ch = 0; ch < s->channels; ch++) {
1433         if (ch < s->out_channels)
1434             s->outptr[channel_map[ch]] = (float *)frame->data[ch];
1435         else
1436             s->outptr[ch] = s->output[ch];
1437         output[ch] = s->output[ch];
1438     }
1439     for (blk = 0; blk < s->num_blocks; blk++) {
1440         if (!err && decode_audio_block(s, blk)) {
1441             av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1442             err = 1;
1443         }
1444         if (err)
1445             for (ch = 0; ch < s->out_channels; ch++)
1446                 memcpy(s->outptr[channel_map[ch]], output[ch], sizeof(**output) * AC3_BLOCK_SIZE);
1447         for (ch = 0; ch < s->out_channels; ch++)
1448             output[ch] = s->outptr[channel_map[ch]];
1449         for (ch = 0; ch < s->out_channels; ch++)
1450             s->outptr[ch] += AC3_BLOCK_SIZE;
1451     }
1452
1453     /* keep last block for error concealment in next frame */
1454     for (ch = 0; ch < s->out_channels; ch++)
1455         memcpy(s->output[ch], output[ch], sizeof(**output) * AC3_BLOCK_SIZE);
1456
1457     /*
1458      * AVMatrixEncoding
1459      *
1460      * Check whether the input layout is compatible, and make sure we're not
1461      * downmixing (else the matrix encoding is no longer applicable).
1462      */
1463     matrix_encoding = AV_MATRIX_ENCODING_NONE;
1464     if (s->channel_mode == AC3_CHMODE_STEREO &&
1465         s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1466         if (s->dolby_surround_mode == AC3_DSURMOD_ON)
1467             matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
1468         else if (s->dolby_headphone_mode == AC3_DHEADPHONMOD_ON)
1469             matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;
1470     } else if (s->channel_mode >= AC3_CHMODE_2F2R &&
1471                s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1472         switch (s->dolby_surround_ex_mode) {
1473         case AC3_DSUREXMOD_ON: // EX or PLIIx
1474             matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
1475             break;
1476         case AC3_DSUREXMOD_PLIIZ:
1477             matrix_encoding = AV_MATRIX_ENCODING_DPLIIZ;
1478             break;
1479         default: // not indicated or off
1480             break;
1481         }
1482     }
1483     if ((ret = ff_side_data_update_matrix_encoding(frame, matrix_encoding)) < 0)
1484         return ret;
1485
1486     /* AVDownmixInfo */
1487     if ((downmix_info = av_downmix_info_update_side_data(frame))) {
1488         switch (s->preferred_downmix) {
1489         case AC3_DMIXMOD_LTRT:
1490             downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_LTRT;
1491             break;
1492         case AC3_DMIXMOD_LORO:
1493             downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_LORO;
1494             break;
1495         case AC3_DMIXMOD_DPLII:
1496             downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_DPLII;
1497             break;
1498         default:
1499             downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_UNKNOWN;
1500             break;
1501         }
1502         downmix_info->center_mix_level        = gain_levels[s->       center_mix_level];
1503         downmix_info->center_mix_level_ltrt   = gain_levels[s->  center_mix_level_ltrt];
1504         downmix_info->surround_mix_level      = gain_levels[s->     surround_mix_level];
1505         downmix_info->surround_mix_level_ltrt = gain_levels[s->surround_mix_level_ltrt];
1506         if (s->lfe_mix_level_exists)
1507             downmix_info->lfe_mix_level       = gain_levels_lfe[s->lfe_mix_level];
1508         else
1509             downmix_info->lfe_mix_level       = 0.0; // -inf dB
1510     } else
1511         return AVERROR(ENOMEM);
1512
1513     *got_frame_ptr = 1;
1514
1515     return FFMIN(buf_size, s->frame_size);
1516 }
1517
1518 /**
1519  * Uninitialize the AC-3 decoder.
1520  */
1521 static av_cold int ac3_decode_end(AVCodecContext *avctx)
1522 {
1523     AC3DecodeContext *s = avctx->priv_data;
1524     ff_mdct_end(&s->imdct_512);
1525     ff_mdct_end(&s->imdct_256);
1526
1527     return 0;
1528 }
1529
1530 #define OFFSET(x) offsetof(AC3DecodeContext, x)
1531 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)
1532 static const AVOption options[] = {
1533     { "drc_scale", "percentage of dynamic range compression to apply", OFFSET(drc_scale), AV_OPT_TYPE_FLOAT, {.dbl = 1.0}, 0.0, 6.0, PAR },
1534     { NULL},
1535 };
1536
1537 static const AVClass ac3_decoder_class = {
1538     .class_name = "AC3 decoder",
1539     .item_name  = av_default_item_name,
1540     .option     = options,
1541     .version    = LIBAVUTIL_VERSION_INT,
1542 };
1543
1544 AVCodec ff_ac3_decoder = {
1545     .name           = "ac3",
1546     .long_name      = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
1547     .type           = AVMEDIA_TYPE_AUDIO,
1548     .id             = AV_CODEC_ID_AC3,
1549     .priv_data_size = sizeof (AC3DecodeContext),
1550     .init           = ac3_decode_init,
1551     .close          = ac3_decode_end,
1552     .decode         = ac3_decode_frame,
1553     .capabilities   = AV_CODEC_CAP_DR1,
1554     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1555                                                       AV_SAMPLE_FMT_NONE },
1556     .priv_class     = &ac3_decoder_class,
1557 };
1558
1559 #if CONFIG_EAC3_DECODER
1560 static const AVClass eac3_decoder_class = {
1561     .class_name = "E-AC3 decoder",
1562     .item_name  = av_default_item_name,
1563     .option     = options,
1564     .version    = LIBAVUTIL_VERSION_INT,
1565 };
1566
1567 AVCodec ff_eac3_decoder = {
1568     .name           = "eac3",
1569     .long_name      = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
1570     .type           = AVMEDIA_TYPE_AUDIO,
1571     .id             = AV_CODEC_ID_EAC3,
1572     .priv_data_size = sizeof (AC3DecodeContext),
1573     .init           = ac3_decode_init,
1574     .close          = ac3_decode_end,
1575     .decode         = ac3_decode_frame,
1576     .capabilities   = AV_CODEC_CAP_DR1,
1577     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1578                                                       AV_SAMPLE_FMT_NONE },
1579     .priv_class     = &eac3_decoder_class,
1580 };
1581 #endif