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