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 "libavutil/crc.h"
  36 #include "libavutil/random.h"
  37 #include "avcodec.h"
  38 #include "ac3_parser.h"
  39 #include "bitstream.h"
  40 #include "dsputil.h"
  41
  42 /** Maximum possible frame size when the specification limit is ignored */
  43 #define AC3_MAX_FRAME_SIZE 21695
  44
  45 /**
  46  * Table of bin locations for rematrixing bands
  47  * reference: Section 7.5.2 Rematrixing : Frequency Band Definitions
  48  */
  49 static const uint8_t rematrix_band_tab[5] = { 13, 25, 37, 61, 253 };
  50
  51 /** table for grouping exponents */
  52 static uint8_t exp_ungroup_tab[128][3];
  53
  54
  55 /** tables for ungrouping mantissas */
  56 static int b1_mantissas[32][3];
  57 static int b2_mantissas[128][3];
  58 static int b3_mantissas[8];
  59 static int b4_mantissas[128][2];
  60 static int b5_mantissas[16];
  61
  62 /**
  63  * Quantization table: levels for symmetric. bits for asymmetric.
  64  * reference: Table 7.18 Mapping of bap to Quantizer
  65  */
  66 static const uint8_t quantization_tab[16] = {
  67     0, 3, 5, 7, 11, 15,
  68     5, 6, 7, 8, 9, 10, 11, 12, 14, 16
  69 };
  70
  71 /** dynamic range table. converts codes to scale factors. */
  72 static float dynamic_range_tab[256];
  73
  74 /** Adjustments in dB gain */
  75 #define LEVEL_MINUS_3DB         0.7071067811865476
  76 #define LEVEL_MINUS_4POINT5DB   0.5946035575013605
  77 #define LEVEL_MINUS_6DB         0.5000000000000000
  78 #define LEVEL_MINUS_9DB         0.3535533905932738
  79 #define LEVEL_ZERO              0.0000000000000000
  80 #define LEVEL_ONE               1.0000000000000000
  81
  82 static const float gain_levels[6] = {
  83     LEVEL_ZERO,
  84     LEVEL_ONE,
  85     LEVEL_MINUS_3DB,
  86     LEVEL_MINUS_4POINT5DB,
  87     LEVEL_MINUS_6DB,
  88     LEVEL_MINUS_9DB
  89 };
  90
  91 /**
  92  * Table for default stereo downmixing coefficients
  93  * reference: Section 7.8.2 Downmixing Into Two Channels
  94  */
  95 static const uint8_t ac3_default_coeffs[8][5][2] = {
  96     { { 1, 0 }, { 0, 1 },                               },
  97     { { 2, 2 },                                         },
  98     { { 1, 0 }, { 0, 1 },                               },
  99     { { 1, 0 }, { 3, 3 }, { 0, 1 },                     },
 100     { { 1, 0 }, { 0, 1 }, { 4, 4 },                     },
 101     { { 1, 0 }, { 3, 3 }, { 0, 1 }, { 5, 5 },           },
 102     { { 1, 0 }, { 0, 1 }, { 4, 0 }, { 0, 4 },           },
 103     { { 1, 0 }, { 3, 3 }, { 0, 1 }, { 4, 0 }, { 0, 4 }, },
 104 };
 105
 106 /* override ac3.h to include coupling channel */
 107 #undef AC3_MAX_CHANNELS
 108 #define AC3_MAX_CHANNELS 7
 109 #define CPL_CH 0
 110
 111 #define AC3_OUTPUT_LFEON  8
 112
 113 typedef struct {
 114     int channel_mode;                       ///< channel mode (acmod)
 115     int block_switch[AC3_MAX_CHANNELS];     ///< block switch flags
 116     int dither_flag[AC3_MAX_CHANNELS];      ///< dither flags
 117     int dither_all;                         ///< true if all channels are dithered
 118     int cpl_in_use;                         ///< coupling in use
 119     int channel_in_cpl[AC3_MAX_CHANNELS];   ///< channel in coupling
 120     int phase_flags_in_use;                 ///< phase flags in use
 121     int phase_flags[18];                    ///< phase flags
 122     int cpl_band_struct[18];                ///< coupling band structure
 123     int num_rematrixing_bands;              ///< number of rematrixing bands
 124     int rematrixing_flags[4];               ///< rematrixing flags
 125     int exp_strategy[AC3_MAX_CHANNELS];     ///< exponent strategies
 126     int snr_offset[AC3_MAX_CHANNELS];       ///< signal-to-noise ratio offsets
 127     int fast_gain[AC3_MAX_CHANNELS];        ///< fast gain values (signal-to-mask ratio)
 128     int dba_mode[AC3_MAX_CHANNELS];         ///< delta bit allocation mode
 129     int dba_nsegs[AC3_MAX_CHANNELS];        ///< number of delta segments
 130     uint8_t dba_offsets[AC3_MAX_CHANNELS][8]; ///< delta segment offsets
 131     uint8_t dba_lengths[AC3_MAX_CHANNELS][8]; ///< delta segment lengths
 132     uint8_t dba_values[AC3_MAX_CHANNELS][8];  ///< delta values for each segment
 133
 134     int sample_rate;                        ///< sample frequency, in Hz
 135     int bit_rate;                           ///< stream bit rate, in bits-per-second
 136     int frame_size;                         ///< current frame size, in bytes
 137
 138     int channels;                           ///< number of total channels
 139     int fbw_channels;                       ///< number of full-bandwidth channels
 140     int lfe_on;                             ///< lfe channel in use
 141     int lfe_ch;                             ///< index of LFE channel
 142     int output_mode;                        ///< output channel configuration
 143     int out_channels;                       ///< number of output channels
 144
 145     int center_mix_level;                   ///< Center mix level index
 146     int surround_mix_level;                 ///< Surround mix level index
 147     float downmix_coeffs[AC3_MAX_CHANNELS][2];  ///< stereo downmix coefficients
 148     float downmix_coeff_adjust[2];          ///< adjustment needed for each output channel when downmixing
 149     float dynamic_range[2];                 ///< dynamic range
 150     int   cpl_coords[AC3_MAX_CHANNELS][18]; ///< coupling coordinates
 151     int   num_cpl_bands;                    ///< number of coupling bands
 152     int   num_cpl_subbands;                 ///< number of coupling sub bands
 153     int   start_freq[AC3_MAX_CHANNELS];     ///< start frequency bin
 154     int   end_freq[AC3_MAX_CHANNELS];       ///< end frequency bin
 155     AC3BitAllocParameters bit_alloc_params; ///< bit allocation parameters
 156
 157     int num_exp_groups[AC3_MAX_CHANNELS];   ///< Number of exponent groups
 158     int8_t  dexps[AC3_MAX_CHANNELS][256];   ///< decoded exponents
 159     uint8_t bap[AC3_MAX_CHANNELS][256];     ///< bit allocation pointers
 160     int16_t psd[AC3_MAX_CHANNELS][256];     ///< scaled exponents
 161     int16_t band_psd[AC3_MAX_CHANNELS][50]; ///< interpolated exponents
 162     int16_t mask[AC3_MAX_CHANNELS][50];     ///< masking curve values
 163
 164     int fixed_coeffs[AC3_MAX_CHANNELS][256];    ///> fixed-point transform coefficients
 165     DECLARE_ALIGNED_16(float, transform_coeffs[AC3_MAX_CHANNELS][256]);  ///< transform coefficients
 166     int downmixed;                              ///< indicates if coeffs are currently downmixed
 167
 168     /* For IMDCT. */
 169     MDCTContext imdct_512;                  ///< for 512 sample IMDCT
 170     MDCTContext imdct_256;                  ///< for 256 sample IMDCT
 171     DSPContext  dsp;                        ///< for optimization
 172     float       add_bias;                   ///< offset for float_to_int16 conversion
 173     float       mul_bias;                   ///< scaling for float_to_int16 conversion
 174
 175     DECLARE_ALIGNED_16(float, output[AC3_MAX_CHANNELS][256]);       ///< output after imdct transform and windowing
 176     DECLARE_ALIGNED_16(short, int_output[AC3_MAX_CHANNELS-1][256]); ///< final 16-bit integer output
 177     DECLARE_ALIGNED_16(float, delay[AC3_MAX_CHANNELS][256]);        ///< delay - added to the next block
 178     DECLARE_ALIGNED_16(float, tmp_imdct[256]);                      ///< temporary storage for imdct transform
 179     DECLARE_ALIGNED_16(float, tmp_output[512]);                     ///< temporary storage for output before windowing
 180     DECLARE_ALIGNED_16(float, window[256]);                         ///< window coefficients
 181
 182     /* Miscellaneous. */
 183     GetBitContext gbc;                      ///< bitstream reader
 184     AVRandomState dith_state;               ///< for dither generation
 185     AVCodecContext *avctx;                  ///< parent context
 186     uint8_t *input_buffer;                  ///< temp buffer to prevent overread
 187 } AC3DecodeContext;
 188
 189 /**
 190  * Symmetrical Dequantization
 191  * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization
 192  *            Tables 7.19 to 7.23
 193  */
 194 static inline int
 195 symmetric_dequant(int code, int levels)
 196 {
 197     return ((code - (levels >> 1)) << 24) / levels;
 198 }
 199
 200 /*
 201  * Initialize tables at runtime.
 202  */
 203 static av_cold void ac3_tables_init(void)
 204 {
 205     int i;
 206
 207     /* generate grouped mantissa tables
 208        reference: Section 7.3.5 Ungrouping of Mantissas */
 209     for(i=0; i<32; i++) {
 210         /* bap=1 mantissas */
 211         b1_mantissas[i][0] = symmetric_dequant( i / 9     , 3);
 212         b1_mantissas[i][1] = symmetric_dequant((i % 9) / 3, 3);
 213         b1_mantissas[i][2] = symmetric_dequant((i % 9) % 3, 3);
 214     }
 215     for(i=0; i<128; i++) {
 216         /* bap=2 mantissas */
 217         b2_mantissas[i][0] = symmetric_dequant( i / 25     , 5);
 218         b2_mantissas[i][1] = symmetric_dequant((i % 25) / 5, 5);
 219         b2_mantissas[i][2] = symmetric_dequant((i % 25) % 5, 5);
 220
 221         /* bap=4 mantissas */
 222         b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
 223         b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
 224     }
 225     /* generate ungrouped mantissa tables
 226        reference: Tables 7.21 and 7.23 */
 227     for(i=0; i<7; i++) {
 228         /* bap=3 mantissas */
 229         b3_mantissas[i] = symmetric_dequant(i, 7);
 230     }
 231     for(i=0; i<15; i++) {
 232         /* bap=5 mantissas */
 233         b5_mantissas[i] = symmetric_dequant(i, 15);
 234     }
 235
 236     /* generate dynamic range table
 237        reference: Section 7.7.1 Dynamic Range Control */
 238     for(i=0; i<256; i++) {
 239         int v = (i >> 5) - ((i >> 7) << 3) - 5;
 240         dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
 241     }
 242
 243     /* generate exponent tables
 244        reference: Section 7.1.3 Exponent Decoding */
 245     for(i=0; i<128; i++) {
 246         exp_ungroup_tab[i][0] =  i / 25;
 247         exp_ungroup_tab[i][1] = (i % 25) / 5;
 248         exp_ungroup_tab[i][2] = (i % 25) % 5;
 249     }
 250 }
 251
 252
 253 /**
 254  * AVCodec initialization
 255  */
 256 static av_cold int ac3_decode_init(AVCodecContext *avctx)
 257 {
 258     AC3DecodeContext *s = avctx->priv_data;
 259     s->avctx = avctx;
 260
 261     ac3_common_init();
 262     ac3_tables_init();
 263     ff_mdct_init(&s->imdct_256, 8, 1);
 264     ff_mdct_init(&s->imdct_512, 9, 1);
 265     ff_kbd_window_init(s->window, 5.0, 256);
 266     dsputil_init(&s->dsp, avctx);
 267     av_init_random(0, &s->dith_state);
 268
 269     /* set bias values for float to int16 conversion */
 270     if(s->dsp.float_to_int16 == ff_float_to_int16_c) {
 271         s->add_bias = 385.0f;
 272         s->mul_bias = 1.0f;
 273     } else {
 274         s->add_bias = 0.0f;
 275         s->mul_bias = 32767.0f;
 276     }
 277
 278     /* allow downmixing to stereo or mono */
 279     if (avctx->channels > 0 && avctx->request_channels > 0 &&
 280             avctx->request_channels < avctx->channels &&
 281             avctx->request_channels <= 2) {
 282         avctx->channels = avctx->request_channels;
 283     }
 284     s->downmixed = 1;
 285
 286     /* allocate context input buffer */
 287     if (avctx->error_resilience >= FF_ER_CAREFUL) {
 288         s->input_buffer = av_mallocz(AC3_MAX_FRAME_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);
 289         if (!s->input_buffer)
 290             return AVERROR_NOMEM;
 291     }
 292
 293     return 0;
 294 }
 295
 296 /**
 297  * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
 298  * GetBitContext within AC3DecodeContext must point to
 299  * start of the synchronized ac3 bitstream.
 300  */
 301 static int ac3_parse_header(AC3DecodeContext *s)
 302 {
 303     AC3HeaderInfo hdr;
 304     GetBitContext *gbc = &s->gbc;
 305     int err, i;
 306
 307     err = ff_ac3_parse_header(gbc, &hdr);
 308     if(err)
 309         return err;
 310
 311     if(hdr.bitstream_id > 10)
 312         return AC3_PARSE_ERROR_BSID;
 313
 314     /* get decoding parameters from header info */
 315     s->bit_alloc_params.sr_code     = hdr.sr_code;
 316     s->channel_mode                 = hdr.channel_mode;
 317     s->lfe_on                       = hdr.lfe_on;
 318     s->bit_alloc_params.sr_shift    = hdr.sr_shift;
 319     s->sample_rate                  = hdr.sample_rate;
 320     s->bit_rate                     = hdr.bit_rate;
 321     s->channels                     = hdr.channels;
 322     s->fbw_channels                 = s->channels - s->lfe_on;
 323     s->lfe_ch                       = s->fbw_channels + 1;
 324     s->frame_size                   = hdr.frame_size;
 325     s->center_mix_level             = hdr.center_mix_level;
 326     s->surround_mix_level           = hdr.surround_mix_level;
 327
 328     /* read the rest of the bsi. read twice for dual mono mode. */
 329     i = !(s->channel_mode);
 330     do {
 331         skip_bits(gbc, 5); // skip dialog normalization
 332         if (get_bits1(gbc))
 333             skip_bits(gbc, 8); //skip compression
 334         if (get_bits1(gbc))
 335             skip_bits(gbc, 8); //skip language code
 336         if (get_bits1(gbc))
 337             skip_bits(gbc, 7); //skip audio production information
 338     } while (i--);
 339
 340     skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
 341
 342     /* skip the timecodes (or extra bitstream information for Alternate Syntax)
 343        TODO: read & use the xbsi1 downmix levels */
 344     if (get_bits1(gbc))
 345         skip_bits(gbc, 14); //skip timecode1 / xbsi1
 346     if (get_bits1(gbc))
 347         skip_bits(gbc, 14); //skip timecode2 / xbsi2
 348
 349     /* skip additional bitstream info */
 350     if (get_bits1(gbc)) {
 351         i = get_bits(gbc, 6);
 352         do {
 353             skip_bits(gbc, 8);
 354         } while(i--);
 355     }
 356
 357     return 0;
 358 }
 359
 360 /**
 361  * Set stereo downmixing coefficients based on frame header info.
 362  * reference: Section 7.8.2 Downmixing Into Two Channels
 363  */
 364 static void set_downmix_coeffs(AC3DecodeContext *s)
 365 {
 366     int i;
 367     float cmix = gain_levels[s->center_mix_level];
 368     float smix = gain_levels[s->surround_mix_level];
 369
 370     for(i=0; i<s->fbw_channels; i++) {
 371         s->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
 372         s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
 373     }
 374     if(s->channel_mode > 1 && s->channel_mode & 1) {
 375         s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix;
 376     }
 377     if(s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
 378         int nf = s->channel_mode - 2;
 379         s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
 380     }
 381     if(s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
 382         int nf = s->channel_mode - 4;
 383         s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix;
 384     }
 385
 386     /* calculate adjustment needed for each channel to avoid clipping */
 387     s->downmix_coeff_adjust[0] = s->downmix_coeff_adjust[1] = 0.0f;
 388     for(i=0; i<s->fbw_channels; i++) {
 389         s->downmix_coeff_adjust[0] += s->downmix_coeffs[i][0];
 390         s->downmix_coeff_adjust[1] += s->downmix_coeffs[i][1];
 391     }
 392     s->downmix_coeff_adjust[0] = 1.0f / s->downmix_coeff_adjust[0];
 393     s->downmix_coeff_adjust[1] = 1.0f / s->downmix_coeff_adjust[1];
 394 }
 395
 396 /**
 397  * Decode the grouped exponents according to exponent strategy.
 398  * reference: Section 7.1.3 Exponent Decoding
 399  */
 400 static void decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
 401                              uint8_t absexp, int8_t *dexps)
 402 {
 403     int i, j, grp, group_size;
 404     int dexp[256];
 405     int expacc, prevexp;
 406
 407     /* unpack groups */
 408     group_size = exp_strategy + (exp_strategy == EXP_D45);
 409     for(grp=0,i=0; grp<ngrps; grp++) {
 410         expacc = get_bits(gbc, 7);
 411         dexp[i++] = exp_ungroup_tab[expacc][0];
 412         dexp[i++] = exp_ungroup_tab[expacc][1];
 413         dexp[i++] = exp_ungroup_tab[expacc][2];
 414     }
 415
 416     /* convert to absolute exps and expand groups */
 417     prevexp = absexp;
 418     for(i=0; i<ngrps*3; i++) {
 419         prevexp = av_clip(prevexp + dexp[i]-2, 0, 24);
 420         for(j=0; j<group_size; j++) {
 421             dexps[(i*group_size)+j] = prevexp;
 422         }
 423     }
 424 }
 425
 426 /**
 427  * Generate transform coefficients for each coupled channel in the coupling
 428  * range using the coupling coefficients and coupling coordinates.
 429  * reference: Section 7.4.3 Coupling Coordinate Format
 430  */
 431 static void uncouple_channels(AC3DecodeContext *s)
 432 {
 433     int i, j, ch, bnd, subbnd;
 434
 435     subbnd = -1;
 436     i = s->start_freq[CPL_CH];
 437     for(bnd=0; bnd<s->num_cpl_bands; bnd++) {
 438         do {
 439             subbnd++;
 440             for(j=0; j<12; j++) {
 441                 for(ch=1; ch<=s->fbw_channels; ch++) {
 442                     if(s->channel_in_cpl[ch]) {
 443                         s->fixed_coeffs[ch][i] = ((int64_t)s->fixed_coeffs[CPL_CH][i] * (int64_t)s->cpl_coords[ch][bnd]) >> 23;
 444                         if (ch == 2 && s->phase_flags[bnd])
 445                             s->fixed_coeffs[ch][i] = -s->fixed_coeffs[ch][i];
 446                     }
 447                 }
 448                 i++;
 449             }
 450         } while(s->cpl_band_struct[subbnd]);
 451     }
 452 }
 453
 454 /**
 455  * Grouped mantissas for 3-level 5-level and 11-level quantization
 456  */
 457 typedef struct {
 458     int b1_mant[3];
 459     int b2_mant[3];
 460     int b4_mant[2];
 461     int b1ptr;
 462     int b2ptr;
 463     int b4ptr;
 464 } mant_groups;
 465
 466 /**
 467  * Get the transform coefficients for a particular channel
 468  * reference: Section 7.3 Quantization and Decoding of Mantissas
 469  */
 470 static void get_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
 471 {
 472     GetBitContext *gbc = &s->gbc;
 473     int i, gcode, tbap, start, end;
 474     uint8_t *exps;
 475     uint8_t *bap;
 476     int *coeffs;
 477
 478     exps = s->dexps[ch_index];
 479     bap = s->bap[ch_index];
 480     coeffs = s->fixed_coeffs[ch_index];
 481     start = s->start_freq[ch_index];
 482     end = s->end_freq[ch_index];
 483
 484     for (i = start; i < end; i++) {
 485         tbap = bap[i];
 486         switch (tbap) {
 487             case 0:
 488                 coeffs[i] = (av_random(&s->dith_state) & 0x7FFFFF) - 4194304;
 489                 break;
 490
 491             case 1:
 492                 if(m->b1ptr > 2) {
 493                     gcode = get_bits(gbc, 5);
 494                     m->b1_mant[0] = b1_mantissas[gcode][0];
 495                     m->b1_mant[1] = b1_mantissas[gcode][1];
 496                     m->b1_mant[2] = b1_mantissas[gcode][2];
 497                     m->b1ptr = 0;
 498                 }
 499                 coeffs[i] = m->b1_mant[m->b1ptr++];
 500                 break;
 501
 502             case 2:
 503                 if(m->b2ptr > 2) {
 504                     gcode = get_bits(gbc, 7);
 505                     m->b2_mant[0] = b2_mantissas[gcode][0];
 506                     m->b2_mant[1] = b2_mantissas[gcode][1];
 507                     m->b2_mant[2] = b2_mantissas[gcode][2];
 508                     m->b2ptr = 0;
 509                 }
 510                 coeffs[i] = m->b2_mant[m->b2ptr++];
 511                 break;
 512
 513             case 3:
 514                 coeffs[i] = b3_mantissas[get_bits(gbc, 3)];
 515                 break;
 516
 517             case 4:
 518                 if(m->b4ptr > 1) {
 519                     gcode = get_bits(gbc, 7);
 520                     m->b4_mant[0] = b4_mantissas[gcode][0];
 521                     m->b4_mant[1] = b4_mantissas[gcode][1];
 522                     m->b4ptr = 0;
 523                 }
 524                 coeffs[i] = m->b4_mant[m->b4ptr++];
 525                 break;
 526
 527             case 5:
 528                 coeffs[i] = b5_mantissas[get_bits(gbc, 4)];
 529                 break;
 530
 531             default: {
 532                 /* asymmetric dequantization */
 533                 int qlevel = quantization_tab[tbap];
 534                 coeffs[i] = get_sbits(gbc, qlevel) << (24 - qlevel);
 535                 break;
 536             }
 537         }
 538         coeffs[i] >>= exps[i];
 539     }
 540 }
 541
 542 /**
 543  * Remove random dithering from coefficients with zero-bit mantissas
 544  * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
 545  */
 546 static void remove_dithering(AC3DecodeContext *s) {
 547     int ch, i;
 548     int end=0;
 549     int *coeffs;
 550     uint8_t *bap;
 551
 552     for(ch=1; ch<=s->fbw_channels; ch++) {
 553         if(!s->dither_flag[ch]) {
 554             coeffs = s->fixed_coeffs[ch];
 555             bap = s->bap[ch];
 556             if(s->channel_in_cpl[ch])
 557                 end = s->start_freq[CPL_CH];
 558             else
 559                 end = s->end_freq[ch];
 560             for(i=0; i<end; i++) {
 561                 if(!bap[i])
 562                     coeffs[i] = 0;
 563             }
 564             if(s->channel_in_cpl[ch]) {
 565                 bap = s->bap[CPL_CH];
 566                 for(; i<s->end_freq[CPL_CH]; i++) {
 567                     if(!bap[i])
 568                         coeffs[i] = 0;
 569                 }
 570             }
 571         }
 572     }
 573 }
 574
 575 /**
 576  * Get the transform coefficients.
 577  */
 578 static void get_transform_coeffs(AC3DecodeContext *s)
 579 {
 580     int ch, end;
 581     int got_cplchan = 0;
 582     mant_groups m;
 583
 584     m.b1ptr = m.b2ptr = m.b4ptr = 3;
 585
 586     for (ch = 1; ch <= s->channels; ch++) {
 587         /* transform coefficients for full-bandwidth channel */
 588         get_transform_coeffs_ch(s, ch, &m);
 589         /* tranform coefficients for coupling channel come right after the
 590            coefficients for the first coupled channel*/
 591         if (s->channel_in_cpl[ch])  {
 592             if (!got_cplchan) {
 593                 get_transform_coeffs_ch(s, CPL_CH, &m);
 594                 uncouple_channels(s);
 595                 got_cplchan = 1;
 596             }
 597             end = s->end_freq[CPL_CH];
 598         } else {
 599             end = s->end_freq[ch];
 600         }
 601         do
 602             s->fixed_coeffs[ch][end] = 0;
 603         while(++end < 256);
 604     }
 605
 606     /* if any channel doesn't use dithering, zero appropriate coefficients */
 607     if(!s->dither_all)
 608         remove_dithering(s);
 609 }
 610
 611 /**
 612  * Stereo rematrixing.
 613  * reference: Section 7.5.4 Rematrixing : Decoding Technique
 614  */
 615 static void do_rematrixing(AC3DecodeContext *s)
 616 {
 617     int bnd, i;
 618     int end, bndend;
 619     int tmp0, tmp1;
 620
 621     end = FFMIN(s->end_freq[1], s->end_freq[2]);
 622
 623     for(bnd=0; bnd<s->num_rematrixing_bands; bnd++) {
 624         if(s->rematrixing_flags[bnd]) {
 625             bndend = FFMIN(end, rematrix_band_tab[bnd+1]);
 626             for(i=rematrix_band_tab[bnd]; i<bndend; i++) {
 627                 tmp0 = s->fixed_coeffs[1][i];
 628                 tmp1 = s->fixed_coeffs[2][i];
 629                 s->fixed_coeffs[1][i] = tmp0 + tmp1;
 630                 s->fixed_coeffs[2][i] = tmp0 - tmp1;
 631             }
 632         }
 633     }
 634 }
 635
 636 /**
 637  * Perform the 256-point IMDCT
 638  */
 639 static void do_imdct_256(AC3DecodeContext *s, int chindex)
 640 {
 641     int i, k;
 642     DECLARE_ALIGNED_16(float, x[128]);
 643     FFTComplex z[2][64];
 644     float *o_ptr = s->tmp_output;
 645
 646     for(i=0; i<2; i++) {
 647         /* de-interleave coefficients */
 648         for(k=0; k<128; k++) {
 649             x[k] = s->transform_coeffs[chindex][2*k+i];
 650         }
 651
 652         /* run standard IMDCT */
 653         s->imdct_256.fft.imdct_calc(&s->imdct_256, o_ptr, x, s->tmp_imdct);
 654
 655         /* reverse the post-rotation & reordering from standard IMDCT */
 656         for(k=0; k<32; k++) {
 657             z[i][32+k].re = -o_ptr[128+2*k];
 658             z[i][32+k].im = -o_ptr[2*k];
 659             z[i][31-k].re =  o_ptr[2*k+1];
 660             z[i][31-k].im =  o_ptr[128+2*k+1];
 661         }
 662     }
 663
 664     /* apply AC-3 post-rotation & reordering */
 665     for(k=0; k<64; k++) {
 666         o_ptr[    2*k  ] = -z[0][   k].im;
 667         o_ptr[    2*k+1] =  z[0][63-k].re;
 668         o_ptr[128+2*k  ] = -z[0][   k].re;
 669         o_ptr[128+2*k+1] =  z[0][63-k].im;
 670         o_ptr[256+2*k  ] = -z[1][   k].re;
 671         o_ptr[256+2*k+1] =  z[1][63-k].im;
 672         o_ptr[384+2*k  ] =  z[1][   k].im;
 673         o_ptr[384+2*k+1] = -z[1][63-k].re;
 674     }
 675 }
 676
 677 /**
 678  * Inverse MDCT Transform.
 679  * Convert frequency domain coefficients to time-domain audio samples.
 680  * reference: Section 7.9.4 Transformation Equations
 681  */
 682 static inline void do_imdct(AC3DecodeContext *s, int channels)
 683 {
 684     int ch;
 685
 686     for (ch=1; ch<=channels; ch++) {
 687         if (s->block_switch[ch]) {
 688             do_imdct_256(s, ch);
 689         } else {
 690             s->imdct_512.fft.imdct_calc(&s->imdct_512, s->tmp_output,
 691                                         s->transform_coeffs[ch], s->tmp_imdct);
 692         }
 693         /* For the first half of the block, apply the window, add the delay
 694            from the previous block, and send to output */
 695         s->dsp.vector_fmul_add_add(s->output[ch-1], s->tmp_output,
 696                                      s->window, s->delay[ch-1], 0, 256, 1);
 697         /* For the second half of the block, apply the window and store the
 698            samples to delay, to be combined with the next block */
 699         s->dsp.vector_fmul_reverse(s->delay[ch-1], s->tmp_output+256,
 700                                    s->window, 256);
 701     }
 702 }
 703
 704 /**
 705  * Downmix the output to mono or stereo.
 706  */
 707 static void ac3_downmix(AC3DecodeContext *s,
 708                         float samples[AC3_MAX_CHANNELS][256], int ch_offset)
 709 {
 710     int i, j;
 711     float v0, v1;
 712
 713     for(i=0; i<256; i++) {
 714         v0 = v1 = 0.0f;
 715         for(j=0; j<s->fbw_channels; j++) {
 716             v0 += samples[j+ch_offset][i] * s->downmix_coeffs[j][0];
 717             v1 += samples[j+ch_offset][i] * s->downmix_coeffs[j][1];
 718         }
 719         v0 *= s->downmix_coeff_adjust[0];
 720         v1 *= s->downmix_coeff_adjust[1];
 721         if(s->output_mode == AC3_CHMODE_MONO) {
 722             samples[ch_offset][i] = (v0 + v1) * LEVEL_MINUS_3DB;
 723         } else if(s->output_mode == AC3_CHMODE_STEREO) {
 724             samples[  ch_offset][i] = v0;
 725             samples[1+ch_offset][i] = v1;
 726         }
 727     }
 728 }
 729
 730 /**
 731  * Upmix delay samples from stereo to original channel layout.
 732  */
 733 static void ac3_upmix_delay(AC3DecodeContext *s)
 734 {
 735     int channel_data_size = sizeof(s->delay[0]);
 736     switch(s->channel_mode) {
 737         case AC3_CHMODE_DUALMONO:
 738         case AC3_CHMODE_STEREO:
 739             /* upmix mono to stereo */
 740             memcpy(s->delay[1], s->delay[0], channel_data_size);
 741             break;
 742         case AC3_CHMODE_2F2R:
 743             memset(s->delay[3], 0, channel_data_size);
 744         case AC3_CHMODE_2F1R:
 745             memset(s->delay[2], 0, channel_data_size);
 746             break;
 747         case AC3_CHMODE_3F2R:
 748             memset(s->delay[4], 0, channel_data_size);
 749         case AC3_CHMODE_3F1R:
 750             memset(s->delay[3], 0, channel_data_size);
 751         case AC3_CHMODE_3F:
 752             memcpy(s->delay[2], s->delay[1], channel_data_size);
 753             memset(s->delay[1], 0, channel_data_size);
 754             break;
 755     }
 756 }
 757
 758 /**
 759  * Parse an audio block from AC-3 bitstream.
 760  */
 761 static int ac3_parse_audio_block(AC3DecodeContext *s, int blk)
 762 {
 763     int fbw_channels = s->fbw_channels;
 764     int channel_mode = s->channel_mode;
 765     int i, bnd, seg, ch;
 766     int different_transforms;
 767     int downmix_output;
 768     GetBitContext *gbc = &s->gbc;
 769     uint8_t bit_alloc_stages[AC3_MAX_CHANNELS];
 770
 771     memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);
 772
 773     /* block switch flags */
 774     different_transforms = 0;
 775     for (ch = 1; ch <= fbw_channels; ch++) {
 776         s->block_switch[ch] = get_bits1(gbc);
 777         if(ch > 1 && s->block_switch[ch] != s->block_switch[1])
 778             different_transforms = 1;
 779     }
 780
 781     /* dithering flags */
 782     s->dither_all = 1;
 783     for (ch = 1; ch <= fbw_channels; ch++) {
 784         s->dither_flag[ch] = get_bits1(gbc);
 785         if(!s->dither_flag[ch])
 786             s->dither_all = 0;
 787     }
 788
 789     /* dynamic range */
 790     i = !(s->channel_mode);
 791     do {
 792         if(get_bits1(gbc)) {
 793             s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)]-1.0) *
 794                                   s->avctx->drc_scale)+1.0;
 795         } else if(blk == 0) {
 796             s->dynamic_range[i] = 1.0f;
 797         }
 798     } while(i--);
 799
 800     /* coupling strategy */
 801     if (get_bits1(gbc)) {
 802         memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
 803         s->cpl_in_use = get_bits1(gbc);
 804         if (s->cpl_in_use) {
 805             /* coupling in use */
 806             int cpl_begin_freq, cpl_end_freq;
 807
 808             if (channel_mode < AC3_CHMODE_STEREO) {
 809                 av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
 810                 return -1;
 811             }
 812
 813             /* determine which channels are coupled */
 814             for (ch = 1; ch <= fbw_channels; ch++)
 815                 s->channel_in_cpl[ch] = get_bits1(gbc);
 816
 817             /* phase flags in use */
 818             if (channel_mode == AC3_CHMODE_STEREO)
 819                 s->phase_flags_in_use = get_bits1(gbc);
 820
 821             /* coupling frequency range and band structure */
 822             cpl_begin_freq = get_bits(gbc, 4);
 823             cpl_end_freq = get_bits(gbc, 4);
 824             if (3 + cpl_end_freq - cpl_begin_freq < 0) {
 825                 av_log(s->avctx, AV_LOG_ERROR, "3+cplendf = %d < cplbegf = %d\n", 3+cpl_end_freq, cpl_begin_freq);
 826                 return -1;
 827             }
 828             s->num_cpl_bands = s->num_cpl_subbands = 3 + cpl_end_freq - cpl_begin_freq;
 829             s->start_freq[CPL_CH] = cpl_begin_freq * 12 + 37;
 830             s->end_freq[CPL_CH] = cpl_end_freq * 12 + 73;
 831             for (bnd = 0; bnd < s->num_cpl_subbands - 1; bnd++) {
 832                 if (get_bits1(gbc)) {
 833                     s->cpl_band_struct[bnd] = 1;
 834                     s->num_cpl_bands--;
 835                 }
 836             }
 837             s->cpl_band_struct[s->num_cpl_subbands-1] = 0;
 838         } else {
 839             /* coupling not in use */
 840             for (ch = 1; ch <= fbw_channels; ch++)
 841                 s->channel_in_cpl[ch] = 0;
 842         }
 843     } else if (!blk) {
 844         av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must be present in block 0\n");
 845         return -1;
 846     }
 847
 848     /* coupling coordinates */
 849     if (s->cpl_in_use) {
 850         int cpl_coords_exist = 0;
 851
 852         for (ch = 1; ch <= fbw_channels; ch++) {
 853             if (s->channel_in_cpl[ch]) {
 854                 if (get_bits1(gbc)) {
 855                     int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
 856                     cpl_coords_exist = 1;
 857                     master_cpl_coord = 3 * get_bits(gbc, 2);
 858                     for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
 859                         cpl_coord_exp = get_bits(gbc, 4);
 860                         cpl_coord_mant = get_bits(gbc, 4);
 861                         if (cpl_coord_exp == 15)
 862                             s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
 863                         else
 864                             s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
 865                         s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
 866                     }
 867                 } else if (!blk) {
 868                     av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must be present in block 0\n");
 869                     return -1;
 870                 }
 871             }
 872         }
 873         /* phase flags */
 874         if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
 875             for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
 876                 s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
 877             }
 878         }
 879     }
 880
 881     /* stereo rematrixing strategy and band structure */
 882     if (channel_mode == AC3_CHMODE_STEREO) {
 883         if (get_bits1(gbc)) {
 884             s->num_rematrixing_bands = 4;
 885             if(s->cpl_in_use && s->start_freq[CPL_CH] <= 61)
 886                 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
 887             for(bnd=0; bnd<s->num_rematrixing_bands; bnd++)
 888                 s->rematrixing_flags[bnd] = get_bits1(gbc);
 889         } else if (!blk) {
 890             av_log(s->avctx, AV_LOG_ERROR, "new rematrixing strategy must be present in block 0\n");
 891             return -1;
 892         }
 893     }
 894
 895     /* exponent strategies for each channel */
 896     s->exp_strategy[CPL_CH] = EXP_REUSE;
 897     s->exp_strategy[s->lfe_ch] = EXP_REUSE;
 898     for (ch = !s->cpl_in_use; ch <= s->channels; ch++) {
 899         if(ch == s->lfe_ch)
 900             s->exp_strategy[ch] = get_bits(gbc, 1);
 901         else
 902             s->exp_strategy[ch] = get_bits(gbc, 2);
 903         if(s->exp_strategy[ch] != EXP_REUSE)
 904             bit_alloc_stages[ch] = 3;
 905     }
 906
 907     /* channel bandwidth */
 908     for (ch = 1; ch <= fbw_channels; ch++) {
 909         s->start_freq[ch] = 0;
 910         if (s->exp_strategy[ch] != EXP_REUSE) {
 911             int group_size;
 912             int prev = s->end_freq[ch];
 913             if (s->channel_in_cpl[ch])
 914                 s->end_freq[ch] = s->start_freq[CPL_CH];
 915             else {
 916                 int bandwidth_code = get_bits(gbc, 6);
 917                 if (bandwidth_code > 60) {
 918                     av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60", bandwidth_code);
 919                     return -1;
 920                 }
 921                 s->end_freq[ch] = bandwidth_code * 3 + 73;
 922             }
 923             group_size = 3 << (s->exp_strategy[ch] - 1);
 924             s->num_exp_groups[ch] = (s->end_freq[ch]+group_size-4) / group_size;
 925             if(blk > 0 && s->end_freq[ch] != prev)
 926                 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
 927         }
 928     }
 929     s->start_freq[s->lfe_ch] = 0;
 930     s->end_freq[s->lfe_ch] = 7;
 931     s->num_exp_groups[s->lfe_ch] = 2;
 932     if (s->cpl_in_use && s->exp_strategy[CPL_CH] != EXP_REUSE) {
 933         s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
 934                                     (3 << (s->exp_strategy[CPL_CH] - 1));
 935     }
 936
 937     /* decode exponents for each channel */
 938     for (ch = !s->cpl_in_use; ch <= s->channels; ch++) {
 939         if (s->exp_strategy[ch] != EXP_REUSE) {
 940             s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
 941             decode_exponents(gbc, s->exp_strategy[ch],
 942                              s->num_exp_groups[ch], s->dexps[ch][0],
 943                              &s->dexps[ch][s->start_freq[ch]+!!ch]);
 944             if(ch != CPL_CH && ch != s->lfe_ch)
 945                 skip_bits(gbc, 2); /* skip gainrng */
 946         }
 947     }
 948
 949     /* bit allocation information */
 950     if (get_bits1(gbc)) {
 951         s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
 952         s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
 953         s->bit_alloc_params.slow_gain  = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
 954         s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
 955         s->bit_alloc_params.floor  = ff_ac3_floor_tab[get_bits(gbc, 3)];
 956         for(ch=!s->cpl_in_use; ch<=s->channels; ch++)
 957             bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
 958     } else if (!blk) {
 959         av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must be present in block 0\n");
 960         return -1;
 961     }
 962
 963     /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
 964     if (get_bits1(gbc)) {
 965         int csnr;
 966         csnr = (get_bits(gbc, 6) - 15) << 4;
 967         for (ch = !s->cpl_in_use; ch <= s->channels; ch++) { /* snr offset and fast gain */
 968             s->snr_offset[ch] = (csnr + get_bits(gbc, 4)) << 2;
 969             s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
 970         }
 971         memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
 972     } else if (!blk) {
 973         av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
 974         return -1;
 975     }
 976
 977     /* coupling leak information */
 978     if (s->cpl_in_use) {
 979         if (get_bits1(gbc)) {
 980             s->bit_alloc_params.cpl_fast_leak = get_bits(gbc, 3);
 981             s->bit_alloc_params.cpl_slow_leak = get_bits(gbc, 3);
 982             bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
 983         } else if (!blk) {
 984             av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must be present in block 0\n");
 985             return -1;
 986         }
 987     }
 988
 989     /* delta bit allocation information */
 990     if (get_bits1(gbc)) {
 991         /* delta bit allocation exists (strategy) */
 992         for (ch = !s->cpl_in_use; ch <= fbw_channels; ch++) {
 993             s->dba_mode[ch] = get_bits(gbc, 2);
 994             if (s->dba_mode[ch] == DBA_RESERVED) {
 995                 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
 996                 return -1;
 997             }
 998             bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
 999         }
1000         /* channel delta offset, len and bit allocation */
1001         for (ch = !s->cpl_in_use; ch <= fbw_channels; ch++) {
1002             if (s->dba_mode[ch] == DBA_NEW) {
1003                 s->dba_nsegs[ch] = get_bits(gbc, 3);
1004                 for (seg = 0; seg <= s->dba_nsegs[ch]; seg++) {
1005                     s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1006                     s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1007                     s->dba_values[ch][seg] = get_bits(gbc, 3);
1008                 }
1009                 /* run last 2 bit allocation stages if new dba values */
1010                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1011             }
1012         }
1013     } else if(blk == 0) {
1014         for(ch=0; ch<=s->channels; ch++) {
1015             s->dba_mode[ch] = DBA_NONE;
1016         }
1017     }
1018
1019     /* Bit allocation */
1020     for(ch=!s->cpl_in_use; ch<=s->channels; ch++) {
1021         if(bit_alloc_stages[ch] > 2) {
1022             /* Exponent mapping into PSD and PSD integration */
1023             ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
1024                                       s->start_freq[ch], s->end_freq[ch],
1025                                       s->psd[ch], s->band_psd[ch]);
1026         }
1027         if(bit_alloc_stages[ch] > 1) {
1028             /* Compute excitation function, Compute masking curve, and
1029                Apply delta bit allocation */
1030             ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1031                                        s->start_freq[ch], s->end_freq[ch],
1032                                        s->fast_gain[ch], (ch == s->lfe_ch),
1033                                        s->dba_mode[ch], s->dba_nsegs[ch],
1034                                        s->dba_offsets[ch], s->dba_lengths[ch],
1035                                        s->dba_values[ch], s->mask[ch]);
1036         }
1037         if(bit_alloc_stages[ch] > 0) {
1038             /* Compute bit allocation */
1039             ff_ac3_bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1040                                       s->start_freq[ch], s->end_freq[ch],
1041                                       s->snr_offset[ch],
1042                                       s->bit_alloc_params.floor,
1043                                       s->bap[ch]);
1044         }
1045     }
1046
1047     /* unused dummy data */
1048     if (get_bits1(gbc)) {
1049         int skipl = get_bits(gbc, 9);
1050         while(skipl--)
1051             skip_bits(gbc, 8);
1052     }
1053
1054     /* unpack the transform coefficients
1055        this also uncouples channels if coupling is in use. */
1056     get_transform_coeffs(s);
1057
1058     /* recover coefficients if rematrixing is in use */
1059     if(s->channel_mode == AC3_CHMODE_STEREO)
1060         do_rematrixing(s);
1061
1062     /* apply scaling to coefficients (headroom, dynrng) */
1063     for(ch=1; ch<=s->channels; ch++) {
1064         float gain = s->mul_bias / 4194304.0f;
1065         if(s->channel_mode == AC3_CHMODE_DUALMONO) {
1066             gain *= s->dynamic_range[ch-1];
1067         } else {
1068             gain *= s->dynamic_range[0];
1069         }
1070         for(i=0; i<256; i++) {
1071             s->transform_coeffs[ch][i] = s->fixed_coeffs[ch][i] * gain;
1072         }
1073     }
1074
1075     /* downmix and MDCT. order depends on whether block switching is used for
1076        any channel in this block. this is because coefficients for the long
1077        and short transforms cannot be mixed. */
1078     downmix_output = s->channels != s->out_channels &&
1079                      !((s->output_mode & AC3_OUTPUT_LFEON) &&
1080                      s->fbw_channels == s->out_channels);
1081     if(different_transforms) {
1082         /* the delay samples have already been downmixed, so we upmix the delay
1083            samples in order to reconstruct all channels before downmixing. */
1084         if(s->downmixed) {
1085             s->downmixed = 0;
1086             ac3_upmix_delay(s);
1087         }
1088
1089         do_imdct(s, s->channels);
1090
1091         if(downmix_output) {
1092             ac3_downmix(s, s->output, 0);
1093         }
1094     } else {
1095         if(downmix_output) {
1096             ac3_downmix(s, s->transform_coeffs, 1);
1097         }
1098
1099         if(!s->downmixed) {
1100             s->downmixed = 1;
1101             ac3_downmix(s, s->delay, 0);
1102         }
1103
1104         do_imdct(s, s->out_channels);
1105     }
1106
1107     /* convert float to 16-bit integer */
1108     for(ch=0; ch<s->out_channels; ch++) {
1109         for(i=0; i<256; i++) {
1110             s->output[ch][i] += s->add_bias;
1111         }
1112         s->dsp.float_to_int16(s->int_output[ch], s->output[ch], 256);
1113     }
1114
1115     return 0;
1116 }
1117
1118 /**
1119  * Decode a single AC-3 frame.
1120  */
1121 static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size,
1122                             const uint8_t *buf, int buf_size)
1123 {
1124     AC3DecodeContext *s = avctx->priv_data;
1125     int16_t *out_samples = (int16_t *)data;
1126     int i, blk, ch, err;
1127
1128     /* initialize the GetBitContext with the start of valid AC-3 Frame */
1129     if (s->input_buffer) {
1130         /* copy input buffer to decoder context to avoid reading past the end
1131            of the buffer, which can be caused by a damaged input stream. */
1132         memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_MAX_FRAME_SIZE));
1133         init_get_bits(&s->gbc, s->input_buffer, buf_size * 8);
1134     } else {
1135         init_get_bits(&s->gbc, buf, buf_size * 8);
1136     }
1137
1138     /* parse the syncinfo */
1139     *data_size = 0;
1140     err = ac3_parse_header(s);
1141
1142     /* check that reported frame size fits in input buffer */
1143     if(s->frame_size > buf_size) {
1144         av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1145         err = AC3_PARSE_ERROR_FRAME_SIZE;
1146     }
1147
1148     /* check for crc mismatch */
1149     if(err != AC3_PARSE_ERROR_FRAME_SIZE && avctx->error_resilience >= FF_ER_CAREFUL) {
1150         if(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2], s->frame_size-2)) {
1151             av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1152             err = AC3_PARSE_ERROR_CRC;
1153         }
1154     }
1155
1156     /* parse the syncinfo */
1157     if(err && err != AC3_PARSE_ERROR_CRC) {
1158         switch(err) {
1159             case AC3_PARSE_ERROR_SYNC:
1160                 av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1161                 break;
1162             case AC3_PARSE_ERROR_BSID:
1163                 av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1164                 break;
1165             case AC3_PARSE_ERROR_SAMPLE_RATE:
1166                 av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1167                 break;
1168             case AC3_PARSE_ERROR_FRAME_SIZE:
1169                 av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1170                 break;
1171             case AC3_PARSE_ERROR_FRAME_TYPE:
1172                 av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1173                 break;
1174             default:
1175                 av_log(avctx, AV_LOG_ERROR, "invalid header\n");
1176                 break;
1177         }
1178     }
1179
1180     /* if frame is ok, set audio parameters */
1181     if (!err) {
1182         avctx->sample_rate = s->sample_rate;
1183         avctx->bit_rate = s->bit_rate;
1184
1185         /* channel config */
1186         s->out_channels = s->channels;
1187         s->output_mode = s->channel_mode;
1188         if(s->lfe_on)
1189             s->output_mode |= AC3_OUTPUT_LFEON;
1190         if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&
1191                 avctx->request_channels < s->channels) {
1192             s->out_channels = avctx->request_channels;
1193             s->output_mode  = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1194         }
1195         avctx->channels = s->out_channels;
1196
1197         /* set downmixing coefficients if needed */
1198         if(s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1199                 s->fbw_channels == s->out_channels)) {
1200             set_downmix_coeffs(s);
1201         }
1202     } else if (!s->out_channels) {
1203         s->out_channels = avctx->channels;
1204         if(s->out_channels < s->channels)
1205             s->output_mode  = s->out_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1206     }
1207
1208     /* parse the audio blocks */
1209     for (blk = 0; blk < NB_BLOCKS; blk++) {
1210         if (!err && ac3_parse_audio_block(s, blk)) {
1211             av_log(avctx, AV_LOG_ERROR, "error parsing the audio block\n");
1212         }
1213         for (i = 0; i < 256; i++)
1214             for (ch = 0; ch < s->out_channels; ch++)
1215                 *(out_samples++) = s->int_output[ch][i];
1216     }
1217     *data_size = NB_BLOCKS * 256 * avctx->channels * sizeof (int16_t);
1218     return s->frame_size;
1219 }
1220
1221 /**
1222  * Uninitialize the AC-3 decoder.
1223  */
1224 static av_cold int ac3_decode_end(AVCodecContext *avctx)
1225 {
1226     AC3DecodeContext *s = avctx->priv_data;
1227     ff_mdct_end(&s->imdct_512);
1228     ff_mdct_end(&s->imdct_256);
1229
1230     av_freep(&s->input_buffer);
1231
1232     return 0;
1233 }
1234
1235 AVCodec ac3_decoder = {
1236     .name = "ac3",
1237     .type = CODEC_TYPE_AUDIO,
1238     .id = CODEC_ID_AC3,
1239     .priv_data_size = sizeof (AC3DecodeContext),
1240     .init = ac3_decode_init,
1241     .close = ac3_decode_end,
1242     .decode = ac3_decode_frame,
1243     .long_name = "ATSC A/52 / AC-3",
1244 };