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