19ceac3645c6e47afd39f43fe71663b3833fda42
[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 #define ALT_BITSTREAM_READER
36
37 #include "avcodec.h"
38 #include "ac3.h"
39 #include "ac3tab.h"
40 #include "bitstream.h"
41 #include "dsputil.h"
42 #include "random.h"
43
44 static const int nfchans_tbl[8] = { 2, 1, 2, 3, 3, 4, 4, 5 };
45
46 /* table for exponent to scale_factor mapping
47  * scale_factor[i] = 2 ^ -(i + 15)
48  */
49 static float scale_factors[25];
50
51 /** table for grouping exponents */
52 static uint8_t exp_ungroup_tbl[128][3];
53
54 static int16_t l3_quantizers_1[32];
55 static int16_t l3_quantizers_2[32];
56 static int16_t l3_quantizers_3[32];
57
58 static int16_t l5_quantizers_1[128];
59 static int16_t l5_quantizers_2[128];
60 static int16_t l5_quantizers_3[128];
61
62 static int16_t l7_quantizers[7];
63
64 static int16_t l11_quantizers_1[128];
65 static int16_t l11_quantizers_2[128];
66
67 static int16_t l15_quantizers[15];
68
69 static const uint8_t qntztab[16] = { 0, 5, 7, 3, 7, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 16 };
70
71 /* Adjustmens in dB gain */
72 #define LEVEL_MINUS_3DB         0.7071067811865476
73 #define LEVEL_MINUS_4POINT5DB   0.5946035575013605
74 #define LEVEL_MINUS_6DB         0.5000000000000000
75 #define LEVEL_PLUS_3DB          1.4142135623730951
76 #define LEVEL_PLUS_6DB          2.0000000000000000
77 #define LEVEL_ZERO              0.0000000000000000
78
79 static const float clevs[4] = { LEVEL_MINUS_3DB, LEVEL_MINUS_4POINT5DB,
80     LEVEL_MINUS_6DB, LEVEL_MINUS_4POINT5DB };
81
82 static const float slevs[4] = { LEVEL_MINUS_3DB, LEVEL_MINUS_6DB, LEVEL_ZERO, LEVEL_MINUS_6DB };
83
84 #define BLOCK_SIZE    256
85
86 /* Output and input configurations. */
87 #define AC3_OUTPUT_UNMODIFIED   0x01
88 #define AC3_OUTPUT_MONO         0x02
89 #define AC3_OUTPUT_STEREO       0x04
90 #define AC3_OUTPUT_DOLBY        0x08
91 #define AC3_OUTPUT_LFEON        0x10
92
93 typedef struct {
94     uint16_t crc1;
95     uint8_t  fscod;
96
97     uint8_t  acmod;
98     uint8_t  cmixlev;
99     uint8_t  surmixlev;
100     uint8_t  dsurmod;
101
102     uint8_t  blksw;
103     uint8_t  dithflag;
104     uint8_t  cplinu;
105     uint8_t  chincpl;
106     uint8_t  phsflginu;
107     uint8_t  cplbegf;
108     uint8_t  cplendf;
109     uint8_t  cplcoe;
110     uint32_t cplbndstrc;
111     uint8_t  rematstr;
112     uint8_t  rematflg;
113     uint8_t  cplexpstr;
114     uint8_t  lfeexpstr;
115     uint8_t  chexpstr[5];
116     uint8_t  sdcycod;
117     uint8_t  fdcycod;
118     uint8_t  sgaincod;
119     uint8_t  dbpbcod;
120     uint8_t  floorcod;
121     uint8_t  csnroffst;
122     uint8_t  cplfsnroffst;
123     uint8_t  cplfgaincod;
124     uint8_t  fsnroffst[5];
125     uint8_t  fgaincod[5];
126     uint8_t  lfefsnroffst;
127     uint8_t  lfefgaincod;
128     uint8_t  cplfleak;
129     uint8_t  cplsleak;
130     uint8_t  cpldeltbae;
131     uint8_t  deltbae[5];
132     uint8_t  cpldeltnseg;
133     uint8_t  cpldeltoffst[8];
134     uint8_t  cpldeltlen[8];
135     uint8_t  cpldeltba[8];
136     uint8_t  deltnseg[5];
137     uint8_t  deltoffst[5][8];
138     uint8_t  deltlen[5][8];
139     uint8_t  deltba[5][8];
140
141     /* Derived Attributes. */
142     int      sampling_rate;
143     int      bit_rate;
144     int      frame_size;
145
146     int      nfchans;           //number of channels
147     int      lfeon;             //lfe channel in use
148
149     float    dynrng;            //dynamic range gain
150     float    dynrng2;           //dynamic range gain for 1+1 mode
151     float    chcoeffs[6];       //normalized channel coefficients
152     float    cplco[5][18];      //coupling coordinates
153     int      ncplbnd;           //number of coupling bands
154     int      ncplsubnd;         //number of coupling sub bands
155     int      cplstrtmant;       //coupling start mantissa
156     int      cplendmant;        //coupling end mantissa
157     int      endmant[5];        //channel end mantissas
158     AC3BitAllocParameters bit_alloc_params; ///< bit allocation parameters
159
160     uint8_t  dcplexps[256];     //decoded coupling exponents
161     uint8_t  dexps[5][256];     //decoded fbw channel exponents
162     uint8_t  dlfeexps[256];     //decoded lfe channel exponents
163     uint8_t  cplbap[256];       //coupling bit allocation pointers
164     uint8_t  bap[5][256];       //fbw channel bit allocation pointers
165     uint8_t  lfebap[256];       //lfe channel bit allocation pointers
166
167     int      blkoutput;         //output configuration for block
168
169     DECLARE_ALIGNED_16(float, transform_coeffs[AC3_MAX_CHANNELS][BLOCK_SIZE]);  //transform coefficients
170
171     /* For IMDCT. */
172     MDCTContext imdct_512;  //for 512 sample imdct transform
173     MDCTContext imdct_256;  //for 256 sample imdct transform
174     DSPContext  dsp;        //for optimization
175
176     DECLARE_ALIGNED_16(float, output[AC3_MAX_CHANNELS][BLOCK_SIZE]);    //output after imdct transform and windowing
177     DECLARE_ALIGNED_16(float, delay[AC3_MAX_CHANNELS][BLOCK_SIZE]);     //delay - added to the next block
178     DECLARE_ALIGNED_16(float, tmp_imdct[BLOCK_SIZE]);               //temporary storage for imdct transform
179     DECLARE_ALIGNED_16(float, tmp_output[BLOCK_SIZE * 2]);          //temporary storage for output before windowing
180     DECLARE_ALIGNED_16(float, window[BLOCK_SIZE]);                  //window coefficients
181
182     /* Miscellaneous. */
183     GetBitContext gb;
184     AVRandomState dith_state;   //for dither generation
185 } AC3DecodeContext;
186
187 /*********** BEGIN INIT HELPER FUNCTIONS ***********/
188 /**
189  * Generate a Kaiser-Bessel Derived Window.
190  */
191 static void ac3_window_init(float *window)
192 {
193    int i, j;
194    double sum = 0.0, bessel, tmp;
195    double local_window[256];
196    double alpha2 = (5.0 * M_PI / 256.0) * (5.0 * M_PI / 256.0);
197
198    for (i = 0; i < 256; i++) {
199        tmp = i * (256 - i) * alpha2;
200        bessel = 1.0;
201        for (j = 100; j > 0; j--) /* defaul to 100 iterations */
202            bessel = bessel * tmp / (j * j) + 1;
203        sum += bessel;
204        local_window[i] = sum;
205    }
206
207    sum++;
208    for (i = 0; i < 256; i++)
209        window[i] = sqrt(local_window[i] / sum);
210 }
211
212 /*
213  * Generate quantizer tables.
214  */
215 static void generate_quantizers_table(int16_t quantizers[], int level, int length)
216 {
217     int i;
218
219     for (i = 0; i < length; i++)
220         quantizers[i] = ((2 * i - level + 1) << 15) / level;
221 }
222
223 static void generate_quantizers_table_1(int16_t quantizers[], int level, int length1, int length2, int size)
224 {
225     int i, j;
226     int16_t v;
227
228     for (i = 0; i < length1; i++) {
229         v = ((2 * i - level + 1) << 15) / level;
230         for (j = 0; j < length2; j++)
231             quantizers[i * length2 + j] = v;
232     }
233
234     for (i = length1 * length2; i < size; i++)
235         quantizers[i] = 0;
236 }
237
238 static void generate_quantizers_table_2(int16_t quantizers[], int level, int length1, int length2, int size)
239 {
240     int i, j;
241     int16_t v;
242
243     for (i = 0; i < length1; i++) {
244         v = ((2 * (i % level) - level + 1) << 15) / level;
245         for (j = 0; j < length2; j++)
246             quantizers[i * length2 + j] = v;
247     }
248
249     for (i = length1 * length2; i < size; i++)
250         quantizers[i] = 0;
251
252 }
253
254 static void generate_quantizers_table_3(int16_t quantizers[], int level, int length1, int length2, int size)
255 {
256     int i, j;
257
258     for (i = 0; i < length1; i++)
259         for (j = 0; j < length2; j++)
260             quantizers[i * length2 + j] = ((2 * (j % level) - level + 1) << 15) / level;
261
262     for (i = length1 * length2; i < size; i++)
263         quantizers[i] = 0;
264 }
265
266 /*
267  * Initialize tables at runtime.
268  */
269 static void ac3_tables_init(void)
270 {
271     int i;
272
273     /* Quantizer ungrouping tables. */
274     // for level-3 quantizers
275     generate_quantizers_table_1(l3_quantizers_1, 3, 3, 9, 32);
276     generate_quantizers_table_2(l3_quantizers_2, 3, 9, 3, 32);
277     generate_quantizers_table_3(l3_quantizers_3, 3, 9, 3, 32);
278
279     //for level-5 quantizers
280     generate_quantizers_table_1(l5_quantizers_1, 5, 5, 25, 128);
281     generate_quantizers_table_2(l5_quantizers_2, 5, 25, 5, 128);
282     generate_quantizers_table_3(l5_quantizers_3, 5, 25, 5, 128);
283
284     //for level-7 quantizers
285     generate_quantizers_table(l7_quantizers, 7, 7);
286
287     //for level-4 quantizers
288     generate_quantizers_table_2(l11_quantizers_1, 11, 11, 11, 128);
289     generate_quantizers_table_3(l11_quantizers_2, 11, 11, 11, 128);
290
291     //for level-15 quantizers
292     generate_quantizers_table(l15_quantizers, 15, 15);
293     /* End Quantizer ungrouping tables. */
294
295     //generate scale factors
296     for (i = 0; i < 25; i++)
297         scale_factors[i] = pow(2.0, -(i + 15));
298
299     /* generate exponent tables
300        reference: Section 7.1.3 Exponent Decoding */
301     for(i=0; i<128; i++) {
302         exp_ungroup_tbl[i][0] =  i / 25;
303         exp_ungroup_tbl[i][1] = (i % 25) / 5;
304         exp_ungroup_tbl[i][2] = (i % 25) % 5;
305     }
306 }
307
308
309 static int ac3_decode_init(AVCodecContext *avctx)
310 {
311     AC3DecodeContext *ctx = avctx->priv_data;
312
313     ac3_common_init();
314     ac3_tables_init();
315     ff_mdct_init(&ctx->imdct_256, 8, 1);
316     ff_mdct_init(&ctx->imdct_512, 9, 1);
317     ac3_window_init(ctx->window);
318     dsputil_init(&ctx->dsp, avctx);
319     av_init_random(0, &ctx->dith_state);
320
321     return 0;
322 }
323 /*********** END INIT FUNCTIONS ***********/
324
325 /* Synchronize to ac3 bitstream.
326  * This function searches for the syncword '0xb77'.
327  *
328  * @param buf Pointer to "probable" ac3 bitstream buffer
329  * @param buf_size Size of buffer
330  * @return Returns the position where syncword is found, -1 if no syncword is found
331  */
332 static int ac3_synchronize(uint8_t *buf, int buf_size)
333 {
334     int i;
335
336     for (i = 0; i < buf_size - 1; i++)
337         if (buf[i] == 0x0b && buf[i + 1] == 0x77)
338             return i;
339
340     return -1;
341 }
342
343 /* Parse the 'sync_info' from the ac3 bitstream.
344  * This function extracts the sync_info from ac3 bitstream.
345  * GetBitContext within AC3DecodeContext must point to
346  * start of the synchronized ac3 bitstream.
347  *
348  * @param ctx  AC3DecodeContext
349  * @return Returns framesize, returns 0 if fscod, frmsizecod or bsid is not valid
350  */
351 static int ac3_parse_sync_info(AC3DecodeContext *ctx)
352 {
353     GetBitContext *gb = &ctx->gb;
354     int frmsizecod, bsid;
355
356     skip_bits(gb, 16); //skip the sync_word, sync_info->sync_word = get_bits(gb, 16);
357     ctx->crc1 = get_bits(gb, 16);
358     ctx->fscod = get_bits(gb, 2);
359     if (ctx->fscod == 0x03)
360         return 0;
361     frmsizecod = get_bits(gb, 6);
362     if (frmsizecod >= 38)
363         return 0;
364     ctx->sampling_rate = ff_ac3_freqs[ctx->fscod];
365     ctx->bit_rate = ff_ac3_bitratetab[frmsizecod >> 1];
366
367     /* we include it here in order to determine validity of ac3 frame */
368     bsid = get_bits(gb, 5);
369     if (bsid > 0x08)
370         return 0;
371     skip_bits(gb, 3); //skip the bsmod, bsi->bsmod = get_bits(gb, 3);
372
373     switch (ctx->fscod) {
374         case 0x00:
375             ctx->frame_size = 4 * ctx->bit_rate;
376             return ctx->frame_size;
377         case 0x01:
378             ctx->frame_size = 2 * (320 * ctx->bit_rate / 147 + (frmsizecod & 1));
379             return ctx->frame_size;
380         case 0x02:
381             ctx->frame_size =  6 * ctx->bit_rate;
382             return ctx->frame_size;
383     }
384
385     /* never reached */
386     return 0;
387 }
388
389 /* Parse bsi from ac3 bitstream.
390  * This function extracts the bitstream information (bsi) from ac3 bitstream.
391  *
392  * @param ctx AC3DecodeContext after processed by ac3_parse_sync_info
393  */
394 static void ac3_parse_bsi(AC3DecodeContext *ctx)
395 {
396     GetBitContext *gb = &ctx->gb;
397     int i;
398
399     ctx->cmixlev = 0;
400     ctx->surmixlev = 0;
401     ctx->dsurmod = 0;
402     ctx->nfchans = 0;
403     ctx->cpldeltbae = DBA_NONE;
404     ctx->cpldeltnseg = 0;
405     for (i = 0; i < 5; i++) {
406         ctx->deltbae[i] = DBA_NONE;
407         ctx->deltnseg[i] = 0;
408     }
409     ctx->dynrng = 1.0;
410     ctx->dynrng2 = 1.0;
411
412     ctx->acmod = get_bits(gb, 3);
413     ctx->nfchans = nfchans_tbl[ctx->acmod];
414
415     if (ctx->acmod & 0x01 && ctx->acmod != 0x01)
416         ctx->cmixlev = get_bits(gb, 2);
417     if (ctx->acmod & 0x04)
418         ctx->surmixlev = get_bits(gb, 2);
419     if (ctx->acmod == 0x02)
420         ctx->dsurmod = get_bits(gb, 2);
421
422     ctx->lfeon = get_bits1(gb);
423
424     i = !(ctx->acmod);
425     do {
426         skip_bits(gb, 5); //skip dialog normalization
427         if (get_bits1(gb))
428             skip_bits(gb, 8); //skip compression
429         if (get_bits1(gb))
430             skip_bits(gb, 8); //skip language code
431         if (get_bits1(gb))
432             skip_bits(gb, 7); //skip audio production information
433     } while (i--);
434
435     skip_bits(gb, 2); //skip copyright bit and original bitstream bit
436
437     if (get_bits1(gb))
438         skip_bits(gb, 14); //skip timecode1
439     if (get_bits1(gb))
440         skip_bits(gb, 14); //skip timecode2
441
442     if (get_bits1(gb)) {
443         i = get_bits(gb, 6); //additional bsi length
444         do {
445             skip_bits(gb, 8);
446         } while(i--);
447     }
448 }
449
450 /**
451  * Decodes the grouped exponents.
452  * This function decodes the coded exponents according to exponent strategy
453  * and stores them in the decoded exponents buffer.
454  *
455  * @param[in]  gb      GetBitContext which points to start of coded exponents
456  * @param[in]  expstr  Exponent coding strategy
457  * @param[in]  ngrps   Number of grouped exponents
458  * @param[in]  absexp  Absolute exponent or DC exponent
459  * @param[out] dexps   Decoded exponents are stored in dexps
460  */
461 static void decode_exponents(GetBitContext *gb, int expstr, int ngrps,
462                              uint8_t absexp, uint8_t *dexps)
463 {
464     int i, j, grp, grpsize;
465     int dexp[256];
466     int expacc, prevexp;
467
468     /* unpack groups */
469     grpsize = expstr + (expstr == EXP_D45);
470     for(grp=0,i=0; grp<ngrps; grp++) {
471         expacc = get_bits(gb, 7);
472         dexp[i++] = exp_ungroup_tbl[expacc][0];
473         dexp[i++] = exp_ungroup_tbl[expacc][1];
474         dexp[i++] = exp_ungroup_tbl[expacc][2];
475     }
476
477     /* convert to absolute exps and expand groups */
478     prevexp = absexp;
479     for(i=0; i<ngrps*3; i++) {
480         prevexp = av_clip(prevexp + dexp[i]-2, 0, 24);
481         for(j=0; j<grpsize; j++) {
482             dexps[(i*grpsize)+j] = prevexp;
483         }
484     }
485 }
486
487 /* Performs bit allocation.
488  * This function performs bit allocation for the requested chanenl.
489  */
490 static void do_bit_allocation(AC3DecodeContext *ctx, int chnl)
491 {
492     int fgain, snroffset;
493
494     if (chnl == 5) {
495         fgain = ff_fgaintab[ctx->cplfgaincod];
496         snroffset = (((ctx->csnroffst - 15) << 4) + ctx->cplfsnroffst) << 2;
497         ac3_parametric_bit_allocation(&ctx->bit_alloc_params, ctx->cplbap,
498                                       ctx->dcplexps, ctx->cplstrtmant,
499                                       ctx->cplendmant, snroffset, fgain, 0,
500                                       ctx->cpldeltbae, ctx->cpldeltnseg,
501                                       ctx->cpldeltoffst, ctx->cpldeltlen,
502                                       ctx->cpldeltba);
503     }
504     else if (chnl == 6) {
505         fgain = ff_fgaintab[ctx->lfefgaincod];
506         snroffset = (((ctx->csnroffst - 15) << 4) + ctx->lfefsnroffst) << 2;
507         ac3_parametric_bit_allocation(&ctx->bit_alloc_params, ctx->lfebap,
508                                       ctx->dlfeexps, 0, 7, snroffset, fgain, 1,
509                                       DBA_NONE, 0, NULL, NULL, NULL);
510     }
511     else {
512         fgain = ff_fgaintab[ctx->fgaincod[chnl]];
513         snroffset = (((ctx->csnroffst - 15) << 4) + ctx->fsnroffst[chnl]) << 2;
514         ac3_parametric_bit_allocation(&ctx->bit_alloc_params, ctx->bap[chnl],
515                                       ctx->dexps[chnl], 0, ctx->endmant[chnl],
516                                       snroffset, fgain, 0, ctx->deltbae[chnl],
517                                       ctx->deltnseg[chnl], ctx->deltoffst[chnl],
518                                       ctx->deltlen[chnl], ctx->deltba[chnl]);
519     }
520 }
521
522 typedef struct { /* grouped mantissas for 3-level 5-leve and 11-level quantization */
523     int16_t l3_quantizers[3];
524     int16_t l5_quantizers[3];
525     int16_t l11_quantizers[2];
526     int l3ptr;
527     int l5ptr;
528     int l11ptr;
529 } mant_groups;
530
531 #define TRANSFORM_COEFF(tc, m, e, f) (tc) = (m) * (f)[(e)]
532
533 /* Get the transform coefficients for coupling channel and uncouple channels.
534  * The coupling transform coefficients starts at the the cplstrtmant, which is
535  * equal to endmant[ch] for fbw channels. Hence we can uncouple channels before
536  * getting transform coefficients for the channel.
537  */
538 static int get_transform_coeffs_cpling(AC3DecodeContext *ctx, mant_groups *m)
539 {
540     GetBitContext *gb = &ctx->gb;
541     int ch, start, end, cplbndstrc, bnd, gcode, tbap;
542     float cplcos[5], cplcoeff;
543     uint8_t *exps = ctx->dcplexps;
544     uint8_t *bap = ctx->cplbap;
545
546     cplbndstrc = ctx->cplbndstrc;
547     start = ctx->cplstrtmant;
548     bnd = 0;
549
550     while (start < ctx->cplendmant) {
551         end = start + 12;
552         while (cplbndstrc & 1) {
553             end += 12;
554             cplbndstrc >>= 1;
555         }
556         cplbndstrc >>= 1;
557         for (ch = 0; ch < ctx->nfchans; ch++)
558             cplcos[ch] = ctx->chcoeffs[ch] * ctx->cplco[ch][bnd];
559         bnd++;
560
561         while (start < end) {
562             tbap = bap[start];
563             switch(tbap) {
564                 case 0:
565                     for (ch = 0; ch < ctx->nfchans; ch++)
566                         if (((ctx->chincpl) >> ch) & 1) {
567                             if ((ctx->dithflag >> ch) & 1) {
568                                 TRANSFORM_COEFF(cplcoeff, av_random(&ctx->dith_state) & 0xFFFF, exps[start], scale_factors);
569                                 ctx->transform_coeffs[ch + 1][start] = cplcoeff * cplcos[ch] * LEVEL_MINUS_3DB;
570                             } else
571                                 ctx->transform_coeffs[ch + 1][start] = 0;
572                         }
573                     start++;
574                     continue;
575                 case 1:
576                     if (m->l3ptr > 2) {
577                         gcode = get_bits(gb, 5);
578                         m->l3_quantizers[0] = l3_quantizers_1[gcode];
579                         m->l3_quantizers[1] = l3_quantizers_2[gcode];
580                         m->l3_quantizers[2] = l3_quantizers_3[gcode];
581                         m->l3ptr = 0;
582                     }
583                     TRANSFORM_COEFF(cplcoeff, m->l3_quantizers[m->l3ptr++], exps[start], scale_factors);
584                     break;
585
586                 case 2:
587                     if (m->l5ptr > 2) {
588                         gcode = get_bits(gb, 7);
589                         m->l5_quantizers[0] = l5_quantizers_1[gcode];
590                         m->l5_quantizers[1] = l5_quantizers_2[gcode];
591                         m->l5_quantizers[2] = l5_quantizers_3[gcode];
592                         m->l5ptr = 0;
593                     }
594                     TRANSFORM_COEFF(cplcoeff, m->l5_quantizers[m->l5ptr++], exps[start], scale_factors);
595                     break;
596
597                 case 3:
598                     TRANSFORM_COEFF(cplcoeff, l7_quantizers[get_bits(gb, 3)], exps[start], scale_factors);
599                     break;
600
601                 case 4:
602                     if (m->l11ptr > 1) {
603                         gcode = get_bits(gb, 7);
604                         m->l11_quantizers[0] = l11_quantizers_1[gcode];
605                         m->l11_quantizers[1] = l11_quantizers_2[gcode];
606                         m->l11ptr = 0;
607                     }
608                     TRANSFORM_COEFF(cplcoeff, m->l11_quantizers[m->l11ptr++], exps[start], scale_factors);
609                     break;
610
611                 case 5:
612                     TRANSFORM_COEFF(cplcoeff, l15_quantizers[get_bits(gb, 4)], exps[start], scale_factors);
613                     break;
614
615                 default:
616                     TRANSFORM_COEFF(cplcoeff, get_sbits(gb, qntztab[tbap]) << (16 - qntztab[tbap]),
617                             exps[start], scale_factors);
618             }
619             for (ch = 0; ch < ctx->nfchans; ch++)
620                 if ((ctx->chincpl >> ch) & 1)
621                     ctx->transform_coeffs[ch + 1][start] = cplcoeff * cplcos[ch];
622             start++;
623         }
624     }
625
626     return 0;
627 }
628
629 /* Get the transform coefficients for particular channel */
630 static int get_transform_coeffs_ch(AC3DecodeContext *ctx, int ch_index, mant_groups *m)
631 {
632     GetBitContext *gb = &ctx->gb;
633     int i, gcode, tbap, dithflag, end;
634     uint8_t *exps;
635     uint8_t *bap;
636     float *coeffs;
637     float factors[25];
638
639     for (i = 0; i < 25; i++)
640         factors[i] = scale_factors[i] * ctx->chcoeffs[ch_index];
641
642     if (ch_index != -1) { /* fbw channels */
643         dithflag = (ctx->dithflag >> ch_index) & 1;
644         exps = ctx->dexps[ch_index];
645         bap = ctx->bap[ch_index];
646         coeffs = ctx->transform_coeffs[ch_index + 1];
647         end = ctx->endmant[ch_index];
648     } else if (ch_index == -1) {
649         dithflag = 0;
650         exps = ctx->dlfeexps;
651         bap = ctx->lfebap;
652         coeffs = ctx->transform_coeffs[0];
653         end = 7;
654     }
655
656
657     for (i = 0; i < end; i++) {
658         tbap = bap[i];
659         switch (tbap) {
660             case 0:
661                 if (!dithflag) {
662                     coeffs[i] = 0;
663                     continue;
664                 }
665                 else {
666                     TRANSFORM_COEFF(coeffs[i], av_random(&ctx->dith_state) & 0xFFFF, exps[i], factors);
667                     coeffs[i] *= LEVEL_MINUS_3DB;
668                     continue;
669                 }
670
671             case 1:
672                 if (m->l3ptr > 2) {
673                     gcode = get_bits(gb, 5);
674                     m->l3_quantizers[0] = l3_quantizers_1[gcode];
675                     m->l3_quantizers[1] = l3_quantizers_2[gcode];
676                     m->l3_quantizers[2] = l3_quantizers_3[gcode];
677                     m->l3ptr = 0;
678                 }
679                 TRANSFORM_COEFF(coeffs[i], m->l3_quantizers[m->l3ptr++], exps[i], factors);
680                 continue;
681
682             case 2:
683                 if (m->l5ptr > 2) {
684                     gcode = get_bits(gb, 7);
685                     m->l5_quantizers[0] = l5_quantizers_1[gcode];
686                     m->l5_quantizers[1] = l5_quantizers_2[gcode];
687                     m->l5_quantizers[2] = l5_quantizers_3[gcode];
688                     m->l5ptr = 0;
689                 }
690                 TRANSFORM_COEFF(coeffs[i], m->l5_quantizers[m->l5ptr++], exps[i], factors);
691                 continue;
692
693             case 3:
694                 TRANSFORM_COEFF(coeffs[i], l7_quantizers[get_bits(gb, 3)], exps[i], factors);
695                 continue;
696
697             case 4:
698                 if (m->l11ptr > 1) {
699                     gcode = get_bits(gb, 7);
700                     m->l11_quantizers[0] = l11_quantizers_1[gcode];
701                     m->l11_quantizers[1] = l11_quantizers_2[gcode];
702                     m->l11ptr = 0;
703                 }
704                 TRANSFORM_COEFF(coeffs[i], m->l11_quantizers[m->l11ptr++], exps[i], factors);
705                 continue;
706
707             case 5:
708                 TRANSFORM_COEFF(coeffs[i], l15_quantizers[get_bits(gb, 4)], exps[i], factors);
709                 continue;
710
711             default:
712                 TRANSFORM_COEFF(coeffs[i], get_sbits(gb, qntztab[tbap]) << (16 - qntztab[tbap]), exps[i], factors);
713                 continue;
714         }
715     }
716
717     return 0;
718 }
719
720 /* Get the transform coefficients.
721  * This function extracts the tranform coefficients form the ac3 bitstream.
722  * This function is called after bit allocation is performed.
723  */
724 static int get_transform_coeffs(AC3DecodeContext * ctx)
725 {
726     int i, end;
727     int got_cplchan = 0;
728     mant_groups m;
729
730     m.l3ptr = m.l5ptr = m.l11ptr = 3;
731
732     for (i = 0; i < ctx->nfchans; i++) {
733         /* transform coefficients for individual channel */
734         if (get_transform_coeffs_ch(ctx, i, &m))
735             return -1;
736         /* tranform coefficients for coupling channels */
737         if ((ctx->chincpl >> i) & 1)  {
738             if (!got_cplchan) {
739                 if (get_transform_coeffs_cpling(ctx, &m)) {
740                     av_log(NULL, AV_LOG_ERROR, "error in decoupling channels\n");
741                     return -1;
742                 }
743                 got_cplchan = 1;
744             }
745             end = ctx->cplendmant;
746         } else
747             end = ctx->endmant[i];
748         do
749             ctx->transform_coeffs[i + 1][end] = 0;
750         while(++end < 256);
751     }
752     if (ctx->lfeon) {
753         if (get_transform_coeffs_ch(ctx, -1, &m))
754                 return -1;
755         for (i = 7; i < 256; i++) {
756             ctx->transform_coeffs[0][i] = 0;
757         }
758     }
759
760     return 0;
761 }
762
763 /* Rematrixing routines. */
764 static void do_rematrixing1(AC3DecodeContext *ctx, int start, int end)
765 {
766     float tmp0, tmp1;
767
768     while (start < end) {
769         tmp0 = ctx->transform_coeffs[1][start];
770         tmp1 = ctx->transform_coeffs[2][start];
771         ctx->transform_coeffs[1][start] = tmp0 + tmp1;
772         ctx->transform_coeffs[2][start] = tmp0 - tmp1;
773         start++;
774     }
775 }
776
777 static void do_rematrixing(AC3DecodeContext *ctx)
778 {
779     int bnd1 = 13, bnd2 = 25, bnd3 = 37, bnd4 = 61;
780     int end, bndend;
781
782     end = FFMIN(ctx->endmant[0], ctx->endmant[1]);
783
784     if (ctx->rematflg & 1)
785         do_rematrixing1(ctx, bnd1, bnd2);
786
787     if (ctx->rematflg & 2)
788         do_rematrixing1(ctx, bnd2, bnd3);
789
790     bndend = bnd4;
791     if (bndend > end) {
792         bndend = end;
793         if (ctx->rematflg & 4)
794             do_rematrixing1(ctx, bnd3, bndend);
795     } else {
796         if (ctx->rematflg & 4)
797             do_rematrixing1(ctx, bnd3, bnd4);
798         if (ctx->rematflg & 8)
799             do_rematrixing1(ctx, bnd4, end);
800     }
801 }
802
803 /* This function sets the normalized channel coefficients.
804  * Transform coefficients are multipllied by the channel
805  * coefficients to get normalized transform coefficients.
806  */
807 static void get_downmix_coeffs(AC3DecodeContext *ctx)
808 {
809     int from = ctx->acmod;
810     int to = ctx->blkoutput;
811     float clev = clevs[ctx->cmixlev];
812     float slev = slevs[ctx->surmixlev];
813     float nf = 1.0; //normalization factor for downmix coeffs
814     int i;
815
816     if (!ctx->acmod) {
817         ctx->chcoeffs[0] = 2 * ctx->dynrng;
818         ctx->chcoeffs[1] = 2 * ctx->dynrng2;
819     } else {
820         for (i = 0; i < ctx->nfchans; i++)
821             ctx->chcoeffs[i] = 2 * ctx->dynrng;
822     }
823
824     if (to == AC3_OUTPUT_UNMODIFIED)
825         return;
826
827     switch (from) {
828         case AC3_ACMOD_DUALMONO:
829             switch (to) {
830                 case AC3_OUTPUT_MONO:
831                 case AC3_OUTPUT_STEREO: /* We Assume that sum of both mono channels is requested */
832                     nf = 0.5;
833                     ctx->chcoeffs[0] *= nf;
834                     ctx->chcoeffs[1] *= nf;
835                     break;
836             }
837             break;
838         case AC3_ACMOD_MONO:
839             switch (to) {
840                 case AC3_OUTPUT_STEREO:
841                     nf = LEVEL_MINUS_3DB;
842                     ctx->chcoeffs[0] *= nf;
843                     break;
844             }
845             break;
846         case AC3_ACMOD_STEREO:
847             switch (to) {
848                 case AC3_OUTPUT_MONO:
849                     nf = LEVEL_MINUS_3DB;
850                     ctx->chcoeffs[0] *= nf;
851                     ctx->chcoeffs[1] *= nf;
852                     break;
853             }
854             break;
855         case AC3_ACMOD_3F:
856             switch (to) {
857                 case AC3_OUTPUT_MONO:
858                     nf = LEVEL_MINUS_3DB / (1.0 + clev);
859                     ctx->chcoeffs[0] *= (nf * LEVEL_MINUS_3DB);
860                     ctx->chcoeffs[2] *= (nf * LEVEL_MINUS_3DB);
861                     ctx->chcoeffs[1] *= ((nf * clev * LEVEL_MINUS_3DB) / 2.0);
862                     break;
863                 case AC3_OUTPUT_STEREO:
864                     nf = 1.0 / (1.0 + clev);
865                     ctx->chcoeffs[0] *= nf;
866                     ctx->chcoeffs[2] *= nf;
867                     ctx->chcoeffs[1] *= (nf * clev);
868                     break;
869             }
870             break;
871         case AC3_ACMOD_2F1R:
872             switch (to) {
873                 case AC3_OUTPUT_MONO:
874                     nf = 2.0 * LEVEL_MINUS_3DB / (2.0 + slev);
875                     ctx->chcoeffs[0] *= (nf * LEVEL_MINUS_3DB);
876                     ctx->chcoeffs[1] *= (nf * LEVEL_MINUS_3DB);
877                     ctx->chcoeffs[2] *= (nf * slev * LEVEL_MINUS_3DB);
878                     break;
879                 case AC3_OUTPUT_STEREO:
880                     nf = 1.0 / (1.0 + (slev * LEVEL_MINUS_3DB));
881                     ctx->chcoeffs[0] *= nf;
882                     ctx->chcoeffs[1] *= nf;
883                     ctx->chcoeffs[2] *= (nf * slev * LEVEL_MINUS_3DB);
884                     break;
885                 case AC3_OUTPUT_DOLBY:
886                     nf = 1.0 / (1.0 + LEVEL_MINUS_3DB);
887                     ctx->chcoeffs[0] *= nf;
888                     ctx->chcoeffs[1] *= nf;
889                     ctx->chcoeffs[2] *= (nf * LEVEL_MINUS_3DB);
890                     break;
891             }
892             break;
893         case AC3_ACMOD_3F1R:
894             switch (to) {
895                 case AC3_OUTPUT_MONO:
896                     nf = LEVEL_MINUS_3DB / (1.0 + clev + (slev / 2.0));
897                     ctx->chcoeffs[0] *= (nf * LEVEL_MINUS_3DB);
898                     ctx->chcoeffs[2] *= (nf * LEVEL_MINUS_3DB);
899                     ctx->chcoeffs[1] *= (nf * clev * LEVEL_PLUS_3DB);
900                     ctx->chcoeffs[3] *= (nf * slev * LEVEL_MINUS_3DB);
901                     break;
902                 case AC3_OUTPUT_STEREO:
903                     nf = 1.0 / (1.0 + clev + (slev * LEVEL_MINUS_3DB));
904                     ctx->chcoeffs[0] *= nf;
905                     ctx->chcoeffs[2] *= nf;
906                     ctx->chcoeffs[1] *= (nf * clev);
907                     ctx->chcoeffs[3] *= (nf * slev * LEVEL_MINUS_3DB);
908                     break;
909                 case AC3_OUTPUT_DOLBY:
910                     nf = 1.0 / (1.0 + (2.0 * LEVEL_MINUS_3DB));
911                     ctx->chcoeffs[0] *= nf;
912                     ctx->chcoeffs[1] *= nf;
913                     ctx->chcoeffs[1] *= (nf * LEVEL_MINUS_3DB);
914                     ctx->chcoeffs[3] *= (nf * LEVEL_MINUS_3DB);
915                     break;
916             }
917             break;
918         case AC3_ACMOD_2F2R:
919             switch (to) {
920                 case AC3_OUTPUT_MONO:
921                     nf = LEVEL_MINUS_3DB / (1.0 + slev);
922                     ctx->chcoeffs[0] *= (nf * LEVEL_MINUS_3DB);
923                     ctx->chcoeffs[1] *= (nf * LEVEL_MINUS_3DB);
924                     ctx->chcoeffs[2] *= (nf * slev * LEVEL_MINUS_3DB);
925                     ctx->chcoeffs[3] *= (nf * slev * LEVEL_MINUS_3DB);
926                     break;
927                 case AC3_OUTPUT_STEREO:
928                     nf = 1.0 / (1.0 + slev);
929                     ctx->chcoeffs[0] *= nf;
930                     ctx->chcoeffs[1] *= nf;
931                     ctx->chcoeffs[2] *= (nf * slev);
932                     ctx->chcoeffs[3] *= (nf * slev);
933                     break;
934                 case AC3_OUTPUT_DOLBY:
935                     nf = 1.0 / (1.0 + (2.0 * LEVEL_MINUS_3DB));
936                     ctx->chcoeffs[0] *= nf;
937                     ctx->chcoeffs[1] *= nf;
938                     ctx->chcoeffs[2] *= (nf * LEVEL_MINUS_3DB);
939                     ctx->chcoeffs[3] *= (nf * LEVEL_MINUS_3DB);
940                     break;
941             }
942             break;
943         case AC3_ACMOD_3F2R:
944             switch (to) {
945                 case AC3_OUTPUT_MONO:
946                     nf = LEVEL_MINUS_3DB / (1.0 + clev + slev);
947                     ctx->chcoeffs[0] *= (nf * LEVEL_MINUS_3DB);
948                     ctx->chcoeffs[2] *= (nf * LEVEL_MINUS_3DB);
949                     ctx->chcoeffs[1] *= (nf * clev * LEVEL_PLUS_3DB);
950                     ctx->chcoeffs[3] *= (nf * slev * LEVEL_MINUS_3DB);
951                     ctx->chcoeffs[4] *= (nf * slev * LEVEL_MINUS_3DB);
952                     break;
953                 case AC3_OUTPUT_STEREO:
954                     nf = 1.0 / (1.0 + clev + slev);
955                     ctx->chcoeffs[0] *= nf;
956                     ctx->chcoeffs[2] *= nf;
957                     ctx->chcoeffs[1] *= (nf * clev);
958                     ctx->chcoeffs[3] *= (nf * slev);
959                     ctx->chcoeffs[4] *= (nf * slev);
960                     break;
961                 case AC3_OUTPUT_DOLBY:
962                     nf = 1.0 / (1.0 + (3.0 * LEVEL_MINUS_3DB));
963                     ctx->chcoeffs[0] *= nf;
964                     ctx->chcoeffs[1] *= nf;
965                     ctx->chcoeffs[1] *= (nf * LEVEL_MINUS_3DB);
966                     ctx->chcoeffs[3] *= (nf * LEVEL_MINUS_3DB);
967                     ctx->chcoeffs[4] *= (nf * LEVEL_MINUS_3DB);
968                     break;
969             }
970             break;
971     }
972 }
973
974 /*********** BEGIN DOWNMIX FUNCTIONS ***********/
975 static inline void mix_dualmono_to_mono(AC3DecodeContext *ctx)
976 {
977     int i;
978     float (*output)[BLOCK_SIZE] = ctx->output;
979
980     for (i = 0; i < 256; i++)
981         output[1][i] += output[2][i];
982     memset(output[2], 0, sizeof(output[2]));
983 }
984
985 static inline void mix_dualmono_to_stereo(AC3DecodeContext *ctx)
986 {
987     int i;
988     float tmp;
989     float (*output)[BLOCK_SIZE] = ctx->output;
990
991     for (i = 0; i < 256; i++) {
992         tmp = output[1][i] + output[2][i];
993         output[1][i] = output[2][i] = tmp;
994     }
995 }
996
997 static inline void upmix_mono_to_stereo(AC3DecodeContext *ctx)
998 {
999     int i;
1000     float (*output)[BLOCK_SIZE] = ctx->output;
1001
1002     for (i = 0; i < 256; i++)
1003         output[2][i] = output[1][i];
1004 }
1005
1006 static inline void mix_stereo_to_mono(AC3DecodeContext *ctx)
1007 {
1008     int i;
1009     float (*output)[BLOCK_SIZE] = ctx->output;
1010
1011     for (i = 0; i < 256; i++)
1012         output[1][i] += output[2][i];
1013     memset(output[2], 0, sizeof(output[2]));
1014 }
1015
1016 static inline void mix_3f_to_mono(AC3DecodeContext *ctx)
1017 {
1018     int i;
1019     float (*output)[BLOCK_SIZE] = ctx->output;
1020
1021     for (i = 0; i < 256; i++)
1022         output[1][i] += (output[2][i] + output[3][i]);
1023     memset(output[2], 0, sizeof(output[2]));
1024     memset(output[3], 0, sizeof(output[3]));
1025 }
1026
1027 static inline void mix_3f_to_stereo(AC3DecodeContext *ctx)
1028 {
1029     int i;
1030     float (*output)[BLOCK_SIZE] = ctx->output;
1031
1032     for (i = 0; i < 256; i++) {
1033         output[1][i] += output[2][i];
1034         output[2][i] += output[3][i];
1035     }
1036     memset(output[3], 0, sizeof(output[3]));
1037 }
1038
1039 static inline void mix_2f_1r_to_mono(AC3DecodeContext *ctx)
1040 {
1041     int i;
1042     float (*output)[BLOCK_SIZE] = ctx->output;
1043
1044     for (i = 0; i < 256; i++)
1045         output[1][i] += (output[2][i] + output[3][i]);
1046     memset(output[2], 0, sizeof(output[2]));
1047     memset(output[3], 0, sizeof(output[3]));
1048
1049 }
1050
1051 static inline void mix_2f_1r_to_stereo(AC3DecodeContext *ctx)
1052 {
1053     int i;
1054     float (*output)[BLOCK_SIZE] = ctx->output;
1055
1056     for (i = 0; i < 256; i++) {
1057         output[1][i] += output[2][i];
1058         output[2][i] += output[3][i];
1059     }
1060     memset(output[3], 0, sizeof(output[3]));
1061 }
1062
1063 static inline void mix_2f_1r_to_dolby(AC3DecodeContext *ctx)
1064 {
1065     int i;
1066     float (*output)[BLOCK_SIZE] = ctx->output;
1067
1068     for (i = 0; i < 256; i++) {
1069         output[1][i] -= output[3][i];
1070         output[2][i] += output[3][i];
1071     }
1072     memset(output[3], 0, sizeof(output[3]));
1073 }
1074
1075 static inline void mix_3f_1r_to_mono(AC3DecodeContext *ctx)
1076 {
1077     int i;
1078     float (*output)[BLOCK_SIZE] = ctx->output;
1079
1080     for (i = 0; i < 256; i++)
1081         output[1][i] = (output[2][i] + output[3][i] + output[4][i]);
1082     memset(output[2], 0, sizeof(output[2]));
1083     memset(output[3], 0, sizeof(output[3]));
1084     memset(output[4], 0, sizeof(output[4]));
1085 }
1086
1087 static inline void mix_3f_1r_to_stereo(AC3DecodeContext *ctx)
1088 {
1089     int i;
1090     float (*output)[BLOCK_SIZE] = ctx->output;
1091
1092     for (i = 0; i < 256; i++) {
1093         output[1][i] += (output[2][i] + output[4][i]);
1094         output[2][i] += (output[3][i] + output[4][i]);
1095     }
1096     memset(output[3], 0, sizeof(output[3]));
1097     memset(output[4], 0, sizeof(output[4]));
1098 }
1099
1100 static inline void mix_3f_1r_to_dolby(AC3DecodeContext *ctx)
1101 {
1102     int i;
1103     float (*output)[BLOCK_SIZE] = ctx->output;
1104
1105     for (i = 0; i < 256; i++) {
1106         output[1][i] += (output[2][i] - output[4][i]);
1107         output[2][i] += (output[3][i] + output[4][i]);
1108     }
1109     memset(output[3], 0, sizeof(output[3]));
1110     memset(output[4], 0, sizeof(output[4]));
1111 }
1112
1113 static inline void mix_2f_2r_to_mono(AC3DecodeContext *ctx)
1114 {
1115     int i;
1116     float (*output)[BLOCK_SIZE] = ctx->output;
1117
1118     for (i = 0; i < 256; i++)
1119         output[1][i] = (output[2][i] + output[3][i] + output[4][i]);
1120     memset(output[2], 0, sizeof(output[2]));
1121     memset(output[3], 0, sizeof(output[3]));
1122     memset(output[4], 0, sizeof(output[4]));
1123 }
1124
1125 static inline void mix_2f_2r_to_stereo(AC3DecodeContext *ctx)
1126 {
1127     int i;
1128     float (*output)[BLOCK_SIZE] = ctx->output;
1129
1130     for (i = 0; i < 256; i++) {
1131         output[1][i] += output[3][i];
1132         output[2][i] += output[4][i];
1133     }
1134     memset(output[3], 0, sizeof(output[3]));
1135     memset(output[4], 0, sizeof(output[4]));
1136 }
1137
1138 static inline void mix_2f_2r_to_dolby(AC3DecodeContext *ctx)
1139 {
1140     int i;
1141     float (*output)[BLOCK_SIZE] = ctx->output;
1142
1143     for (i = 0; i < 256; i++) {
1144         output[1][i] -= output[3][i];
1145         output[2][i] += output[4][i];
1146     }
1147     memset(output[3], 0, sizeof(output[3]));
1148     memset(output[4], 0, sizeof(output[4]));
1149 }
1150
1151 static inline void mix_3f_2r_to_mono(AC3DecodeContext *ctx)
1152 {
1153     int i;
1154     float (*output)[BLOCK_SIZE] = ctx->output;
1155
1156     for (i = 0; i < 256; i++)
1157         output[1][i] += (output[2][i] + output[3][i] + output[4][i] + output[5][i]);
1158     memset(output[2], 0, sizeof(output[2]));
1159     memset(output[3], 0, sizeof(output[3]));
1160     memset(output[4], 0, sizeof(output[4]));
1161     memset(output[5], 0, sizeof(output[5]));
1162 }
1163
1164 static inline void mix_3f_2r_to_stereo(AC3DecodeContext *ctx)
1165 {
1166     int i;
1167     float (*output)[BLOCK_SIZE] = ctx->output;
1168
1169     for (i = 0; i < 256; i++) {
1170         output[1][i] += (output[2][i] + output[4][i]);
1171         output[2][i] += (output[3][i] + output[5][i]);
1172     }
1173     memset(output[3], 0, sizeof(output[3]));
1174     memset(output[4], 0, sizeof(output[4]));
1175     memset(output[5], 0, sizeof(output[5]));
1176 }
1177
1178 static inline void mix_3f_2r_to_dolby(AC3DecodeContext *ctx)
1179 {
1180     int i;
1181     float (*output)[BLOCK_SIZE] = ctx->output;
1182
1183     for (i = 0; i < 256; i++) {
1184         output[1][i] += (output[2][i] - output[4][i] - output[5][i]);
1185         output[2][i] += (output[3][i] + output[4][i] + output[5][i]);
1186     }
1187     memset(output[3], 0, sizeof(output[3]));
1188     memset(output[4], 0, sizeof(output[4]));
1189     memset(output[5], 0, sizeof(output[5]));
1190 }
1191 /*********** END DOWNMIX FUNCTIONS ***********/
1192
1193 /* Downmix the output.
1194  * This function downmixes the output when the number of input
1195  * channels is not equal to the number of output channels requested.
1196  */
1197 static void do_downmix(AC3DecodeContext *ctx)
1198 {
1199     int from = ctx->acmod;
1200     int to = ctx->blkoutput;
1201
1202     if (to == AC3_OUTPUT_UNMODIFIED)
1203         return;
1204
1205     switch (from) {
1206         case AC3_ACMOD_DUALMONO:
1207             switch (to) {
1208                 case AC3_OUTPUT_MONO:
1209                     mix_dualmono_to_mono(ctx);
1210                     break;
1211                 case AC3_OUTPUT_STEREO: /* We assume that sum of both mono channels is requested */
1212                     mix_dualmono_to_stereo(ctx);
1213                     break;
1214             }
1215             break;
1216         case AC3_ACMOD_MONO:
1217             switch (to) {
1218                 case AC3_OUTPUT_STEREO:
1219                     upmix_mono_to_stereo(ctx);
1220                     break;
1221             }
1222             break;
1223         case AC3_ACMOD_STEREO:
1224             switch (to) {
1225                 case AC3_OUTPUT_MONO:
1226                     mix_stereo_to_mono(ctx);
1227                     break;
1228             }
1229             break;
1230         case AC3_ACMOD_3F:
1231             switch (to) {
1232                 case AC3_OUTPUT_MONO:
1233                     mix_3f_to_mono(ctx);
1234                     break;
1235                 case AC3_OUTPUT_STEREO:
1236                     mix_3f_to_stereo(ctx);
1237                     break;
1238             }
1239             break;
1240         case AC3_ACMOD_2F1R:
1241             switch (to) {
1242                 case AC3_OUTPUT_MONO:
1243                     mix_2f_1r_to_mono(ctx);
1244                     break;
1245                 case AC3_OUTPUT_STEREO:
1246                     mix_2f_1r_to_stereo(ctx);
1247                     break;
1248                 case AC3_OUTPUT_DOLBY:
1249                     mix_2f_1r_to_dolby(ctx);
1250                     break;
1251             }
1252             break;
1253         case AC3_ACMOD_3F1R:
1254             switch (to) {
1255                 case AC3_OUTPUT_MONO:
1256                     mix_3f_1r_to_mono(ctx);
1257                     break;
1258                 case AC3_OUTPUT_STEREO:
1259                     mix_3f_1r_to_stereo(ctx);
1260                     break;
1261                 case AC3_OUTPUT_DOLBY:
1262                     mix_3f_1r_to_dolby(ctx);
1263                     break;
1264             }
1265             break;
1266         case AC3_ACMOD_2F2R:
1267             switch (to) {
1268                 case AC3_OUTPUT_MONO:
1269                     mix_2f_2r_to_mono(ctx);
1270                     break;
1271                 case AC3_OUTPUT_STEREO:
1272                     mix_2f_2r_to_stereo(ctx);
1273                     break;
1274                 case AC3_OUTPUT_DOLBY:
1275                     mix_2f_2r_to_dolby(ctx);
1276                     break;
1277             }
1278             break;
1279         case AC3_ACMOD_3F2R:
1280             switch (to) {
1281                 case AC3_OUTPUT_MONO:
1282                     mix_3f_2r_to_mono(ctx);
1283                     break;
1284                 case AC3_OUTPUT_STEREO:
1285                     mix_3f_2r_to_stereo(ctx);
1286                     break;
1287                 case AC3_OUTPUT_DOLBY:
1288                     mix_3f_2r_to_dolby(ctx);
1289                     break;
1290             }
1291             break;
1292     }
1293 }
1294
1295 /* This function performs the imdct on 256 sample transform
1296  * coefficients.
1297  */
1298 static void do_imdct_256(AC3DecodeContext *ctx, int chindex)
1299 {
1300     int i, k;
1301     float x[128];
1302     FFTComplex z[2][64];
1303     float *o_ptr = ctx->tmp_output;
1304
1305     for(i=0; i<2; i++) {
1306         /* de-interleave coefficients */
1307         for(k=0; k<128; k++) {
1308             x[k] = ctx->transform_coeffs[chindex][2*k+i];
1309         }
1310
1311         /* run standard IMDCT */
1312         ctx->imdct_256.fft.imdct_calc(&ctx->imdct_256, o_ptr, x, ctx->tmp_imdct);
1313
1314         /* reverse the post-rotation & reordering from standard IMDCT */
1315         for(k=0; k<32; k++) {
1316             z[i][32+k].re = -o_ptr[128+2*k];
1317             z[i][32+k].im = -o_ptr[2*k];
1318             z[i][31-k].re =  o_ptr[2*k+1];
1319             z[i][31-k].im =  o_ptr[128+2*k+1];
1320         }
1321     }
1322
1323     /* apply AC-3 post-rotation & reordering */
1324     for(k=0; k<64; k++) {
1325         o_ptr[    2*k  ] = -z[0][   k].im;
1326         o_ptr[    2*k+1] =  z[0][63-k].re;
1327         o_ptr[128+2*k  ] = -z[0][   k].re;
1328         o_ptr[128+2*k+1] =  z[0][63-k].im;
1329         o_ptr[256+2*k  ] = -z[1][   k].re;
1330         o_ptr[256+2*k+1] =  z[1][63-k].im;
1331         o_ptr[384+2*k  ] =  z[1][   k].im;
1332         o_ptr[384+2*k+1] = -z[1][63-k].re;
1333     }
1334 }
1335
1336 /* IMDCT Transform. */
1337 static inline void do_imdct(AC3DecodeContext *ctx)
1338 {
1339     int ch;
1340
1341     if (ctx->blkoutput & AC3_OUTPUT_LFEON) {
1342         ctx->imdct_512.fft.imdct_calc(&ctx->imdct_512, ctx->tmp_output,
1343                                       ctx->transform_coeffs[0], ctx->tmp_imdct);
1344     }
1345     for (ch=1; ch<=ctx->nfchans; ch++) {
1346         if ((ctx->blksw >> (ch-1)) & 1)
1347             do_imdct_256(ctx, ch);
1348         else
1349             ctx->imdct_512.fft.imdct_calc(&ctx->imdct_512, ctx->tmp_output,
1350                                           ctx->transform_coeffs[ch],
1351                                           ctx->tmp_imdct);
1352
1353         ctx->dsp.vector_fmul_add_add(ctx->output[ch], ctx->tmp_output,
1354                                      ctx->window, ctx->delay[ch], 384, 256, 1);
1355         ctx->dsp.vector_fmul_reverse(ctx->delay[ch], ctx->tmp_output+256,
1356                                      ctx->window, 256);
1357     }
1358 }
1359
1360 /* Parse the audio block from ac3 bitstream.
1361  * This function extract the audio block from the ac3 bitstream
1362  * and produces the output for the block. This function must
1363  * be called for each of the six audio block in the ac3 bitstream.
1364  */
1365 static int ac3_parse_audio_block(AC3DecodeContext * ctx)
1366 {
1367     int nfchans = ctx->nfchans;
1368     int acmod = ctx->acmod;
1369     int i, bnd, rbnd, seg, grpsize;
1370     GetBitContext *gb = &ctx->gb;
1371     int bit_alloc_flags = 0;
1372     uint8_t *dexps;
1373     int mstrcplco, cplcoexp, cplcomant;
1374     int dynrng, chbwcod, ngrps, cplabsexp, skipl;
1375
1376     ctx->blksw = 0;
1377     for (i = 0; i < nfchans; i++) /*block switch flag */
1378         ctx->blksw |= get_bits1(gb) << i;
1379
1380     ctx->dithflag = 0;
1381     for (i = 0; i < nfchans; i++) /* dithering flag */
1382         ctx->dithflag |= get_bits1(gb) << i;
1383
1384     if (get_bits1(gb)) { /* dynamic range */
1385         dynrng = get_sbits(gb, 8);
1386         ctx->dynrng = ((((dynrng & 0x1f) | 0x20) << 13) * scale_factors[3 - (dynrng >> 5)]);
1387     }
1388
1389     if (acmod == 0x00 && get_bits1(gb)) { /* dynamic range 1+1 mode */
1390         dynrng = get_sbits(gb, 8);
1391         ctx->dynrng2 = ((((dynrng & 0x1f) | 0x20) << 13) * scale_factors[3 - (dynrng >> 5)]);
1392     }
1393
1394     get_downmix_coeffs(ctx);
1395
1396     if (get_bits1(gb)) { /* coupling strategy */
1397         ctx->cplinu = get_bits1(gb);
1398         ctx->cplbndstrc = 0;
1399         ctx->chincpl = 0;
1400         if (ctx->cplinu) { /* coupling in use */
1401             for (i = 0; i < nfchans; i++)
1402                 ctx->chincpl |= get_bits1(gb) << i;
1403
1404             if (acmod == 0x02)
1405                 ctx->phsflginu = get_bits1(gb); //phase flag in use
1406
1407             ctx->cplbegf = get_bits(gb, 4);
1408             ctx->cplendf = get_bits(gb, 4);
1409
1410             if (3 + ctx->cplendf - ctx->cplbegf < 0) {
1411                 av_log(NULL, AV_LOG_ERROR, "cplendf = %d < cplbegf = %d\n", ctx->cplendf, ctx->cplbegf);
1412                 return -1;
1413             }
1414
1415             ctx->ncplbnd = ctx->ncplsubnd = 3 + ctx->cplendf - ctx->cplbegf;
1416             ctx->cplstrtmant = ctx->cplbegf * 12 + 37;
1417             ctx->cplendmant = ctx->cplendf * 12 + 73;
1418             for (i = 0; i < ctx->ncplsubnd - 1; i++) /* coupling band structure */
1419                 if (get_bits1(gb)) {
1420                     ctx->cplbndstrc |= 1 << i;
1421                     ctx->ncplbnd--;
1422                 }
1423         }
1424     }
1425
1426     if (ctx->cplinu) {
1427         ctx->cplcoe = 0;
1428
1429         for (i = 0; i < nfchans; i++)
1430             if ((ctx->chincpl) >> i & 1)
1431                 if (get_bits1(gb)) { /* coupling co-ordinates */
1432                     ctx->cplcoe |= 1 << i;
1433                     mstrcplco = 3 * get_bits(gb, 2);
1434                     for (bnd = 0; bnd < ctx->ncplbnd; bnd++) {
1435                         cplcoexp = get_bits(gb, 4);
1436                         cplcomant = get_bits(gb, 4);
1437                         if (cplcoexp == 15)
1438                             cplcomant <<= 14;
1439                         else
1440                             cplcomant = (cplcomant | 0x10) << 13;
1441                         ctx->cplco[i][bnd] = cplcomant * scale_factors[cplcoexp + mstrcplco];
1442                     }
1443                 }
1444
1445         if (acmod == 0x02 && ctx->phsflginu && (ctx->cplcoe & 1 || ctx->cplcoe & 2))
1446             for (bnd = 0; bnd < ctx->ncplbnd; bnd++)
1447                 if (get_bits1(gb))
1448                     ctx->cplco[1][bnd] = -ctx->cplco[1][bnd];
1449     }
1450
1451     if (acmod == 0x02) {/* rematrixing */
1452         ctx->rematstr = get_bits1(gb);
1453         if (ctx->rematstr) {
1454             ctx->rematflg = 0;
1455
1456             if (!(ctx->cplinu) || ctx->cplbegf > 2)
1457                 for (rbnd = 0; rbnd < 4; rbnd++)
1458                     ctx->rematflg |= get_bits1(gb) << rbnd;
1459             if (ctx->cplbegf > 0 && ctx->cplbegf <= 2 && ctx->cplinu)
1460                 for (rbnd = 0; rbnd < 3; rbnd++)
1461                     ctx->rematflg |= get_bits1(gb) << rbnd;
1462             if (ctx->cplbegf == 0 && ctx->cplinu)
1463                 for (rbnd = 0; rbnd < 2; rbnd++)
1464                     ctx->rematflg |= get_bits1(gb) << rbnd;
1465         }
1466     }
1467
1468     ctx->cplexpstr = EXP_REUSE;
1469     ctx->lfeexpstr = EXP_REUSE;
1470     if (ctx->cplinu) /* coupling exponent strategy */
1471         ctx->cplexpstr = get_bits(gb, 2);
1472     for (i = 0; i < nfchans; i++)  /* channel exponent strategy */
1473         ctx->chexpstr[i] = get_bits(gb, 2);
1474     if (ctx->lfeon)  /* lfe exponent strategy */
1475         ctx->lfeexpstr = get_bits1(gb);
1476
1477     for (i = 0; i < nfchans; i++) /* channel bandwidth code */
1478         if (ctx->chexpstr[i] != EXP_REUSE) {
1479             if ((ctx->chincpl >> i) & 1)
1480                 ctx->endmant[i] = ctx->cplstrtmant;
1481             else {
1482                 chbwcod = get_bits(gb, 6);
1483                 if (chbwcod > 60) {
1484                     av_log(NULL, AV_LOG_ERROR, "chbwcod = %d > 60", chbwcod);
1485                     return -1;
1486                 }
1487                 ctx->endmant[i] = chbwcod * 3 + 73;
1488             }
1489         }
1490
1491     if (ctx->cplexpstr != EXP_REUSE) {/* coupling exponents */
1492         bit_alloc_flags = 64;
1493         cplabsexp = get_bits(gb, 4) << 1;
1494         ngrps = (ctx->cplendmant - ctx->cplstrtmant) / (3 << (ctx->cplexpstr - 1));
1495         decode_exponents(gb, ctx->cplexpstr, ngrps, cplabsexp, ctx->dcplexps + ctx->cplstrtmant);
1496     }
1497
1498     for (i = 0; i < nfchans; i++) /* fbw channel exponents */
1499         if (ctx->chexpstr[i] != EXP_REUSE) {
1500             bit_alloc_flags |= 1 << i;
1501             grpsize = 3 << (ctx->chexpstr[i] - 1);
1502             ngrps = (ctx->endmant[i] + grpsize - 4) / grpsize;
1503             dexps = ctx->dexps[i];
1504             dexps[0] = get_bits(gb, 4);
1505             decode_exponents(gb, ctx->chexpstr[i], ngrps, dexps[0], dexps + 1);
1506             skip_bits(gb, 2); /* skip gainrng */
1507         }
1508
1509     if (ctx->lfeexpstr != EXP_REUSE) { /* lfe exponents */
1510         bit_alloc_flags |= 32;
1511         ctx->dlfeexps[0] = get_bits(gb, 4);
1512         decode_exponents(gb, ctx->lfeexpstr, 2, ctx->dlfeexps[0], ctx->dlfeexps + 1);
1513     }
1514
1515     if (get_bits1(gb)) { /* bit allocation information */
1516         bit_alloc_flags = 127;
1517         ctx->sdcycod = get_bits(gb, 2);
1518         ctx->fdcycod = get_bits(gb, 2);
1519         ctx->sgaincod = get_bits(gb, 2);
1520         ctx->dbpbcod = get_bits(gb, 2);
1521         ctx->floorcod = get_bits(gb, 3);
1522     }
1523
1524     if (get_bits1(gb)) { /* snroffset */
1525         bit_alloc_flags = 127;
1526         ctx->csnroffst = get_bits(gb, 6);
1527         if (ctx->cplinu) { /* coupling fine snr offset and fast gain code */
1528             ctx->cplfsnroffst = get_bits(gb, 4);
1529             ctx->cplfgaincod = get_bits(gb, 3);
1530         }
1531         for (i = 0; i < nfchans; i++) { /* channel fine snr offset and fast gain code */
1532             ctx->fsnroffst[i] = get_bits(gb, 4);
1533             ctx->fgaincod[i] = get_bits(gb, 3);
1534         }
1535         if (ctx->lfeon) { /* lfe fine snr offset and fast gain code */
1536             ctx->lfefsnroffst = get_bits(gb, 4);
1537             ctx->lfefgaincod = get_bits(gb, 3);
1538         }
1539     }
1540
1541     if (ctx->cplinu && get_bits1(gb)) { /* coupling leak information */
1542         bit_alloc_flags |= 64;
1543         ctx->cplfleak = get_bits(gb, 3);
1544         ctx->cplsleak = get_bits(gb, 3);
1545     }
1546
1547     if (get_bits1(gb)) { /* delta bit allocation information */
1548         bit_alloc_flags = 127;
1549
1550         if (ctx->cplinu) {
1551             ctx->cpldeltbae = get_bits(gb, 2);
1552             if (ctx->cpldeltbae == DBA_RESERVED) {
1553                 av_log(NULL, AV_LOG_ERROR, "coupling delta bit allocation strategy reserved\n");
1554                 return -1;
1555             }
1556         }
1557
1558         for (i = 0; i < nfchans; i++) {
1559             ctx->deltbae[i] = get_bits(gb, 2);
1560             if (ctx->deltbae[i] == DBA_RESERVED) {
1561                 av_log(NULL, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1562                 return -1;
1563             }
1564         }
1565
1566         if (ctx->cplinu)
1567             if (ctx->cpldeltbae == DBA_NEW) { /*coupling delta offset, len and bit allocation */
1568                 ctx->cpldeltnseg = get_bits(gb, 3);
1569                 for (seg = 0; seg <= ctx->cpldeltnseg; seg++) {
1570                     ctx->cpldeltoffst[seg] = get_bits(gb, 5);
1571                     ctx->cpldeltlen[seg] = get_bits(gb, 4);
1572                     ctx->cpldeltba[seg] = get_bits(gb, 3);
1573                 }
1574             }
1575
1576         for (i = 0; i < nfchans; i++)
1577             if (ctx->deltbae[i] == DBA_NEW) {/*channel delta offset, len and bit allocation */
1578                 ctx->deltnseg[i] = get_bits(gb, 3);
1579                 for (seg = 0; seg <= ctx->deltnseg[i]; seg++) {
1580                     ctx->deltoffst[i][seg] = get_bits(gb, 5);
1581                     ctx->deltlen[i][seg] = get_bits(gb, 4);
1582                     ctx->deltba[i][seg] = get_bits(gb, 3);
1583                 }
1584             }
1585     }
1586
1587     if (bit_alloc_flags) {
1588         /* set bit allocation parameters */
1589         ctx->bit_alloc_params.fscod = ctx->fscod;
1590         ctx->bit_alloc_params.halfratecod = 0;
1591         ctx->bit_alloc_params.sdecay = ff_sdecaytab[ctx->sdcycod];
1592         ctx->bit_alloc_params.fdecay = ff_fdecaytab[ctx->fdcycod];
1593         ctx->bit_alloc_params.sgain = ff_sgaintab[ctx->sgaincod];
1594         ctx->bit_alloc_params.dbknee = ff_dbkneetab[ctx->dbpbcod];
1595         ctx->bit_alloc_params.floor = ff_floortab[ctx->floorcod];
1596         ctx->bit_alloc_params.cplfleak = ctx->cplfleak;
1597         ctx->bit_alloc_params.cplsleak = ctx->cplsleak;
1598
1599         if (ctx->chincpl && (bit_alloc_flags & 64))
1600             do_bit_allocation(ctx, 5);
1601         for (i = 0; i < nfchans; i++)
1602             if ((bit_alloc_flags >> i) & 1)
1603                 do_bit_allocation(ctx, i);
1604         if (ctx->lfeon && (bit_alloc_flags & 32))
1605             do_bit_allocation(ctx, 6);
1606     }
1607
1608     if (get_bits1(gb)) { /* unused dummy data */
1609         skipl = get_bits(gb, 9);
1610         while(skipl--)
1611             skip_bits(gb, 8);
1612     }
1613     /* unpack the transform coefficients
1614      * * this also uncouples channels if coupling is in use.
1615      */
1616     if (get_transform_coeffs(ctx)) {
1617         av_log(NULL, AV_LOG_ERROR, "Error in routine get_transform_coeffs\n");
1618         return -1;
1619     }
1620
1621     /* recover coefficients if rematrixing is in use */
1622     if (ctx->rematflg)
1623         do_rematrixing(ctx);
1624
1625     do_downmix(ctx);
1626
1627     do_imdct(ctx);
1628
1629     return 0;
1630 }
1631
1632 static inline int16_t convert(int32_t i)
1633 {
1634     if (i > 0x43c07fff)
1635         return 32767;
1636     else if (i <= 0x43bf8000)
1637         return -32768;
1638     else
1639         return (i - 0x43c00000);
1640 }
1641
1642 /* Decode ac3 frame.
1643  *
1644  * @param avctx Pointer to AVCodecContext
1645  * @param data Pointer to pcm smaples
1646  * @param data_size Set to number of pcm samples produced by decoding
1647  * @param buf Data to be decoded
1648  * @param buf_size Size of the buffer
1649  */
1650 static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size, uint8_t *buf, int buf_size)
1651 {
1652     AC3DecodeContext *ctx = (AC3DecodeContext *)avctx->priv_data;
1653     int frame_start;
1654     int16_t *out_samples = (int16_t *)data;
1655     int i, j, k, start;
1656     int32_t *int_ptr[6];
1657
1658     for (i = 0; i < 6; i++)
1659         int_ptr[i] = (int32_t *)(&ctx->output[i]);
1660
1661     //Synchronize the frame.
1662     frame_start = ac3_synchronize(buf, buf_size);
1663     if (frame_start == -1) {
1664         av_log(avctx, AV_LOG_ERROR, "frame is not synchronized\n");
1665         *data_size = 0;
1666         return buf_size;
1667     }
1668
1669     //Initialize the GetBitContext with the start of valid AC3 Frame.
1670     init_get_bits(&(ctx->gb), buf + frame_start, (buf_size - frame_start) * 8);
1671
1672     //Parse the syncinfo.
1673     //If 'fscod' or 'bsid' is not valid the decoder shall mute as per the standard.
1674     if (!ac3_parse_sync_info(ctx)) {
1675         av_log(avctx, AV_LOG_ERROR, "\n");
1676         *data_size = 0;
1677         return buf_size;
1678     }
1679
1680     //Parse the BSI.
1681     //If 'bsid' is not valid decoder shall not decode the audio as per the standard.
1682     ac3_parse_bsi(ctx);
1683
1684     avctx->sample_rate = ctx->sampling_rate;
1685     avctx->bit_rate = ctx->bit_rate;
1686
1687     if (avctx->channels == 0) {
1688         ctx->blkoutput |= AC3_OUTPUT_UNMODIFIED;
1689         if (ctx->lfeon)
1690             ctx->blkoutput |= AC3_OUTPUT_LFEON;
1691         avctx->channels = ctx->nfchans + ctx->lfeon;
1692     }
1693     else if (avctx->channels == 1)
1694         ctx->blkoutput |= AC3_OUTPUT_MONO;
1695     else if (avctx->channels == 2) {
1696         if (ctx->dsurmod == 0x02)
1697             ctx->blkoutput |= AC3_OUTPUT_DOLBY;
1698         else
1699             ctx->blkoutput |= AC3_OUTPUT_STEREO;
1700     }
1701     else {
1702         if (avctx->channels < (ctx->nfchans + ctx->lfeon))
1703             av_log(avctx, AV_LOG_INFO, "ac3_decoder: AC3 Source Channels Are Less Then Specified %d: Output to %d Channels\n",avctx->channels, ctx->nfchans + ctx->lfeon);
1704         ctx->blkoutput |= AC3_OUTPUT_UNMODIFIED;
1705         if (ctx->lfeon)
1706             ctx->blkoutput |= AC3_OUTPUT_LFEON;
1707         avctx->channels = ctx->nfchans + ctx->lfeon;
1708     }
1709
1710     //av_log(avctx, AV_LOG_INFO, "channels = %d \t bit rate = %d \t sampling rate = %d \n", avctx->channels, avctx->bit_rate * 1000, avctx->sample_rate);
1711
1712     //Parse the Audio Blocks.
1713     for (i = 0; i < NB_BLOCKS; i++) {
1714         if (ac3_parse_audio_block(ctx)) {
1715             av_log(avctx, AV_LOG_ERROR, "error parsing the audio block\n");
1716             *data_size = 0;
1717             return ctx->frame_size;
1718         }
1719         start = (ctx->blkoutput & AC3_OUTPUT_LFEON) ? 0 : 1;
1720         for (k = 0; k < BLOCK_SIZE; k++)
1721             for (j = start; j <= avctx->channels; j++)
1722                 *(out_samples++) = convert(int_ptr[j][k]);
1723     }
1724     *data_size = NB_BLOCKS * BLOCK_SIZE * avctx->channels * sizeof (int16_t);
1725     return ctx->frame_size;
1726 }
1727
1728 /* Uninitialize ac3 decoder.
1729  */
1730 static int ac3_decode_end(AVCodecContext *avctx)
1731 {
1732     AC3DecodeContext *ctx = (AC3DecodeContext *)avctx->priv_data;
1733     ff_mdct_end(&ctx->imdct_512);
1734     ff_mdct_end(&ctx->imdct_256);
1735
1736     return 0;
1737 }
1738
1739 AVCodec ac3_decoder = {
1740     .name = "ac3",
1741     .type = CODEC_TYPE_AUDIO,
1742     .id = CODEC_ID_AC3,
1743     .priv_data_size = sizeof (AC3DecodeContext),
1744     .init = ac3_decode_init,
1745     .close = ac3_decode_end,
1746     .decode = ac3_decode_frame,
1747 };
1748