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