libavcodec/ac3dec.c

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