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