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