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