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

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