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