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