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