libavcodec/ac3dec.c

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