Replace FFmpeg with Libav in licence headers
[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
39 /** Large enough for maximum possible frame size when the specification limit is ignored */
40 #define AC3_FRAME_BUFFER_SIZE 32768
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
49 /** tables for ungrouping mantissas */
50 static int b1_mantissas[32][3];
51 static int b2_mantissas[128][3];
52 static int b3_mantissas[8];
53 static int b4_mantissas[128][2];
54 static int b5_mantissas[16];
55
56 /**
57  * Quantization table: levels for symmetric. bits for asymmetric.
58  * reference: Table 7.18 Mapping of bap to Quantizer
59  */
60 static const uint8_t quantization_tab[16] = {
61     0, 3, 5, 7, 11, 15,
62     5, 6, 7, 8, 9, 10, 11, 12, 14, 16
63 };
64
65 /** dynamic range table. converts codes to scale factors. */
66 static float dynamic_range_tab[256];
67
68 /** Adjustments in dB gain */
69 #define LEVEL_PLUS_3DB          1.4142135623730950
70 #define LEVEL_PLUS_1POINT5DB    1.1892071150027209
71 #define LEVEL_MINUS_1POINT5DB   0.8408964152537145
72 #define LEVEL_MINUS_3DB         0.7071067811865476
73 #define LEVEL_MINUS_4POINT5DB   0.5946035575013605
74 #define LEVEL_MINUS_6DB         0.5000000000000000
75 #define LEVEL_MINUS_9DB         0.3535533905932738
76 #define LEVEL_ZERO              0.0000000000000000
77 #define LEVEL_ONE               1.0000000000000000
78
79 static const float gain_levels[9] = {
80     LEVEL_PLUS_3DB,
81     LEVEL_PLUS_1POINT5DB,
82     LEVEL_ONE,
83     LEVEL_MINUS_1POINT5DB,
84     LEVEL_MINUS_3DB,
85     LEVEL_MINUS_4POINT5DB,
86     LEVEL_MINUS_6DB,
87     LEVEL_ZERO,
88     LEVEL_MINUS_9DB
89 };
90
91 /**
92  * Table for center mix levels
93  * reference: Section 5.4.2.4 cmixlev
94  */
95 static const uint8_t center_levels[4] = { 4, 5, 6, 5 };
96
97 /**
98  * Table for surround mix levels
99  * reference: Section 5.4.2.5 surmixlev
100  */
101 static const uint8_t surround_levels[4] = { 4, 6, 7, 6 };
102
103 /**
104  * Table for default stereo downmixing coefficients
105  * reference: Section 7.8.2 Downmixing Into Two Channels
106  */
107 static const uint8_t ac3_default_coeffs[8][5][2] = {
108     { { 2, 7 }, { 7, 2 },                               },
109     { { 4, 4 },                                         },
110     { { 2, 7 }, { 7, 2 },                               },
111     { { 2, 7 }, { 5, 5 }, { 7, 2 },                     },
112     { { 2, 7 }, { 7, 2 }, { 6, 6 },                     },
113     { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 },           },
114     { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 },           },
115     { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
116 };
117
118 /**
119  * Symmetrical Dequantization
120  * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization
121  *            Tables 7.19 to 7.23
122  */
123 static inline int
124 symmetric_dequant(int code, int levels)
125 {
126     return ((code - (levels >> 1)) << 24) / levels;
127 }
128
129 /*
130  * Initialize tables at runtime.
131  */
132 static av_cold void ac3_tables_init(void)
133 {
134     int i;
135
136     /* generate table for ungrouping 3 values in 7 bits
137        reference: Section 7.1.3 Exponent Decoding */
138     for(i=0; i<128; i++) {
139         ungroup_3_in_7_bits_tab[i][0] =  i / 25;
140         ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5;
141         ungroup_3_in_7_bits_tab[i][2] = (i % 25) % 5;
142     }
143
144     /* generate grouped mantissa tables
145        reference: Section 7.3.5 Ungrouping of Mantissas */
146     for(i=0; i<32; i++) {
147         /* bap=1 mantissas */
148         b1_mantissas[i][0] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][0], 3);
149         b1_mantissas[i][1] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][1], 3);
150         b1_mantissas[i][2] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][2], 3);
151     }
152     for(i=0; i<128; i++) {
153         /* bap=2 mantissas */
154         b2_mantissas[i][0] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][0], 5);
155         b2_mantissas[i][1] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][1], 5);
156         b2_mantissas[i][2] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][2], 5);
157
158         /* bap=4 mantissas */
159         b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
160         b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
161     }
162     /* generate ungrouped mantissa tables
163        reference: Tables 7.21 and 7.23 */
164     for(i=0; i<7; i++) {
165         /* bap=3 mantissas */
166         b3_mantissas[i] = symmetric_dequant(i, 7);
167     }
168     for(i=0; i<15; i++) {
169         /* bap=5 mantissas */
170         b5_mantissas[i] = symmetric_dequant(i, 15);
171     }
172
173     /* generate dynamic range table
174        reference: Section 7.7.1 Dynamic Range Control */
175     for(i=0; i<256; i++) {
176         int v = (i >> 5) - ((i >> 7) << 3) - 5;
177         dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
178     }
179 }
180
181
182 /**
183  * AVCodec initialization
184  */
185 static av_cold int ac3_decode_init(AVCodecContext *avctx)
186 {
187     AC3DecodeContext *s = avctx->priv_data;
188     s->avctx = avctx;
189
190     ff_ac3_common_init();
191     ac3_tables_init();
192     ff_mdct_init(&s->imdct_256, 8, 1, 1.0);
193     ff_mdct_init(&s->imdct_512, 9, 1, 1.0);
194     ff_kbd_window_init(s->window, 5.0, 256);
195     dsputil_init(&s->dsp, avctx);
196     ff_fmt_convert_init(&s->fmt_conv, avctx);
197     av_lfg_init(&s->dith_state, 0);
198
199     /* set scale value for float to int16 conversion */
200     s->mul_bias = 32767.0f;
201
202     /* allow downmixing to stereo or mono */
203     if (avctx->channels > 0 && avctx->request_channels > 0 &&
204             avctx->request_channels < avctx->channels &&
205             avctx->request_channels <= 2) {
206         avctx->channels = avctx->request_channels;
207     }
208     s->downmixed = 1;
209
210     /* allocate context input buffer */
211     if (avctx->error_recognition >= FF_ER_CAREFUL) {
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
217     avctx->sample_fmt = AV_SAMPLE_FMT_S16;
218     return 0;
219 }
220
221 /**
222  * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
223  * GetBitContext within AC3DecodeContext must point to
224  * the start of the synchronized AC-3 bitstream.
225  */
226 static int ac3_parse_header(AC3DecodeContext *s)
227 {
228     GetBitContext *gbc = &s->gbc;
229     int i;
230
231     /* read the rest of the bsi. read twice for dual mono mode. */
232     i = !(s->channel_mode);
233     do {
234         skip_bits(gbc, 5); // skip dialog normalization
235         if (get_bits1(gbc))
236             skip_bits(gbc, 8); //skip compression
237         if (get_bits1(gbc))
238             skip_bits(gbc, 8); //skip language code
239         if (get_bits1(gbc))
240             skip_bits(gbc, 7); //skip audio production information
241     } while (i--);
242
243     skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
244
245     /* skip the timecodes (or extra bitstream information for Alternate Syntax)
246        TODO: read & use the xbsi1 downmix levels */
247     if (get_bits1(gbc))
248         skip_bits(gbc, 14); //skip timecode1 / xbsi1
249     if (get_bits1(gbc))
250         skip_bits(gbc, 14); //skip timecode2 / xbsi2
251
252     /* skip additional bitstream info */
253     if (get_bits1(gbc)) {
254         i = get_bits(gbc, 6);
255         do {
256             skip_bits(gbc, 8);
257         } while(i--);
258     }
259
260     return 0;
261 }
262
263 /**
264  * Common function to parse AC-3 or E-AC-3 frame header
265  */
266 static int parse_frame_header(AC3DecodeContext *s)
267 {
268     AC3HeaderInfo hdr;
269     int err;
270
271     err = ff_ac3_parse_header(&s->gbc, &hdr);
272     if(err)
273         return err;
274
275     /* get decoding parameters from header info */
276     s->bit_alloc_params.sr_code     = hdr.sr_code;
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             ff_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             ff_imdct_half(&s->imdct_256, s->delay[ch-1], x);
636         } else {
637             ff_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     /* initialize the GetBitContext with the start of valid AC-3 Frame */
1317     if (s->input_buffer) {
1318         /* copy input buffer to decoder context to avoid reading past the end
1319            of the buffer, which can be caused by a damaged input stream. */
1320         memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1321         init_get_bits(&s->gbc, s->input_buffer, buf_size * 8);
1322     } else {
1323         init_get_bits(&s->gbc, buf, buf_size * 8);
1324     }
1325
1326     /* parse the syncinfo */
1327     *data_size = 0;
1328     err = parse_frame_header(s);
1329
1330     if (err) {
1331         switch(err) {
1332             case AAC_AC3_PARSE_ERROR_SYNC:
1333                 av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1334                 return -1;
1335             case AAC_AC3_PARSE_ERROR_BSID:
1336                 av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1337                 break;
1338             case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
1339                 av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1340                 break;
1341             case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
1342                 av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1343                 break;
1344             case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
1345                 /* skip frame if CRC is ok. otherwise use error concealment. */
1346                 /* TODO: add support for substreams and dependent frames */
1347                 if(s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
1348                     av_log(avctx, AV_LOG_ERROR, "unsupported frame type : skipping frame\n");
1349                     return s->frame_size;
1350                 } else {
1351                     av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1352                 }
1353                 break;
1354             default:
1355                 av_log(avctx, AV_LOG_ERROR, "invalid header\n");
1356                 break;
1357         }
1358     } else {
1359         /* check that reported frame size fits in input buffer */
1360         if (s->frame_size > buf_size) {
1361             av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1362             err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
1363         } else if (avctx->error_recognition >= FF_ER_CAREFUL) {
1364             /* check for crc mismatch */
1365             if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2], s->frame_size-2)) {
1366                 av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1367                 err = AAC_AC3_PARSE_ERROR_CRC;
1368             }
1369         }
1370     }
1371
1372     /* if frame is ok, set audio parameters */
1373     if (!err) {
1374         avctx->sample_rate = s->sample_rate;
1375         avctx->bit_rate = s->bit_rate;
1376
1377         /* channel config */
1378         s->out_channels = s->channels;
1379         s->output_mode = s->channel_mode;
1380         if(s->lfe_on)
1381             s->output_mode |= AC3_OUTPUT_LFEON;
1382         if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&
1383                 avctx->request_channels < s->channels) {
1384             s->out_channels = avctx->request_channels;
1385             s->output_mode  = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1386             s->channel_layout = ff_ac3_channel_layout_tab[s->output_mode];
1387         }
1388         avctx->channels = s->out_channels;
1389         avctx->channel_layout = s->channel_layout;
1390
1391         /* set downmixing coefficients if needed */
1392         if(s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1393                 s->fbw_channels == s->out_channels)) {
1394             set_downmix_coeffs(s);
1395         }
1396     } else if (!s->out_channels) {
1397         s->out_channels = avctx->channels;
1398         if(s->out_channels < s->channels)
1399             s->output_mode  = s->out_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1400     }
1401
1402     /* decode the audio blocks */
1403     channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1404     for (ch = 0; ch < s->out_channels; ch++)
1405         output[ch] = s->output[channel_map[ch]];
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         s->fmt_conv.float_to_int16_interleave(out_samples, output, 256, s->out_channels);
1412         out_samples += 256 * s->out_channels;
1413     }
1414     *data_size = s->num_blocks * 256 * avctx->channels * sizeof (int16_t);
1415     return FFMIN(buf_size, s->frame_size);
1416 }
1417
1418 /**
1419  * Uninitialize the AC-3 decoder.
1420  */
1421 static av_cold int ac3_decode_end(AVCodecContext *avctx)
1422 {
1423     AC3DecodeContext *s = avctx->priv_data;
1424     ff_mdct_end(&s->imdct_512);
1425     ff_mdct_end(&s->imdct_256);
1426
1427     av_freep(&s->input_buffer);
1428
1429     return 0;
1430 }
1431
1432 AVCodec ff_ac3_decoder = {
1433     .name = "ac3",
1434     .type = AVMEDIA_TYPE_AUDIO,
1435     .id = CODEC_ID_AC3,
1436     .priv_data_size = sizeof (AC3DecodeContext),
1437     .init = ac3_decode_init,
1438     .close = ac3_decode_end,
1439     .decode = ac3_decode_frame,
1440     .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
1441 };
1442
1443 #if CONFIG_EAC3_DECODER
1444 AVCodec ff_eac3_decoder = {
1445     .name = "eac3",
1446     .type = AVMEDIA_TYPE_AUDIO,
1447     .id = CODEC_ID_EAC3,
1448     .priv_data_size = sizeof (AC3DecodeContext),
1449     .init = ac3_decode_init,
1450     .close = ac3_decode_end,
1451     .decode = ac3_decode_frame,
1452     .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
1453 };
1454 #endif