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