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/channel_layout.h"
  33 #include "libavutil/crc.h"
  34 #include "libavutil/downmix_info.h"
  35 #include "libavutil/opt.h"
  36 #include "bswapdsp.h"
  37 #include "internal.h"
  38 #include "aac_ac3_parser.h"
  39 #include "ac3_parser_internal.h"
  40 #include "ac3dec.h"
  41 #include "ac3dec_data.h"
  42 #include "kbdwin.h"
  43
  44 /**
  45  * table for ungrouping 3 values in 7 bits.
  46  * used for exponents and bap=2 mantissas
  47  */
  48 static uint8_t ungroup_3_in_7_bits_tab[128][3];
  49
  50 /** tables for ungrouping mantissas */
  51 static int b1_mantissas[32][3];
  52 static int b2_mantissas[128][3];
  53 static int b3_mantissas[8];
  54 static int b4_mantissas[128][2];
  55 static int b5_mantissas[16];
  56
  57 /**
  58  * Quantization table: levels for symmetric. bits for asymmetric.
  59  * reference: Table 7.18 Mapping of bap to Quantizer
  60  */
  61 static const uint8_t quantization_tab[16] = {
  62     0, 3, 5, 7, 11, 15,
  63     5, 6, 7, 8, 9, 10, 11, 12, 14, 16
  64 };
  65
  66 #if (!USE_FIXED)
  67 /** dynamic range table. converts codes to scale factors. */
  68 static float dynamic_range_tab[256];
  69 float ff_ac3_heavy_dynamic_range_tab[256];
  70 #endif
  71
  72 /** Adjustments in dB gain */
  73 static const float gain_levels[9] = {
  74     LEVEL_PLUS_3DB,
  75     LEVEL_PLUS_1POINT5DB,
  76     LEVEL_ONE,
  77     LEVEL_MINUS_1POINT5DB,
  78     LEVEL_MINUS_3DB,
  79     LEVEL_MINUS_4POINT5DB,
  80     LEVEL_MINUS_6DB,
  81     LEVEL_ZERO,
  82     LEVEL_MINUS_9DB
  83 };
  84
  85 /** Adjustments in dB gain (LFE, +10 to -21 dB) */
  86 static const float gain_levels_lfe[32] = {
  87     3.162275, 2.818382, 2.511886, 2.238719, 1.995261, 1.778278, 1.584893,
  88     1.412536, 1.258924, 1.122018, 1.000000, 0.891251, 0.794328, 0.707946,
  89     0.630957, 0.562341, 0.501187, 0.446683, 0.398107, 0.354813, 0.316227,
  90     0.281838, 0.251188, 0.223872, 0.199526, 0.177828, 0.158489, 0.141253,
  91     0.125892, 0.112201, 0.100000, 0.089125
  92 };
  93
  94 /**
  95  * Table for default stereo downmixing coefficients
  96  * reference: Section 7.8.2 Downmixing Into Two Channels
  97  */
  98 static const uint8_t ac3_default_coeffs[8][5][2] = {
  99     { { 2, 7 }, { 7, 2 },                               },
 100     { { 4, 4 },                                         },
 101     { { 2, 7 }, { 7, 2 },                               },
 102     { { 2, 7 }, { 5, 5 }, { 7, 2 },                     },
 103     { { 2, 7 }, { 7, 2 }, { 6, 6 },                     },
 104     { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 },           },
 105     { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 },           },
 106     { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
 107 };
 108
 109 /**
 110  * Symmetrical Dequantization
 111  * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization
 112  *            Tables 7.19 to 7.23
 113  */
 114 static inline int
 115 symmetric_dequant(int code, int levels)
 116 {
 117     return ((code - (levels >> 1)) * (1 << 24)) / levels;
 118 }
 119
 120 /*
 121  * Initialize tables at runtime.
 122  */
 123 static av_cold void ac3_tables_init(void)
 124 {
 125     int i;
 126
 127     /* generate table for ungrouping 3 values in 7 bits
 128        reference: Section 7.1.3 Exponent Decoding */
 129     for (i = 0; i < 128; i++) {
 130         ungroup_3_in_7_bits_tab[i][0] =  i / 25;
 131         ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5;
 132         ungroup_3_in_7_bits_tab[i][2] = (i % 25) % 5;
 133     }
 134
 135     /* generate grouped mantissa tables
 136        reference: Section 7.3.5 Ungrouping of Mantissas */
 137     for (i = 0; i < 32; i++) {
 138         /* bap=1 mantissas */
 139         b1_mantissas[i][0] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][0], 3);
 140         b1_mantissas[i][1] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][1], 3);
 141         b1_mantissas[i][2] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][2], 3);
 142     }
 143     for (i = 0; i < 128; i++) {
 144         /* bap=2 mantissas */
 145         b2_mantissas[i][0] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][0], 5);
 146         b2_mantissas[i][1] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][1], 5);
 147         b2_mantissas[i][2] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][2], 5);
 148
 149         /* bap=4 mantissas */
 150         b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
 151         b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
 152     }
 153     /* generate ungrouped mantissa tables
 154        reference: Tables 7.21 and 7.23 */
 155     for (i = 0; i < 7; i++) {
 156         /* bap=3 mantissas */
 157         b3_mantissas[i] = symmetric_dequant(i, 7);
 158     }
 159     for (i = 0; i < 15; i++) {
 160         /* bap=5 mantissas */
 161         b5_mantissas[i] = symmetric_dequant(i, 15);
 162     }
 163
 164 #if (!USE_FIXED)
 165     /* generate dynamic range table
 166        reference: Section 7.7.1 Dynamic Range Control */
 167     for (i = 0; i < 256; i++) {
 168         int v = (i >> 5) - ((i >> 7) << 3) - 5;
 169         dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
 170     }
 171
 172     /* generate compr dynamic range table
 173        reference: Section 7.7.2 Heavy Compression */
 174     for (i = 0; i < 256; i++) {
 175         int v = (i >> 4) - ((i >> 7) << 4) - 4;
 176         ff_ac3_heavy_dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0xF) | 0x10);
 177     }
 178 #endif
 179 }
 180
 181 /**
 182  * AVCodec initialization
 183  */
 184 static av_cold int ac3_decode_init(AVCodecContext *avctx)
 185 {
 186     AC3DecodeContext *s = avctx->priv_data;
 187     int i, ret;
 188
 189     s->avctx = avctx;
 190
 191     ac3_tables_init();
 192     if ((ret = ff_mdct_init(&s->imdct_256, 8, 1, 1.0)) < 0 ||
 193         (ret = ff_mdct_init(&s->imdct_512, 9, 1, 1.0)) < 0)
 194         return ret;
 195     AC3_RENAME(ff_kbd_window_init)(s->window, 5.0, 256);
 196     ff_bswapdsp_init(&s->bdsp);
 197
 198 #if (USE_FIXED)
 199     s->fdsp = avpriv_alloc_fixed_dsp(avctx->flags & AV_CODEC_FLAG_BITEXACT);
 200 #else
 201     ff_fmt_convert_init(&s->fmt_conv, avctx);
 202     s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
 203 #endif
 204     if (!s->fdsp)
 205         return AVERROR(ENOMEM);
 206
 207     ff_ac3dsp_init(&s->ac3dsp, avctx->flags & AV_CODEC_FLAG_BITEXACT);
 208     av_lfg_init(&s->dith_state, 0);
 209
 210     if (USE_FIXED)
 211         avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
 212     else
 213         avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
 214
 215     /* allow downmixing to stereo or mono */
 216     if (avctx->channels > 1 &&
 217         avctx->request_channel_layout == AV_CH_LAYOUT_MONO)
 218         avctx->channels = 1;
 219     else if (avctx->channels > 2 &&
 220              avctx->request_channel_layout == AV_CH_LAYOUT_STEREO)
 221         avctx->channels = 2;
 222     s->downmixed = 1;
 223
 224     for (i = 0; i < AC3_MAX_CHANNELS; i++) {
 225         s->xcfptr[i] = s->transform_coeffs[i];
 226         s->dlyptr[i] = s->delay[i];
 227     }
 228
 229     return 0;
 230 }
 231
 232 /**
 233  * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
 234  * GetBitContext within AC3DecodeContext must point to
 235  * the start of the synchronized AC-3 bitstream.
 236  */
 237 static int ac3_parse_header(AC3DecodeContext *s)
 238 {
 239     GetBitContext *gbc = &s->gbc;
 240     int i;
 241
 242     /* read the rest of the bsi. read twice for dual mono mode. */
 243     i = !s->channel_mode;
 244     do {
 245         s->dialog_normalization[(!s->channel_mode)-i] = -get_bits(gbc, 5);
 246         if (s->dialog_normalization[(!s->channel_mode)-i] == 0) {
 247             s->dialog_normalization[(!s->channel_mode)-i] = -31;
 248         }
 249         if (s->target_level != 0) {
 250             s->level_gain[(!s->channel_mode)-i] = powf(2.0f,
 251                 (float)(s->target_level -
 252                 s->dialog_normalization[(!s->channel_mode)-i])/6.0f);
 253         }
 254         if (s->compression_exists[(!s->channel_mode)-i] = get_bits1(gbc)) {
 255             s->heavy_dynamic_range[(!s->channel_mode)-i] =
 256                 AC3_HEAVY_RANGE(get_bits(gbc, 8));
 257         }
 258         if (get_bits1(gbc))
 259             skip_bits(gbc, 8); //skip language code
 260         if (get_bits1(gbc))
 261             skip_bits(gbc, 7); //skip audio production information
 262     } while (i--);
 263
 264     skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
 265
 266     /* skip the timecodes or parse the Alternate Bit Stream Syntax */
 267     if (s->bitstream_id != 6) {
 268         if (get_bits1(gbc))
 269             skip_bits(gbc, 14); //skip timecode1
 270         if (get_bits1(gbc))
 271             skip_bits(gbc, 14); //skip timecode2
 272     } else {
 273         if (get_bits1(gbc)) {
 274             s->preferred_downmix       = get_bits(gbc, 2);
 275             s->center_mix_level_ltrt   = get_bits(gbc, 3);
 276             s->surround_mix_level_ltrt = av_clip(get_bits(gbc, 3), 3, 7);
 277             s->center_mix_level        = get_bits(gbc, 3);
 278             s->surround_mix_level      = av_clip(get_bits(gbc, 3), 3, 7);
 279         }
 280         if (get_bits1(gbc)) {
 281             s->dolby_surround_ex_mode = get_bits(gbc, 2);
 282             s->dolby_headphone_mode   = get_bits(gbc, 2);
 283             skip_bits(gbc, 10); // skip adconvtyp (1), xbsi2 (8), encinfo (1)
 284         }
 285     }
 286
 287     /* skip additional bitstream info */
 288     if (get_bits1(gbc)) {
 289         i = get_bits(gbc, 6);
 290         do {
 291             skip_bits(gbc, 8);
 292         } while (i--);
 293     }
 294
 295     return 0;
 296 }
 297
 298 /**
 299  * Common function to parse AC-3 or E-AC-3 frame header
 300  */
 301 static int parse_frame_header(AC3DecodeContext *s)
 302 {
 303     AC3HeaderInfo hdr;
 304     int err;
 305
 306     err = ff_ac3_parse_header(&s->gbc, &hdr);
 307     if (err)
 308         return err;
 309
 310     /* get decoding parameters from header info */
 311     s->bit_alloc_params.sr_code     = hdr.sr_code;
 312     s->bitstream_id                 = hdr.bitstream_id;
 313     s->bitstream_mode               = hdr.bitstream_mode;
 314     s->channel_mode                 = hdr.channel_mode;
 315     s->lfe_on                       = hdr.lfe_on;
 316     s->bit_alloc_params.sr_shift    = hdr.sr_shift;
 317     s->sample_rate                  = hdr.sample_rate;
 318     s->bit_rate                     = hdr.bit_rate;
 319     s->channels                     = hdr.channels;
 320     s->fbw_channels                 = s->channels - s->lfe_on;
 321     s->lfe_ch                       = s->fbw_channels + 1;
 322     s->frame_size                   = hdr.frame_size;
 323     s->superframe_size             += hdr.frame_size;
 324     s->preferred_downmix            = AC3_DMIXMOD_NOTINDICATED;
 325     s->center_mix_level             = hdr.center_mix_level;
 326     s->center_mix_level_ltrt        = 4; // -3.0dB
 327     s->surround_mix_level           = hdr.surround_mix_level;
 328     s->surround_mix_level_ltrt      = 4; // -3.0dB
 329     s->lfe_mix_level_exists         = 0;
 330     s->num_blocks                   = hdr.num_blocks;
 331     s->frame_type                   = hdr.frame_type;
 332     s->substreamid                  = hdr.substreamid;
 333     s->dolby_surround_mode          = hdr.dolby_surround_mode;
 334     s->dolby_surround_ex_mode       = AC3_DSUREXMOD_NOTINDICATED;
 335     s->dolby_headphone_mode         = AC3_DHEADPHONMOD_NOTINDICATED;
 336
 337     if (s->lfe_on) {
 338         s->start_freq[s->lfe_ch]     = 0;
 339         s->end_freq[s->lfe_ch]       = 7;
 340         s->num_exp_groups[s->lfe_ch] = 2;
 341         s->channel_in_cpl[s->lfe_ch] = 0;
 342     }
 343
 344     if (s->bitstream_id <= 10) {
 345         s->eac3                  = 0;
 346         s->snr_offset_strategy   = 2;
 347         s->block_switch_syntax   = 1;
 348         s->dither_flag_syntax    = 1;
 349         s->bit_allocation_syntax = 1;
 350         s->fast_gain_syntax      = 0;
 351         s->first_cpl_leak        = 0;
 352         s->dba_syntax            = 1;
 353         s->skip_syntax           = 1;
 354         memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
 355         return ac3_parse_header(s);
 356     } else if (CONFIG_EAC3_DECODER) {
 357         s->eac3 = 1;
 358         return ff_eac3_parse_header(s);
 359     } else {
 360         av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n");
 361         return AVERROR(ENOSYS);
 362     }
 363 }
 364
 365 /**
 366  * Set stereo downmixing coefficients based on frame header info.
 367  * reference: Section 7.8.2 Downmixing Into Two Channels
 368  */
 369 static int set_downmix_coeffs(AC3DecodeContext *s)
 370 {
 371     int i;
 372     float cmix = gain_levels[s->  center_mix_level];
 373     float smix = gain_levels[s->surround_mix_level];
 374     float norm0, norm1;
 375     float downmix_coeffs[2][AC3_MAX_CHANNELS];
 376
 377     if (!s->downmix_coeffs[0]) {
 378         s->downmix_coeffs[0] = av_malloc_array(2 * AC3_MAX_CHANNELS,
 379                                                sizeof(**s->downmix_coeffs));
 380         if (!s->downmix_coeffs[0])
 381             return AVERROR(ENOMEM);
 382         s->downmix_coeffs[1] = s->downmix_coeffs[0] + AC3_MAX_CHANNELS;
 383     }
 384
 385     for (i = 0; i < s->fbw_channels; i++) {
 386         downmix_coeffs[0][i] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
 387         downmix_coeffs[1][i] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
 388     }
 389     if (s->channel_mode > 1 && s->channel_mode & 1) {
 390         downmix_coeffs[0][1] = downmix_coeffs[1][1] = cmix;
 391     }
 392     if (s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
 393         int nf = s->channel_mode - 2;
 394         downmix_coeffs[0][nf] = downmix_coeffs[1][nf] = smix * LEVEL_MINUS_3DB;
 395     }
 396     if (s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
 397         int nf = s->channel_mode - 4;
 398         downmix_coeffs[0][nf] = downmix_coeffs[1][nf+1] = smix;
 399     }
 400
 401     /* renormalize */
 402     norm0 = norm1 = 0.0;
 403     for (i = 0; i < s->fbw_channels; i++) {
 404         norm0 += downmix_coeffs[0][i];
 405         norm1 += downmix_coeffs[1][i];
 406     }
 407     norm0 = 1.0f / norm0;
 408     norm1 = 1.0f / norm1;
 409     for (i = 0; i < s->fbw_channels; i++) {
 410         downmix_coeffs[0][i] *= norm0;
 411         downmix_coeffs[1][i] *= norm1;
 412     }
 413
 414     if (s->output_mode == AC3_CHMODE_MONO) {
 415         for (i = 0; i < s->fbw_channels; i++)
 416             downmix_coeffs[0][i] = (downmix_coeffs[0][i] +
 417                                     downmix_coeffs[1][i]) * LEVEL_MINUS_3DB;
 418     }
 419     for (i = 0; i < s->fbw_channels; i++) {
 420         s->downmix_coeffs[0][i] = FIXR12(downmix_coeffs[0][i]);
 421         s->downmix_coeffs[1][i] = FIXR12(downmix_coeffs[1][i]);
 422     }
 423
 424     return 0;
 425 }
 426
 427 /**
 428  * Decode the grouped exponents according to exponent strategy.
 429  * reference: Section 7.1.3 Exponent Decoding
 430  */
 431 static int decode_exponents(AC3DecodeContext *s,
 432                             GetBitContext *gbc, int exp_strategy, int ngrps,
 433                             uint8_t absexp, int8_t *dexps)
 434 {
 435     int i, j, grp, group_size;
 436     int dexp[256];
 437     int expacc, prevexp;
 438
 439     /* unpack groups */
 440     group_size = exp_strategy + (exp_strategy == EXP_D45);
 441     for (grp = 0, i = 0; grp < ngrps; grp++) {
 442         expacc = get_bits(gbc, 7);
 443         if (expacc >= 125) {
 444             av_log(s->avctx, AV_LOG_ERROR, "expacc %d is out-of-range\n", expacc);
 445             return AVERROR_INVALIDDATA;
 446         }
 447         dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
 448         dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
 449         dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
 450     }
 451
 452     /* convert to absolute exps and expand groups */
 453     prevexp = absexp;
 454     for (i = 0, j = 0; i < ngrps * 3; i++) {
 455         prevexp += dexp[i] - 2;
 456         if (prevexp > 24U) {
 457             av_log(s->avctx, AV_LOG_ERROR, "exponent %d is out-of-range\n", prevexp);
 458             return AVERROR_INVALIDDATA;
 459         }
 460         switch (group_size) {
 461         case 4: dexps[j++] = prevexp;
 462                 dexps[j++] = prevexp;
 463         case 2: dexps[j++] = prevexp;
 464         case 1: dexps[j++] = prevexp;
 465         }
 466     }
 467     return 0;
 468 }
 469
 470 /**
 471  * Generate transform coefficients for each coupled channel in the coupling
 472  * range using the coupling coefficients and coupling coordinates.
 473  * reference: Section 7.4.3 Coupling Coordinate Format
 474  */
 475 static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
 476 {
 477     int bin, band, ch;
 478
 479     bin = s->start_freq[CPL_CH];
 480     for (band = 0; band < s->num_cpl_bands; band++) {
 481         int band_start = bin;
 482         int band_end = bin + s->cpl_band_sizes[band];
 483         for (ch = 1; ch <= s->fbw_channels; ch++) {
 484             if (s->channel_in_cpl[ch]) {
 485                 int cpl_coord = s->cpl_coords[ch][band] << 5;
 486                 for (bin = band_start; bin < band_end; bin++) {
 487                     s->fixed_coeffs[ch][bin] =
 488                         MULH(s->fixed_coeffs[CPL_CH][bin] * (1 << 4), cpl_coord);
 489                 }
 490                 if (ch == 2 && s->phase_flags[band]) {
 491                     for (bin = band_start; bin < band_end; bin++)
 492                         s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin];
 493                 }
 494             }
 495         }
 496         bin = band_end;
 497     }
 498 }
 499
 500 /**
 501  * Grouped mantissas for 3-level 5-level and 11-level quantization
 502  */
 503 typedef struct mant_groups {
 504     int b1_mant[2];
 505     int b2_mant[2];
 506     int b4_mant;
 507     int b1;
 508     int b2;
 509     int b4;
 510 } mant_groups;
 511
 512 /**
 513  * Decode the transform coefficients for a particular channel
 514  * reference: Section 7.3 Quantization and Decoding of Mantissas
 515  */
 516 static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
 517 {
 518     int start_freq = s->start_freq[ch_index];
 519     int end_freq   = s->end_freq[ch_index];
 520     uint8_t *baps  = s->bap[ch_index];
 521     int8_t *exps   = s->dexps[ch_index];
 522     int32_t *coeffs = s->fixed_coeffs[ch_index];
 523     int dither     = (ch_index == CPL_CH) || s->dither_flag[ch_index];
 524     GetBitContext *gbc = &s->gbc;
 525     int freq;
 526
 527     for (freq = start_freq; freq < end_freq; freq++) {
 528         int bap = baps[freq];
 529         int mantissa;
 530         switch (bap) {
 531         case 0:
 532             /* random noise with approximate range of -0.707 to 0.707 */
 533             if (dither)
 534                 mantissa = (((av_lfg_get(&s->dith_state)>>8)*181)>>8) - 5931008;
 535             else
 536                 mantissa = 0;
 537             break;
 538         case 1:
 539             if (m->b1) {
 540                 m->b1--;
 541                 mantissa = m->b1_mant[m->b1];
 542             } else {
 543                 int bits      = get_bits(gbc, 5);
 544                 mantissa      = b1_mantissas[bits][0];
 545                 m->b1_mant[1] = b1_mantissas[bits][1];
 546                 m->b1_mant[0] = b1_mantissas[bits][2];
 547                 m->b1         = 2;
 548             }
 549             break;
 550         case 2:
 551             if (m->b2) {
 552                 m->b2--;
 553                 mantissa = m->b2_mant[m->b2];
 554             } else {
 555                 int bits      = get_bits(gbc, 7);
 556                 mantissa      = b2_mantissas[bits][0];
 557                 m->b2_mant[1] = b2_mantissas[bits][1];
 558                 m->b2_mant[0] = b2_mantissas[bits][2];
 559                 m->b2         = 2;
 560             }
 561             break;
 562         case 3:
 563             mantissa = b3_mantissas[get_bits(gbc, 3)];
 564             break;
 565         case 4:
 566             if (m->b4) {
 567                 m->b4 = 0;
 568                 mantissa = m->b4_mant;
 569             } else {
 570                 int bits   = get_bits(gbc, 7);
 571                 mantissa   = b4_mantissas[bits][0];
 572                 m->b4_mant = b4_mantissas[bits][1];
 573                 m->b4      = 1;
 574             }
 575             break;
 576         case 5:
 577             mantissa = b5_mantissas[get_bits(gbc, 4)];
 578             break;
 579         default: /* 6 to 15 */
 580             /* Shift mantissa and sign-extend it. */
 581             if (bap > 15) {
 582                 av_log(s->avctx, AV_LOG_ERROR, "bap %d is invalid in plain AC-3\n", bap);
 583                 bap = 15;
 584             }
 585             mantissa = (unsigned)get_sbits(gbc, quantization_tab[bap]) << (24 - quantization_tab[bap]);
 586             break;
 587         }
 588         coeffs[freq] = mantissa >> exps[freq];
 589     }
 590 }
 591
 592 /**
 593  * Remove random dithering from coupling range coefficients with zero-bit
 594  * mantissas for coupled channels which do not use dithering.
 595  * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
 596  */
 597 static void remove_dithering(AC3DecodeContext *s) {
 598     int ch, i;
 599
 600     for (ch = 1; ch <= s->fbw_channels; ch++) {
 601         if (!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
 602             for (i = s->start_freq[CPL_CH]; i < s->end_freq[CPL_CH]; i++) {
 603                 if (!s->bap[CPL_CH][i])
 604                     s->fixed_coeffs[ch][i] = 0;
 605             }
 606         }
 607     }
 608 }
 609
 610 static inline void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk,
 611                                               int ch, mant_groups *m)
 612 {
 613     if (!s->channel_uses_aht[ch]) {
 614         ac3_decode_transform_coeffs_ch(s, ch, m);
 615     } else {
 616         /* if AHT is used, mantissas for all blocks are encoded in the first
 617            block of the frame. */
 618         int bin;
 619         if (CONFIG_EAC3_DECODER && !blk)
 620             ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
 621         for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
 622             s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
 623         }
 624     }
 625 }
 626
 627 /**
 628  * Decode the transform coefficients.
 629  */
 630 static inline void decode_transform_coeffs(AC3DecodeContext *s, int blk)
 631 {
 632     int ch, end;
 633     int got_cplchan = 0;
 634     mant_groups m;
 635
 636     m.b1 = m.b2 = m.b4 = 0;
 637
 638     for (ch = 1; ch <= s->channels; ch++) {
 639         /* transform coefficients for full-bandwidth channel */
 640         decode_transform_coeffs_ch(s, blk, ch, &m);
 641         /* transform coefficients for coupling channel come right after the
 642            coefficients for the first coupled channel*/
 643         if (s->channel_in_cpl[ch])  {
 644             if (!got_cplchan) {
 645                 decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
 646                 calc_transform_coeffs_cpl(s);
 647                 got_cplchan = 1;
 648             }
 649             end = s->end_freq[CPL_CH];
 650         } else {
 651             end = s->end_freq[ch];
 652         }
 653         do
 654             s->fixed_coeffs[ch][end] = 0;
 655         while (++end < 256);
 656     }
 657
 658     /* zero the dithered coefficients for appropriate channels */
 659     remove_dithering(s);
 660 }
 661
 662 /**
 663  * Stereo rematrixing.
 664  * reference: Section 7.5.4 Rematrixing : Decoding Technique
 665  */
 666 static void do_rematrixing(AC3DecodeContext *s)
 667 {
 668     int bnd, i;
 669     int end, bndend;
 670
 671     end = FFMIN(s->end_freq[1], s->end_freq[2]);
 672
 673     for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) {
 674         if (s->rematrixing_flags[bnd]) {
 675             bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd + 1]);
 676             for (i = ff_ac3_rematrix_band_tab[bnd]; i < bndend; i++) {
 677                 int tmp0 = s->fixed_coeffs[1][i];
 678                 s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
 679                 s->fixed_coeffs[2][i]  = tmp0 - s->fixed_coeffs[2][i];
 680             }
 681         }
 682     }
 683 }
 684
 685 /**
 686  * Inverse MDCT Transform.
 687  * Convert frequency domain coefficients to time-domain audio samples.
 688  * reference: Section 7.9.4 Transformation Equations
 689  */
 690 static inline void do_imdct(AC3DecodeContext *s, int channels, int offset)
 691 {
 692     int ch;
 693
 694     for (ch = 1; ch <= channels; ch++) {
 695         if (s->block_switch[ch]) {
 696             int i;
 697             FFTSample *x = s->tmp_output + 128;
 698             for (i = 0; i < 128; i++)
 699                 x[i] = s->transform_coeffs[ch][2 * i];
 700             s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
 701 #if USE_FIXED
 702             s->fdsp->vector_fmul_window_scaled(s->outptr[ch - 1], s->delay[ch - 1 + offset],
 703                                        s->tmp_output, s->window, 128, 8);
 704 #else
 705             s->fdsp->vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1 + offset],
 706                                        s->tmp_output, s->window, 128);
 707 #endif
 708             for (i = 0; i < 128; i++)
 709                 x[i] = s->transform_coeffs[ch][2 * i + 1];
 710             s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch - 1 + offset], x);
 711         } else {
 712             s->imdct_512.imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
 713 #if USE_FIXED
 714             s->fdsp->vector_fmul_window_scaled(s->outptr[ch - 1], s->delay[ch - 1 + offset],
 715                                        s->tmp_output, s->window, 128, 8);
 716 #else
 717             s->fdsp->vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1 + offset],
 718                                        s->tmp_output, s->window, 128);
 719 #endif
 720             memcpy(s->delay[ch - 1 + offset], s->tmp_output + 128, 128 * sizeof(FFTSample));
 721         }
 722     }
 723 }
 724
 725 /**
 726  * Upmix delay samples from stereo to original channel layout.
 727  */
 728 static void ac3_upmix_delay(AC3DecodeContext *s)
 729 {
 730     int channel_data_size = sizeof(s->delay[0]);
 731     switch (s->channel_mode) {
 732     case AC3_CHMODE_DUALMONO:
 733     case AC3_CHMODE_STEREO:
 734         /* upmix mono to stereo */
 735         memcpy(s->delay[1], s->delay[0], channel_data_size);
 736         break;
 737     case AC3_CHMODE_2F2R:
 738         memset(s->delay[3], 0, channel_data_size);
 739     case AC3_CHMODE_2F1R:
 740         memset(s->delay[2], 0, channel_data_size);
 741         break;
 742     case AC3_CHMODE_3F2R:
 743         memset(s->delay[4], 0, channel_data_size);
 744     case AC3_CHMODE_3F1R:
 745         memset(s->delay[3], 0, channel_data_size);
 746     case AC3_CHMODE_3F:
 747         memcpy(s->delay[2], s->delay[1], channel_data_size);
 748         memset(s->delay[1], 0, channel_data_size);
 749         break;
 750     }
 751 }
 752
 753 /**
 754  * Decode band structure for coupling, spectral extension, or enhanced coupling.
 755  * The band structure defines how many subbands are in each band.  For each
 756  * subband in the range, 1 means it is combined with the previous band, and 0
 757  * means that it starts a new band.
 758  *
 759  * @param[in] gbc bit reader context
 760  * @param[in] blk block number
 761  * @param[in] eac3 flag to indicate E-AC-3
 762  * @param[in] ecpl flag to indicate enhanced coupling
 763  * @param[in] start_subband subband number for start of range
 764  * @param[in] end_subband subband number for end of range
 765  * @param[in] default_band_struct default band structure table
 766  * @param[out] num_bands number of bands (optionally NULL)
 767  * @param[out] band_sizes array containing the number of bins in each band (optionally NULL)
 768  * @param[in,out] band_struct current band structure
 769  */
 770 static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
 771                                   int ecpl, int start_subband, int end_subband,
 772                                   const uint8_t *default_band_struct,
 773                                   int *num_bands, uint8_t *band_sizes,
 774                                   uint8_t *band_struct, int band_struct_size)
 775 {
 776     int subbnd, bnd, n_subbands, n_bands=0;
 777     uint8_t bnd_sz[22];
 778
 779     n_subbands = end_subband - start_subband;
 780
 781     if (!blk)
 782         memcpy(band_struct, default_band_struct, band_struct_size);
 783
 784     av_assert0(band_struct_size >= start_subband + n_subbands);
 785
 786     band_struct += start_subband + 1;
 787
 788     /* decode band structure from bitstream or use default */
 789     if (!eac3 || get_bits1(gbc)) {
 790         for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
 791             band_struct[subbnd] = get_bits1(gbc);
 792         }
 793     }
 794
 795     /* calculate number of bands and band sizes based on band structure.
 796        note that the first 4 subbands in enhanced coupling span only 6 bins
 797        instead of 12. */
 798     if (num_bands || band_sizes ) {
 799         n_bands = n_subbands;
 800         bnd_sz[0] = ecpl ? 6 : 12;
 801         for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
 802             int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
 803             if (band_struct[subbnd - 1]) {
 804                 n_bands--;
 805                 bnd_sz[bnd] += subbnd_size;
 806             } else {
 807                 bnd_sz[++bnd] = subbnd_size;
 808             }
 809         }
 810     }
 811
 812     /* set optional output params */
 813     if (num_bands)
 814         *num_bands = n_bands;
 815     if (band_sizes)
 816         memcpy(band_sizes, bnd_sz, n_bands);
 817 }
 818
 819 static inline int spx_strategy(AC3DecodeContext *s, int blk)
 820 {
 821     GetBitContext *bc = &s->gbc;
 822     int fbw_channels = s->fbw_channels;
 823     int dst_start_freq, dst_end_freq, src_start_freq,
 824         start_subband, end_subband, ch;
 825
 826     /* determine which channels use spx */
 827     if (s->channel_mode == AC3_CHMODE_MONO) {
 828         s->channel_uses_spx[1] = 1;
 829     } else {
 830         for (ch = 1; ch <= fbw_channels; ch++)
 831             s->channel_uses_spx[ch] = get_bits1(bc);
 832     }
 833
 834     /* get the frequency bins of the spx copy region and the spx start
 835        and end subbands */
 836     dst_start_freq = get_bits(bc, 2);
 837     start_subband  = get_bits(bc, 3) + 2;
 838     if (start_subband > 7)
 839         start_subband += start_subband - 7;
 840     end_subband    = get_bits(bc, 3) + 5;
 841 #if USE_FIXED
 842     s->spx_dst_end_freq = end_freq_inv_tab[end_subband-5];
 843 #endif
 844     if (end_subband   > 7)
 845         end_subband   += end_subband   - 7;
 846     dst_start_freq = dst_start_freq * 12 + 25;
 847     src_start_freq = start_subband  * 12 + 25;
 848     dst_end_freq   = end_subband    * 12 + 25;
 849
 850     /* check validity of spx ranges */
 851     if (start_subband >= end_subband) {
 852         av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
 853                "range (%d >= %d)\n", start_subband, end_subband);
 854         return AVERROR_INVALIDDATA;
 855     }
 856     if (dst_start_freq >= src_start_freq) {
 857         av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
 858                "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
 859         return AVERROR_INVALIDDATA;
 860     }
 861
 862     s->spx_dst_start_freq = dst_start_freq;
 863     s->spx_src_start_freq = src_start_freq;
 864     if (!USE_FIXED)
 865         s->spx_dst_end_freq   = dst_end_freq;
 866
 867     decode_band_structure(bc, blk, s->eac3, 0,
 868                           start_subband, end_subband,
 869                           ff_eac3_default_spx_band_struct,
 870                           &s->num_spx_bands,
 871                           s->spx_band_sizes,
 872                           s->spx_band_struct, sizeof(s->spx_band_struct));
 873     return 0;
 874 }
 875
 876 static inline void spx_coordinates(AC3DecodeContext *s)
 877 {
 878     GetBitContext *bc = &s->gbc;
 879     int fbw_channels = s->fbw_channels;
 880     int ch, bnd;
 881
 882     for (ch = 1; ch <= fbw_channels; ch++) {
 883         if (s->channel_uses_spx[ch]) {
 884             if (s->first_spx_coords[ch] || get_bits1(bc)) {
 885                 INTFLOAT spx_blend;
 886                 int bin, master_spx_coord;
 887
 888                 s->first_spx_coords[ch] = 0;
 889                 spx_blend = AC3_SPX_BLEND(get_bits(bc, 5));
 890                 master_spx_coord = get_bits(bc, 2) * 3;
 891
 892                 bin = s->spx_src_start_freq;
 893                 for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
 894                     int bandsize = s->spx_band_sizes[bnd];
 895                     int spx_coord_exp, spx_coord_mant;
 896                     INTFLOAT nratio, sblend, nblend;
 897 #if USE_FIXED
 898                     /* calculate blending factors */
 899                     int64_t accu = ((bin << 23) + (bandsize << 22))
 900                                  * (int64_t)s->spx_dst_end_freq;
 901                     nratio = (int)(accu >> 32);
 902                     nratio -= spx_blend << 18;
 903
 904                     if (nratio < 0) {
 905                         nblend = 0;
 906                         sblend = 0x800000;
 907                     } else if (nratio > 0x7fffff) {
 908                         nblend = 14529495; // sqrt(3) in FP.23
 909                         sblend = 0;
 910                     } else {
 911                         nblend = fixed_sqrt(nratio, 23);
 912                         accu = (int64_t)nblend * 1859775393;
 913                         nblend = (int)((accu + (1<<29)) >> 30);
 914                         sblend = fixed_sqrt(0x800000 - nratio, 23);
 915                     }
 916 #else
 917                     float spx_coord;
 918
 919                     /* calculate blending factors */
 920                     nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
 921                     nratio = av_clipf(nratio, 0.0f, 1.0f);
 922                     nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
 923                                                    // to give unity variance
 924                     sblend = sqrtf(1.0f - nratio);
 925 #endif
 926                     bin += bandsize;
 927
 928                     /* decode spx coordinates */
 929                     spx_coord_exp  = get_bits(bc, 4);
 930                     spx_coord_mant = get_bits(bc, 2);
 931                     if (spx_coord_exp == 15) spx_coord_mant <<= 1;
 932                     else                     spx_coord_mant += 4;
 933                     spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
 934
 935                     /* multiply noise and signal blending factors by spx coordinate */
 936 #if USE_FIXED
 937                     accu = (int64_t)nblend * spx_coord_mant;
 938                     s->spx_noise_blend[ch][bnd]  = (int)((accu + (1<<22)) >> 23);
 939                     accu = (int64_t)sblend * spx_coord_mant;
 940                     s->spx_signal_blend[ch][bnd] = (int)((accu + (1<<22)) >> 23);
 941 #else
 942                     spx_coord = spx_coord_mant * (1.0f / (1 << 23));
 943                     s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
 944                     s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
 945 #endif
 946                 }
 947             }
 948         } else {
 949             s->first_spx_coords[ch] = 1;
 950         }
 951     }
 952 }
 953
 954 static inline int coupling_strategy(AC3DecodeContext *s, int blk,
 955                                     uint8_t *bit_alloc_stages)
 956 {
 957     GetBitContext *bc = &s->gbc;
 958     int fbw_channels = s->fbw_channels;
 959     int channel_mode = s->channel_mode;
 960     int ch;
 961
 962     memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
 963     if (!s->eac3)
 964         s->cpl_in_use[blk] = get_bits1(bc);
 965     if (s->cpl_in_use[blk]) {
 966         /* coupling in use */
 967         int cpl_start_subband, cpl_end_subband;
 968
 969         if (channel_mode < AC3_CHMODE_STEREO) {
 970             av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
 971             return AVERROR_INVALIDDATA;
 972         }
 973
 974         /* check for enhanced coupling */
 975         if (s->eac3 && get_bits1(bc)) {
 976             /* TODO: parse enhanced coupling strategy info */
 977             avpriv_request_sample(s->avctx, "Enhanced coupling");
 978             return AVERROR_PATCHWELCOME;
 979         }
 980
 981         /* determine which channels are coupled */
 982         if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
 983             s->channel_in_cpl[1] = 1;
 984             s->channel_in_cpl[2] = 1;
 985         } else {
 986             for (ch = 1; ch <= fbw_channels; ch++)
 987                 s->channel_in_cpl[ch] = get_bits1(bc);
 988         }
 989
 990         /* phase flags in use */
 991         if (channel_mode == AC3_CHMODE_STEREO)
 992             s->phase_flags_in_use = get_bits1(bc);
 993
 994         /* coupling frequency range */
 995         cpl_start_subband = get_bits(bc, 4);
 996         cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
 997                                           get_bits(bc, 4) + 3;
 998         if (cpl_start_subband >= cpl_end_subband) {
 999             av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
1000                    cpl_start_subband, cpl_end_subband);
1001             return AVERROR_INVALIDDATA;
1002         }
1003         s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
1004         s->end_freq[CPL_CH]   = cpl_end_subband   * 12 + 37;
1005
1006         decode_band_structure(bc, blk, s->eac3, 0, cpl_start_subband,
1007                               cpl_end_subband,
1008                               ff_eac3_default_cpl_band_struct,
1009                               &s->num_cpl_bands, s->cpl_band_sizes,
1010                               s->cpl_band_struct, sizeof(s->cpl_band_struct));
1011     } else {
1012         /* coupling not in use */
1013         for (ch = 1; ch <= fbw_channels; ch++) {
1014             s->channel_in_cpl[ch] = 0;
1015             s->first_cpl_coords[ch] = 1;
1016         }
1017         s->first_cpl_leak = s->eac3;
1018         s->phase_flags_in_use = 0;
1019     }
1020
1021     return 0;
1022 }
1023
1024 static inline int coupling_coordinates(AC3DecodeContext *s, int blk)
1025 {
1026     GetBitContext *bc = &s->gbc;
1027     int fbw_channels = s->fbw_channels;
1028     int ch, bnd;
1029     int cpl_coords_exist = 0;
1030
1031     for (ch = 1; ch <= fbw_channels; ch++) {
1032         if (s->channel_in_cpl[ch]) {
1033             if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(bc)) {
1034                 int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
1035                 s->first_cpl_coords[ch] = 0;
1036                 cpl_coords_exist = 1;
1037                 master_cpl_coord = 3 * get_bits(bc, 2);
1038                 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1039                     cpl_coord_exp  = get_bits(bc, 4);
1040                     cpl_coord_mant = get_bits(bc, 4);
1041                     if (cpl_coord_exp == 15)
1042                         s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
1043                     else
1044                         s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
1045                     s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
1046                 }
1047             } else if (!blk) {
1048                 av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
1049                        "be present in block 0\n");
1050                 return AVERROR_INVALIDDATA;
1051             }
1052         } else {
1053             /* channel not in coupling */
1054             s->first_cpl_coords[ch] = 1;
1055         }
1056     }
1057     /* phase flags */
1058     if (s->channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
1059         for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1060             s->phase_flags[bnd] = s->phase_flags_in_use ? get_bits1(bc) : 0;
1061         }
1062     }
1063
1064     return 0;
1065 }
1066
1067 /**
1068  * Decode a single audio block from the AC-3 bitstream.
1069  */
1070 static int decode_audio_block(AC3DecodeContext *s, int blk, int offset)
1071 {
1072     int fbw_channels = s->fbw_channels;
1073     int channel_mode = s->channel_mode;
1074     int i, bnd, seg, ch, ret;
1075     int different_transforms;
1076     int downmix_output;
1077     int cpl_in_use;
1078     GetBitContext *gbc = &s->gbc;
1079     uint8_t bit_alloc_stages[AC3_MAX_CHANNELS] = { 0 };
1080
1081     /* block switch flags */
1082     different_transforms = 0;
1083     if (s->block_switch_syntax) {
1084         for (ch = 1; ch <= fbw_channels; ch++) {
1085             s->block_switch[ch] = get_bits1(gbc);
1086             if (ch > 1 && s->block_switch[ch] != s->block_switch[1])
1087                 different_transforms = 1;
1088         }
1089     }
1090
1091     /* dithering flags */
1092     if (s->dither_flag_syntax) {
1093         for (ch = 1; ch <= fbw_channels; ch++) {
1094             s->dither_flag[ch] = get_bits1(gbc);
1095         }
1096     }
1097
1098     /* dynamic range */
1099     i = !s->channel_mode;
1100     do {
1101         if (get_bits1(gbc)) {
1102             /* Allow asymmetric application of DRC when drc_scale > 1.
1103                Amplification of quiet sounds is enhanced */
1104             int range_bits = get_bits(gbc, 8);
1105             INTFLOAT range = AC3_RANGE(range_bits);
1106             if (range_bits <= 127 || s->drc_scale <= 1.0)
1107                 s->dynamic_range[i] = AC3_DYNAMIC_RANGE(range);
1108             else
1109                 s->dynamic_range[i] = range;
1110         } else if (blk == 0) {
1111             s->dynamic_range[i] = AC3_DYNAMIC_RANGE1;
1112         }
1113     } while (i--);
1114
1115     /* spectral extension strategy */
1116     if (s->eac3 && (!blk || get_bits1(gbc))) {
1117         s->spx_in_use = get_bits1(gbc);
1118         if (s->spx_in_use) {
1119             if ((ret = spx_strategy(s, blk)) < 0)
1120                 return ret;
1121         }
1122     }
1123     if (!s->eac3 || !s->spx_in_use) {
1124         s->spx_in_use = 0;
1125         for (ch = 1; ch <= fbw_channels; ch++) {
1126             s->channel_uses_spx[ch] = 0;
1127             s->first_spx_coords[ch] = 1;
1128         }
1129     }
1130
1131     /* spectral extension coordinates */
1132     if (s->spx_in_use)
1133         spx_coordinates(s);
1134
1135     /* coupling strategy */
1136     if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
1137         if ((ret = coupling_strategy(s, blk, bit_alloc_stages)) < 0)
1138             return ret;
1139     } else if (!s->eac3) {
1140         if (!blk) {
1141             av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "
1142                    "be present in block 0\n");
1143             return AVERROR_INVALIDDATA;
1144         } else {
1145             s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
1146         }
1147     }
1148     cpl_in_use = s->cpl_in_use[blk];
1149
1150     /* coupling coordinates */
1151     if (cpl_in_use) {
1152         if ((ret = coupling_coordinates(s, blk)) < 0)
1153             return ret;
1154     }
1155
1156     /* stereo rematrixing strategy and band structure */
1157     if (channel_mode == AC3_CHMODE_STEREO) {
1158         if ((s->eac3 && !blk) || get_bits1(gbc)) {
1159             s->num_rematrixing_bands = 4;
1160             if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
1161                 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
1162             } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
1163                 s->num_rematrixing_bands--;
1164             }
1165             for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
1166                 s->rematrixing_flags[bnd] = get_bits1(gbc);
1167         } else if (!blk) {
1168             av_log(s->avctx, AV_LOG_WARNING, "Warning: "
1169                    "new rematrixing strategy not present in block 0\n");
1170             s->num_rematrixing_bands = 0;
1171         }
1172     }
1173
1174     /* exponent strategies for each channel */
1175     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1176         if (!s->eac3)
1177             s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
1178         if (s->exp_strategy[blk][ch] != EXP_REUSE)
1179             bit_alloc_stages[ch] = 3;
1180     }
1181
1182     /* channel bandwidth */
1183     for (ch = 1; ch <= fbw_channels; ch++) {
1184         s->start_freq[ch] = 0;
1185         if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1186             int group_size;
1187             int prev = s->end_freq[ch];
1188             if (s->channel_in_cpl[ch])
1189                 s->end_freq[ch] = s->start_freq[CPL_CH];
1190             else if (s->channel_uses_spx[ch])
1191                 s->end_freq[ch] = s->spx_src_start_freq;
1192             else {
1193                 int bandwidth_code = get_bits(gbc, 6);
1194                 if (bandwidth_code > 60) {
1195                     av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1196                     return AVERROR_INVALIDDATA;
1197                 }
1198                 s->end_freq[ch] = bandwidth_code * 3 + 73;
1199             }
1200             group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1201             s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
1202             if (blk > 0 && s->end_freq[ch] != prev)
1203                 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1204         }
1205     }
1206     if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1207         s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
1208                                     (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1209     }
1210
1211     /* decode exponents for each channel */
1212     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1213         if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1214             s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1215             if (decode_exponents(s, gbc, s->exp_strategy[blk][ch],
1216                                  s->num_exp_groups[ch], s->dexps[ch][0],
1217                                  &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1218                 return AVERROR_INVALIDDATA;
1219             }
1220             if (ch != CPL_CH && ch != s->lfe_ch)
1221                 skip_bits(gbc, 2); /* skip gainrng */
1222         }
1223     }
1224
1225     /* bit allocation information */
1226     if (s->bit_allocation_syntax) {
1227         if (get_bits1(gbc)) {
1228             s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1229             s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1230             s->bit_alloc_params.slow_gain  = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
1231             s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
1232             s->bit_alloc_params.floor  = ff_ac3_floor_tab[get_bits(gbc, 3)];
1233             for (ch = !cpl_in_use; ch <= s->channels; ch++)
1234                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1235         } else if (!blk) {
1236             av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must "
1237                    "be present in block 0\n");
1238             return AVERROR_INVALIDDATA;
1239         }
1240     }
1241
1242     /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1243     if (!s->eac3 || !blk) {
1244         if (s->snr_offset_strategy && get_bits1(gbc)) {
1245             int snr = 0;
1246             int csnr;
1247             csnr = (get_bits(gbc, 6) - 15) << 4;
1248             for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1249                 /* snr offset */
1250                 if (ch == i || s->snr_offset_strategy == 2)
1251                     snr = (csnr + get_bits(gbc, 4)) << 2;
1252                 /* run at least last bit allocation stage if snr offset changes */
1253                 if (blk && s->snr_offset[ch] != snr) {
1254                     bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1255                 }
1256                 s->snr_offset[ch] = snr;
1257
1258                 /* fast gain (normal AC-3 only) */
1259                 if (!s->eac3) {
1260                     int prev = s->fast_gain[ch];
1261                     s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1262                     /* run last 2 bit allocation stages if fast gain changes */
1263                     if (blk && prev != s->fast_gain[ch])
1264                         bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1265                 }
1266             }
1267         } else if (!s->eac3 && !blk) {
1268             av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1269             return AVERROR_INVALIDDATA;
1270         }
1271     }
1272
1273     /* fast gain (E-AC-3 only) */
1274     if (s->fast_gain_syntax && get_bits1(gbc)) {
1275         for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1276             int prev = s->fast_gain[ch];
1277             s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1278             /* run last 2 bit allocation stages if fast gain changes */
1279             if (blk && prev != s->fast_gain[ch])
1280                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1281         }
1282     } else if (s->eac3 && !blk) {
1283         for (ch = !cpl_in_use; ch <= s->channels; ch++)
1284             s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1285     }
1286
1287     /* E-AC-3 to AC-3 converter SNR offset */
1288     if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1289         skip_bits(gbc, 10); // skip converter snr offset
1290     }
1291
1292     /* coupling leak information */
1293     if (cpl_in_use) {
1294         if (s->first_cpl_leak || get_bits1(gbc)) {
1295             int fl = get_bits(gbc, 3);
1296             int sl = get_bits(gbc, 3);
1297             /* run last 2 bit allocation stages for coupling channel if
1298                coupling leak changes */
1299             if (blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1300                 sl != s->bit_alloc_params.cpl_slow_leak)) {
1301                 bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1302             }
1303             s->bit_alloc_params.cpl_fast_leak = fl;
1304             s->bit_alloc_params.cpl_slow_leak = sl;
1305         } else if (!s->eac3 && !blk) {
1306             av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must "
1307                    "be present in block 0\n");
1308             return AVERROR_INVALIDDATA;
1309         }
1310         s->first_cpl_leak = 0;
1311     }
1312
1313     /* delta bit allocation information */
1314     if (s->dba_syntax && get_bits1(gbc)) {
1315         /* delta bit allocation exists (strategy) */
1316         for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1317             s->dba_mode[ch] = get_bits(gbc, 2);
1318             if (s->dba_mode[ch] == DBA_RESERVED) {
1319                 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1320                 return AVERROR_INVALIDDATA;
1321             }
1322             bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1323         }
1324         /* channel delta offset, len and bit allocation */
1325         for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1326             if (s->dba_mode[ch] == DBA_NEW) {
1327                 s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;
1328                 for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
1329                     s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1330                     s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1331                     s->dba_values[ch][seg]  = get_bits(gbc, 3);
1332                 }
1333                 /* run last 2 bit allocation stages if new dba values */
1334                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1335             }
1336         }
1337     } else if (blk == 0) {
1338         for (ch = 0; ch <= s->channels; ch++) {
1339             s->dba_mode[ch] = DBA_NONE;
1340         }
1341     }
1342
1343     /* Bit allocation */
1344     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1345         if (bit_alloc_stages[ch] > 2) {
1346             /* Exponent mapping into PSD and PSD integration */
1347             ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
1348                                       s->start_freq[ch], s->end_freq[ch],
1349                                       s->psd[ch], s->band_psd[ch]);
1350         }
1351         if (bit_alloc_stages[ch] > 1) {
1352             /* Compute excitation function, Compute masking curve, and
1353                Apply delta bit allocation */
1354             if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1355                                            s->start_freq[ch],  s->end_freq[ch],
1356                                            s->fast_gain[ch],   (ch == s->lfe_ch),
1357                                            s->dba_mode[ch],    s->dba_nsegs[ch],
1358                                            s->dba_offsets[ch], s->dba_lengths[ch],
1359                                            s->dba_values[ch],  s->mask[ch])) {
1360                 av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1361                 return AVERROR_INVALIDDATA;
1362             }
1363         }
1364         if (bit_alloc_stages[ch] > 0) {
1365             /* Compute bit allocation */
1366             const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1367                                      ff_eac3_hebap_tab : ff_ac3_bap_tab;
1368             s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1369                                       s->start_freq[ch], s->end_freq[ch],
1370                                       s->snr_offset[ch],
1371                                       s->bit_alloc_params.floor,
1372                                       bap_tab, s->bap[ch]);
1373         }
1374     }
1375
1376     /* unused dummy data */
1377     if (s->skip_syntax && get_bits1(gbc)) {
1378         int skipl = get_bits(gbc, 9);
1379         skip_bits_long(gbc, 8 * skipl);
1380     }
1381
1382     /* unpack the transform coefficients
1383        this also uncouples channels if coupling is in use. */
1384     decode_transform_coeffs(s, blk);
1385
1386     /* TODO: generate enhanced coupling coordinates and uncouple */
1387
1388     /* recover coefficients if rematrixing is in use */
1389     if (s->channel_mode == AC3_CHMODE_STEREO)
1390         do_rematrixing(s);
1391
1392     /* apply scaling to coefficients (headroom, dynrng) */
1393     for (ch = 1; ch <= s->channels; ch++) {
1394         int audio_channel = 0;
1395         INTFLOAT gain;
1396         if (s->channel_mode == AC3_CHMODE_DUALMONO && ch <= 2)
1397             audio_channel = 2-ch;
1398         if (s->heavy_compression && s->compression_exists[audio_channel])
1399             gain = s->heavy_dynamic_range[audio_channel];
1400         else
1401             gain = s->dynamic_range[audio_channel];
1402
1403 #if USE_FIXED
1404         scale_coefs(s->transform_coeffs[ch], s->fixed_coeffs[ch], gain, 256);
1405 #else
1406         if (s->target_level != 0)
1407           gain = gain * s->level_gain[audio_channel];
1408         gain *= 1.0 / 4194304.0f;
1409         s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch],
1410                                                s->fixed_coeffs[ch], gain, 256);
1411 #endif
1412     }
1413
1414     /* apply spectral extension to high frequency bins */
1415     if (CONFIG_EAC3_DECODER && s->spx_in_use) {
1416         ff_eac3_apply_spectral_extension(s);
1417     }
1418
1419     /* downmix and MDCT. order depends on whether block switching is used for
1420        any channel in this block. this is because coefficients for the long
1421        and short transforms cannot be mixed. */
1422     downmix_output = s->channels != s->out_channels &&
1423                      !((s->output_mode & AC3_OUTPUT_LFEON) &&
1424                      s->fbw_channels == s->out_channels);
1425     if (different_transforms) {
1426         /* the delay samples have already been downmixed, so we upmix the delay
1427            samples in order to reconstruct all channels before downmixing. */
1428         if (s->downmixed) {
1429             s->downmixed = 0;
1430             ac3_upmix_delay(s);
1431         }
1432
1433         do_imdct(s, s->channels, offset);
1434
1435         if (downmix_output) {
1436 #if USE_FIXED
1437             ac3_downmix_c_fixed16(s->outptr, s->downmix_coeffs,
1438                               s->out_channels, s->fbw_channels, 256);
1439 #else
1440             ff_ac3dsp_downmix(&s->ac3dsp, s->outptr, s->downmix_coeffs,
1441                               s->out_channels, s->fbw_channels, 256);
1442 #endif
1443         }
1444     } else {
1445         if (downmix_output) {
1446             AC3_RENAME(ff_ac3dsp_downmix)(&s->ac3dsp, s->xcfptr + 1, s->downmix_coeffs,
1447                                           s->out_channels, s->fbw_channels, 256);
1448         }
1449
1450         if (downmix_output && !s->downmixed) {
1451             s->downmixed = 1;
1452             AC3_RENAME(ff_ac3dsp_downmix)(&s->ac3dsp, s->dlyptr, s->downmix_coeffs,
1453                                           s->out_channels, s->fbw_channels, 128);
1454         }
1455
1456         do_imdct(s, s->out_channels, offset);
1457     }
1458
1459     return 0;
1460 }
1461
1462 /**
1463  * Decode a single AC-3 frame.
1464  */
1465 static int ac3_decode_frame(AVCodecContext * avctx, void *data,
1466                             int *got_frame_ptr, AVPacket *avpkt)
1467 {
1468     AVFrame *frame     = data;
1469     const uint8_t *buf = avpkt->data;
1470     int buf_size, full_buf_size = avpkt->size;
1471     AC3DecodeContext *s = avctx->priv_data;
1472     int blk, ch, err, offset, ret;
1473     int i;
1474     int skip = 0, got_independent_frame = 0;
1475     const uint8_t *channel_map;
1476     uint8_t extended_channel_map[EAC3_MAX_CHANNELS];
1477     const SHORTFLOAT *output[AC3_MAX_CHANNELS];
1478     enum AVMatrixEncoding matrix_encoding;
1479     AVDownmixInfo *downmix_info;
1480
1481     s->superframe_size = 0;
1482
1483     buf_size = full_buf_size;
1484     for (i = 1; i < buf_size; i += 2) {
1485         if (buf[i] == 0x77 || buf[i] == 0x0B) {
1486             if ((buf[i] ^ buf[i-1]) == (0x77 ^ 0x0B)) {
1487                 i--;
1488                 break;
1489             } else if ((buf[i] ^ buf[i+1]) == (0x77 ^ 0x0B)) {
1490                 break;
1491             }
1492         }
1493     }
1494     if (i >= buf_size)
1495         return AVERROR_INVALIDDATA;
1496     if (i > 10)
1497         return i;
1498     buf += i;
1499     buf_size -= i;
1500
1501     /* copy input buffer to decoder context to avoid reading past the end
1502        of the buffer, which can be caused by a damaged input stream. */
1503     if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
1504         // seems to be byte-swapped AC-3
1505         int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1506         s->bdsp.bswap16_buf((uint16_t *) s->input_buffer,
1507                             (const uint16_t *) buf, cnt);
1508     } else
1509         memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1510
1511     /* if consistent noise generation is enabled, seed the linear feedback generator
1512      * with the contents of the AC-3 frame so that the noise is identical across
1513      * decodes given the same AC-3 frame data, for use with non-linear edititing software. */
1514     if (s->consistent_noise_generation)
1515         av_lfg_init_from_data(&s->dith_state, s->input_buffer, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1516
1517     buf = s->input_buffer;
1518 dependent_frame:
1519     /* initialize the GetBitContext with the start of valid AC-3 Frame */
1520     if ((ret = init_get_bits8(&s->gbc, buf, buf_size)) < 0)
1521         return ret;
1522
1523     /* parse the syncinfo */
1524     err = parse_frame_header(s);
1525
1526     if (err) {
1527         switch (err) {
1528         case AAC_AC3_PARSE_ERROR_SYNC:
1529             av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1530             return AVERROR_INVALIDDATA;
1531         case AAC_AC3_PARSE_ERROR_BSID:
1532             av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1533             break;
1534         case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
1535             av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1536             break;
1537         case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
1538             av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1539             break;
1540         case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
1541             /* skip frame if CRC is ok. otherwise use error concealment. */
1542             /* TODO: add support for substreams */
1543             if (s->substreamid) {
1544                 av_log(avctx, AV_LOG_DEBUG,
1545                        "unsupported substream %d: skipping frame\n",
1546                        s->substreamid);
1547                 *got_frame_ptr = 0;
1548                 return buf_size;
1549             } else {
1550                 av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1551             }
1552             break;
1553         case AAC_AC3_PARSE_ERROR_CRC:
1554         case AAC_AC3_PARSE_ERROR_CHANNEL_CFG:
1555             break;
1556         default: // Normal AVERROR do not try to recover.
1557             *got_frame_ptr = 0;
1558             return err;
1559         }
1560     } else {
1561         /* check that reported frame size fits in input buffer */
1562         if (s->frame_size > buf_size) {
1563             av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1564             err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
1565         } else if (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL)) {
1566             /* check for crc mismatch */
1567             if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
1568                        s->frame_size - 2)) {
1569                 av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1570                 if (avctx->err_recognition & AV_EF_EXPLODE)
1571                     return AVERROR_INVALIDDATA;
1572                 err = AAC_AC3_PARSE_ERROR_CRC;
1573             }
1574         }
1575     }
1576
1577     if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT && !got_independent_frame) {
1578         av_log(avctx, AV_LOG_WARNING, "Ignoring dependent frame without independent frame.\n");
1579         *got_frame_ptr = 0;
1580         return FFMIN(full_buf_size, s->frame_size);
1581     }
1582
1583     /* channel config */
1584     if (!err || (s->channels && s->out_channels != s->channels)) {
1585         s->out_channels = s->channels;
1586         s->output_mode  = s->channel_mode;
1587         if (s->lfe_on)
1588             s->output_mode |= AC3_OUTPUT_LFEON;
1589         if (s->channels > 1 &&
1590             avctx->request_channel_layout == AV_CH_LAYOUT_MONO) {
1591             s->out_channels = 1;
1592             s->output_mode  = AC3_CHMODE_MONO;
1593         } else if (s->channels > 2 &&
1594                    avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
1595             s->out_channels = 2;
1596             s->output_mode  = AC3_CHMODE_STEREO;
1597         }
1598
1599         s->loro_center_mix_level   = gain_levels[s->  center_mix_level];
1600         s->loro_surround_mix_level = gain_levels[s->surround_mix_level];
1601         s->ltrt_center_mix_level   = LEVEL_MINUS_3DB;
1602         s->ltrt_surround_mix_level = LEVEL_MINUS_3DB;
1603         /* set downmixing coefficients if needed */
1604         if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1605                 s->fbw_channels == s->out_channels)) {
1606             if ((ret = set_downmix_coeffs(s)) < 0) {
1607                 av_log(avctx, AV_LOG_ERROR, "error setting downmix coeffs\n");
1608                 return ret;
1609             }
1610         }
1611     } else if (!s->channels) {
1612         av_log(avctx, AV_LOG_ERROR, "unable to determine channel mode\n");
1613         return AVERROR_INVALIDDATA;
1614     }
1615     avctx->channels = s->out_channels;
1616     avctx->channel_layout = avpriv_ac3_channel_layout_tab[s->output_mode & ~AC3_OUTPUT_LFEON];
1617     if (s->output_mode & AC3_OUTPUT_LFEON)
1618         avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1619
1620     /* set audio service type based on bitstream mode for AC-3 */
1621     avctx->audio_service_type = s->bitstream_mode;
1622     if (s->bitstream_mode == 0x7 && s->channels > 1)
1623         avctx->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
1624
1625     /* decode the audio blocks */
1626     channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1627     offset = s->frame_type == EAC3_FRAME_TYPE_DEPENDENT ? AC3_MAX_CHANNELS : 0;
1628     for (ch = 0; ch < AC3_MAX_CHANNELS; ch++) {
1629         output[ch] = s->output[ch + offset];
1630         s->outptr[ch] = s->output[ch + offset];
1631     }
1632     for (ch = 0; ch < s->channels; ch++) {
1633         if (ch < s->out_channels)
1634             s->outptr[channel_map[ch]] = s->output_buffer[ch + offset];
1635     }
1636     for (blk = 0; blk < s->num_blocks; blk++) {
1637         if (!err && decode_audio_block(s, blk, offset)) {
1638             av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1639             err = 1;
1640         }
1641         if (err)
1642             for (ch = 0; ch < s->out_channels; ch++)
1643                 memcpy(s->output_buffer[ch + offset] + AC3_BLOCK_SIZE*blk, output[ch], AC3_BLOCK_SIZE*sizeof(SHORTFLOAT));
1644         for (ch = 0; ch < s->out_channels; ch++)
1645             output[ch] = s->outptr[channel_map[ch]];
1646         for (ch = 0; ch < s->out_channels; ch++) {
1647             if (!ch || channel_map[ch])
1648                 s->outptr[channel_map[ch]] += AC3_BLOCK_SIZE;
1649         }
1650     }
1651
1652     /* keep last block for error concealment in next frame */
1653     for (ch = 0; ch < s->out_channels; ch++)
1654         memcpy(s->output[ch + offset], output[ch], AC3_BLOCK_SIZE*sizeof(SHORTFLOAT));
1655
1656     /* check if there is dependent frame */
1657     if (buf_size > s->frame_size) {
1658         AC3HeaderInfo hdr;
1659         int err;
1660
1661         if (buf_size - s->frame_size <= 16) {
1662             skip = buf_size - s->frame_size;
1663             goto skip;
1664         }
1665
1666         if ((ret = init_get_bits8(&s->gbc, buf + s->frame_size, buf_size - s->frame_size)) < 0)
1667             return ret;
1668
1669         err = ff_ac3_parse_header(&s->gbc, &hdr);
1670         if (err)
1671             return err;
1672
1673         if (hdr.frame_type == EAC3_FRAME_TYPE_DEPENDENT) {
1674             if (hdr.num_blocks != s->num_blocks || s->sample_rate != hdr.sample_rate) {
1675                 av_log(avctx, AV_LOG_WARNING, "Ignoring non-compatible dependent frame.\n");
1676             } else {
1677                 buf += s->frame_size;
1678                 buf_size -= s->frame_size;
1679                 s->prev_output_mode = s->output_mode;
1680                 s->prev_bit_rate = s->bit_rate;
1681                 got_independent_frame = 1;
1682                 goto dependent_frame;
1683             }
1684         }
1685     }
1686 skip:
1687
1688     frame->decode_error_flags = err ? FF_DECODE_ERROR_INVALID_BITSTREAM : 0;
1689
1690     /* if frame is ok, set audio parameters */
1691     if (!err) {
1692         avctx->sample_rate = s->sample_rate;
1693         avctx->bit_rate    = s->bit_rate + s->prev_bit_rate;
1694     }
1695
1696     for (ch = 0; ch < EAC3_MAX_CHANNELS; ch++)
1697         extended_channel_map[ch] = ch;
1698
1699     if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT) {
1700         uint64_t ich_layout = avpriv_ac3_channel_layout_tab[s->prev_output_mode & ~AC3_OUTPUT_LFEON];
1701         int channel_map_size = ff_ac3_channels_tab[s->output_mode & ~AC3_OUTPUT_LFEON] + s->lfe_on;
1702         uint64_t channel_layout;
1703         int extend = 0;
1704
1705         if (s->prev_output_mode & AC3_OUTPUT_LFEON)
1706             ich_layout |= AV_CH_LOW_FREQUENCY;
1707
1708         channel_layout = ich_layout;
1709         for (ch = 0; ch < 16; ch++) {
1710             if (s->channel_map & (1 << (EAC3_MAX_CHANNELS - ch - 1))) {
1711                 channel_layout |= ff_eac3_custom_channel_map_locations[ch][1];
1712             }
1713         }
1714         if (av_get_channel_layout_nb_channels(channel_layout) > EAC3_MAX_CHANNELS) {
1715             av_log(avctx, AV_LOG_ERROR, "Too many channels (%d) coded\n",
1716                    av_get_channel_layout_nb_channels(channel_layout));
1717             return AVERROR_INVALIDDATA;
1718         }
1719
1720         avctx->channel_layout = channel_layout;
1721         avctx->channels = av_get_channel_layout_nb_channels(channel_layout);
1722
1723         for (ch = 0; ch < EAC3_MAX_CHANNELS; ch++) {
1724             if (s->channel_map & (1 << (EAC3_MAX_CHANNELS - ch - 1))) {
1725                 if (ff_eac3_custom_channel_map_locations[ch][0]) {
1726                     int index = av_get_channel_layout_channel_index(channel_layout,
1727                                                                     ff_eac3_custom_channel_map_locations[ch][1]);
1728                     if (index < 0)
1729                         return AVERROR_INVALIDDATA;
1730                     if (extend >= channel_map_size)
1731                         return AVERROR_INVALIDDATA;
1732
1733                     extended_channel_map[index] = offset + channel_map[extend++];
1734                 } else {
1735                     int i;
1736
1737                     for (i = 0; i < 64; i++) {
1738                         if ((1ULL << i) & ff_eac3_custom_channel_map_locations[ch][1]) {
1739                             int index = av_get_channel_layout_channel_index(channel_layout,
1740                                                                             1ULL << i);
1741                             if (index < 0)
1742                                 return AVERROR_INVALIDDATA;
1743                             if (extend >= channel_map_size)
1744                                 return AVERROR_INVALIDDATA;
1745
1746                             extended_channel_map[index] = offset + channel_map[extend++];
1747                         }
1748                     }
1749                 }
1750             }
1751         }
1752     }
1753
1754     /* get output buffer */
1755     frame->nb_samples = s->num_blocks * AC3_BLOCK_SIZE;
1756     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1757         return ret;
1758
1759     for (ch = 0; ch < avctx->channels; ch++) {
1760         int map = extended_channel_map[ch];
1761         av_assert0(ch>=AV_NUM_DATA_POINTERS || frame->extended_data[ch] == frame->data[ch]);
1762         memcpy((SHORTFLOAT *)frame->extended_data[ch],
1763                s->output_buffer[map],
1764                s->num_blocks * AC3_BLOCK_SIZE * sizeof(SHORTFLOAT));
1765     }
1766
1767     /*
1768      * AVMatrixEncoding
1769      *
1770      * Check whether the input layout is compatible, and make sure we're not
1771      * downmixing (else the matrix encoding is no longer applicable).
1772      */
1773     matrix_encoding = AV_MATRIX_ENCODING_NONE;
1774     if (s->channel_mode == AC3_CHMODE_STEREO &&
1775         s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1776         if (s->dolby_surround_mode == AC3_DSURMOD_ON)
1777             matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
1778         else if (s->dolby_headphone_mode == AC3_DHEADPHONMOD_ON)
1779             matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;
1780     } else if (s->channel_mode >= AC3_CHMODE_2F2R &&
1781                s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1782         switch (s->dolby_surround_ex_mode) {
1783         case AC3_DSUREXMOD_ON: // EX or PLIIx
1784             matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
1785             break;
1786         case AC3_DSUREXMOD_PLIIZ:
1787             matrix_encoding = AV_MATRIX_ENCODING_DPLIIZ;
1788             break;
1789         default: // not indicated or off
1790             break;
1791         }
1792     }
1793     if ((ret = ff_side_data_update_matrix_encoding(frame, matrix_encoding)) < 0)
1794         return ret;
1795
1796     /* AVDownmixInfo */
1797     if ((downmix_info = av_downmix_info_update_side_data(frame))) {
1798         switch (s->preferred_downmix) {
1799         case AC3_DMIXMOD_LTRT:
1800             downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_LTRT;
1801             break;
1802         case AC3_DMIXMOD_LORO:
1803             downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_LORO;
1804             break;
1805         case AC3_DMIXMOD_DPLII:
1806             downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_DPLII;
1807             break;
1808         default:
1809             downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_UNKNOWN;
1810             break;
1811         }
1812         downmix_info->center_mix_level        = gain_levels[s->       center_mix_level];
1813         downmix_info->center_mix_level_ltrt   = gain_levels[s->  center_mix_level_ltrt];
1814         downmix_info->surround_mix_level      = gain_levels[s->     surround_mix_level];
1815         downmix_info->surround_mix_level_ltrt = gain_levels[s->surround_mix_level_ltrt];
1816         if (s->lfe_mix_level_exists)
1817             downmix_info->lfe_mix_level       = gain_levels_lfe[s->lfe_mix_level];
1818         else
1819             downmix_info->lfe_mix_level       = 0.0; // -inf dB
1820     } else
1821         return AVERROR(ENOMEM);
1822
1823     *got_frame_ptr = 1;
1824
1825     if (!s->superframe_size)
1826         return FFMIN(full_buf_size, s->frame_size + skip);
1827
1828     return FFMIN(full_buf_size, s->superframe_size + skip);
1829 }
1830
1831 /**
1832  * Uninitialize the AC-3 decoder.
1833  */
1834 static av_cold int ac3_decode_end(AVCodecContext *avctx)
1835 {
1836     AC3DecodeContext *s = avctx->priv_data;
1837     ff_mdct_end(&s->imdct_512);
1838     ff_mdct_end(&s->imdct_256);
1839     av_freep(&s->fdsp);
1840     av_freep(&s->downmix_coeffs[0]);
1841
1842     return 0;
1843 }
1844
1845 #define OFFSET(x) offsetof(AC3DecodeContext, x)
1846 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)