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