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