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