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