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