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