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