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