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