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