a81286c375c4bd0053730ad6f19aabddb2b93b21
[ffmpeg.git] / libavcodec / ac3dec.c
1 /*
2  * AC-3 Audio Decoder
3  * This code is developed as part of Google Summer of Code 2006 Program.
4  *
5  * Copyright (c) 2006 Kartikey Mahendra BHATT (bhattkm at gmail dot com).
6  * Copyright (c) 2007 Justin Ruggles
7  *
8  * Portions of this code are derived from liba52
9  * http://liba52.sourceforge.net
10  * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org>
11  * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
12  *
13  * This file is part of FFmpeg.
14  *
15  * FFmpeg is free software; you can redistribute it and/or
16  * modify it under the terms of the GNU General Public
17  * License as published by the Free Software Foundation; either
18  * version 2 of the License, or (at your option) any later version.
19  *
20  * FFmpeg is distributed in the hope that it will be useful,
21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
23  * General Public License for more details.
24  *
25  * You should have received a copy of the GNU General Public
26  * License along with FFmpeg; if not, write to the Free Software
27  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
28  */
29
30 #include <stdio.h>
31 #include <stddef.h>
32 #include <math.h>
33 #include <string.h>
34
35 #include "avcodec.h"
36 #include "ac3_parser.h"
37 #include "bitstream.h"
38 #include "crc.h"
39 #include "dsputil.h"
40 #include "random.h"
41
42 /**
43  * Table of bin locations for rematrixing bands
44  * reference: Section 7.5.2 Rematrixing : Frequency Band Definitions
45  */
46 static const uint8_t rematrix_band_tab[5] = { 13, 25, 37, 61, 253 };
47
48 /**
49  * table for exponent to scale_factor mapping
50  * scale_factors[i] = 2 ^ -i
51  */
52 static float scale_factors[25];
53
54 /** table for grouping exponents */
55 static uint8_t exp_ungroup_tab[128][3];
56
57
58 /** tables for ungrouping mantissas */
59 static float b1_mantissas[32][3];
60 static float b2_mantissas[128][3];
61 static float b3_mantissas[8];
62 static float b4_mantissas[128][2];
63 static float b5_mantissas[16];
64
65 /**
66  * Quantization table: levels for symmetric. bits for asymmetric.
67  * reference: Table 7.18 Mapping of bap to Quantizer
68  */
69 static const uint8_t quantization_tab[16] = {
70     0, 3, 5, 7, 11, 15,
71     5, 6, 7, 8, 9, 10, 11, 12, 14, 16
72 };
73
74 /** dynamic range table. converts codes to scale factors. */
75 static float dynamic_range_tab[256];
76
77 /** Adjustments in dB gain */
78 #define LEVEL_MINUS_3DB         0.7071067811865476
79 #define LEVEL_MINUS_4POINT5DB   0.5946035575013605
80 #define LEVEL_MINUS_6DB         0.5000000000000000
81 #define LEVEL_MINUS_9DB         0.3535533905932738
82 #define LEVEL_ZERO              0.0000000000000000
83 #define LEVEL_ONE               1.0000000000000000
84
85 static const float gain_levels[6] = {
86     LEVEL_ZERO,
87     LEVEL_ONE,
88     LEVEL_MINUS_3DB,
89     LEVEL_MINUS_4POINT5DB,
90     LEVEL_MINUS_6DB,
91     LEVEL_MINUS_9DB
92 };
93
94 /**
95  * Table for center mix levels
96  * reference: Section 5.4.2.4 cmixlev
97  */
98 static const uint8_t center_levels[4] = { 2, 3, 4, 3 };
99
100 /**
101  * Table for surround mix levels
102  * reference: Section 5.4.2.5 surmixlev
103  */
104 static const uint8_t surround_levels[4] = { 2, 4, 0, 4 };
105
106 /**
107  * Table for default stereo downmixing coefficients
108  * reference: Section 7.8.2 Downmixing Into Two Channels
109  */
110 static const uint8_t ac3_default_coeffs[8][5][2] = {
111     { { 1, 0 }, { 0, 1 },                               },
112     { { 2, 2 },                                         },
113     { { 1, 0 }, { 0, 1 },                               },
114     { { 1, 0 }, { 3, 3 }, { 0, 1 },                     },
115     { { 1, 0 }, { 0, 1 }, { 4, 4 },                     },
116     { { 1, 0 }, { 3, 3 }, { 0, 1 }, { 5, 5 },           },
117     { { 1, 0 }, { 0, 1 }, { 4, 0 }, { 0, 4 },           },
118     { { 1, 0 }, { 3, 3 }, { 0, 1 }, { 4, 0 }, { 0, 4 }, },
119 };
120
121 /* override ac3.h to include coupling channel */
122 #undef AC3_MAX_CHANNELS
123 #define AC3_MAX_CHANNELS 7
124 #define CPL_CH 0
125
126 #define AC3_OUTPUT_LFEON  8
127
128 typedef struct {
129     int channel_mode;                       ///< channel mode (acmod)
130     int block_switch[AC3_MAX_CHANNELS];     ///< block switch flags
131     int dither_flag[AC3_MAX_CHANNELS];      ///< dither flags
132     int dither_all;                         ///< true if all channels are dithered
133     int cpl_in_use;                         ///< coupling in use
134     int channel_in_cpl[AC3_MAX_CHANNELS];   ///< channel in coupling
135     int phase_flags_in_use;                 ///< phase flags in use
136     int phase_flags[18];                    ///< phase flags
137     int cpl_band_struct[18];                ///< coupling band structure
138     int num_rematrixing_bands;              ///< number of rematrixing bands
139     int rematrixing_flags[4];               ///< rematrixing flags
140     int exp_strategy[AC3_MAX_CHANNELS];     ///< exponent strategies
141     int snr_offset[AC3_MAX_CHANNELS];       ///< signal-to-noise ratio offsets
142     int fast_gain[AC3_MAX_CHANNELS];        ///< fast gain values (signal-to-mask ratio)
143     int dba_mode[AC3_MAX_CHANNELS];         ///< delta bit allocation mode
144     int dba_nsegs[AC3_MAX_CHANNELS];        ///< number of delta segments
145     uint8_t dba_offsets[AC3_MAX_CHANNELS][8]; ///< delta segment offsets
146     uint8_t dba_lengths[AC3_MAX_CHANNELS][8]; ///< delta segment lengths
147     uint8_t dba_values[AC3_MAX_CHANNELS][8];  ///< delta values for each segment
148
149     int sample_rate;                        ///< sample frequency, in Hz
150     int bit_rate;                           ///< stream bit rate, in bits-per-second
151     int frame_size;                         ///< current frame size, in bytes
152
153     int channels;                           ///< number of total channels
154     int fbw_channels;                       ///< number of full-bandwidth channels
155     int lfe_on;                             ///< lfe channel in use
156     int lfe_ch;                             ///< index of LFE channel
157     int output_mode;                        ///< output channel configuration
158     int out_channels;                       ///< number of output channels
159
160     int center_mix_level;                   ///< Center mix level index
161     int surround_mix_level;                 ///< Surround mix level index
162     float downmix_coeffs[AC3_MAX_CHANNELS][2];  ///< stereo downmix coefficients
163     float dynamic_range[2];                 ///< dynamic range
164     float cpl_coords[AC3_MAX_CHANNELS][18]; ///< coupling coordinates
165     int   num_cpl_bands;                    ///< number of coupling bands
166     int   num_cpl_subbands;                 ///< number of coupling sub bands
167     int   start_freq[AC3_MAX_CHANNELS];     ///< start frequency bin
168     int   end_freq[AC3_MAX_CHANNELS];       ///< end frequency bin
169     AC3BitAllocParameters bit_alloc_params; ///< bit allocation parameters
170
171     int8_t  dexps[AC3_MAX_CHANNELS][256];   ///< decoded exponents
172     uint8_t bap[AC3_MAX_CHANNELS][256];     ///< bit allocation pointers
173     int16_t psd[AC3_MAX_CHANNELS][256];     ///< scaled exponents
174     int16_t band_psd[AC3_MAX_CHANNELS][50]; ///< interpolated exponents
175     int16_t mask[AC3_MAX_CHANNELS][50];     ///< masking curve values
176
177     DECLARE_ALIGNED_16(float, transform_coeffs[AC3_MAX_CHANNELS][256]);  ///< transform coefficients
178
179     /* For IMDCT. */
180     MDCTContext imdct_512;                  ///< for 512 sample IMDCT
181     MDCTContext imdct_256;                  ///< for 256 sample IMDCT
182     DSPContext  dsp;                        ///< for optimization
183     float       add_bias;                   ///< offset for float_to_int16 conversion
184     float       mul_bias;                   ///< scaling for float_to_int16 conversion
185
186     DECLARE_ALIGNED_16(float, output[AC3_MAX_CHANNELS-1][256]);     ///< output after imdct transform and windowing
187     DECLARE_ALIGNED_16(short, int_output[AC3_MAX_CHANNELS-1][256]); ///< final 16-bit integer output
188     DECLARE_ALIGNED_16(float, delay[AC3_MAX_CHANNELS-1][256]);      ///< delay - added to the next block
189     DECLARE_ALIGNED_16(float, tmp_imdct[256]);                      ///< temporary storage for imdct transform
190     DECLARE_ALIGNED_16(float, tmp_output[512]);                     ///< temporary storage for output before windowing
191     DECLARE_ALIGNED_16(float, window[256]);                         ///< window coefficients
192
193     /* Miscellaneous. */
194     GetBitContext gbc;                      ///< bitstream reader
195     AVRandomState dith_state;               ///< for dither generation
196     AVCodecContext *avctx;                  ///< parent context
197 } AC3DecodeContext;
198
199 /**
200  * Generate a Kaiser-Bessel Derived Window.
201  */
202 static void ac3_window_init(float *window)
203 {
204    int i, j;
205    double sum = 0.0, bessel, tmp;
206    double local_window[256];
207    double alpha2 = (5.0 * M_PI / 256.0) * (5.0 * M_PI / 256.0);
208
209    for (i = 0; i < 256; i++) {
210        tmp = i * (256 - i) * alpha2;
211        bessel = 1.0;
212        for (j = 100; j > 0; j--) /* default to 100 iterations */
213            bessel = bessel * tmp / (j * j) + 1;
214        sum += bessel;
215        local_window[i] = sum;
216    }
217
218    sum++;
219    for (i = 0; i < 256; i++)
220        window[i] = sqrt(local_window[i] / sum);
221 }
222
223 /**
224  * Symmetrical Dequantization
225  * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization
226  *            Tables 7.19 to 7.23
227  */
228 static inline float
229 symmetric_dequant(int code, int levels)
230 {
231     return (code - (levels >> 1)) * (2.0f / levels);
232 }
233
234 /*
235  * Initialize tables at runtime.
236  */
237 static void ac3_tables_init(void)
238 {
239     int i;
240
241     /* generate grouped mantissa tables
242        reference: Section 7.3.5 Ungrouping of Mantissas */
243     for(i=0; i<32; i++) {
244         /* bap=1 mantissas */
245         b1_mantissas[i][0] = symmetric_dequant( i / 9     , 3);
246         b1_mantissas[i][1] = symmetric_dequant((i % 9) / 3, 3);
247         b1_mantissas[i][2] = symmetric_dequant((i % 9) % 3, 3);
248     }
249     for(i=0; i<128; i++) {
250         /* bap=2 mantissas */
251         b2_mantissas[i][0] = symmetric_dequant( i / 25     , 5);
252         b2_mantissas[i][1] = symmetric_dequant((i % 25) / 5, 5);
253         b2_mantissas[i][2] = symmetric_dequant((i % 25) % 5, 5);
254
255         /* bap=4 mantissas */
256         b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
257         b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
258     }
259     /* generate ungrouped mantissa tables
260        reference: Tables 7.21 and 7.23 */
261     for(i=0; i<7; i++) {
262         /* bap=3 mantissas */
263         b3_mantissas[i] = symmetric_dequant(i, 7);
264     }
265     for(i=0; i<15; i++) {
266         /* bap=5 mantissas */
267         b5_mantissas[i] = symmetric_dequant(i, 15);
268     }
269
270     /* generate dynamic range table
271        reference: Section 7.7.1 Dynamic Range Control */
272     for(i=0; i<256; i++) {
273         int v = (i >> 5) - ((i >> 7) << 3) - 5;
274         dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
275     }
276
277     /* generate scale factors for exponents and asymmetrical dequantization
278        reference: Section 7.3.2 Expansion of Mantissas for Asymmetric Quantization */
279     for (i = 0; i < 25; i++)
280         scale_factors[i] = pow(2.0, -i);
281
282     /* generate exponent tables
283        reference: Section 7.1.3 Exponent Decoding */
284     for(i=0; i<128; i++) {
285         exp_ungroup_tab[i][0] =  i / 25;
286         exp_ungroup_tab[i][1] = (i % 25) / 5;
287         exp_ungroup_tab[i][2] = (i % 25) % 5;
288     }
289 }
290
291
292 /**
293  * AVCodec initialization
294  */
295 static int ac3_decode_init(AVCodecContext *avctx)
296 {
297     AC3DecodeContext *s = avctx->priv_data;
298     s->avctx = avctx;
299
300     ac3_common_init();
301     ac3_tables_init();
302     ff_mdct_init(&s->imdct_256, 8, 1);
303     ff_mdct_init(&s->imdct_512, 9, 1);
304     ac3_window_init(s->window);
305     dsputil_init(&s->dsp, avctx);
306     av_init_random(0, &s->dith_state);
307
308     /* set bias values for float to int16 conversion */
309     if(s->dsp.float_to_int16 == ff_float_to_int16_c) {
310         s->add_bias = 385.0f;
311         s->mul_bias = 1.0f;
312     } else {
313         s->add_bias = 0.0f;
314         s->mul_bias = 32767.0f;
315     }
316
317     /* allow downmixing to stereo or mono */
318     if (avctx->channels > 0 && avctx->request_channels > 0 &&
319             avctx->request_channels < avctx->channels &&
320             avctx->request_channels <= 2) {
321         avctx->channels = avctx->request_channels;
322     }
323
324     return 0;
325 }
326
327 /**
328  * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
329  * GetBitContext within AC3DecodeContext must point to
330  * start of the synchronized ac3 bitstream.
331  */
332 static int ac3_parse_header(AC3DecodeContext *s)
333 {
334     AC3HeaderInfo hdr;
335     GetBitContext *gbc = &s->gbc;
336     int err, i;
337
338     err = ff_ac3_parse_header(gbc->buffer, &hdr);
339     if(err)
340         return err;
341
342     if(hdr.bitstream_id > 10)
343         return AC3_PARSE_ERROR_BSID;
344
345     /* get decoding parameters from header info */
346     s->bit_alloc_params.sr_code     = hdr.sr_code;
347     s->channel_mode                 = hdr.channel_mode;
348     s->lfe_on                       = hdr.lfe_on;
349     s->bit_alloc_params.sr_shift    = hdr.sr_shift;
350     s->sample_rate                  = hdr.sample_rate;
351     s->bit_rate                     = hdr.bit_rate;
352     s->channels                     = hdr.channels;
353     s->fbw_channels                 = s->channels - s->lfe_on;
354     s->lfe_ch                       = s->fbw_channels + 1;
355     s->frame_size                   = hdr.frame_size;
356
357     /* set default output to all source channels */
358     s->out_channels = s->channels;
359     s->output_mode = s->channel_mode;
360     if(s->lfe_on)
361         s->output_mode |= AC3_OUTPUT_LFEON;
362
363     /* set default mix levels */
364     s->center_mix_level   = 3;  // -4.5dB
365     s->surround_mix_level = 4;  // -6.0dB
366
367     /* skip over portion of header which has already been read */
368     skip_bits(gbc, 16); // skip the sync_word
369     skip_bits(gbc, 16); // skip crc1
370     skip_bits(gbc, 8);  // skip fscod and frmsizecod
371     skip_bits(gbc, 11); // skip bsid, bsmod, and acmod
372     if(s->channel_mode == AC3_CHMODE_STEREO) {
373         skip_bits(gbc, 2); // skip dsurmod
374     } else {
375         if((s->channel_mode & 1) && s->channel_mode != AC3_CHMODE_MONO)
376             s->center_mix_level = center_levels[get_bits(gbc, 2)];
377         if(s->channel_mode & 4)
378             s->surround_mix_level = surround_levels[get_bits(gbc, 2)];
379     }
380     skip_bits1(gbc); // skip lfeon
381
382     /* read the rest of the bsi. read twice for dual mono mode. */
383     i = !(s->channel_mode);
384     do {
385         skip_bits(gbc, 5); // skip dialog normalization
386         if (get_bits1(gbc))
387             skip_bits(gbc, 8); //skip compression
388         if (get_bits1(gbc))
389             skip_bits(gbc, 8); //skip language code
390         if (get_bits1(gbc))
391             skip_bits(gbc, 7); //skip audio production information
392     } while (i--);
393
394     skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
395
396     /* skip the timecodes (or extra bitstream information for Alternate Syntax)
397        TODO: read & use the xbsi1 downmix levels */
398     if (get_bits1(gbc))
399         skip_bits(gbc, 14); //skip timecode1 / xbsi1
400     if (get_bits1(gbc))
401         skip_bits(gbc, 14); //skip timecode2 / xbsi2
402
403     /* skip additional bitstream info */
404     if (get_bits1(gbc)) {
405         i = get_bits(gbc, 6);
406         do {
407             skip_bits(gbc, 8);
408         } while(i--);
409     }
410
411     return 0;
412 }
413
414 /**
415  * Set stereo downmixing coefficients based on frame header info.
416  * reference: Section 7.8.2 Downmixing Into Two Channels
417  */
418 static void set_downmix_coeffs(AC3DecodeContext *s)
419 {
420     int i;
421     float cmix = gain_levels[s->center_mix_level];
422     float smix = gain_levels[s->surround_mix_level];
423
424     for(i=0; i<s->fbw_channels; i++) {
425         s->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
426         s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
427     }
428     if(s->channel_mode > 1 && s->channel_mode & 1) {
429         s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix;
430     }
431     if(s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
432         int nf = s->channel_mode - 2;
433         s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
434     }
435     if(s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
436         int nf = s->channel_mode - 4;
437         s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix;
438     }
439 }
440
441 /**
442  * Decode the grouped exponents according to exponent strategy.
443  * reference: Section 7.1.3 Exponent Decoding
444  */
445 static void decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
446                              uint8_t absexp, int8_t *dexps)
447 {
448     int i, j, grp, group_size;
449     int dexp[256];
450     int expacc, prevexp;
451
452     /* unpack groups */
453     group_size = exp_strategy + (exp_strategy == EXP_D45);
454     for(grp=0,i=0; grp<ngrps; grp++) {
455         expacc = get_bits(gbc, 7);
456         dexp[i++] = exp_ungroup_tab[expacc][0];
457         dexp[i++] = exp_ungroup_tab[expacc][1];
458         dexp[i++] = exp_ungroup_tab[expacc][2];
459     }
460
461     /* convert to absolute exps and expand groups */
462     prevexp = absexp;
463     for(i=0; i<ngrps*3; i++) {
464         prevexp = av_clip(prevexp + dexp[i]-2, 0, 24);
465         for(j=0; j<group_size; j++) {
466             dexps[(i*group_size)+j] = prevexp;
467         }
468     }
469 }
470
471 /**
472  * Generate transform coefficients for each coupled channel in the coupling
473  * range using the coupling coefficients and coupling coordinates.
474  * reference: Section 7.4.3 Coupling Coordinate Format
475  */
476 static void uncouple_channels(AC3DecodeContext *s)
477 {
478     int i, j, ch, bnd, subbnd;
479
480     subbnd = -1;
481     i = s->start_freq[CPL_CH];
482     for(bnd=0; bnd<s->num_cpl_bands; bnd++) {
483         do {
484             subbnd++;
485             for(j=0; j<12; j++) {
486                 for(ch=1; ch<=s->fbw_channels; ch++) {
487                     if(s->channel_in_cpl[ch]) {
488                         s->transform_coeffs[ch][i] = s->transform_coeffs[CPL_CH][i] * s->cpl_coords[ch][bnd] * 8.0f;
489                         if (ch == 2 && s->phase_flags[bnd])
490                             s->transform_coeffs[ch][i] = -s->transform_coeffs[ch][i];
491                     }
492                 }
493                 i++;
494             }
495         } while(s->cpl_band_struct[subbnd]);
496     }
497 }
498
499 /**
500  * Grouped mantissas for 3-level 5-level and 11-level quantization
501  */
502 typedef struct {
503     float b1_mant[3];
504     float b2_mant[3];
505     float b4_mant[2];
506     int b1ptr;
507     int b2ptr;
508     int b4ptr;
509 } mant_groups;
510
511 /**
512  * Get the transform coefficients for a particular channel
513  * reference: Section 7.3 Quantization and Decoding of Mantissas
514  */
515 static int get_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
516 {
517     GetBitContext *gbc = &s->gbc;
518     int i, gcode, tbap, start, end;
519     uint8_t *exps;
520     uint8_t *bap;
521     float *coeffs;
522
523     exps = s->dexps[ch_index];
524     bap = s->bap[ch_index];
525     coeffs = s->transform_coeffs[ch_index];
526     start = s->start_freq[ch_index];
527     end = s->end_freq[ch_index];
528
529     for (i = start; i < end; i++) {
530         tbap = bap[i];
531         switch (tbap) {
532             case 0:
533                 coeffs[i] = ((av_random(&s->dith_state) & 0xFFFF) / 65535.0f) - 0.5f;
534                 break;
535
536             case 1:
537                 if(m->b1ptr > 2) {
538                     gcode = get_bits(gbc, 5);
539                     m->b1_mant[0] = b1_mantissas[gcode][0];
540                     m->b1_mant[1] = b1_mantissas[gcode][1];
541                     m->b1_mant[2] = b1_mantissas[gcode][2];
542                     m->b1ptr = 0;
543                 }
544                 coeffs[i] = m->b1_mant[m->b1ptr++];
545                 break;
546
547             case 2:
548                 if(m->b2ptr > 2) {
549                     gcode = get_bits(gbc, 7);
550                     m->b2_mant[0] = b2_mantissas[gcode][0];
551                     m->b2_mant[1] = b2_mantissas[gcode][1];
552                     m->b2_mant[2] = b2_mantissas[gcode][2];
553                     m->b2ptr = 0;
554                 }
555                 coeffs[i] = m->b2_mant[m->b2ptr++];
556                 break;
557
558             case 3:
559                 coeffs[i] = b3_mantissas[get_bits(gbc, 3)];
560                 break;
561
562             case 4:
563                 if(m->b4ptr > 1) {
564                     gcode = get_bits(gbc, 7);
565                     m->b4_mant[0] = b4_mantissas[gcode][0];
566                     m->b4_mant[1] = b4_mantissas[gcode][1];
567                     m->b4ptr = 0;
568                 }
569                 coeffs[i] = m->b4_mant[m->b4ptr++];
570                 break;
571
572             case 5:
573                 coeffs[i] = b5_mantissas[get_bits(gbc, 4)];
574                 break;
575
576             default:
577                 /* asymmetric dequantization */
578                 coeffs[i] = get_sbits(gbc, quantization_tab[tbap]) * scale_factors[quantization_tab[tbap]-1];
579                 break;
580         }
581         coeffs[i] *= scale_factors[exps[i]];
582     }
583
584     return 0;
585 }
586
587 /**
588  * Remove random dithering from coefficients with zero-bit mantissas
589  * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
590  */
591 static void remove_dithering(AC3DecodeContext *s) {
592     int ch, i;
593     int end=0;
594     float *coeffs;
595     uint8_t *bap;
596
597     for(ch=1; ch<=s->fbw_channels; ch++) {
598         if(!s->dither_flag[ch]) {
599             coeffs = s->transform_coeffs[ch];
600             bap = s->bap[ch];
601             if(s->channel_in_cpl[ch])
602                 end = s->start_freq[CPL_CH];
603             else
604                 end = s->end_freq[ch];
605             for(i=0; i<end; i++) {
606                 if(!bap[i])
607                     coeffs[i] = 0.0f;
608             }
609             if(s->channel_in_cpl[ch]) {
610                 bap = s->bap[CPL_CH];
611                 for(; i<s->end_freq[CPL_CH]; i++) {
612                     if(!bap[i])
613                         coeffs[i] = 0.0f;
614                 }
615             }
616         }
617     }
618 }
619
620 /**
621  * Get the transform coefficients.
622  */
623 static int get_transform_coeffs(AC3DecodeContext *s)
624 {
625     int ch, end;
626     int got_cplchan = 0;
627     mant_groups m;
628
629     m.b1ptr = m.b2ptr = m.b4ptr = 3;
630
631     for (ch = 1; ch <= s->channels; ch++) {
632         /* transform coefficients for full-bandwidth channel */
633         if (get_transform_coeffs_ch(s, ch, &m))
634             return -1;
635         /* tranform coefficients for coupling channel come right after the
636            coefficients for the first coupled channel*/
637         if (s->channel_in_cpl[ch])  {
638             if (!got_cplchan) {
639                 if (get_transform_coeffs_ch(s, CPL_CH, &m)) {
640                     av_log(s->avctx, AV_LOG_ERROR, "error in decoupling channels\n");
641                     return -1;
642                 }
643                 uncouple_channels(s);
644                 got_cplchan = 1;
645             }
646             end = s->end_freq[CPL_CH];
647         } else {
648             end = s->end_freq[ch];
649         }
650         do
651             s->transform_coeffs[ch][end] = 0;
652         while(++end < 256);
653     }
654
655     /* if any channel doesn't use dithering, zero appropriate coefficients */
656     if(!s->dither_all)
657         remove_dithering(s);
658
659     return 0;
660 }
661
662 /**
663  * Stereo rematrixing.
664  * reference: Section 7.5.4 Rematrixing : Decoding Technique
665  */
666 static void do_rematrixing(AC3DecodeContext *s)
667 {
668     int bnd, i;
669     int end, bndend;
670     float tmp0, tmp1;
671
672     end = FFMIN(s->end_freq[1], s->end_freq[2]);
673
674     for(bnd=0; bnd<s->num_rematrixing_bands; bnd++) {
675         if(s->rematrixing_flags[bnd]) {
676             bndend = FFMIN(end, rematrix_band_tab[bnd+1]);
677             for(i=rematrix_band_tab[bnd]; i<bndend; i++) {
678                 tmp0 = s->transform_coeffs[1][i];
679                 tmp1 = s->transform_coeffs[2][i];
680                 s->transform_coeffs[1][i] = tmp0 + tmp1;
681                 s->transform_coeffs[2][i] = tmp0 - tmp1;
682             }
683         }
684     }
685 }
686
687 /**
688  * Perform the 256-point IMDCT
689  */
690 static void do_imdct_256(AC3DecodeContext *s, int chindex)
691 {
692     int i, k;
693     DECLARE_ALIGNED_16(float, x[128]);
694     FFTComplex z[2][64];
695     float *o_ptr = s->tmp_output;
696
697     for(i=0; i<2; i++) {
698         /* de-interleave coefficients */
699         for(k=0; k<128; k++) {
700             x[k] = s->transform_coeffs[chindex][2*k+i];
701         }
702
703         /* run standard IMDCT */
704         s->imdct_256.fft.imdct_calc(&s->imdct_256, o_ptr, x, s->tmp_imdct);
705
706         /* reverse the post-rotation & reordering from standard IMDCT */
707         for(k=0; k<32; k++) {
708             z[i][32+k].re = -o_ptr[128+2*k];
709             z[i][32+k].im = -o_ptr[2*k];
710             z[i][31-k].re =  o_ptr[2*k+1];
711             z[i][31-k].im =  o_ptr[128+2*k+1];
712         }
713     }
714
715     /* apply AC-3 post-rotation & reordering */
716     for(k=0; k<64; k++) {
717         o_ptr[    2*k  ] = -z[0][   k].im;
718         o_ptr[    2*k+1] =  z[0][63-k].re;
719         o_ptr[128+2*k  ] = -z[0][   k].re;
720         o_ptr[128+2*k+1] =  z[0][63-k].im;
721         o_ptr[256+2*k  ] = -z[1][   k].re;
722         o_ptr[256+2*k+1] =  z[1][63-k].im;
723         o_ptr[384+2*k  ] =  z[1][   k].im;
724         o_ptr[384+2*k+1] = -z[1][63-k].re;
725     }
726 }
727
728 /**
729  * Inverse MDCT Transform.
730  * Convert frequency domain coefficients to time-domain audio samples.
731  * reference: Section 7.9.4 Transformation Equations
732  */
733 static inline void do_imdct(AC3DecodeContext *s)
734 {
735     int ch;
736     int channels;
737
738     /* Don't perform the IMDCT on the LFE channel unless it's used in the output */
739     channels = s->fbw_channels;
740     if(s->output_mode & AC3_OUTPUT_LFEON)
741         channels++;
742
743     for (ch=1; ch<=channels; ch++) {
744         if (s->block_switch[ch]) {
745             do_imdct_256(s, ch);
746         } else {
747             s->imdct_512.fft.imdct_calc(&s->imdct_512, s->tmp_output,
748                                         s->transform_coeffs[ch], s->tmp_imdct);
749         }
750         /* For the first half of the block, apply the window, add the delay
751            from the previous block, and send to output */
752         s->dsp.vector_fmul_add_add(s->output[ch-1], s->tmp_output,
753                                      s->window, s->delay[ch-1], 0, 256, 1);
754         /* For the second half of the block, apply the window and store the
755            samples to delay, to be combined with the next block */
756         s->dsp.vector_fmul_reverse(s->delay[ch-1], s->tmp_output+256,
757                                    s->window, 256);
758     }
759 }
760
761 /**
762  * Downmix the output to mono or stereo.
763  */
764 static void ac3_downmix(AC3DecodeContext *s)
765 {
766     int i, j;
767     float v0, v1, s0, s1;
768
769     for(i=0; i<256; i++) {
770         v0 = v1 = s0 = s1 = 0.0f;
771         for(j=0; j<s->fbw_channels; j++) {
772             v0 += s->output[j][i] * s->downmix_coeffs[j][0];
773             v1 += s->output[j][i] * s->downmix_coeffs[j][1];
774             s0 += s->downmix_coeffs[j][0];
775             s1 += s->downmix_coeffs[j][1];
776         }
777         v0 /= s0;
778         v1 /= s1;
779         if(s->output_mode == AC3_CHMODE_MONO) {
780             s->output[0][i] = (v0 + v1) * LEVEL_MINUS_3DB;
781         } else if(s->output_mode == AC3_CHMODE_STEREO) {
782             s->output[0][i] = v0;
783             s->output[1][i] = v1;
784         }
785     }
786 }
787
788 /**
789  * Parse an audio block from AC-3 bitstream.
790  */
791 static int ac3_parse_audio_block(AC3DecodeContext *s, int blk)
792 {
793     int fbw_channels = s->fbw_channels;
794     int channel_mode = s->channel_mode;
795     int i, bnd, seg, ch;
796     GetBitContext *gbc = &s->gbc;
797     uint8_t bit_alloc_stages[AC3_MAX_CHANNELS];
798
799     memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);
800
801     /* block switch flags */
802     for (ch = 1; ch <= fbw_channels; ch++)
803         s->block_switch[ch] = get_bits1(gbc);
804
805     /* dithering flags */
806     s->dither_all = 1;
807     for (ch = 1; ch <= fbw_channels; ch++) {
808         s->dither_flag[ch] = get_bits1(gbc);
809         if(!s->dither_flag[ch])
810             s->dither_all = 0;
811     }
812
813     /* dynamic range */
814     i = !(s->channel_mode);
815     do {
816         if(get_bits1(gbc)) {
817             s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)]-1.0) *
818                                   s->avctx->drc_scale)+1.0;
819         } else if(blk == 0) {
820             s->dynamic_range[i] = 1.0f;
821         }
822     } while(i--);
823
824     /* coupling strategy */
825     if (get_bits1(gbc)) {
826         memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
827         s->cpl_in_use = get_bits1(gbc);
828         if (s->cpl_in_use) {
829             /* coupling in use */
830             int cpl_begin_freq, cpl_end_freq;
831
832             /* determine which channels are coupled */
833             for (ch = 1; ch <= fbw_channels; ch++)
834                 s->channel_in_cpl[ch] = get_bits1(gbc);
835
836             /* phase flags in use */
837             if (channel_mode == AC3_CHMODE_STEREO)
838                 s->phase_flags_in_use = get_bits1(gbc);
839
840             /* coupling frequency range and band structure */
841             cpl_begin_freq = get_bits(gbc, 4);
842             cpl_end_freq = get_bits(gbc, 4);
843             if (3 + cpl_end_freq - cpl_begin_freq < 0) {
844                 av_log(s->avctx, AV_LOG_ERROR, "3+cplendf = %d < cplbegf = %d\n", 3+cpl_end_freq, cpl_begin_freq);
845                 return -1;
846             }
847             s->num_cpl_bands = s->num_cpl_subbands = 3 + cpl_end_freq - cpl_begin_freq;
848             s->start_freq[CPL_CH] = cpl_begin_freq * 12 + 37;
849             s->end_freq[CPL_CH] = cpl_end_freq * 12 + 73;
850             for (bnd = 0; bnd < s->num_cpl_subbands - 1; bnd++) {
851                 if (get_bits1(gbc)) {
852                     s->cpl_band_struct[bnd] = 1;
853                     s->num_cpl_bands--;
854                 }
855             }
856             s->cpl_band_struct[s->num_cpl_subbands-1] = 0;
857         } else {
858             /* coupling not in use */
859             for (ch = 1; ch <= fbw_channels; ch++)
860                 s->channel_in_cpl[ch] = 0;
861         }
862     }
863
864     /* coupling coordinates */
865     if (s->cpl_in_use) {
866         int cpl_coords_exist = 0;
867
868         for (ch = 1; ch <= fbw_channels; ch++) {
869             if (s->channel_in_cpl[ch]) {
870                 if (get_bits1(gbc)) {
871                     int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
872                     cpl_coords_exist = 1;
873                     master_cpl_coord = 3 * get_bits(gbc, 2);
874                     for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
875                         cpl_coord_exp = get_bits(gbc, 4);
876                         cpl_coord_mant = get_bits(gbc, 4);
877                         if (cpl_coord_exp == 15)
878                             s->cpl_coords[ch][bnd] = cpl_coord_mant / 16.0f;
879                         else
880                             s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16.0f) / 32.0f;
881                         s->cpl_coords[ch][bnd] *= scale_factors[cpl_coord_exp + master_cpl_coord];
882                     }
883                 }
884             }
885         }
886         /* phase flags */
887         if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
888             for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
889                 s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
890             }
891         }
892     }
893
894     /* stereo rematrixing strategy and band structure */
895     if (channel_mode == AC3_CHMODE_STEREO) {
896         if (get_bits1(gbc)) {
897             s->num_rematrixing_bands = 4;
898             if(s->cpl_in_use && s->start_freq[CPL_CH] <= 61)
899                 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
900             for(bnd=0; bnd<s->num_rematrixing_bands; bnd++)
901                 s->rematrixing_flags[bnd] = get_bits1(gbc);
902         }
903     }
904
905     /* exponent strategies for each channel */
906     s->exp_strategy[CPL_CH] = EXP_REUSE;
907     s->exp_strategy[s->lfe_ch] = EXP_REUSE;
908     for (ch = !s->cpl_in_use; ch <= s->channels; ch++) {
909         if(ch == s->lfe_ch)
910             s->exp_strategy[ch] = get_bits(gbc, 1);
911         else
912             s->exp_strategy[ch] = get_bits(gbc, 2);
913         if(s->exp_strategy[ch] != EXP_REUSE)
914             bit_alloc_stages[ch] = 3;
915     }
916
917     /* channel bandwidth */
918     for (ch = 1; ch <= fbw_channels; ch++) {
919         s->start_freq[ch] = 0;
920         if (s->exp_strategy[ch] != EXP_REUSE) {
921             int prev = s->end_freq[ch];
922             if (s->channel_in_cpl[ch])
923                 s->end_freq[ch] = s->start_freq[CPL_CH];
924             else {
925                 int bandwidth_code = get_bits(gbc, 6);
926                 if (bandwidth_code > 60) {
927                     av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60", bandwidth_code);
928                     return -1;
929                 }
930                 s->end_freq[ch] = bandwidth_code * 3 + 73;
931             }
932             if(blk > 0 && s->end_freq[ch] != prev)
933                 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
934         }
935     }
936     s->start_freq[s->lfe_ch] = 0;
937     s->end_freq[s->lfe_ch] = 7;
938
939     /* decode exponents for each channel */
940     for (ch = !s->cpl_in_use; ch <= s->channels; ch++) {
941         if (s->exp_strategy[ch] != EXP_REUSE) {
942             int group_size, num_groups;
943             group_size = 3 << (s->exp_strategy[ch] - 1);
944             if(ch == CPL_CH)
945                 num_groups = (s->end_freq[ch] - s->start_freq[ch]) / group_size;
946             else if(ch == s->lfe_ch)
947                 num_groups = 2;
948             else
949                 num_groups = (s->end_freq[ch] + group_size - 4) / group_size;
950             s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
951             decode_exponents(gbc, s->exp_strategy[ch], num_groups, s->dexps[ch][0],
952                              &s->dexps[ch][s->start_freq[ch]+!!ch]);
953             if(ch != CPL_CH && ch != s->lfe_ch)
954                 skip_bits(gbc, 2); /* skip gainrng */
955         }
956     }
957
958     /* bit allocation information */
959     if (get_bits1(gbc)) {
960         s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
961         s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
962         s->bit_alloc_params.slow_gain  = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
963         s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
964         s->bit_alloc_params.floor  = ff_ac3_floor_tab[get_bits(gbc, 3)];
965         for(ch=!s->cpl_in_use; ch<=s->channels; ch++) {
966             bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
967         }
968     }
969
970     /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
971     if (get_bits1(gbc)) {
972         int csnr;
973         csnr = (get_bits(gbc, 6) - 15) << 4;
974         for (ch = !s->cpl_in_use; ch <= s->channels; ch++) { /* snr offset and fast gain */
975             s->snr_offset[ch] = (csnr + get_bits(gbc, 4)) << 2;
976             s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
977         }
978         memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
979     }
980
981     /* coupling leak information */
982     if (s->cpl_in_use && get_bits1(gbc)) {
983         s->bit_alloc_params.cpl_fast_leak = get_bits(gbc, 3);
984         s->bit_alloc_params.cpl_slow_leak = get_bits(gbc, 3);
985         bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
986     }
987
988     /* delta bit allocation information */
989     if (get_bits1(gbc)) {
990         /* delta bit allocation exists (strategy) */
991         for (ch = !s->cpl_in_use; ch <= fbw_channels; ch++) {
992             s->dba_mode[ch] = get_bits(gbc, 2);
993             if (s->dba_mode[ch] == DBA_RESERVED) {
994                 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
995                 return -1;
996             }
997             bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
998         }
999         /* channel delta offset, len and bit allocation */
1000         for (ch = !s->cpl_in_use; ch <= fbw_channels; ch++) {
1001             if (s->dba_mode[ch] == DBA_NEW) {
1002                 s->dba_nsegs[ch] = get_bits(gbc, 3);
1003                 for (seg = 0; seg <= s->dba_nsegs[ch]; seg++) {
1004                     s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1005                     s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1006                     s->dba_values[ch][seg] = get_bits(gbc, 3);
1007                 }
1008             }
1009         }
1010     } else if(blk == 0) {
1011         for(ch=0; ch<=s->channels; ch++) {
1012             s->dba_mode[ch] = DBA_NONE;
1013         }
1014     }
1015
1016     /* Bit allocation */
1017     for(ch=!s->cpl_in_use; ch<=s->channels; ch++) {
1018         if(bit_alloc_stages[ch] > 2) {
1019             /* Exponent mapping into PSD and PSD integration */
1020             ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
1021                                       s->start_freq[ch], s->end_freq[ch],
1022                                       s->psd[ch], s->band_psd[ch]);
1023         }
1024         if(bit_alloc_stages[ch] > 1) {
1025             /* Compute excitation function, Compute masking curve, and
1026                Apply delta bit allocation */
1027             ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1028                                        s->start_freq[ch], s->end_freq[ch],
1029                                        s->fast_gain[ch], (ch == s->lfe_ch),
1030                                        s->dba_mode[ch], s->dba_nsegs[ch],
1031                                        s->dba_offsets[ch], s->dba_lengths[ch],
1032                                        s->dba_values[ch], s->mask[ch]);
1033         }
1034         if(bit_alloc_stages[ch] > 0) {
1035             /* Compute bit allocation */
1036             ff_ac3_bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1037                                       s->start_freq[ch], s->end_freq[ch],
1038                                       s->snr_offset[ch],
1039                                       s->bit_alloc_params.floor,
1040                                       s->bap[ch]);
1041         }
1042     }
1043
1044     /* unused dummy data */
1045     if (get_bits1(gbc)) {
1046         int skipl = get_bits(gbc, 9);
1047         while(skipl--)
1048             skip_bits(gbc, 8);
1049     }
1050
1051     /* unpack the transform coefficients
1052        this also uncouples channels if coupling is in use. */
1053     if (get_transform_coeffs(s)) {
1054         av_log(s->avctx, AV_LOG_ERROR, "Error in routine get_transform_coeffs\n");
1055         return -1;
1056     }
1057
1058     /* recover coefficients if rematrixing is in use */
1059     if(s->channel_mode == AC3_CHMODE_STEREO)
1060         do_rematrixing(s);
1061
1062     /* apply scaling to coefficients (headroom, dynrng) */
1063     for(ch=1; ch<=s->channels; ch++) {
1064         float gain = 2.0f * s->mul_bias;
1065         if(s->channel_mode == AC3_CHMODE_DUALMONO) {
1066             gain *= s->dynamic_range[ch-1];
1067         } else {
1068             gain *= s->dynamic_range[0];
1069         }
1070         for(i=0; i<s->end_freq[ch]; i++) {
1071             s->transform_coeffs[ch][i] *= gain;
1072         }
1073     }
1074
1075     do_imdct(s);
1076
1077     /* downmix output if needed */
1078     if(s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1079             s->fbw_channels == s->out_channels)) {
1080         ac3_downmix(s);
1081     }
1082
1083     /* convert float to 16-bit integer */
1084     for(ch=0; ch<s->out_channels; ch++) {
1085         for(i=0; i<256; i++) {
1086             s->output[ch][i] += s->add_bias;
1087         }
1088         s->dsp.float_to_int16(s->int_output[ch], s->output[ch], 256);
1089     }
1090
1091     return 0;
1092 }
1093
1094 /**
1095  * Decode a single AC-3 frame.
1096  */
1097 static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size, uint8_t *buf, int buf_size)
1098 {
1099     AC3DecodeContext *s = avctx->priv_data;
1100     int16_t *out_samples = (int16_t *)data;
1101     int i, blk, ch, err;
1102
1103     /* initialize the GetBitContext with the start of valid AC-3 Frame */
1104     init_get_bits(&s->gbc, buf, buf_size * 8);
1105
1106     /* parse the syncinfo */
1107     err = ac3_parse_header(s);
1108     if(err) {
1109         switch(err) {
1110             case AC3_PARSE_ERROR_SYNC:
1111                 av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1112                 break;
1113             case AC3_PARSE_ERROR_BSID:
1114                 av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1115                 break;
1116             case AC3_PARSE_ERROR_SAMPLE_RATE:
1117                 av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1118                 break;
1119             case AC3_PARSE_ERROR_FRAME_SIZE:
1120                 av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1121                 break;
1122             default:
1123                 av_log(avctx, AV_LOG_ERROR, "invalid header\n");
1124                 break;
1125         }
1126         return -1;
1127     }
1128
1129     /* check that reported frame size fits in input buffer */
1130     if(s->frame_size > buf_size) {
1131         av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1132         return -1;
1133     }
1134
1135     /* check for crc mismatch */
1136     if(avctx->error_resilience > 0) {
1137         if(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2], s->frame_size-2)) {
1138             av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1139             return -1;
1140         }
1141         /* TODO: error concealment */
1142     }
1143
1144     avctx->sample_rate = s->sample_rate;
1145     avctx->bit_rate = s->bit_rate;
1146
1147     /* channel config */
1148     s->out_channels = s->channels;
1149     if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&
1150             avctx->request_channels < s->channels) {
1151         s->out_channels = avctx->request_channels;
1152         s->output_mode  = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1153     }
1154     avctx->channels = s->out_channels;
1155
1156     /* set downmixing coefficients if needed */
1157     if(s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1158             s->fbw_channels == s->out_channels)) {
1159         set_downmix_coeffs(s);
1160     }
1161
1162     /* parse the audio blocks */
1163     for (blk = 0; blk < NB_BLOCKS; blk++) {
1164         if (ac3_parse_audio_block(s, blk)) {
1165             av_log(avctx, AV_LOG_ERROR, "error parsing the audio block\n");
1166             *data_size = 0;
1167             return s->frame_size;
1168         }
1169         for (i = 0; i < 256; i++)
1170             for (ch = 0; ch < s->out_channels; ch++)
1171                 *(out_samples++) = s->int_output[ch][i];
1172     }
1173     *data_size = NB_BLOCKS * 256 * avctx->channels * sizeof (int16_t);
1174     return s->frame_size;
1175 }
1176
1177 /**
1178  * Uninitialize the AC-3 decoder.
1179  */
1180 static int ac3_decode_end(AVCodecContext *avctx)
1181 {
1182     AC3DecodeContext *s = avctx->priv_data;
1183     ff_mdct_end(&s->imdct_512);
1184     ff_mdct_end(&s->imdct_256);
1185
1186     return 0;
1187 }
1188
1189 AVCodec ac3_decoder = {
1190     .name = "ac3",
1191     .type = CODEC_TYPE_AUDIO,
1192     .id = CODEC_ID_AC3,
1193     .priv_data_size = sizeof (AC3DecodeContext),
1194     .init = ac3_decode_init,
1195     .close = ac3_decode_end,
1196     .decode = ac3_decode_frame,
1197 };