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