git.sesse.net Git - ffmpeg/blob - libavcodec/ac3dec.c

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