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