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