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

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