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

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