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