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