avcodec/ac3: Explicitly return to discard large amounts of nonsense bytes
[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/downmix_info.h"
35 #include "libavutil/opt.h"
36 #include "bswapdsp.h"
37 #include "internal.h"
38 #include "aac_ac3_parser.h"
39 #include "ac3_parser_internal.h"
40 #include "ac3dec.h"
41 #include "ac3dec_data.h"
42 #include "kbdwin.h"
43
44 /**
45  * table for ungrouping 3 values in 7 bits.
46  * used for exponents and bap=2 mantissas
47  */
48 static uint8_t ungroup_3_in_7_bits_tab[128][3];
49
50 /** tables for ungrouping mantissas */
51 static int b1_mantissas[32][3];
52 static int b2_mantissas[128][3];
53 static int b3_mantissas[8];
54 static int b4_mantissas[128][2];
55 static int b5_mantissas[16];
56
57 /**
58  * Quantization table: levels for symmetric. bits for asymmetric.
59  * reference: Table 7.18 Mapping of bap to Quantizer
60  */
61 static const uint8_t quantization_tab[16] = {
62     0, 3, 5, 7, 11, 15,
63     5, 6, 7, 8, 9, 10, 11, 12, 14, 16
64 };
65
66 #if (!USE_FIXED)
67 /** dynamic range table. converts codes to scale factors. */
68 static float dynamic_range_tab[256];
69 float ff_ac3_heavy_dynamic_range_tab[256];
70 #endif
71
72 /** Adjustments in dB gain */
73 static const float gain_levels[9] = {
74     LEVEL_PLUS_3DB,
75     LEVEL_PLUS_1POINT5DB,
76     LEVEL_ONE,
77     LEVEL_MINUS_1POINT5DB,
78     LEVEL_MINUS_3DB,
79     LEVEL_MINUS_4POINT5DB,
80     LEVEL_MINUS_6DB,
81     LEVEL_ZERO,
82     LEVEL_MINUS_9DB
83 };
84
85 /** Adjustments in dB gain (LFE, +10 to -21 dB) */
86 static const float gain_levels_lfe[32] = {
87     3.162275, 2.818382, 2.511886, 2.238719, 1.995261, 1.778278, 1.584893,
88     1.412536, 1.258924, 1.122018, 1.000000, 0.891251, 0.794328, 0.707946,
89     0.630957, 0.562341, 0.501187, 0.446683, 0.398107, 0.354813, 0.316227,
90     0.281838, 0.251188, 0.223872, 0.199526, 0.177828, 0.158489, 0.141253,
91     0.125892, 0.112201, 0.100000, 0.089125
92 };
93
94 /**
95  * Table for default stereo downmixing coefficients
96  * reference: Section 7.8.2 Downmixing Into Two Channels
97  */
98 static const uint8_t ac3_default_coeffs[8][5][2] = {
99     { { 2, 7 }, { 7, 2 },                               },
100     { { 4, 4 },                                         },
101     { { 2, 7 }, { 7, 2 },                               },
102     { { 2, 7 }, { 5, 5 }, { 7, 2 },                     },
103     { { 2, 7 }, { 7, 2 }, { 6, 6 },                     },
104     { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 },           },
105     { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 },           },
106     { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
107 };
108
109 /**
110  * Symmetrical Dequantization
111  * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization
112  *            Tables 7.19 to 7.23
113  */
114 static inline int
115 symmetric_dequant(int code, int levels)
116 {
117     return ((code - (levels >> 1)) * (1 << 24)) / levels;
118 }
119
120 /*
121  * Initialize tables at runtime.
122  */
123 static av_cold void ac3_tables_init(void)
124 {
125     int i;
126
127     /* generate table for ungrouping 3 values in 7 bits
128        reference: Section 7.1.3 Exponent Decoding */
129     for (i = 0; i < 128; i++) {
130         ungroup_3_in_7_bits_tab[i][0] =  i / 25;
131         ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5;
132         ungroup_3_in_7_bits_tab[i][2] = (i % 25) % 5;
133     }
134
135     /* generate grouped mantissa tables
136        reference: Section 7.3.5 Ungrouping of Mantissas */
137     for (i = 0; i < 32; i++) {
138         /* bap=1 mantissas */
139         b1_mantissas[i][0] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][0], 3);
140         b1_mantissas[i][1] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][1], 3);
141         b1_mantissas[i][2] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][2], 3);
142     }
143     for (i = 0; i < 128; i++) {
144         /* bap=2 mantissas */
145         b2_mantissas[i][0] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][0], 5);
146         b2_mantissas[i][1] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][1], 5);
147         b2_mantissas[i][2] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][2], 5);
148
149         /* bap=4 mantissas */
150         b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
151         b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
152     }
153     /* generate ungrouped mantissa tables
154        reference: Tables 7.21 and 7.23 */
155     for (i = 0; i < 7; i++) {
156         /* bap=3 mantissas */
157         b3_mantissas[i] = symmetric_dequant(i, 7);
158     }
159     for (i = 0; i < 15; i++) {
160         /* bap=5 mantissas */
161         b5_mantissas[i] = symmetric_dequant(i, 15);
162     }
163
164 #if (!USE_FIXED)
165     /* generate dynamic range table
166        reference: Section 7.7.1 Dynamic Range Control */
167     for (i = 0; i < 256; i++) {
168         int v = (i >> 5) - ((i >> 7) << 3) - 5;
169         dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
170     }
171
172     /* generate compr dynamic range table
173        reference: Section 7.7.2 Heavy Compression */
174     for (i = 0; i < 256; i++) {
175         int v = (i >> 4) - ((i >> 7) << 4) - 4;
176         ff_ac3_heavy_dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0xF) | 0x10);
177     }
178 #endif
179 }
180
181 /**
182  * AVCodec initialization
183  */
184 static av_cold int ac3_decode_init(AVCodecContext *avctx)
185 {
186     AC3DecodeContext *s = avctx->priv_data;
187     int i;
188
189     s->avctx = avctx;
190
191     ac3_tables_init();
192     ff_mdct_init(&s->imdct_256, 8, 1, 1.0);
193     ff_mdct_init(&s->imdct_512, 9, 1, 1.0);
194     AC3_RENAME(ff_kbd_window_init)(s->window, 5.0, 256);
195     ff_bswapdsp_init(&s->bdsp);
196
197 #if (USE_FIXED)
198     s->fdsp = avpriv_alloc_fixed_dsp(avctx->flags & AV_CODEC_FLAG_BITEXACT);
199 #else
200     s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
201     ff_fmt_convert_init(&s->fmt_conv, avctx);
202 #endif
203
204     ff_ac3dsp_init(&s->ac3dsp, avctx->flags & AV_CODEC_FLAG_BITEXACT);
205     av_lfg_init(&s->dith_state, 0);
206
207     if (USE_FIXED)
208         avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
209     else
210         avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
211
212     /* allow downmixing to stereo or mono */
213     if (avctx->channels > 1 &&
214         avctx->request_channel_layout == AV_CH_LAYOUT_MONO)
215         avctx->channels = 1;
216     else if (avctx->channels > 2 &&
217              avctx->request_channel_layout == AV_CH_LAYOUT_STEREO)
218         avctx->channels = 2;
219     s->downmixed = 1;
220
221     for (i = 0; i < AC3_MAX_CHANNELS; i++) {
222         s->xcfptr[i] = s->transform_coeffs[i];
223         s->dlyptr[i] = s->delay[i];
224     }
225
226     return 0;
227 }
228
229 /**
230  * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
231  * GetBitContext within AC3DecodeContext must point to
232  * the start of the synchronized AC-3 bitstream.
233  */
234 static int ac3_parse_header(AC3DecodeContext *s)
235 {
236     GetBitContext *gbc = &s->gbc;
237     int i;
238
239     /* read the rest of the bsi. read twice for dual mono mode. */
240     i = !s->channel_mode;
241     do {
242         s->dialog_normalization[(!s->channel_mode)-i] = -get_bits(gbc, 5);
243         if (s->dialog_normalization[(!s->channel_mode)-i] == 0) {
244             s->dialog_normalization[(!s->channel_mode)-i] = -31;
245         }
246         if (s->target_level != 0) {
247             s->level_gain[(!s->channel_mode)-i] = powf(2.0f,
248                 (float)(s->target_level -
249                 s->dialog_normalization[(!s->channel_mode)-i])/6.0f);
250         }
251         if (s->compression_exists[(!s->channel_mode)-i] = get_bits1(gbc)) {
252             s->heavy_dynamic_range[(!s->channel_mode)-i] =
253                 AC3_HEAVY_RANGE(get_bits(gbc, 8));
254         }
255         if (get_bits1(gbc))
256             skip_bits(gbc, 8); //skip language code
257         if (get_bits1(gbc))
258             skip_bits(gbc, 7); //skip audio production information
259     } while (i--);
260
261     skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
262
263     /* skip the timecodes or parse the Alternate Bit Stream Syntax */
264     if (s->bitstream_id != 6) {
265         if (get_bits1(gbc))
266             skip_bits(gbc, 14); //skip timecode1
267         if (get_bits1(gbc))
268             skip_bits(gbc, 14); //skip timecode2
269     } else {
270         if (get_bits1(gbc)) {
271             s->preferred_downmix       = get_bits(gbc, 2);
272             s->center_mix_level_ltrt   = get_bits(gbc, 3);
273             s->surround_mix_level_ltrt = av_clip(get_bits(gbc, 3), 3, 7);
274             s->center_mix_level        = get_bits(gbc, 3);
275             s->surround_mix_level      = av_clip(get_bits(gbc, 3), 3, 7);
276         }
277         if (get_bits1(gbc)) {
278             s->dolby_surround_ex_mode = get_bits(gbc, 2);
279             s->dolby_headphone_mode   = get_bits(gbc, 2);
280             skip_bits(gbc, 10); // skip adconvtyp (1), xbsi2 (8), encinfo (1)
281         }
282     }
283
284     /* skip additional bitstream info */
285     if (get_bits1(gbc)) {
286         i = get_bits(gbc, 6);
287         do {
288             skip_bits(gbc, 8);
289         } while (i--);
290     }
291
292     return 0;
293 }
294
295 /**
296  * Common function to parse AC-3 or E-AC-3 frame header
297  */
298 static int parse_frame_header(AC3DecodeContext *s)
299 {
300     AC3HeaderInfo hdr;
301     int err;
302
303     err = ff_ac3_parse_header(&s->gbc, &hdr);
304     if (err)
305         return err;
306
307     /* get decoding parameters from header info */
308     s->bit_alloc_params.sr_code     = hdr.sr_code;
309     s->bitstream_id                 = hdr.bitstream_id;
310     s->bitstream_mode               = hdr.bitstream_mode;
311     s->channel_mode                 = hdr.channel_mode;
312     s->lfe_on                       = hdr.lfe_on;
313     s->bit_alloc_params.sr_shift    = hdr.sr_shift;
314     s->sample_rate                  = hdr.sample_rate;
315     s->bit_rate                     = hdr.bit_rate;
316     s->channels                     = hdr.channels;
317     s->fbw_channels                 = s->channels - s->lfe_on;
318     s->lfe_ch                       = s->fbw_channels + 1;
319     s->frame_size                   = hdr.frame_size;
320     s->superframe_size             += hdr.frame_size;
321     s->preferred_downmix            = AC3_DMIXMOD_NOTINDICATED;
322     s->center_mix_level             = hdr.center_mix_level;
323     s->center_mix_level_ltrt        = 4; // -3.0dB
324     s->surround_mix_level           = hdr.surround_mix_level;
325     s->surround_mix_level_ltrt      = 4; // -3.0dB
326     s->lfe_mix_level_exists         = 0;
327     s->num_blocks                   = hdr.num_blocks;
328     s->frame_type                   = hdr.frame_type;
329     s->substreamid                  = hdr.substreamid;
330     s->dolby_surround_mode          = hdr.dolby_surround_mode;
331     s->dolby_surround_ex_mode       = AC3_DSUREXMOD_NOTINDICATED;
332     s->dolby_headphone_mode         = AC3_DHEADPHONMOD_NOTINDICATED;
333
334     if (s->lfe_on) {
335         s->start_freq[s->lfe_ch]     = 0;
336         s->end_freq[s->lfe_ch]       = 7;
337         s->num_exp_groups[s->lfe_ch] = 2;
338         s->channel_in_cpl[s->lfe_ch] = 0;
339     }
340
341     if (s->bitstream_id <= 10) {
342         s->eac3                  = 0;
343         s->snr_offset_strategy   = 2;
344         s->block_switch_syntax   = 1;
345         s->dither_flag_syntax    = 1;
346         s->bit_allocation_syntax = 1;
347         s->fast_gain_syntax      = 0;
348         s->first_cpl_leak        = 0;
349         s->dba_syntax            = 1;
350         s->skip_syntax           = 1;
351         memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
352         return ac3_parse_header(s);
353     } else if (CONFIG_EAC3_DECODER) {
354         s->eac3 = 1;
355         return ff_eac3_parse_header(s);
356     } else {
357         av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n");
358         return AVERROR(ENOSYS);
359     }
360 }
361
362 /**
363  * Set stereo downmixing coefficients based on frame header info.
364  * reference: Section 7.8.2 Downmixing Into Two Channels
365  */
366 static int set_downmix_coeffs(AC3DecodeContext *s)
367 {
368     int i;
369     float cmix = gain_levels[s->  center_mix_level];
370     float smix = gain_levels[s->surround_mix_level];
371     float norm0, norm1;
372     float downmix_coeffs[2][AC3_MAX_CHANNELS];
373
374     if (!s->downmix_coeffs[0]) {
375         s->downmix_coeffs[0] = av_malloc_array(2 * AC3_MAX_CHANNELS,
376                                                sizeof(**s->downmix_coeffs));
377         if (!s->downmix_coeffs[0])
378             return AVERROR(ENOMEM);
379         s->downmix_coeffs[1] = s->downmix_coeffs[0] + AC3_MAX_CHANNELS;
380     }
381
382     for (i = 0; i < s->fbw_channels; i++) {
383         downmix_coeffs[0][i] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
384         downmix_coeffs[1][i] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
385     }
386     if (s->channel_mode > 1 && s->channel_mode & 1) {
387         downmix_coeffs[0][1] = downmix_coeffs[1][1] = cmix;
388     }
389     if (s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
390         int nf = s->channel_mode - 2;
391         downmix_coeffs[0][nf] = downmix_coeffs[1][nf] = smix * LEVEL_MINUS_3DB;
392     }
393     if (s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
394         int nf = s->channel_mode - 4;
395         downmix_coeffs[0][nf] = downmix_coeffs[1][nf+1] = smix;
396     }
397
398     /* renormalize */
399     norm0 = norm1 = 0.0;
400     for (i = 0; i < s->fbw_channels; i++) {
401         norm0 += downmix_coeffs[0][i];
402         norm1 += downmix_coeffs[1][i];
403     }
404     norm0 = 1.0f / norm0;
405     norm1 = 1.0f / norm1;
406     for (i = 0; i < s->fbw_channels; i++) {
407         downmix_coeffs[0][i] *= norm0;
408         downmix_coeffs[1][i] *= norm1;
409     }
410
411     if (s->output_mode == AC3_CHMODE_MONO) {
412         for (i = 0; i < s->fbw_channels; i++)
413             downmix_coeffs[0][i] = (downmix_coeffs[0][i] +
414                                     downmix_coeffs[1][i]) * LEVEL_MINUS_3DB;
415     }
416     for (i = 0; i < s->fbw_channels; i++) {
417         s->downmix_coeffs[0][i] = FIXR12(downmix_coeffs[0][i]);
418         s->downmix_coeffs[1][i] = FIXR12(downmix_coeffs[1][i]);
419     }
420
421     return 0;
422 }
423
424 /**
425  * Decode the grouped exponents according to exponent strategy.
426  * reference: Section 7.1.3 Exponent Decoding
427  */
428 static int decode_exponents(AC3DecodeContext *s,
429                             GetBitContext *gbc, int exp_strategy, int ngrps,
430                             uint8_t absexp, int8_t *dexps)
431 {
432     int i, j, grp, group_size;
433     int dexp[256];
434     int expacc, prevexp;
435
436     /* unpack groups */
437     group_size = exp_strategy + (exp_strategy == EXP_D45);
438     for (grp = 0, i = 0; grp < ngrps; grp++) {
439         expacc = get_bits(gbc, 7);
440         if (expacc >= 125) {
441             av_log(s->avctx, AV_LOG_ERROR, "expacc %d is out-of-range\n", expacc);
442             return AVERROR_INVALIDDATA;
443         }
444         dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
445         dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
446         dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
447     }
448
449     /* convert to absolute exps and expand groups */
450     prevexp = absexp;
451     for (i = 0, j = 0; i < ngrps * 3; i++) {
452         prevexp += dexp[i] - 2;
453         if (prevexp > 24U) {
454             av_log(s->avctx, AV_LOG_ERROR, "exponent %d is out-of-range\n", prevexp);
455             return AVERROR_INVALIDDATA;
456         }
457         switch (group_size) {
458         case 4: dexps[j++] = prevexp;
459                 dexps[j++] = prevexp;
460         case 2: dexps[j++] = prevexp;
461         case 1: dexps[j++] = prevexp;
462         }
463     }
464     return 0;
465 }
466
467 /**
468  * Generate transform coefficients for each coupled channel in the coupling
469  * range using the coupling coefficients and coupling coordinates.
470  * reference: Section 7.4.3 Coupling Coordinate Format
471  */
472 static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
473 {
474     int bin, band, ch;
475
476     bin = s->start_freq[CPL_CH];
477     for (band = 0; band < s->num_cpl_bands; band++) {
478         int band_start = bin;
479         int band_end = bin + s->cpl_band_sizes[band];
480         for (ch = 1; ch <= s->fbw_channels; ch++) {
481             if (s->channel_in_cpl[ch]) {
482                 int cpl_coord = s->cpl_coords[ch][band] << 5;
483                 for (bin = band_start; bin < band_end; bin++) {
484                     s->fixed_coeffs[ch][bin] =
485                         MULH(s->fixed_coeffs[CPL_CH][bin] * (1 << 4), cpl_coord);
486                 }
487                 if (ch == 2 && s->phase_flags[band]) {
488                     for (bin = band_start; bin < band_end; bin++)
489                         s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin];
490                 }
491             }
492         }
493         bin = band_end;
494     }
495 }
496
497 /**
498  * Grouped mantissas for 3-level 5-level and 11-level quantization
499  */
500 typedef struct mant_groups {
501     int b1_mant[2];
502     int b2_mant[2];
503     int b4_mant;
504     int b1;
505     int b2;
506     int b4;
507 } mant_groups;
508
509 /**
510  * Decode the transform coefficients for a particular channel
511  * reference: Section 7.3 Quantization and Decoding of Mantissas
512  */
513 static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
514 {
515     int start_freq = s->start_freq[ch_index];
516     int end_freq   = s->end_freq[ch_index];
517     uint8_t *baps  = s->bap[ch_index];
518     int8_t *exps   = s->dexps[ch_index];
519     int32_t *coeffs = s->fixed_coeffs[ch_index];
520     int dither     = (ch_index == CPL_CH) || s->dither_flag[ch_index];
521     GetBitContext *gbc = &s->gbc;
522     int freq;
523
524     for (freq = start_freq; freq < end_freq; freq++) {
525         int bap = baps[freq];
526         int mantissa;
527         switch (bap) {
528         case 0:
529             /* random noise with approximate range of -0.707 to 0.707 */
530             if (dither)
531                 mantissa = (((av_lfg_get(&s->dith_state)>>8)*181)>>8) - 5931008;
532             else
533                 mantissa = 0;
534             break;
535         case 1:
536             if (m->b1) {
537                 m->b1--;
538                 mantissa = m->b1_mant[m->b1];
539             } else {
540                 int bits      = get_bits(gbc, 5);
541                 mantissa      = b1_mantissas[bits][0];
542                 m->b1_mant[1] = b1_mantissas[bits][1];
543                 m->b1_mant[0] = b1_mantissas[bits][2];
544                 m->b1         = 2;
545             }
546             break;
547         case 2:
548             if (m->b2) {
549                 m->b2--;
550                 mantissa = m->b2_mant[m->b2];
551             } else {
552                 int bits      = get_bits(gbc, 7);
553                 mantissa      = b2_mantissas[bits][0];
554                 m->b2_mant[1] = b2_mantissas[bits][1];
555                 m->b2_mant[0] = b2_mantissas[bits][2];
556                 m->b2         = 2;
557             }
558             break;
559         case 3:
560             mantissa = b3_mantissas[get_bits(gbc, 3)];
561             break;
562         case 4:
563             if (m->b4) {
564                 m->b4 = 0;
565                 mantissa = m->b4_mant;
566             } else {
567                 int bits   = get_bits(gbc, 7);
568                 mantissa   = b4_mantissas[bits][0];
569                 m->b4_mant = b4_mantissas[bits][1];
570                 m->b4      = 1;
571             }
572             break;
573         case 5:
574             mantissa = b5_mantissas[get_bits(gbc, 4)];
575             break;
576         default: /* 6 to 15 */
577             /* Shift mantissa and sign-extend it. */
578             if (bap > 15) {
579                 av_log(s->avctx, AV_LOG_ERROR, "bap %d is invalid in plain AC-3\n", bap);
580                 bap = 15;
581             }
582             mantissa = (unsigned)get_sbits(gbc, quantization_tab[bap]) << (24 - quantization_tab[bap]);
583             break;
584         }
585         coeffs[freq] = mantissa >> exps[freq];
586     }
587 }
588
589 /**
590  * Remove random dithering from coupling range coefficients with zero-bit
591  * mantissas for coupled channels which do not use dithering.
592  * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
593  */
594 static void remove_dithering(AC3DecodeContext *s) {
595     int ch, i;
596
597     for (ch = 1; ch <= s->fbw_channels; ch++) {
598         if (!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
599             for (i = s->start_freq[CPL_CH]; i < s->end_freq[CPL_CH]; i++) {
600                 if (!s->bap[CPL_CH][i])
601                     s->fixed_coeffs[ch][i] = 0;
602             }
603         }
604     }
605 }
606
607 static inline void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk,
608                                               int ch, mant_groups *m)
609 {
610     if (!s->channel_uses_aht[ch]) {
611         ac3_decode_transform_coeffs_ch(s, ch, m);
612     } else {
613         /* if AHT is used, mantissas for all blocks are encoded in the first
614            block of the frame. */
615         int bin;
616         if (CONFIG_EAC3_DECODER && !blk)
617             ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
618         for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
619             s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
620         }
621     }
622 }
623
624 /**
625  * Decode the transform coefficients.
626  */
627 static inline void decode_transform_coeffs(AC3DecodeContext *s, int blk)
628 {
629     int ch, end;
630     int got_cplchan = 0;
631     mant_groups m;
632
633     m.b1 = m.b2 = m.b4 = 0;
634
635     for (ch = 1; ch <= s->channels; ch++) {
636         /* transform coefficients for full-bandwidth channel */
637         decode_transform_coeffs_ch(s, blk, ch, &m);
638         /* transform coefficients for coupling channel come right after the
639            coefficients for the first coupled channel*/
640         if (s->channel_in_cpl[ch])  {
641             if (!got_cplchan) {
642                 decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
643                 calc_transform_coeffs_cpl(s);
644                 got_cplchan = 1;
645             }
646             end = s->end_freq[CPL_CH];
647         } else {
648             end = s->end_freq[ch];
649         }
650         do
651             s->fixed_coeffs[ch][end] = 0;
652         while (++end < 256);
653     }
654
655     /* zero the dithered coefficients for appropriate channels */
656     remove_dithering(s);
657 }
658
659 /**
660  * Stereo rematrixing.
661  * reference: Section 7.5.4 Rematrixing : Decoding Technique
662  */
663 static void do_rematrixing(AC3DecodeContext *s)
664 {
665     int bnd, i;
666     int end, bndend;
667
668     end = FFMIN(s->end_freq[1], s->end_freq[2]);
669
670     for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) {
671         if (s->rematrixing_flags[bnd]) {
672             bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd + 1]);
673             for (i = ff_ac3_rematrix_band_tab[bnd]; i < bndend; i++) {
674                 int tmp0 = s->fixed_coeffs[1][i];
675                 s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
676                 s->fixed_coeffs[2][i]  = tmp0 - s->fixed_coeffs[2][i];
677             }
678         }
679     }
680 }
681
682 /**
683  * Inverse MDCT Transform.
684  * Convert frequency domain coefficients to time-domain audio samples.
685  * reference: Section 7.9.4 Transformation Equations
686  */
687 static inline void do_imdct(AC3DecodeContext *s, int channels, int offset)
688 {
689     int ch;
690
691     for (ch = 1; ch <= channels; ch++) {
692         if (s->block_switch[ch]) {
693             int i;
694             FFTSample *x = s->tmp_output + 128;
695             for (i = 0; i < 128; i++)
696                 x[i] = s->transform_coeffs[ch][2 * i];
697             s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
698 #if USE_FIXED
699             s->fdsp->vector_fmul_window_scaled(s->outptr[ch - 1], s->delay[ch - 1 + offset],
700                                        s->tmp_output, s->window, 128, 8);
701 #else
702             s->fdsp->vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1 + offset],
703                                        s->tmp_output, s->window, 128);
704 #endif
705             for (i = 0; i < 128; i++)
706                 x[i] = s->transform_coeffs[ch][2 * i + 1];
707             s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch - 1 + offset], x);
708         } else {
709             s->imdct_512.imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
710 #if USE_FIXED
711             s->fdsp->vector_fmul_window_scaled(s->outptr[ch - 1], s->delay[ch - 1 + offset],
712                                        s->tmp_output, s->window, 128, 8);
713 #else
714             s->fdsp->vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1 + offset],
715                                        s->tmp_output, s->window, 128);
716 #endif
717             memcpy(s->delay[ch - 1 + offset], s->tmp_output + 128, 128 * sizeof(FFTSample));
718         }
719     }
720 }
721
722 /**
723  * Upmix delay samples from stereo to original channel layout.
724  */
725 static void ac3_upmix_delay(AC3DecodeContext *s)
726 {
727     int channel_data_size = sizeof(s->delay[0]);
728     switch (s->channel_mode) {
729     case AC3_CHMODE_DUALMONO:
730     case AC3_CHMODE_STEREO:
731         /* upmix mono to stereo */
732         memcpy(s->delay[1], s->delay[0], channel_data_size);
733         break;
734     case AC3_CHMODE_2F2R:
735         memset(s->delay[3], 0, channel_data_size);
736     case AC3_CHMODE_2F1R:
737         memset(s->delay[2], 0, channel_data_size);
738         break;
739     case AC3_CHMODE_3F2R:
740         memset(s->delay[4], 0, channel_data_size);
741     case AC3_CHMODE_3F1R:
742         memset(s->delay[3], 0, channel_data_size);
743     case AC3_CHMODE_3F:
744         memcpy(s->delay[2], s->delay[1], channel_data_size);
745         memset(s->delay[1], 0, channel_data_size);
746         break;
747     }
748 }
749
750 /**
751  * Decode band structure for coupling, spectral extension, or enhanced coupling.
752  * The band structure defines how many subbands are in each band.  For each
753  * subband in the range, 1 means it is combined with the previous band, and 0
754  * means that it starts a new band.
755  *
756  * @param[in] gbc bit reader context
757  * @param[in] blk block number
758  * @param[in] eac3 flag to indicate E-AC-3
759  * @param[in] ecpl flag to indicate enhanced coupling
760  * @param[in] start_subband subband number for start of range
761  * @param[in] end_subband subband number for end of range
762  * @param[in] default_band_struct default band structure table
763  * @param[out] num_bands number of bands (optionally NULL)
764  * @param[out] band_sizes array containing the number of bins in each band (optionally NULL)
765  * @param[in,out] band_struct current band structure
766  */
767 static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
768                                   int ecpl, int start_subband, int end_subband,
769                                   const uint8_t *default_band_struct,
770                                   int *num_bands, uint8_t *band_sizes,
771                                   uint8_t *band_struct, int band_struct_size)
772 {
773     int subbnd, bnd, n_subbands, n_bands=0;
774     uint8_t bnd_sz[22];
775
776     n_subbands = end_subband - start_subband;
777
778     if (!blk)
779         memcpy(band_struct, default_band_struct, band_struct_size);
780
781     av_assert0(band_struct_size >= start_subband + n_subbands);
782
783     band_struct += start_subband + 1;
784
785     /* decode band structure from bitstream or use default */
786     if (!eac3 || get_bits1(gbc)) {
787         for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
788             band_struct[subbnd] = get_bits1(gbc);
789         }
790     }
791
792     /* calculate number of bands and band sizes based on band structure.
793        note that the first 4 subbands in enhanced coupling span only 6 bins
794        instead of 12. */
795     if (num_bands || band_sizes ) {
796         n_bands = n_subbands;
797         bnd_sz[0] = ecpl ? 6 : 12;
798         for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
799             int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
800             if (band_struct[subbnd - 1]) {
801                 n_bands--;
802                 bnd_sz[bnd] += subbnd_size;
803             } else {
804                 bnd_sz[++bnd] = subbnd_size;
805             }
806         }
807     }
808
809     /* set optional output params */
810     if (num_bands)
811         *num_bands = n_bands;
812     if (band_sizes)
813         memcpy(band_sizes, bnd_sz, n_bands);
814 }
815
816 static inline int spx_strategy(AC3DecodeContext *s, int blk)
817 {
818     GetBitContext *bc = &s->gbc;
819     int fbw_channels = s->fbw_channels;
820     int dst_start_freq, dst_end_freq, src_start_freq,
821         start_subband, end_subband, ch;
822
823     /* determine which channels use spx */
824     if (s->channel_mode == AC3_CHMODE_MONO) {
825         s->channel_uses_spx[1] = 1;
826     } else {
827         for (ch = 1; ch <= fbw_channels; ch++)
828             s->channel_uses_spx[ch] = get_bits1(bc);
829     }
830
831     /* get the frequency bins of the spx copy region and the spx start
832        and end subbands */
833     dst_start_freq = get_bits(bc, 2);
834     start_subband  = get_bits(bc, 3) + 2;
835     if (start_subband > 7)
836         start_subband += start_subband - 7;
837     end_subband    = get_bits(bc, 3) + 5;
838 #if USE_FIXED
839     s->spx_dst_end_freq = end_freq_inv_tab[end_subband-5];
840 #endif
841     if (end_subband   > 7)
842         end_subband   += end_subband   - 7;
843     dst_start_freq = dst_start_freq * 12 + 25;
844     src_start_freq = start_subband  * 12 + 25;
845     dst_end_freq   = end_subband    * 12 + 25;
846
847     /* check validity of spx ranges */
848     if (start_subband >= end_subband) {
849         av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
850                "range (%d >= %d)\n", start_subband, end_subband);
851         return AVERROR_INVALIDDATA;
852     }
853     if (dst_start_freq >= src_start_freq) {
854         av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
855                "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
856         return AVERROR_INVALIDDATA;
857     }
858
859     s->spx_dst_start_freq = dst_start_freq;
860     s->spx_src_start_freq = src_start_freq;
861     if (!USE_FIXED)
862         s->spx_dst_end_freq   = dst_end_freq;
863
864     decode_band_structure(bc, blk, s->eac3, 0,
865                           start_subband, end_subband,
866                           ff_eac3_default_spx_band_struct,
867                           &s->num_spx_bands,
868                           s->spx_band_sizes,
869                           s->spx_band_struct, sizeof(s->spx_band_struct));
870     return 0;
871 }
872
873 static inline void spx_coordinates(AC3DecodeContext *s)
874 {
875     GetBitContext *bc = &s->gbc;
876     int fbw_channels = s->fbw_channels;
877     int ch, bnd;
878
879     for (ch = 1; ch <= fbw_channels; ch++) {
880         if (s->channel_uses_spx[ch]) {
881             if (s->first_spx_coords[ch] || get_bits1(bc)) {
882                 INTFLOAT spx_blend;
883                 int bin, master_spx_coord;
884
885                 s->first_spx_coords[ch] = 0;
886                 spx_blend = AC3_SPX_BLEND(get_bits(bc, 5));
887                 master_spx_coord = get_bits(bc, 2) * 3;
888
889                 bin = s->spx_src_start_freq;
890                 for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
891                     int bandsize = s->spx_band_sizes[bnd];
892                     int spx_coord_exp, spx_coord_mant;
893                     INTFLOAT nratio, sblend, nblend;
894 #if USE_FIXED
895                     /* calculate blending factors */
896                     int64_t accu = ((bin << 23) + (bandsize << 22))
897                                  * (int64_t)s->spx_dst_end_freq;
898                     nratio = (int)(accu >> 32);
899                     nratio -= spx_blend << 18;
900
901                     if (nratio < 0) {
902                         nblend = 0;
903                         sblend = 0x800000;
904                     } else if (nratio > 0x7fffff) {
905                         nblend = 14529495; // sqrt(3) in FP.23
906                         sblend = 0;
907                     } else {
908                         nblend = fixed_sqrt(nratio, 23);
909                         accu = (int64_t)nblend * 1859775393;
910                         nblend = (int)((accu + (1<<29)) >> 30);
911                         sblend = fixed_sqrt(0x800000 - nratio, 23);
912                     }
913 #else
914                     float spx_coord;
915
916                     /* calculate blending factors */
917                     nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
918                     nratio = av_clipf(nratio, 0.0f, 1.0f);
919                     nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
920                                                    // to give unity variance
921                     sblend = sqrtf(1.0f - nratio);
922 #endif
923                     bin += bandsize;
924
925                     /* decode spx coordinates */
926                     spx_coord_exp  = get_bits(bc, 4);
927                     spx_coord_mant = get_bits(bc, 2);
928                     if (spx_coord_exp == 15) spx_coord_mant <<= 1;
929                     else                     spx_coord_mant += 4;
930                     spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
931
932                     /* multiply noise and signal blending factors by spx coordinate */
933 #if USE_FIXED
934                     accu = (int64_t)nblend * spx_coord_mant;
935                     s->spx_noise_blend[ch][bnd]  = (int)((accu + (1<<22)) >> 23);
936                     accu = (int64_t)sblend * spx_coord_mant;
937                     s->spx_signal_blend[ch][bnd] = (int)((accu + (1<<22)) >> 23);
938 #else
939                     spx_coord = spx_coord_mant * (1.0f / (1 << 23));
940                     s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
941                     s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
942 #endif
943                 }
944             }
945         } else {
946             s->first_spx_coords[ch] = 1;
947         }
948     }
949 }
950
951 static inline int coupling_strategy(AC3DecodeContext *s, int blk,
952                                     uint8_t *bit_alloc_stages)
953 {
954     GetBitContext *bc = &s->gbc;
955     int fbw_channels = s->fbw_channels;
956     int channel_mode = s->channel_mode;
957     int ch;
958
959     memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
960     if (!s->eac3)
961         s->cpl_in_use[blk] = get_bits1(bc);
962     if (s->cpl_in_use[blk]) {
963         /* coupling in use */
964         int cpl_start_subband, cpl_end_subband;
965
966         if (channel_mode < AC3_CHMODE_STEREO) {
967             av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
968             return AVERROR_INVALIDDATA;
969         }
970
971         /* check for enhanced coupling */
972         if (s->eac3 && get_bits1(bc)) {
973             /* TODO: parse enhanced coupling strategy info */
974             avpriv_request_sample(s->avctx, "Enhanced coupling");
975             return AVERROR_PATCHWELCOME;
976         }
977
978         /* determine which channels are coupled */
979         if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
980             s->channel_in_cpl[1] = 1;
981             s->channel_in_cpl[2] = 1;
982         } else {
983             for (ch = 1; ch <= fbw_channels; ch++)
984                 s->channel_in_cpl[ch] = get_bits1(bc);
985         }
986
987         /* phase flags in use */
988         if (channel_mode == AC3_CHMODE_STEREO)
989             s->phase_flags_in_use = get_bits1(bc);
990
991         /* coupling frequency range */
992         cpl_start_subband = get_bits(bc, 4);
993         cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
994                                           get_bits(bc, 4) + 3;
995         if (cpl_start_subband >= cpl_end_subband) {
996             av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
997                    cpl_start_subband, cpl_end_subband);
998             return AVERROR_INVALIDDATA;
999         }
1000         s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
1001         s->end_freq[CPL_CH]   = cpl_end_subband   * 12 + 37;
1002
1003         decode_band_structure(bc, blk, s->eac3, 0, cpl_start_subband,
1004                               cpl_end_subband,
1005                               ff_eac3_default_cpl_band_struct,
1006                               &s->num_cpl_bands, s->cpl_band_sizes,
1007                               s->cpl_band_struct, sizeof(s->cpl_band_struct));
1008     } else {
1009         /* coupling not in use */
1010         for (ch = 1; ch <= fbw_channels; ch++) {
1011             s->channel_in_cpl[ch] = 0;
1012             s->first_cpl_coords[ch] = 1;
1013         }
1014         s->first_cpl_leak = s->eac3;
1015         s->phase_flags_in_use = 0;
1016     }
1017
1018     return 0;
1019 }
1020
1021 static inline int coupling_coordinates(AC3DecodeContext *s, int blk)
1022 {
1023     GetBitContext *bc = &s->gbc;
1024     int fbw_channels = s->fbw_channels;
1025     int ch, bnd;
1026     int cpl_coords_exist = 0;
1027
1028     for (ch = 1; ch <= fbw_channels; ch++) {
1029         if (s->channel_in_cpl[ch]) {
1030             if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(bc)) {
1031                 int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
1032                 s->first_cpl_coords[ch] = 0;
1033                 cpl_coords_exist = 1;
1034                 master_cpl_coord = 3 * get_bits(bc, 2);
1035                 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1036                     cpl_coord_exp  = get_bits(bc, 4);
1037                     cpl_coord_mant = get_bits(bc, 4);
1038                     if (cpl_coord_exp == 15)
1039                         s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
1040                     else
1041                         s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
1042                     s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
1043                 }
1044             } else if (!blk) {
1045                 av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
1046                        "be present in block 0\n");
1047                 return AVERROR_INVALIDDATA;
1048             }
1049         } else {
1050             /* channel not in coupling */
1051             s->first_cpl_coords[ch] = 1;
1052         }
1053     }
1054     /* phase flags */
1055     if (s->channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
1056         for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1057             s->phase_flags[bnd] = s->phase_flags_in_use ? get_bits1(bc) : 0;
1058         }
1059     }
1060
1061     return 0;
1062 }
1063
1064 /**
1065  * Decode a single audio block from the AC-3 bitstream.
1066  */
1067 static int decode_audio_block(AC3DecodeContext *s, int blk, int offset)
1068 {
1069     int fbw_channels = s->fbw_channels;
1070     int channel_mode = s->channel_mode;
1071     int i, bnd, seg, ch, ret;
1072     int different_transforms;
1073     int downmix_output;
1074     int cpl_in_use;
1075     GetBitContext *gbc = &s->gbc;
1076     uint8_t bit_alloc_stages[AC3_MAX_CHANNELS] = { 0 };
1077
1078     /* block switch flags */
1079     different_transforms = 0;
1080     if (s->block_switch_syntax) {
1081         for (ch = 1; ch <= fbw_channels; ch++) {
1082             s->block_switch[ch] = get_bits1(gbc);
1083             if (ch > 1 && s->block_switch[ch] != s->block_switch[1])
1084                 different_transforms = 1;
1085         }
1086     }
1087
1088     /* dithering flags */
1089     if (s->dither_flag_syntax) {
1090         for (ch = 1; ch <= fbw_channels; ch++) {
1091             s->dither_flag[ch] = get_bits1(gbc);
1092         }
1093     }
1094
1095     /* dynamic range */
1096     i = !s->channel_mode;
1097     do {
1098         if (get_bits1(gbc)) {
1099             /* Allow asymmetric application of DRC when drc_scale > 1.
1100                Amplification of quiet sounds is enhanced */
1101             int range_bits = get_bits(gbc, 8);
1102             INTFLOAT range = AC3_RANGE(range_bits);
1103             if (range_bits <= 127 || s->drc_scale <= 1.0)
1104                 s->dynamic_range[i] = AC3_DYNAMIC_RANGE(range);
1105             else
1106                 s->dynamic_range[i] = range;
1107         } else if (blk == 0) {
1108             s->dynamic_range[i] = AC3_DYNAMIC_RANGE1;
1109         }
1110     } while (i--);
1111
1112     /* spectral extension strategy */
1113     if (s->eac3 && (!blk || get_bits1(gbc))) {
1114         s->spx_in_use = get_bits1(gbc);
1115         if (s->spx_in_use) {
1116             if ((ret = spx_strategy(s, blk)) < 0)
1117                 return ret;
1118         }
1119     }
1120     if (!s->eac3 || !s->spx_in_use) {
1121         s->spx_in_use = 0;
1122         for (ch = 1; ch <= fbw_channels; ch++) {
1123             s->channel_uses_spx[ch] = 0;
1124             s->first_spx_coords[ch] = 1;
1125         }
1126     }
1127
1128     /* spectral extension coordinates */
1129     if (s->spx_in_use)
1130         spx_coordinates(s);
1131
1132     /* coupling strategy */
1133     if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
1134         if ((ret = coupling_strategy(s, blk, bit_alloc_stages)) < 0)
1135             return ret;
1136     } else if (!s->eac3) {
1137         if (!blk) {
1138             av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "
1139                    "be present in block 0\n");
1140             return AVERROR_INVALIDDATA;
1141         } else {
1142             s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
1143         }
1144     }
1145     cpl_in_use = s->cpl_in_use[blk];
1146
1147     /* coupling coordinates */
1148     if (cpl_in_use) {
1149         if ((ret = coupling_coordinates(s, blk)) < 0)
1150             return ret;
1151     }
1152
1153     /* stereo rematrixing strategy and band structure */
1154     if (channel_mode == AC3_CHMODE_STEREO) {
1155         if ((s->eac3 && !blk) || get_bits1(gbc)) {
1156             s->num_rematrixing_bands = 4;
1157             if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
1158                 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
1159             } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
1160                 s->num_rematrixing_bands--;
1161             }
1162             for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
1163                 s->rematrixing_flags[bnd] = get_bits1(gbc);
1164         } else if (!blk) {
1165             av_log(s->avctx, AV_LOG_WARNING, "Warning: "
1166                    "new rematrixing strategy not present in block 0\n");
1167             s->num_rematrixing_bands = 0;
1168         }
1169     }
1170
1171     /* exponent strategies for each channel */
1172     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1173         if (!s->eac3)
1174             s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
1175         if (s->exp_strategy[blk][ch] != EXP_REUSE)
1176             bit_alloc_stages[ch] = 3;
1177     }
1178
1179     /* channel bandwidth */
1180     for (ch = 1; ch <= fbw_channels; ch++) {
1181         s->start_freq[ch] = 0;
1182         if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1183             int group_size;
1184             int prev = s->end_freq[ch];
1185             if (s->channel_in_cpl[ch])
1186                 s->end_freq[ch] = s->start_freq[CPL_CH];
1187             else if (s->channel_uses_spx[ch])
1188                 s->end_freq[ch] = s->spx_src_start_freq;
1189             else {
1190                 int bandwidth_code = get_bits(gbc, 6);
1191                 if (bandwidth_code > 60) {
1192                     av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1193                     return AVERROR_INVALIDDATA;
1194                 }
1195                 s->end_freq[ch] = bandwidth_code * 3 + 73;
1196             }
1197             group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1198             s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
1199             if (blk > 0 && s->end_freq[ch] != prev)
1200                 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1201         }
1202     }
1203     if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1204         s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
1205                                     (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1206     }
1207
1208     /* decode exponents for each channel */
1209     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1210         if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1211             s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1212             if (decode_exponents(s, gbc, s->exp_strategy[blk][ch],
1213                                  s->num_exp_groups[ch], s->dexps[ch][0],
1214                                  &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1215                 return AVERROR_INVALIDDATA;
1216             }
1217             if (ch != CPL_CH && ch != s->lfe_ch)
1218                 skip_bits(gbc, 2); /* skip gainrng */
1219         }
1220     }
1221
1222     /* bit allocation information */
1223     if (s->bit_allocation_syntax) {
1224         if (get_bits1(gbc)) {
1225             s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1226             s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1227             s->bit_alloc_params.slow_gain  = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
1228             s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
1229             s->bit_alloc_params.floor  = ff_ac3_floor_tab[get_bits(gbc, 3)];
1230             for (ch = !cpl_in_use; ch <= s->channels; ch++)
1231                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1232         } else if (!blk) {
1233             av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must "
1234                    "be present in block 0\n");
1235             return AVERROR_INVALIDDATA;
1236         }
1237     }
1238
1239     /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1240     if (!s->eac3 || !blk) {
1241         if (s->snr_offset_strategy && get_bits1(gbc)) {
1242             int snr = 0;
1243             int csnr;
1244             csnr = (get_bits(gbc, 6) - 15) << 4;
1245             for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1246                 /* snr offset */
1247                 if (ch == i || s->snr_offset_strategy == 2)
1248                     snr = (csnr + get_bits(gbc, 4)) << 2;
1249                 /* run at least last bit allocation stage if snr offset changes */
1250                 if (blk && s->snr_offset[ch] != snr) {
1251                     bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1252                 }
1253                 s->snr_offset[ch] = snr;
1254
1255                 /* fast gain (normal AC-3 only) */
1256                 if (!s->eac3) {
1257                     int prev = s->fast_gain[ch];
1258                     s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1259                     /* run last 2 bit allocation stages if fast gain changes */
1260                     if (blk && prev != s->fast_gain[ch])
1261                         bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1262                 }
1263             }
1264         } else if (!s->eac3 && !blk) {
1265             av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1266             return AVERROR_INVALIDDATA;
1267         }
1268     }
1269
1270     /* fast gain (E-AC-3 only) */
1271     if (s->fast_gain_syntax && get_bits1(gbc)) {
1272         for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1273             int prev = s->fast_gain[ch];
1274             s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1275             /* run last 2 bit allocation stages if fast gain changes */
1276             if (blk && prev != s->fast_gain[ch])
1277                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1278         }
1279     } else if (s->eac3 && !blk) {
1280         for (ch = !cpl_in_use; ch <= s->channels; ch++)
1281             s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1282     }
1283
1284     /* E-AC-3 to AC-3 converter SNR offset */
1285     if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1286         skip_bits(gbc, 10); // skip converter snr offset
1287     }
1288
1289     /* coupling leak information */
1290     if (cpl_in_use) {
1291         if (s->first_cpl_leak || get_bits1(gbc)) {
1292             int fl = get_bits(gbc, 3);
1293             int sl = get_bits(gbc, 3);
1294             /* run last 2 bit allocation stages for coupling channel if
1295                coupling leak changes */
1296             if (blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1297                 sl != s->bit_alloc_params.cpl_slow_leak)) {
1298                 bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1299             }
1300             s->bit_alloc_params.cpl_fast_leak = fl;
1301             s->bit_alloc_params.cpl_slow_leak = sl;
1302         } else if (!s->eac3 && !blk) {
1303             av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must "
1304                    "be present in block 0\n");
1305             return AVERROR_INVALIDDATA;
1306         }
1307         s->first_cpl_leak = 0;
1308     }
1309
1310     /* delta bit allocation information */
1311     if (s->dba_syntax && get_bits1(gbc)) {
1312         /* delta bit allocation exists (strategy) */
1313         for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1314             s->dba_mode[ch] = get_bits(gbc, 2);
1315             if (s->dba_mode[ch] == DBA_RESERVED) {
1316                 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1317                 return AVERROR_INVALIDDATA;
1318             }
1319             bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1320         }
1321         /* channel delta offset, len and bit allocation */
1322         for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1323             if (s->dba_mode[ch] == DBA_NEW) {
1324                 s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;
1325                 for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
1326                     s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1327                     s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1328                     s->dba_values[ch][seg]  = get_bits(gbc, 3);
1329                 }
1330                 /* run last 2 bit allocation stages if new dba values */
1331                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1332             }
1333         }
1334     } else if (blk == 0) {
1335         for (ch = 0; ch <= s->channels; ch++) {
1336             s->dba_mode[ch] = DBA_NONE;
1337         }
1338     }
1339
1340     /* Bit allocation */
1341     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1342         if (bit_alloc_stages[ch] > 2) {
1343             /* Exponent mapping into PSD and PSD integration */
1344             ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
1345                                       s->start_freq[ch], s->end_freq[ch],
1346                                       s->psd[ch], s->band_psd[ch]);
1347         }
1348         if (bit_alloc_stages[ch] > 1) {
1349             /* Compute excitation function, Compute masking curve, and
1350                Apply delta bit allocation */
1351             if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1352                                            s->start_freq[ch],  s->end_freq[ch],
1353                                            s->fast_gain[ch],   (ch == s->lfe_ch),
1354                                            s->dba_mode[ch],    s->dba_nsegs[ch],
1355                                            s->dba_offsets[ch], s->dba_lengths[ch],
1356                                            s->dba_values[ch],  s->mask[ch])) {
1357                 av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1358                 return AVERROR_INVALIDDATA;
1359             }
1360         }
1361         if (bit_alloc_stages[ch] > 0) {
1362             /* Compute bit allocation */
1363             const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1364                                      ff_eac3_hebap_tab : ff_ac3_bap_tab;
1365             s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1366                                       s->start_freq[ch], s->end_freq[ch],
1367                                       s->snr_offset[ch],
1368                                       s->bit_alloc_params.floor,
1369                                       bap_tab, s->bap[ch]);
1370         }
1371     }
1372
1373     /* unused dummy data */
1374     if (s->skip_syntax && get_bits1(gbc)) {
1375         int skipl = get_bits(gbc, 9);
1376         skip_bits_long(gbc, 8 * skipl);
1377     }
1378
1379     /* unpack the transform coefficients
1380        this also uncouples channels if coupling is in use. */
1381     decode_transform_coeffs(s, blk);
1382
1383     /* TODO: generate enhanced coupling coordinates and uncouple */
1384
1385     /* recover coefficients if rematrixing is in use */
1386     if (s->channel_mode == AC3_CHMODE_STEREO)
1387         do_rematrixing(s);
1388
1389     /* apply scaling to coefficients (headroom, dynrng) */
1390     for (ch = 1; ch <= s->channels; ch++) {
1391         int audio_channel = 0;
1392         INTFLOAT gain;
1393         if (s->channel_mode == AC3_CHMODE_DUALMONO && ch <= 2)
1394             audio_channel = 2-ch;
1395         if (s->heavy_compression && s->compression_exists[audio_channel])
1396             gain = s->heavy_dynamic_range[audio_channel];
1397         else
1398             gain = s->dynamic_range[audio_channel];
1399
1400 #if USE_FIXED
1401         scale_coefs(s->transform_coeffs[ch], s->fixed_coeffs[ch], gain, 256);
1402 #else
1403         if (s->target_level != 0)
1404           gain = gain * s->level_gain[audio_channel];
1405         gain *= 1.0 / 4194304.0f;
1406         s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch],
1407                                                s->fixed_coeffs[ch], gain, 256);
1408 #endif
1409     }
1410
1411     /* apply spectral extension to high frequency bins */
1412     if (CONFIG_EAC3_DECODER && s->spx_in_use) {
1413         ff_eac3_apply_spectral_extension(s);
1414     }
1415
1416     /* downmix and MDCT. order depends on whether block switching is used for
1417        any channel in this block. this is because coefficients for the long
1418        and short transforms cannot be mixed. */
1419     downmix_output = s->channels != s->out_channels &&
1420                      !((s->output_mode & AC3_OUTPUT_LFEON) &&
1421                      s->fbw_channels == s->out_channels);
1422     if (different_transforms) {
1423         /* the delay samples have already been downmixed, so we upmix the delay
1424            samples in order to reconstruct all channels before downmixing. */
1425         if (s->downmixed) {
1426             s->downmixed = 0;
1427             ac3_upmix_delay(s);
1428         }
1429
1430         do_imdct(s, s->channels, offset);
1431
1432         if (downmix_output) {
1433 #if USE_FIXED
1434             ac3_downmix_c_fixed16(s->outptr, s->downmix_coeffs,
1435                               s->out_channels, s->fbw_channels, 256);
1436 #else
1437             ff_ac3dsp_downmix(&s->ac3dsp, s->outptr, s->downmix_coeffs,
1438                               s->out_channels, s->fbw_channels, 256);
1439 #endif
1440         }
1441     } else {
1442         if (downmix_output) {
1443             AC3_RENAME(ff_ac3dsp_downmix)(&s->ac3dsp, s->xcfptr + 1, s->downmix_coeffs,
1444                                           s->out_channels, s->fbw_channels, 256);
1445         }
1446
1447         if (downmix_output && !s->downmixed) {
1448             s->downmixed = 1;
1449             AC3_RENAME(ff_ac3dsp_downmix)(&s->ac3dsp, s->dlyptr, s->downmix_coeffs,
1450                                           s->out_channels, s->fbw_channels, 128);
1451         }
1452
1453         do_imdct(s, s->out_channels, offset);
1454     }
1455
1456     return 0;
1457 }
1458
1459 /**
1460  * Decode a single AC-3 frame.
1461  */
1462 static int ac3_decode_frame(AVCodecContext * avctx, void *data,
1463                             int *got_frame_ptr, AVPacket *avpkt)
1464 {
1465     AVFrame *frame     = data;
1466     const uint8_t *buf = avpkt->data;
1467     int buf_size, full_buf_size = avpkt->size;
1468     AC3DecodeContext *s = avctx->priv_data;
1469     int blk, ch, err, offset, ret;
1470     int i;
1471     int skip = 0, got_independent_frame = 0;
1472     const uint8_t *channel_map;
1473     uint8_t extended_channel_map[EAC3_MAX_CHANNELS];
1474     const SHORTFLOAT *output[AC3_MAX_CHANNELS];
1475     enum AVMatrixEncoding matrix_encoding;
1476     AVDownmixInfo *downmix_info;
1477
1478     s->superframe_size = 0;
1479
1480     buf_size = full_buf_size;
1481     for (i = 1; i < buf_size; i += 2) {
1482         if (buf[i] == 0x77 || buf[i] == 0x0B) {
1483             if ((buf[i] ^ buf[i-1]) == (0x77 ^ 0x0B)) {
1484                 i--;
1485                 break;
1486             } else if ((buf[i] ^ buf[i+1]) == (0x77 ^ 0x0B)) {
1487                 break;
1488             }
1489         }
1490     }
1491     if (i >= buf_size)
1492         return AVERROR_INVALIDDATA;
1493     if (i > 10)
1494         return i;
1495     buf += i;
1496     buf_size -= i;
1497
1498     /* copy input buffer to decoder context to avoid reading past the end
1499        of the buffer, which can be caused by a damaged input stream. */
1500     if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
1501         // seems to be byte-swapped AC-3
1502         int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1503         s->bdsp.bswap16_buf((uint16_t *) s->input_buffer,
1504                             (const uint16_t *) buf, cnt);
1505     } else
1506         memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1507
1508     /* if consistent noise generation is enabled, seed the linear feedback generator
1509      * with the contents of the AC-3 frame so that the noise is identical across
1510      * decodes given the same AC-3 frame data, for use with non-linear edititing software. */
1511     if (s->consistent_noise_generation)
1512         av_lfg_init_from_data(&s->dith_state, s->input_buffer, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1513
1514     buf = s->input_buffer;
1515 dependent_frame:
1516     /* initialize the GetBitContext with the start of valid AC-3 Frame */
1517     if ((ret = init_get_bits8(&s->gbc, buf, buf_size)) < 0)
1518         return ret;
1519
1520     /* parse the syncinfo */
1521     err = parse_frame_header(s);
1522
1523     if (err) {
1524         switch (err) {
1525         case AAC_AC3_PARSE_ERROR_SYNC:
1526             av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1527             return AVERROR_INVALIDDATA;
1528         case AAC_AC3_PARSE_ERROR_BSID:
1529             av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1530             break;
1531         case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
1532             av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1533             break;
1534         case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
1535             av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1536             break;
1537         case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
1538             /* skip frame if CRC is ok. otherwise use error concealment. */
1539             /* TODO: add support for substreams */
1540             if (s->substreamid) {
1541                 av_log(avctx, AV_LOG_DEBUG,
1542                        "unsupported substream %d: skipping frame\n",
1543                        s->substreamid);
1544                 *got_frame_ptr = 0;
1545                 return buf_size;
1546             } else {
1547                 av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1548             }
1549             break;
1550         case AAC_AC3_PARSE_ERROR_CRC:
1551         case AAC_AC3_PARSE_ERROR_CHANNEL_CFG:
1552             break;
1553         default: // Normal AVERROR do not try to recover.
1554             *got_frame_ptr = 0;
1555             return err;
1556         }
1557     } else {
1558         /* check that reported frame size fits in input buffer */
1559         if (s->frame_size > buf_size) {
1560             av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1561             err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
1562         } else if (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL)) {
1563             /* check for crc mismatch */
1564             if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
1565                        s->frame_size - 2)) {
1566                 av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1567                 if (avctx->err_recognition & AV_EF_EXPLODE)
1568                     return AVERROR_INVALIDDATA;
1569                 err = AAC_AC3_PARSE_ERROR_CRC;
1570             }
1571         }
1572     }
1573
1574     if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT && !got_independent_frame) {
1575         av_log(avctx, AV_LOG_WARNING, "Ignoring dependent frame without independent frame.\n");
1576         *got_frame_ptr = 0;
1577         return FFMIN(full_buf_size, s->frame_size);
1578     }
1579
1580     /* channel config */
1581     if (!err || (s->channels && s->out_channels != s->channels)) {
1582         s->out_channels = s->channels;
1583         s->output_mode  = s->channel_mode;
1584         if (s->lfe_on)
1585             s->output_mode |= AC3_OUTPUT_LFEON;
1586         if (s->channels > 1 &&
1587             avctx->request_channel_layout == AV_CH_LAYOUT_MONO) {
1588             s->out_channels = 1;
1589             s->output_mode  = AC3_CHMODE_MONO;
1590         } else if (s->channels > 2 &&
1591                    avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
1592             s->out_channels = 2;
1593             s->output_mode  = AC3_CHMODE_STEREO;
1594         }
1595
1596         s->loro_center_mix_level   = gain_levels[s->  center_mix_level];
1597         s->loro_surround_mix_level = gain_levels[s->surround_mix_level];
1598         s->ltrt_center_mix_level   = LEVEL_MINUS_3DB;
1599         s->ltrt_surround_mix_level = LEVEL_MINUS_3DB;
1600         /* set downmixing coefficients if needed */
1601         if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1602                 s->fbw_channels == s->out_channels)) {
1603             if ((ret = set_downmix_coeffs(s)) < 0) {
1604                 av_log(avctx, AV_LOG_ERROR, "error setting downmix coeffs\n");
1605                 return ret;
1606             }
1607         }
1608     } else if (!s->channels) {
1609         av_log(avctx, AV_LOG_ERROR, "unable to determine channel mode\n");
1610         return AVERROR_INVALIDDATA;
1611     }
1612     avctx->channels = s->out_channels;
1613     avctx->channel_layout = avpriv_ac3_channel_layout_tab[s->output_mode & ~AC3_OUTPUT_LFEON];
1614     if (s->output_mode & AC3_OUTPUT_LFEON)
1615         avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1616
1617     /* set audio service type based on bitstream mode for AC-3 */
1618     avctx->audio_service_type = s->bitstream_mode;
1619     if (s->bitstream_mode == 0x7 && s->channels > 1)
1620         avctx->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
1621
1622     /* decode the audio blocks */
1623     channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1624     offset = s->frame_type == EAC3_FRAME_TYPE_DEPENDENT ? AC3_MAX_CHANNELS : 0;
1625     for (ch = 0; ch < AC3_MAX_CHANNELS; ch++) {
1626         output[ch] = s->output[ch + offset];
1627         s->outptr[ch] = s->output[ch + offset];
1628     }
1629     for (ch = 0; ch < s->channels; ch++) {
1630         if (ch < s->out_channels)
1631             s->outptr[channel_map[ch]] = s->output_buffer[ch + offset];
1632     }
1633     for (blk = 0; blk < s->num_blocks; blk++) {
1634         if (!err && decode_audio_block(s, blk, offset)) {
1635             av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1636             err = 1;
1637         }
1638         if (err)
1639             for (ch = 0; ch < s->out_channels; ch++)
1640                 memcpy(s->output_buffer[ch + offset] + AC3_BLOCK_SIZE*blk, output[ch], AC3_BLOCK_SIZE*sizeof(SHORTFLOAT));
1641         for (ch = 0; ch < s->out_channels; ch++)
1642             output[ch] = s->outptr[channel_map[ch]];
1643         for (ch = 0; ch < s->out_channels; ch++) {
1644             if (!ch || channel_map[ch])
1645                 s->outptr[channel_map[ch]] += AC3_BLOCK_SIZE;
1646         }
1647     }
1648
1649     /* keep last block for error concealment in next frame */
1650     for (ch = 0; ch < s->out_channels; ch++)
1651         memcpy(s->output[ch + offset], output[ch], AC3_BLOCK_SIZE*sizeof(SHORTFLOAT));
1652
1653     /* check if there is dependent frame */
1654     if (buf_size > s->frame_size) {
1655         AC3HeaderInfo hdr;
1656         int err;
1657
1658         if (buf_size - s->frame_size <= 16) {
1659             skip = buf_size - s->frame_size;
1660             goto skip;
1661         }
1662
1663         if ((ret = init_get_bits8(&s->gbc, buf + s->frame_size, buf_size - s->frame_size)) < 0)
1664             return ret;
1665
1666         err = ff_ac3_parse_header(&s->gbc, &hdr);
1667         if (err)
1668             return err;
1669
1670         if (hdr.frame_type == EAC3_FRAME_TYPE_DEPENDENT) {
1671             if (hdr.num_blocks != s->num_blocks || s->sample_rate != hdr.sample_rate) {
1672                 av_log(avctx, AV_LOG_WARNING, "Ignoring non-compatible dependent frame.\n");
1673             } else {
1674                 buf += s->frame_size;
1675                 buf_size -= s->frame_size;
1676                 s->prev_output_mode = s->output_mode;
1677                 s->prev_bit_rate = s->bit_rate;
1678                 got_independent_frame = 1;
1679                 goto dependent_frame;
1680             }
1681         }
1682     }
1683 skip:
1684
1685     frame->decode_error_flags = err ? FF_DECODE_ERROR_INVALID_BITSTREAM : 0;
1686
1687     /* if frame is ok, set audio parameters */
1688     if (!err) {
1689         avctx->sample_rate = s->sample_rate;
1690         avctx->bit_rate    = s->bit_rate + s->prev_bit_rate;
1691     }
1692
1693     for (ch = 0; ch < EAC3_MAX_CHANNELS; ch++)
1694         extended_channel_map[ch] = ch;
1695
1696     if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT) {
1697         uint64_t ich_layout = avpriv_ac3_channel_layout_tab[s->prev_output_mode & ~AC3_OUTPUT_LFEON];
1698         int channel_map_size = ff_ac3_channels_tab[s->output_mode & ~AC3_OUTPUT_LFEON] + s->lfe_on;
1699         uint64_t channel_layout;
1700         int extend = 0;
1701
1702         if (s->prev_output_mode & AC3_OUTPUT_LFEON)
1703             ich_layout |= AV_CH_LOW_FREQUENCY;
1704
1705         channel_layout = ich_layout;
1706         for (ch = 0; ch < 16; ch++) {
1707             if (s->channel_map & (1 << (EAC3_MAX_CHANNELS - ch - 1))) {
1708                 channel_layout |= ff_eac3_custom_channel_map_locations[ch][1];
1709             }
1710         }
1711         if (av_get_channel_layout_nb_channels(channel_layout) > EAC3_MAX_CHANNELS) {
1712             av_log(avctx, AV_LOG_ERROR, "Too many channels (%d) coded\n",
1713                    av_get_channel_layout_nb_channels(channel_layout));
1714             return AVERROR_INVALIDDATA;
1715         }
1716
1717         avctx->channel_layout = channel_layout;
1718         avctx->channels = av_get_channel_layout_nb_channels(channel_layout);
1719
1720         for (ch = 0; ch < EAC3_MAX_CHANNELS; ch++) {
1721             if (s->channel_map & (1 << (EAC3_MAX_CHANNELS - ch - 1))) {
1722                 if (ff_eac3_custom_channel_map_locations[ch][0]) {
1723                     int index = av_get_channel_layout_channel_index(channel_layout,
1724                                                                     ff_eac3_custom_channel_map_locations[ch][1]);
1725                     if (index < 0)
1726                         return AVERROR_INVALIDDATA;
1727                     if (extend >= channel_map_size)
1728                         return AVERROR_INVALIDDATA;
1729
1730                     extended_channel_map[index] = offset + channel_map[extend++];
1731                 } else {
1732                     int i;
1733
1734                     for (i = 0; i < 64; i++) {
1735                         if ((1ULL << i) & ff_eac3_custom_channel_map_locations[ch][1]) {
1736                             int index = av_get_channel_layout_channel_index(channel_layout,
1737                                                                             1ULL << i);
1738                             if (index < 0)
1739                                 return AVERROR_INVALIDDATA;
1740                             if (extend >= channel_map_size)
1741                                 return AVERROR_INVALIDDATA;
1742
1743                             extended_channel_map[index] = offset + channel_map[extend++];
1744                         }
1745                     }
1746                 }
1747             }
1748         }
1749     }
1750
1751     /* get output buffer */
1752     frame->nb_samples = s->num_blocks * AC3_BLOCK_SIZE;
1753     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1754         return ret;
1755
1756     for (ch = 0; ch < avctx->channels; ch++) {
1757         int map = extended_channel_map[ch];
1758         av_assert0(ch>=AV_NUM_DATA_POINTERS || frame->extended_data[ch] == frame->data[ch]);
1759         memcpy((SHORTFLOAT *)frame->extended_data[ch],
1760                s->output_buffer[map],
1761                s->num_blocks * AC3_BLOCK_SIZE * sizeof(SHORTFLOAT));
1762     }
1763
1764     /*
1765      * AVMatrixEncoding
1766      *
1767      * Check whether the input layout is compatible, and make sure we're not
1768      * downmixing (else the matrix encoding is no longer applicable).
1769      */
1770     matrix_encoding = AV_MATRIX_ENCODING_NONE;
1771     if (s->channel_mode == AC3_CHMODE_STEREO &&
1772         s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1773         if (s->dolby_surround_mode == AC3_DSURMOD_ON)
1774             matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
1775         else if (s->dolby_headphone_mode == AC3_DHEADPHONMOD_ON)
1776             matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;
1777     } else if (s->channel_mode >= AC3_CHMODE_2F2R &&
1778                s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1779         switch (s->dolby_surround_ex_mode) {
1780         case AC3_DSUREXMOD_ON: // EX or PLIIx
1781             matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
1782             break;
1783         case AC3_DSUREXMOD_PLIIZ:
1784             matrix_encoding = AV_MATRIX_ENCODING_DPLIIZ;
1785             break;
1786         default: // not indicated or off
1787             break;
1788         }
1789     }
1790     if ((ret = ff_side_data_update_matrix_encoding(frame, matrix_encoding)) < 0)
1791         return ret;
1792
1793     /* AVDownmixInfo */
1794     if ((downmix_info = av_downmix_info_update_side_data(frame))) {
1795         switch (s->preferred_downmix) {
1796         case AC3_DMIXMOD_LTRT:
1797             downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_LTRT;
1798             break;
1799         case AC3_DMIXMOD_LORO:
1800             downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_LORO;
1801             break;
1802         case AC3_DMIXMOD_DPLII:
1803             downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_DPLII;
1804             break;
1805         default:
1806             downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_UNKNOWN;
1807             break;
1808         }
1809         downmix_info->center_mix_level        = gain_levels[s->       center_mix_level];
1810         downmix_info->center_mix_level_ltrt   = gain_levels[s->  center_mix_level_ltrt];
1811         downmix_info->surround_mix_level      = gain_levels[s->     surround_mix_level];
1812         downmix_info->surround_mix_level_ltrt = gain_levels[s->surround_mix_level_ltrt];
1813         if (s->lfe_mix_level_exists)
1814             downmix_info->lfe_mix_level       = gain_levels_lfe[s->lfe_mix_level];
1815         else
1816             downmix_info->lfe_mix_level       = 0.0; // -inf dB
1817     } else
1818         return AVERROR(ENOMEM);
1819
1820     *got_frame_ptr = 1;
1821
1822     if (!s->superframe_size)
1823         return FFMIN(full_buf_size, s->frame_size + skip);
1824
1825     return FFMIN(full_buf_size, s->superframe_size + skip);
1826 }
1827
1828 /**
1829  * Uninitialize the AC-3 decoder.
1830  */
1831 static av_cold int ac3_decode_end(AVCodecContext *avctx)
1832 {
1833     AC3DecodeContext *s = avctx->priv_data;
1834     ff_mdct_end(&s->imdct_512);
1835     ff_mdct_end(&s->imdct_256);
1836     av_freep(&s->fdsp);
1837     av_freep(&s->downmix_coeffs[0]);
1838
1839     return 0;
1840 }
1841
1842 #define OFFSET(x) offsetof(AC3DecodeContext, x)
1843 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)