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