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

   1 /*
   2  * AC-3 Audio Decoder
   3  * This code was developed as part of Google Summer of Code 2006.
   4  * E-AC-3 support was added as part of Google Summer of Code 2007.
   5  *
   6  * Copyright (c) 2006 Kartikey Mahendra BHATT (bhattkm at gmail dot com)
   7  * Copyright (c) 2007-2008 Bartlomiej Wolowiec <bartek.wolowiec@gmail.com>
   8  * Copyright (c) 2007 Justin Ruggles <justin.ruggles@gmail.com>
   9  *
  10  * This file is part of Libav.
  11  *
  12  * Libav is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU Lesser General Public
  14  * License as published by the Free Software Foundation; either
  15  * version 2.1 of the License, or (at your option) any later version.
  16  *
  17  * Libav is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20  * Lesser General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU Lesser General Public
  23  * License along with Libav; if not, write to the Free Software
  24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  25  */
  26
  27 #include <stdio.h>
  28 #include <stddef.h>
  29 #include <math.h>
  30 #include <string.h>
  31
  32 #include "libavutil/crc.h"
  33 #include "internal.h"
  34 #include "aac_ac3_parser.h"
  35 #include "ac3_parser.h"
  36 #include "ac3dec.h"
  37 #include "ac3dec_data.h"
  38 #include "kbdwin.h"
  39
  40 /** Large enough for maximum possible frame size when the specification limit is ignored */
  41 #define AC3_FRAME_BUFFER_SIZE 32768
  42
  43 /**
  44  * table for ungrouping 3 values in 7 bits.
  45  * used for exponents and bap=2 mantissas
  46  */
  47 static uint8_t ungroup_3_in_7_bits_tab[128][3];
  48
  49
  50 /** tables for ungrouping mantissas */
  51 static int b1_mantissas[32][3];
  52 static int b2_mantissas[128][3];
  53 static int b3_mantissas[8];
  54 static int b4_mantissas[128][2];
  55 static int b5_mantissas[16];
  56
  57 /**
  58  * Quantization table: levels for symmetric. bits for asymmetric.
  59  * reference: Table 7.18 Mapping of bap to Quantizer
  60  */
  61 static const uint8_t quantization_tab[16] = {
  62     0, 3, 5, 7, 11, 15,
  63     5, 6, 7, 8, 9, 10, 11, 12, 14, 16
  64 };
  65
  66 /** dynamic range table. converts codes to scale factors. */
  67 static float dynamic_range_tab[256];
  68
  69 /** Adjustments in dB gain */
  70 static const float gain_levels[9] = {
  71     LEVEL_PLUS_3DB,
  72     LEVEL_PLUS_1POINT5DB,
  73     LEVEL_ONE,
  74     LEVEL_MINUS_1POINT5DB,
  75     LEVEL_MINUS_3DB,
  76     LEVEL_MINUS_4POINT5DB,
  77     LEVEL_MINUS_6DB,
  78     LEVEL_ZERO,
  79     LEVEL_MINUS_9DB
  80 };
  81
  82 /**
  83  * Table for center mix levels
  84  * reference: Section 5.4.2.4 cmixlev
  85  */
  86 static const uint8_t center_levels[4] = { 4, 5, 6, 5 };
  87
  88 /**
  89  * Table for surround mix levels
  90  * reference: Section 5.4.2.5 surmixlev
  91  */
  92 static const uint8_t surround_levels[4] = { 4, 6, 7, 6 };
  93
  94 /**
  95  * Table for default stereo downmixing coefficients
  96  * reference: Section 7.8.2 Downmixing Into Two Channels
  97  */
  98 static const uint8_t ac3_default_coeffs[8][5][2] = {
  99     { { 2, 7 }, { 7, 2 },                               },
 100     { { 4, 4 },                                         },
 101     { { 2, 7 }, { 7, 2 },                               },
 102     { { 2, 7 }, { 5, 5 }, { 7, 2 },                     },
 103     { { 2, 7 }, { 7, 2 }, { 6, 6 },                     },
 104     { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 },           },
 105     { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 },           },
 106     { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
 107 };
 108
 109 /**
 110  * Symmetrical Dequantization
 111  * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization
 112  *            Tables 7.19 to 7.23
 113  */
 114 static inline int
 115 symmetric_dequant(int code, int levels)
 116 {
 117     return ((code - (levels >> 1)) << 24) / levels;
 118 }
 119
 120 /*
 121  * Initialize tables at runtime.
 122  */
 123 static av_cold void ac3_tables_init(void)
 124 {
 125     int i;
 126
 127     /* generate table for ungrouping 3 values in 7 bits
 128        reference: Section 7.1.3 Exponent Decoding */
 129     for(i=0; i<128; i++) {
 130         ungroup_3_in_7_bits_tab[i][0] =  i / 25;
 131         ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5;
 132         ungroup_3_in_7_bits_tab[i][2] = (i % 25) % 5;
 133     }
 134
 135     /* generate grouped mantissa tables
 136        reference: Section 7.3.5 Ungrouping of Mantissas */
 137     for(i=0; i<32; i++) {
 138         /* bap=1 mantissas */
 139         b1_mantissas[i][0] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][0], 3);
 140         b1_mantissas[i][1] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][1], 3);
 141         b1_mantissas[i][2] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][2], 3);
 142     }
 143     for(i=0; i<128; i++) {
 144         /* bap=2 mantissas */
 145         b2_mantissas[i][0] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][0], 5);
 146         b2_mantissas[i][1] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][1], 5);
 147         b2_mantissas[i][2] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][2], 5);
 148
 149         /* bap=4 mantissas */
 150         b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
 151         b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
 152     }
 153     /* generate ungrouped mantissa tables
 154        reference: Tables 7.21 and 7.23 */
 155     for(i=0; i<7; i++) {
 156         /* bap=3 mantissas */
 157         b3_mantissas[i] = symmetric_dequant(i, 7);
 158     }
 159     for(i=0; i<15; i++) {
 160         /* bap=5 mantissas */
 161         b5_mantissas[i] = symmetric_dequant(i, 15);
 162     }
 163
 164     /* generate dynamic range table
 165        reference: Section 7.7.1 Dynamic Range Control */
 166     for(i=0; i<256; i++) {
 167         int v = (i >> 5) - ((i >> 7) << 3) - 5;
 168         dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
 169     }
 170 }
 171
 172
 173 /**
 174  * AVCodec initialization
 175  */
 176 static av_cold int ac3_decode_init(AVCodecContext *avctx)
 177 {
 178     AC3DecodeContext *s = avctx->priv_data;
 179     s->avctx = avctx;
 180
 181     ff_ac3_common_init();
 182     ac3_tables_init();
 183     ff_mdct_init(&s->imdct_256, 8, 1, 1.0);
 184     ff_mdct_init(&s->imdct_512, 9, 1, 1.0);
 185     ff_kbd_window_init(s->window, 5.0, 256);
 186     dsputil_init(&s->dsp, avctx);
 187     ff_ac3dsp_init(&s->ac3dsp, avctx->flags & CODEC_FLAG_BITEXACT);
 188     ff_fmt_convert_init(&s->fmt_conv, avctx);
 189     av_lfg_init(&s->dith_state, 0);
 190
 191     /* set scale value for float to int16 conversion */
 192     s->mul_bias = 32767.0f;
 193
 194     /* allow downmixing to stereo or mono */
 195     if (avctx->channels > 0 && avctx->request_channels > 0 &&
 196             avctx->request_channels < avctx->channels &&
 197             avctx->request_channels <= 2) {
 198         avctx->channels = avctx->request_channels;
 199     }
 200     s->downmixed = 1;
 201
 202     /* allocate context input buffer */
 203         s->input_buffer = av_mallocz(AC3_FRAME_BUFFER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);
 204         if (!s->input_buffer)
 205             return AVERROR(ENOMEM);
 206
 207     avctx->sample_fmt = AV_SAMPLE_FMT_S16;
 208     return 0;
 209 }
 210
 211 /**
 212  * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
 213  * GetBitContext within AC3DecodeContext must point to
 214  * the start of the synchronized AC-3 bitstream.
 215  */
 216 static int ac3_parse_header(AC3DecodeContext *s)
 217 {
 218     GetBitContext *gbc = &s->gbc;
 219     int i;
 220
 221     /* read the rest of the bsi. read twice for dual mono mode. */
 222     i = !(s->channel_mode);
 223     do {
 224         skip_bits(gbc, 5); // skip dialog normalization
 225         if (get_bits1(gbc))
 226             skip_bits(gbc, 8); //skip compression
 227         if (get_bits1(gbc))
 228             skip_bits(gbc, 8); //skip language code
 229         if (get_bits1(gbc))
 230             skip_bits(gbc, 7); //skip audio production information
 231     } while (i--);
 232
 233     skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
 234
 235     /* skip the timecodes (or extra bitstream information for Alternate Syntax)
 236        TODO: read & use the xbsi1 downmix levels */
 237     if (get_bits1(gbc))
 238         skip_bits(gbc, 14); //skip timecode1 / xbsi1
 239     if (get_bits1(gbc))
 240         skip_bits(gbc, 14); //skip timecode2 / xbsi2
 241
 242     /* skip additional bitstream info */
 243     if (get_bits1(gbc)) {
 244         i = get_bits(gbc, 6);
 245         do {
 246             skip_bits(gbc, 8);
 247         } while(i--);
 248     }
 249
 250     return 0;
 251 }
 252
 253 /**
 254  * Common function to parse AC-3 or E-AC-3 frame header
 255  */
 256 static int parse_frame_header(AC3DecodeContext *s)
 257 {
 258     AC3HeaderInfo hdr;
 259     int err;
 260
 261     err = ff_ac3_parse_header(&s->gbc, &hdr);
 262     if(err)
 263         return err;
 264
 265     /* get decoding parameters from header info */
 266     s->bit_alloc_params.sr_code     = hdr.sr_code;
 267     s->bitstream_mode               = hdr.bitstream_mode;
 268     s->channel_mode                 = hdr.channel_mode;
 269     s->channel_layout               = hdr.channel_layout;
 270     s->lfe_on                       = hdr.lfe_on;
 271     s->bit_alloc_params.sr_shift    = hdr.sr_shift;
 272     s->sample_rate                  = hdr.sample_rate;
 273     s->bit_rate                     = hdr.bit_rate;
 274     s->channels                     = hdr.channels;
 275     s->fbw_channels                 = s->channels - s->lfe_on;
 276     s->lfe_ch                       = s->fbw_channels + 1;
 277     s->frame_size                   = hdr.frame_size;
 278     s->center_mix_level             = hdr.center_mix_level;
 279     s->surround_mix_level           = hdr.surround_mix_level;
 280     s->num_blocks                   = hdr.num_blocks;
 281     s->frame_type                   = hdr.frame_type;
 282     s->substreamid                  = hdr.substreamid;
 283
 284     if(s->lfe_on) {
 285         s->start_freq[s->lfe_ch] = 0;
 286         s->end_freq[s->lfe_ch] = 7;
 287         s->num_exp_groups[s->lfe_ch] = 2;
 288         s->channel_in_cpl[s->lfe_ch] = 0;
 289     }
 290
 291     if (hdr.bitstream_id <= 10) {
 292         s->eac3                  = 0;
 293         s->snr_offset_strategy   = 2;
 294         s->block_switch_syntax   = 1;
 295         s->dither_flag_syntax    = 1;
 296         s->bit_allocation_syntax = 1;
 297         s->fast_gain_syntax      = 0;
 298         s->first_cpl_leak        = 0;
 299         s->dba_syntax            = 1;
 300         s->skip_syntax           = 1;
 301         memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
 302         return ac3_parse_header(s);
 303     } else if (CONFIG_EAC3_DECODER) {
 304         s->eac3 = 1;
 305         return ff_eac3_parse_header(s);
 306     } else {
 307         av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n");
 308         return -1;
 309     }
 310 }
 311
 312 /**
 313  * Set stereo downmixing coefficients based on frame header info.
 314  * reference: Section 7.8.2 Downmixing Into Two Channels
 315  */
 316 static void set_downmix_coeffs(AC3DecodeContext *s)
 317 {
 318     int i;
 319     float cmix = gain_levels[center_levels[s->center_mix_level]];
 320     float smix = gain_levels[surround_levels[s->surround_mix_level]];
 321     float norm0, norm1;
 322
 323     for(i=0; i<s->fbw_channels; i++) {
 324         s->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
 325         s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
 326     }
 327     if(s->channel_mode > 1 && s->channel_mode & 1) {
 328         s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix;
 329     }
 330     if(s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
 331         int nf = s->channel_mode - 2;
 332         s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
 333     }
 334     if(s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
 335         int nf = s->channel_mode - 4;
 336         s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix;
 337     }
 338
 339     /* renormalize */
 340     norm0 = norm1 = 0.0;
 341     for(i=0; i<s->fbw_channels; i++) {
 342         norm0 += s->downmix_coeffs[i][0];
 343         norm1 += s->downmix_coeffs[i][1];
 344     }
 345     norm0 = 1.0f / norm0;
 346     norm1 = 1.0f / norm1;
 347     for(i=0; i<s->fbw_channels; i++) {
 348         s->downmix_coeffs[i][0] *= norm0;
 349         s->downmix_coeffs[i][1] *= norm1;
 350     }
 351
 352     if(s->output_mode == AC3_CHMODE_MONO) {
 353         for(i=0; i<s->fbw_channels; i++)
 354             s->downmix_coeffs[i][0] = (s->downmix_coeffs[i][0] + s->downmix_coeffs[i][1]) * LEVEL_MINUS_3DB;
 355     }
 356 }
 357
 358 /**
 359  * Decode the grouped exponents according to exponent strategy.
 360  * reference: Section 7.1.3 Exponent Decoding
 361  */
 362 static int decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
 363                             uint8_t absexp, int8_t *dexps)
 364 {
 365     int i, j, grp, group_size;
 366     int dexp[256];
 367     int expacc, prevexp;
 368
 369     /* unpack groups */
 370     group_size = exp_strategy + (exp_strategy == EXP_D45);
 371     for(grp=0,i=0; grp<ngrps; grp++) {
 372         expacc = get_bits(gbc, 7);
 373         dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
 374         dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
 375         dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
 376     }
 377
 378     /* convert to absolute exps and expand groups */
 379     prevexp = absexp;
 380     for(i=0,j=0; i<ngrps*3; i++) {
 381         prevexp += dexp[i] - 2;
 382         if (prevexp > 24U)
 383             return -1;
 384         switch (group_size) {
 385             case 4: dexps[j++] = prevexp;
 386                     dexps[j++] = prevexp;
 387             case 2: dexps[j++] = prevexp;
 388             case 1: dexps[j++] = prevexp;
 389         }
 390     }
 391     return 0;
 392 }
 393
 394 /**
 395  * Generate transform coefficients for each coupled channel in the coupling
 396  * range using the coupling coefficients and coupling coordinates.
 397  * reference: Section 7.4.3 Coupling Coordinate Format
 398  */
 399 static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
 400 {
 401     int bin, band, ch;
 402
 403     bin = s->start_freq[CPL_CH];
 404     for (band = 0; band < s->num_cpl_bands; band++) {
 405         int band_start = bin;
 406         int band_end = bin + s->cpl_band_sizes[band];
 407         for (ch = 1; ch <= s->fbw_channels; ch++) {
 408             if (s->channel_in_cpl[ch]) {
 409                 int cpl_coord = s->cpl_coords[ch][band] << 5;
 410                 for (bin = band_start; bin < band_end; bin++) {
 411                     s->fixed_coeffs[ch][bin] = MULH(s->fixed_coeffs[CPL_CH][bin] << 4, cpl_coord);
 412                 }
 413                 if (ch == 2 && s->phase_flags[band]) {
 414                     for (bin = band_start; bin < band_end; bin++)
 415                         s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin];
 416                 }
 417             }
 418         }
 419         bin = band_end;
 420     }
 421 }
 422
 423 /**
 424  * Grouped mantissas for 3-level 5-level and 11-level quantization
 425  */
 426 typedef struct {
 427     int b1_mant[2];
 428     int b2_mant[2];
 429     int b4_mant;
 430     int b1;
 431     int b2;
 432     int b4;
 433 } mant_groups;
 434
 435 /**
 436  * Decode the transform coefficients for a particular channel
 437  * reference: Section 7.3 Quantization and Decoding of Mantissas
 438  */
 439 static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
 440 {
 441     int start_freq = s->start_freq[ch_index];
 442     int end_freq = s->end_freq[ch_index];
 443     uint8_t *baps = s->bap[ch_index];
 444     int8_t *exps = s->dexps[ch_index];
 445     int *coeffs = s->fixed_coeffs[ch_index];
 446     int dither = (ch_index == CPL_CH) || s->dither_flag[ch_index];
 447     GetBitContext *gbc = &s->gbc;
 448     int freq;
 449
 450     for(freq = start_freq; freq < end_freq; freq++){
 451         int bap = baps[freq];
 452         int mantissa;
 453         switch(bap){
 454             case 0:
 455                 if (dither)
 456                     mantissa = (av_lfg_get(&s->dith_state) & 0x7FFFFF) - 0x400000;
 457                 else
 458                     mantissa = 0;
 459                 break;
 460             case 1:
 461                 if(m->b1){
 462                     m->b1--;
 463                     mantissa = m->b1_mant[m->b1];
 464                 }
 465                 else{
 466                     int bits      = get_bits(gbc, 5);
 467                     mantissa      = b1_mantissas[bits][0];
 468                     m->b1_mant[1] = b1_mantissas[bits][1];
 469                     m->b1_mant[0] = b1_mantissas[bits][2];
 470                     m->b1         = 2;
 471                 }
 472                 break;
 473             case 2:
 474                 if(m->b2){
 475                     m->b2--;
 476                     mantissa = m->b2_mant[m->b2];
 477                 }
 478                 else{
 479                     int bits      = get_bits(gbc, 7);
 480                     mantissa      = b2_mantissas[bits][0];
 481                     m->b2_mant[1] = b2_mantissas[bits][1];
 482                     m->b2_mant[0] = b2_mantissas[bits][2];
 483                     m->b2         = 2;
 484                 }
 485                 break;
 486             case 3:
 487                 mantissa = b3_mantissas[get_bits(gbc, 3)];
 488                 break;
 489             case 4:
 490                 if(m->b4){
 491                     m->b4 = 0;
 492                     mantissa = m->b4_mant;
 493                 }
 494                 else{
 495                     int bits   = get_bits(gbc, 7);
 496                     mantissa   = b4_mantissas[bits][0];
 497                     m->b4_mant = b4_mantissas[bits][1];
 498                     m->b4      = 1;
 499                 }
 500                 break;
 501             case 5:
 502                 mantissa = b5_mantissas[get_bits(gbc, 4)];
 503                 break;
 504             default: /* 6 to 15 */
 505                 mantissa = get_bits(gbc, quantization_tab[bap]);
 506                 /* Shift mantissa and sign-extend it. */
 507                 mantissa = (mantissa << (32-quantization_tab[bap]))>>8;
 508                 break;
 509         }
 510         coeffs[freq] = mantissa >> exps[freq];
 511     }
 512 }
 513
 514 /**
 515  * Remove random dithering from coupling range coefficients with zero-bit
 516  * mantissas for coupled channels which do not use dithering.
 517  * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
 518  */
 519 static void remove_dithering(AC3DecodeContext *s) {
 520     int ch, i;
 521
 522     for(ch=1; ch<=s->fbw_channels; ch++) {
 523         if(!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
 524             for(i = s->start_freq[CPL_CH]; i<s->end_freq[CPL_CH]; i++) {
 525                 if(!s->bap[CPL_CH][i])
 526                     s->fixed_coeffs[ch][i] = 0;
 527             }
 528         }
 529     }
 530 }
 531
 532 static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,
 533                                     mant_groups *m)
 534 {
 535     if (!s->channel_uses_aht[ch]) {
 536         ac3_decode_transform_coeffs_ch(s, ch, m);
 537     } else {
 538         /* if AHT is used, mantissas for all blocks are encoded in the first
 539            block of the frame. */
 540         int bin;
 541         if (!blk && CONFIG_EAC3_DECODER)
 542             ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
 543         for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
 544             s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
 545         }
 546     }
 547 }
 548
 549 /**
 550  * Decode the transform coefficients.
 551  */
 552 static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
 553 {
 554     int ch, end;
 555     int got_cplchan = 0;
 556     mant_groups m;
 557
 558     m.b1 = m.b2 = m.b4 = 0;
 559
 560     for (ch = 1; ch <= s->channels; ch++) {
 561         /* transform coefficients for full-bandwidth channel */
 562         decode_transform_coeffs_ch(s, blk, ch, &m);
 563         /* tranform coefficients for coupling channel come right after the
 564            coefficients for the first coupled channel*/
 565         if (s->channel_in_cpl[ch])  {
 566             if (!got_cplchan) {
 567                 decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
 568                 calc_transform_coeffs_cpl(s);
 569                 got_cplchan = 1;
 570             }
 571             end = s->end_freq[CPL_CH];
 572         } else {
 573             end = s->end_freq[ch];
 574         }
 575         do
 576             s->fixed_coeffs[ch][end] = 0;
 577         while(++end < 256);
 578     }
 579
 580     /* zero the dithered coefficients for appropriate channels */
 581     remove_dithering(s);
 582 }
 583
 584 /**
 585  * Stereo rematrixing.
 586  * reference: Section 7.5.4 Rematrixing : Decoding Technique
 587  */
 588 static void do_rematrixing(AC3DecodeContext *s)
 589 {
 590     int bnd, i;
 591     int end, bndend;
 592
 593     end = FFMIN(s->end_freq[1], s->end_freq[2]);
 594
 595     for(bnd=0; bnd<s->num_rematrixing_bands; bnd++) {
 596         if(s->rematrixing_flags[bnd]) {
 597             bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd+1]);
 598             for(i=ff_ac3_rematrix_band_tab[bnd]; i<bndend; i++) {
 599                 int tmp0 = s->fixed_coeffs[1][i];
 600                 s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
 601                 s->fixed_coeffs[2][i]  = tmp0 - s->fixed_coeffs[2][i];
 602             }
 603         }
 604     }
 605 }
 606
 607 /**
 608  * Inverse MDCT Transform.
 609  * Convert frequency domain coefficients to time-domain audio samples.
 610  * reference: Section 7.9.4 Transformation Equations
 611  */
 612 static inline void do_imdct(AC3DecodeContext *s, int channels)
 613 {
 614     int ch;
 615
 616     for (ch=1; ch<=channels; ch++) {
 617         if (s->block_switch[ch]) {
 618             int i;
 619             float *x = s->tmp_output+128;
 620             for(i=0; i<128; i++)
 621                 x[i] = s->transform_coeffs[ch][2*i];
 622             s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
 623             s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, 128);
 624             for(i=0; i<128; i++)
 625                 x[i] = s->transform_coeffs[ch][2*i+1];
 626             s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch-1], x);
 627         } else {
 628             s->imdct_512.imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
 629             s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, 128);
 630             memcpy(s->delay[ch-1], s->tmp_output+128, 128*sizeof(float));
 631         }
 632     }
 633 }
 634
 635 /**
 636  * Downmix the output to mono or stereo.
 637  */
 638 void ff_ac3_downmix_c(float (*samples)[256], float (*matrix)[2], int out_ch, int in_ch, int len)
 639 {
 640     int i, j;
 641     float v0, v1;
 642     if(out_ch == 2) {
 643         for(i=0; i<len; i++) {
 644             v0 = v1 = 0.0f;
 645             for(j=0; j<in_ch; j++) {
 646                 v0 += samples[j][i] * matrix[j][0];
 647                 v1 += samples[j][i] * matrix[j][1];
 648             }
 649             samples[0][i] = v0;
 650             samples[1][i] = v1;
 651         }
 652     } else if(out_ch == 1) {
 653         for(i=0; i<len; i++) {
 654             v0 = 0.0f;
 655             for(j=0; j<in_ch; j++)
 656                 v0 += samples[j][i] * matrix[j][0];
 657             samples[0][i] = v0;
 658         }
 659     }
 660 }
 661
 662 /**
 663  * Upmix delay samples from stereo to original channel layout.
 664  */
 665 static void ac3_upmix_delay(AC3DecodeContext *s)
 666 {
 667     int channel_data_size = sizeof(s->delay[0]);
 668     switch(s->channel_mode) {
 669         case AC3_CHMODE_DUALMONO:
 670         case AC3_CHMODE_STEREO:
 671             /* upmix mono to stereo */
 672             memcpy(s->delay[1], s->delay[0], channel_data_size);
 673             break;
 674         case AC3_CHMODE_2F2R:
 675             memset(s->delay[3], 0, channel_data_size);
 676         case AC3_CHMODE_2F1R:
 677             memset(s->delay[2], 0, channel_data_size);
 678             break;
 679         case AC3_CHMODE_3F2R:
 680             memset(s->delay[4], 0, channel_data_size);
 681         case AC3_CHMODE_3F1R:
 682             memset(s->delay[3], 0, channel_data_size);
 683         case AC3_CHMODE_3F:
 684             memcpy(s->delay[2], s->delay[1], channel_data_size);
 685             memset(s->delay[1], 0, channel_data_size);
 686             break;
 687     }
 688 }
 689
 690 /**
 691  * Decode band structure for coupling, spectral extension, or enhanced coupling.
 692  * The band structure defines how many subbands are in each band.  For each
 693  * subband in the range, 1 means it is combined with the previous band, and 0
 694  * means that it starts a new band.
 695  *
 696  * @param[in] gbc bit reader context
 697  * @param[in] blk block number
 698  * @param[in] eac3 flag to indicate E-AC-3
 699  * @param[in] ecpl flag to indicate enhanced coupling
 700  * @param[in] start_subband subband number for start of range
 701  * @param[in] end_subband subband number for end of range
 702  * @param[in] default_band_struct default band structure table
 703  * @param[out] num_bands number of bands (optionally NULL)
 704  * @param[out] band_sizes array containing the number of bins in each band (optionally NULL)
 705  */
 706 static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
 707                                   int ecpl, int start_subband, int end_subband,
 708                                   const uint8_t *default_band_struct,
 709                                   int *num_bands, uint8_t *band_sizes)
 710 {
 711     int subbnd, bnd, n_subbands, n_bands=0;
 712     uint8_t bnd_sz[22];
 713     uint8_t coded_band_struct[22];
 714     const uint8_t *band_struct;
 715
 716     n_subbands = end_subband - start_subband;
 717
 718     /* decode band structure from bitstream or use default */
 719     if (!eac3 || get_bits1(gbc)) {
 720         for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
 721             coded_band_struct[subbnd] = get_bits1(gbc);
 722         }
 723         band_struct = coded_band_struct;
 724     } else if (!blk) {
 725         band_struct = &default_band_struct[start_subband+1];
 726     } else {
 727         /* no change in band structure */
 728         return;
 729     }
 730
 731     /* calculate number of bands and band sizes based on band structure.
 732        note that the first 4 subbands in enhanced coupling span only 6 bins
 733        instead of 12. */
 734     if (num_bands || band_sizes ) {
 735         n_bands = n_subbands;
 736         bnd_sz[0] = ecpl ? 6 : 12;
 737         for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
 738             int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
 739             if (band_struct[subbnd-1]) {
 740                 n_bands--;
 741                 bnd_sz[bnd] += subbnd_size;
 742             } else {
 743                 bnd_sz[++bnd] = subbnd_size;
 744             }
 745         }
 746     }
 747
 748     /* set optional output params */
 749     if (num_bands)
 750         *num_bands = n_bands;
 751     if (band_sizes)
 752         memcpy(band_sizes, bnd_sz, n_bands);
 753 }
 754
 755 /**
 756  * Decode a single audio block from the AC-3 bitstream.
 757  */
 758 static int decode_audio_block(AC3DecodeContext *s, int blk)
 759 {
 760     int fbw_channels = s->fbw_channels;
 761     int channel_mode = s->channel_mode;
 762     int i, bnd, seg, ch;
 763     int different_transforms;
 764     int downmix_output;
 765     int cpl_in_use;
 766     GetBitContext *gbc = &s->gbc;
 767     uint8_t bit_alloc_stages[AC3_MAX_CHANNELS];
 768
 769     memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);
 770
 771     /* block switch flags */
 772     different_transforms = 0;
 773     if (s->block_switch_syntax) {
 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
 781     /* dithering flags */
 782     if (s->dither_flag_syntax) {
 783         for (ch = 1; ch <= fbw_channels; ch++) {
 784             s->dither_flag[ch] = get_bits1(gbc);
 785         }
 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     /* spectral extension strategy */
 800     if (s->eac3 && (!blk || get_bits1(gbc))) {
 801         s->spx_in_use = get_bits1(gbc);
 802         if (s->spx_in_use) {
 803             int dst_start_freq, dst_end_freq, src_start_freq,
 804                 start_subband, end_subband;
 805
 806             /* determine which channels use spx */
 807             if (s->channel_mode == AC3_CHMODE_MONO) {
 808                 s->channel_uses_spx[1] = 1;
 809             } else {
 810                 for (ch = 1; ch <= fbw_channels; ch++)
 811                     s->channel_uses_spx[ch] = get_bits1(gbc);
 812             }
 813
 814             /* get the frequency bins of the spx copy region and the spx start
 815                and end subbands */
 816             dst_start_freq = get_bits(gbc, 2);
 817             start_subband  = get_bits(gbc, 3) + 2;
 818             if (start_subband > 7)
 819                 start_subband += start_subband - 7;
 820             end_subband    = get_bits(gbc, 3) + 5;
 821             if (end_subband   > 7)
 822                 end_subband   += end_subband   - 7;
 823             dst_start_freq = dst_start_freq * 12 + 25;
 824             src_start_freq = start_subband  * 12 + 25;
 825             dst_end_freq   = end_subband    * 12 + 25;
 826
 827             /* check validity of spx ranges */
 828             if (start_subband >= end_subband) {
 829                 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
 830                        "range (%d >= %d)\n", start_subband, end_subband);
 831                 return -1;
 832             }
 833             if (dst_start_freq >= src_start_freq) {
 834                 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
 835                        "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
 836                 return -1;
 837             }
 838
 839             s->spx_dst_start_freq = dst_start_freq;
 840             s->spx_src_start_freq = src_start_freq;
 841             s->spx_dst_end_freq   = dst_end_freq;
 842
 843             decode_band_structure(gbc, blk, s->eac3, 0,
 844                                   start_subband, end_subband,
 845                                   ff_eac3_default_spx_band_struct,
 846                                   &s->num_spx_bands,
 847                                   s->spx_band_sizes);
 848         } else {
 849             for (ch = 1; ch <= fbw_channels; ch++) {
 850                 s->channel_uses_spx[ch] = 0;
 851                 s->first_spx_coords[ch] = 1;
 852             }
 853         }
 854     }
 855
 856     /* spectral extension coordinates */
 857     if (s->spx_in_use) {
 858         for (ch = 1; ch <= fbw_channels; ch++) {
 859             if (s->channel_uses_spx[ch]) {
 860                 if (s->first_spx_coords[ch] || get_bits1(gbc)) {
 861                     float spx_blend;
 862                     int bin, master_spx_coord;
 863
 864                     s->first_spx_coords[ch] = 0;
 865                     spx_blend = get_bits(gbc, 5) * (1.0f/32);
 866                     master_spx_coord = get_bits(gbc, 2) * 3;
 867
 868                     bin = s->spx_src_start_freq;
 869                     for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
 870                         int bandsize;
 871                         int spx_coord_exp, spx_coord_mant;
 872                         float nratio, sblend, nblend, spx_coord;
 873
 874                         /* calculate blending factors */
 875                         bandsize = s->spx_band_sizes[bnd];
 876                         nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
 877                         nratio = av_clipf(nratio, 0.0f, 1.0f);
 878                         nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3) to give unity variance
 879                         sblend = sqrtf(1.0f - nratio);
 880                         bin += bandsize;
 881
 882                         /* decode spx coordinates */
 883                         spx_coord_exp  = get_bits(gbc, 4);
 884                         spx_coord_mant = get_bits(gbc, 2);
 885                         if (spx_coord_exp == 15) spx_coord_mant <<= 1;
 886                         else                     spx_coord_mant += 4;
 887                         spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
 888                         spx_coord = spx_coord_mant * (1.0f/(1<<23));
 889
 890                         /* multiply noise and signal blending factors by spx coordinate */
 891                         s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
 892                         s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
 893                     }
 894                 }
 895             } else {
 896                 s->first_spx_coords[ch] = 1;
 897             }
 898         }
 899     }
 900
 901     /* coupling strategy */
 902     if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
 903         memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
 904         if (!s->eac3)
 905             s->cpl_in_use[blk] = get_bits1(gbc);
 906         if (s->cpl_in_use[blk]) {
 907             /* coupling in use */
 908             int cpl_start_subband, cpl_end_subband;
 909
 910             if (channel_mode < AC3_CHMODE_STEREO) {
 911                 av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
 912                 return -1;
 913             }
 914
 915             /* check for enhanced coupling */
 916             if (s->eac3 && get_bits1(gbc)) {
 917                 /* TODO: parse enhanced coupling strategy info */
 918                 av_log_missing_feature(s->avctx, "Enhanced coupling", 1);
 919                 return -1;
 920             }
 921
 922             /* determine which channels are coupled */
 923             if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
 924                 s->channel_in_cpl[1] = 1;
 925                 s->channel_in_cpl[2] = 1;
 926             } else {
 927                 for (ch = 1; ch <= fbw_channels; ch++)
 928                     s->channel_in_cpl[ch] = get_bits1(gbc);
 929             }
 930
 931             /* phase flags in use */
 932             if (channel_mode == AC3_CHMODE_STEREO)
 933                 s->phase_flags_in_use = get_bits1(gbc);
 934
 935             /* coupling frequency range */
 936             cpl_start_subband = get_bits(gbc, 4);
 937             cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
 938                                               get_bits(gbc, 4) + 3;
 939             if (cpl_start_subband >= cpl_end_subband) {
 940                 av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
 941                        cpl_start_subband, cpl_end_subband);
 942                 return -1;
 943             }
 944             s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
 945             s->end_freq[CPL_CH]   = cpl_end_subband   * 12 + 37;
 946
 947             decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
 948                                   cpl_end_subband,
 949                                   ff_eac3_default_cpl_band_struct,
 950                                   &s->num_cpl_bands, s->cpl_band_sizes);
 951         } else {
 952             /* coupling not in use */
 953             for (ch = 1; ch <= fbw_channels; ch++) {
 954                 s->channel_in_cpl[ch] = 0;
 955                 s->first_cpl_coords[ch] = 1;
 956             }
 957             s->first_cpl_leak = s->eac3;
 958             s->phase_flags_in_use = 0;
 959         }
 960     } else if (!s->eac3) {
 961         if(!blk) {
 962             av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must be present in block 0\n");
 963             return -1;
 964         } else {
 965             s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
 966         }
 967     }
 968     cpl_in_use = s->cpl_in_use[blk];
 969
 970     /* coupling coordinates */
 971     if (cpl_in_use) {
 972         int cpl_coords_exist = 0;
 973
 974         for (ch = 1; ch <= fbw_channels; ch++) {
 975             if (s->channel_in_cpl[ch]) {
 976                 if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
 977                     int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
 978                     s->first_cpl_coords[ch] = 0;
 979                     cpl_coords_exist = 1;
 980                     master_cpl_coord = 3 * get_bits(gbc, 2);
 981                     for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
 982                         cpl_coord_exp = get_bits(gbc, 4);
 983                         cpl_coord_mant = get_bits(gbc, 4);
 984                         if (cpl_coord_exp == 15)
 985                             s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
 986                         else
 987                             s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
 988                         s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
 989                     }
 990                 } else if (!blk) {
 991                     av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must be present in block 0\n");
 992                     return -1;
 993                 }
 994             } else {
 995                 /* channel not in coupling */
 996                 s->first_cpl_coords[ch] = 1;
 997             }
 998         }
 999         /* phase flags */
1000         if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
1001             for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1002                 s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
1003             }
1004         }
1005     }
1006
1007     /* stereo rematrixing strategy and band structure */
1008     if (channel_mode == AC3_CHMODE_STEREO) {
1009         if ((s->eac3 && !blk) || get_bits1(gbc)) {
1010             s->num_rematrixing_bands = 4;
1011             if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
1012                 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
1013             } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
1014                 s->num_rematrixing_bands--;
1015             }
1016             for(bnd=0; bnd<s->num_rematrixing_bands; bnd++)
1017                 s->rematrixing_flags[bnd] = get_bits1(gbc);
1018         } else if (!blk) {
1019             av_log(s->avctx, AV_LOG_WARNING, "Warning: new rematrixing strategy not present in block 0\n");
1020             s->num_rematrixing_bands = 0;
1021         }
1022     }
1023
1024     /* exponent strategies for each channel */
1025     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1026         if (!s->eac3)
1027             s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
1028         if(s->exp_strategy[blk][ch] != EXP_REUSE)
1029             bit_alloc_stages[ch] = 3;
1030     }
1031
1032     /* channel bandwidth */
1033     for (ch = 1; ch <= fbw_channels; ch++) {
1034         s->start_freq[ch] = 0;
1035         if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1036             int group_size;
1037             int prev = s->end_freq[ch];
1038             if (s->channel_in_cpl[ch])
1039                 s->end_freq[ch] = s->start_freq[CPL_CH];
1040             else if (s->channel_uses_spx[ch])
1041                 s->end_freq[ch] = s->spx_src_start_freq;
1042             else {
1043                 int bandwidth_code = get_bits(gbc, 6);
1044                 if (bandwidth_code > 60) {
1045                     av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1046                     return -1;
1047                 }
1048                 s->end_freq[ch] = bandwidth_code * 3 + 73;
1049             }
1050             group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1051             s->num_exp_groups[ch] = (s->end_freq[ch]+group_size-4) / group_size;
1052             if(blk > 0 && s->end_freq[ch] != prev)
1053                 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1054         }
1055     }
1056     if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1057         s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
1058                                     (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1059     }
1060
1061     /* decode exponents for each channel */
1062     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1063         if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1064             s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1065             if (decode_exponents(gbc, s->exp_strategy[blk][ch],
1066                                  s->num_exp_groups[ch], s->dexps[ch][0],
1067                                  &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1068                 av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
1069                 return -1;
1070             }
1071             if(ch != CPL_CH && ch != s->lfe_ch)
1072                 skip_bits(gbc, 2); /* skip gainrng */
1073         }
1074     }
1075
1076     /* bit allocation information */
1077     if (s->bit_allocation_syntax) {
1078         if (get_bits1(gbc)) {
1079             s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1080             s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1081             s->bit_alloc_params.slow_gain  = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
1082             s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
1083             s->bit_alloc_params.floor  = ff_ac3_floor_tab[get_bits(gbc, 3)];
1084             for(ch=!cpl_in_use; ch<=s->channels; ch++)
1085                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1086         } else if (!blk) {
1087             av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must be present in block 0\n");
1088             return -1;
1089         }
1090     }
1091
1092     /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1093     if(!s->eac3 || !blk){
1094         if(s->snr_offset_strategy && get_bits1(gbc)) {
1095             int snr = 0;
1096             int csnr;
1097             csnr = (get_bits(gbc, 6) - 15) << 4;
1098             for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1099                 /* snr offset */
1100                 if (ch == i || s->snr_offset_strategy == 2)
1101                     snr = (csnr + get_bits(gbc, 4)) << 2;
1102                 /* run at least last bit allocation stage if snr offset changes */
1103                 if(blk && s->snr_offset[ch] != snr) {
1104                     bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1105                 }
1106                 s->snr_offset[ch] = snr;
1107
1108                 /* fast gain (normal AC-3 only) */
1109                 if (!s->eac3) {
1110                     int prev = s->fast_gain[ch];
1111                     s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1112                     /* run last 2 bit allocation stages if fast gain changes */
1113                     if(blk && prev != s->fast_gain[ch])
1114                         bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1115                 }
1116             }
1117         } else if (!s->eac3 && !blk) {
1118             av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1119             return -1;
1120         }
1121     }
1122
1123     /* fast gain (E-AC-3 only) */
1124     if (s->fast_gain_syntax && get_bits1(gbc)) {
1125         for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1126             int prev = s->fast_gain[ch];
1127             s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1128             /* run last 2 bit allocation stages if fast gain changes */
1129             if(blk && prev != s->fast_gain[ch])
1130                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1131         }
1132     } else if (s->eac3 && !blk) {
1133         for (ch = !cpl_in_use; ch <= s->channels; ch++)
1134             s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1135     }
1136
1137     /* E-AC-3 to AC-3 converter SNR offset */
1138     if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1139         skip_bits(gbc, 10); // skip converter snr offset
1140     }
1141
1142     /* coupling leak information */
1143     if (cpl_in_use) {
1144         if (s->first_cpl_leak || get_bits1(gbc)) {
1145             int fl = get_bits(gbc, 3);
1146             int sl = get_bits(gbc, 3);
1147             /* run last 2 bit allocation stages for coupling channel if
1148                coupling leak changes */
1149             if(blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1150                        sl != s->bit_alloc_params.cpl_slow_leak)) {
1151                 bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1152             }
1153             s->bit_alloc_params.cpl_fast_leak = fl;
1154             s->bit_alloc_params.cpl_slow_leak = sl;
1155         } else if (!s->eac3 && !blk) {
1156             av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must be present in block 0\n");
1157             return -1;
1158         }
1159         s->first_cpl_leak = 0;
1160     }
1161
1162     /* delta bit allocation information */
1163     if (s->dba_syntax && get_bits1(gbc)) {
1164         /* delta bit allocation exists (strategy) */
1165         for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1166             s->dba_mode[ch] = get_bits(gbc, 2);
1167             if (s->dba_mode[ch] == DBA_RESERVED) {
1168                 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1169                 return -1;
1170             }
1171             bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1172         }
1173         /* channel delta offset, len and bit allocation */
1174         for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1175             if (s->dba_mode[ch] == DBA_NEW) {
1176                 s->dba_nsegs[ch] = get_bits(gbc, 3);
1177                 for (seg = 0; seg <= s->dba_nsegs[ch]; seg++) {
1178                     s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1179                     s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1180                     s->dba_values[ch][seg] = get_bits(gbc, 3);
1181                 }
1182                 /* run last 2 bit allocation stages if new dba values */
1183                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1184             }
1185         }
1186     } else if(blk == 0) {
1187         for(ch=0; ch<=s->channels; ch++) {
1188             s->dba_mode[ch] = DBA_NONE;
1189         }
1190     }
1191
1192     /* Bit allocation */
1193     for(ch=!cpl_in_use; ch<=s->channels; ch++) {
1194         if(bit_alloc_stages[ch] > 2) {
1195             /* Exponent mapping into PSD and PSD integration */
1196             ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
1197                                       s->start_freq[ch], s->end_freq[ch],
1198                                       s->psd[ch], s->band_psd[ch]);
1199         }
1200         if(bit_alloc_stages[ch] > 1) {
1201             /* Compute excitation function, Compute masking curve, and
1202                Apply delta bit allocation */
1203             if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1204                                            s->start_freq[ch], s->end_freq[ch],
1205                                            s->fast_gain[ch], (ch == s->lfe_ch),
1206                                            s->dba_mode[ch], s->dba_nsegs[ch],
1207                                            s->dba_offsets[ch], s->dba_lengths[ch],
1208                                            s->dba_values[ch], s->mask[ch])) {
1209                 av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1210                 return -1;
1211             }
1212         }
1213         if(bit_alloc_stages[ch] > 0) {
1214             /* Compute bit allocation */
1215             const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1216                                      ff_eac3_hebap_tab : ff_ac3_bap_tab;
1217             s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1218                                       s->start_freq[ch], s->end_freq[ch],
1219                                       s->snr_offset[ch],
1220                                       s->bit_alloc_params.floor,
1221                                       bap_tab, s->bap[ch]);
1222         }
1223     }
1224
1225     /* unused dummy data */
1226     if (s->skip_syntax && get_bits1(gbc)) {
1227         int skipl = get_bits(gbc, 9);
1228         while(skipl--)
1229             skip_bits(gbc, 8);
1230     }
1231
1232     /* unpack the transform coefficients
1233        this also uncouples channels if coupling is in use. */
1234     decode_transform_coeffs(s, blk);
1235
1236     /* TODO: generate enhanced coupling coordinates and uncouple */
1237
1238     /* recover coefficients if rematrixing is in use */
1239     if(s->channel_mode == AC3_CHMODE_STEREO)
1240         do_rematrixing(s);
1241
1242     /* apply scaling to coefficients (headroom, dynrng) */
1243     for(ch=1; ch<=s->channels; ch++) {
1244         float gain = s->mul_bias / 4194304.0f;
1245         if(s->channel_mode == AC3_CHMODE_DUALMONO) {
1246             gain *= s->dynamic_range[2-ch];
1247         } else {
1248             gain *= s->dynamic_range[0];
1249         }
1250         s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch], s->fixed_coeffs[ch], gain, 256);
1251     }
1252
1253     /* apply spectral extension to high frequency bins */
1254     if (s->spx_in_use && CONFIG_EAC3_DECODER) {
1255         ff_eac3_apply_spectral_extension(s);
1256     }
1257
1258     /* downmix and MDCT. order depends on whether block switching is used for
1259        any channel in this block. this is because coefficients for the long
1260        and short transforms cannot be mixed. */
1261     downmix_output = s->channels != s->out_channels &&
1262                      !((s->output_mode & AC3_OUTPUT_LFEON) &&
1263                      s->fbw_channels == s->out_channels);
1264     if(different_transforms) {
1265         /* the delay samples have already been downmixed, so we upmix the delay
1266            samples in order to reconstruct all channels before downmixing. */
1267         if(s->downmixed) {
1268             s->downmixed = 0;
1269             ac3_upmix_delay(s);
1270         }
1271
1272         do_imdct(s, s->channels);
1273
1274         if(downmix_output) {
1275             s->dsp.ac3_downmix(s->output, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
1276         }
1277     } else {
1278         if(downmix_output) {
1279             s->dsp.ac3_downmix(s->transform_coeffs+1, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
1280         }
1281
1282         if(downmix_output && !s->downmixed) {
1283             s->downmixed = 1;
1284             s->dsp.ac3_downmix(s->delay, s->downmix_coeffs, s->out_channels, s->fbw_channels, 128);
1285         }
1286
1287         do_imdct(s, s->out_channels);
1288     }
1289
1290     return 0;
1291 }
1292
1293 /**
1294  * Decode a single AC-3 frame.
1295  */
1296 static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size,
1297                             AVPacket *avpkt)
1298 {
1299     const uint8_t *buf = avpkt->data;
1300     int buf_size = avpkt->size;
1301     AC3DecodeContext *s = avctx->priv_data;
1302     int16_t *out_samples = (int16_t *)data;
1303     int blk, ch, err;
1304     const uint8_t *channel_map;
1305     const float *output[AC3_MAX_CHANNELS];
1306
1307     /* copy input buffer to decoder context to avoid reading past the end
1308        of the buffer, which can be caused by a damaged input stream. */
1309     if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
1310         // seems to be byte-swapped AC-3
1311         int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1312         s->dsp.bswap16_buf((uint16_t *)s->input_buffer, (const uint16_t *)buf, cnt);
1313     } else
1314         memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1315     buf = s->input_buffer;
1316     /* initialize the GetBitContext with the start of valid AC-3 Frame */
1317     init_get_bits(&s->gbc, buf, buf_size * 8);
1318
1319     /* parse the syncinfo */
1320     *data_size = 0;
1321     err = parse_frame_header(s);
1322
1323     if (err) {
1324         switch(err) {
1325             case AAC_AC3_PARSE_ERROR_SYNC:
1326                 av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1327                 return -1;
1328             case AAC_AC3_PARSE_ERROR_BSID:
1329                 av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1330                 break;
1331             case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
1332                 av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1333                 break;
1334             case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
1335                 av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1336                 break;
1337             case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
1338                 /* skip frame if CRC is ok. otherwise use error concealment. */
1339                 /* TODO: add support for substreams and dependent frames */
1340                 if(s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
1341                     av_log(avctx, AV_LOG_ERROR, "unsupported frame type : skipping frame\n");
1342                     return s->frame_size;
1343                 } else {
1344                     av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1345                 }
1346                 break;
1347             default:
1348                 av_log(avctx, AV_LOG_ERROR, "invalid header\n");
1349                 break;
1350         }
1351     } else {
1352         /* check that reported frame size fits in input buffer */
1353         if (s->frame_size > buf_size) {
1354             av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1355             err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
1356         } else if (avctx->error_recognition >= FF_ER_CAREFUL) {
1357             /* check for crc mismatch */
1358             if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2], s->frame_size-2)) {
1359                 av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1360                 err = AAC_AC3_PARSE_ERROR_CRC;
1361             }
1362         }
1363     }
1364
1365     /* if frame is ok, set audio parameters */
1366     if (!err) {
1367         avctx->sample_rate = s->sample_rate;
1368         avctx->bit_rate = s->bit_rate;
1369
1370         /* channel config */
1371         s->out_channels = s->channels;
1372         s->output_mode = s->channel_mode;
1373         if(s->lfe_on)
1374             s->output_mode |= AC3_OUTPUT_LFEON;
1375         if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&
1376                 avctx->request_channels < s->channels) {
1377             s->out_channels = avctx->request_channels;
1378             s->output_mode  = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1379             s->channel_layout = ff_ac3_channel_layout_tab[s->output_mode];
1380         }
1381         avctx->channels = s->out_channels;
1382         avctx->channel_layout = s->channel_layout;
1383
1384         /* set downmixing coefficients if needed */
1385         if(s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1386                 s->fbw_channels == s->out_channels)) {
1387             set_downmix_coeffs(s);
1388         }
1389     } else if (!s->out_channels) {
1390         s->out_channels = avctx->channels;
1391         if(s->out_channels < s->channels)
1392             s->output_mode  = s->out_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1393     }
1394     /* set audio service type based on bitstream mode for AC-3 */
1395     avctx->audio_service_type = s->bitstream_mode;
1396     if (s->bitstream_mode == 0x7 && s->channels > 1)
1397         avctx->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
1398
1399     /* decode the audio blocks */
1400     channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1401     for (ch = 0; ch < s->out_channels; ch++)
1402         output[ch] = s->output[channel_map[ch]];
1403     for (blk = 0; blk < s->num_blocks; blk++) {
1404         if (!err && decode_audio_block(s, blk)) {
1405             av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1406             err = 1;
1407         }
1408         s->fmt_conv.float_to_int16_interleave(out_samples, output, 256, s->out_channels);
1409         out_samples += 256 * s->out_channels;
1410     }
1411     *data_size = s->num_blocks * 256 * avctx->channels * sizeof (int16_t);
1412     return FFMIN(buf_size, s->frame_size);
1413 }
1414
1415 /**
1416  * Uninitialize the AC-3 decoder.
1417  */
1418 static av_cold int ac3_decode_end(AVCodecContext *avctx)
1419 {
1420     AC3DecodeContext *s = avctx->priv_data;
1421     ff_mdct_end(&s->imdct_512);
1422     ff_mdct_end(&s->imdct_256);
1423
1424     av_freep(&s->input_buffer);
1425
1426     return 0;
1427 }
1428
1429 AVCodec ff_ac3_decoder = {
1430     .name = "ac3",
1431     .type = AVMEDIA_TYPE_AUDIO,
1432     .id = CODEC_ID_AC3,
1433     .priv_data_size = sizeof (AC3DecodeContext),
1434     .init = ac3_decode_init,
1435     .close = ac3_decode_end,
1436     .decode = ac3_decode_frame,
1437     .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
1438 };
1439
1440 #if CONFIG_EAC3_DECODER
1441 AVCodec ff_eac3_decoder = {
1442     .name = "eac3",
1443     .type = AVMEDIA_TYPE_AUDIO,
1444     .id = CODEC_ID_EAC3,
1445     .priv_data_size = sizeof (AC3DecodeContext),
1446     .init = ac3_decode_init,
1447     .close = ac3_decode_end,
1448     .decode = ac3_decode_frame,
1449     .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
1450 };
1451 #endif