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