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