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