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         }
 899     }
 900     if (!s->eac3 || !s->spx_in_use) {
 901         s->spx_in_use = 0;
 902         for (ch = 1; ch <= fbw_channels; ch++) {
 903             s->channel_uses_spx[ch] = 0;
 904             s->first_spx_coords[ch] = 1;
 905         }
 906     }
 907
 908     /* spectral extension coordinates */
 909     if (s->spx_in_use) {
 910         for (ch = 1; ch <= fbw_channels; ch++) {
 911             if (s->channel_uses_spx[ch]) {
 912                 if (s->first_spx_coords[ch] || get_bits1(gbc)) {
 913                     INTFLOAT spx_blend;
 914                     int bin, master_spx_coord;
 915
 916                     s->first_spx_coords[ch] = 0;
 917                     spx_blend = AC3_SPX_BLEND(get_bits(gbc, 5));
 918                     master_spx_coord = get_bits(gbc, 2) * 3;
 919
 920                     bin = s->spx_src_start_freq;
 921                     for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
 922                         int bandsize = s->spx_band_sizes[bnd];
 923                         int spx_coord_exp, spx_coord_mant;
 924                         INTFLOAT nratio, sblend, nblend;
 925 #if USE_FIXED
 926                         /* calculate blending factors */
 927                         int64_t accu = ((bin << 23) + (bandsize << 22))
 928                                      * (int64_t)s->spx_dst_end_freq;
 929                         nratio = (int)(accu >> 32);
 930                         nratio -= spx_blend << 18;
 931
 932                         if (nratio < 0) {
 933                             nblend = 0;
 934                             sblend = 0x800000;
 935                         } else if (nratio > 0x7fffff) {
 936                             nblend = 14529495; // sqrt(3) in FP.23
 937                             sblend = 0;
 938                         } else {
 939                             nblend = fixed_sqrt(nratio, 23);
 940                             accu = (int64_t)nblend * 1859775393;
 941                             nblend = (int)((accu + (1<<29)) >> 30);
 942                             sblend = fixed_sqrt(0x800000 - nratio, 23);
 943                         }
 944 #else
 945                         float spx_coord;
 946
 947                         /* calculate blending factors */
 948                         nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
 949                         nratio = av_clipf(nratio, 0.0f, 1.0f);
 950                         nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
 951                                                        // to give unity variance
 952                         sblend = sqrtf(1.0f - nratio);
 953 #endif
 954                         bin += bandsize;
 955
 956                         /* decode spx coordinates */
 957                         spx_coord_exp  = get_bits(gbc, 4);
 958                         spx_coord_mant = get_bits(gbc, 2);
 959                         if (spx_coord_exp == 15) spx_coord_mant <<= 1;
 960                         else                     spx_coord_mant += 4;
 961                         spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
 962
 963                         /* multiply noise and signal blending factors by spx coordinate */
 964 #if USE_FIXED
 965                         accu = (int64_t)nblend * spx_coord_mant;
 966                         s->spx_noise_blend[ch][bnd]  = (int)((accu + (1<<22)) >> 23);
 967                         accu = (int64_t)sblend * spx_coord_mant;
 968                         s->spx_signal_blend[ch][bnd] = (int)((accu + (1<<22)) >> 23);
 969 #else
 970                         spx_coord = spx_coord_mant * (1.0f / (1 << 23));
 971                         s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
 972                         s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
 973 #endif
 974                     }
 975                 }
 976             } else {
 977                 s->first_spx_coords[ch] = 1;
 978             }
 979         }
 980     }
 981
 982     /* coupling strategy */
 983     if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
 984         memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
 985         if (!s->eac3)
 986             s->cpl_in_use[blk] = get_bits1(gbc);
 987         if (s->cpl_in_use[blk]) {
 988             /* coupling in use */
 989             int cpl_start_subband, cpl_end_subband;
 990
 991             if (channel_mode < AC3_CHMODE_STEREO) {
 992                 av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
 993                 return AVERROR_INVALIDDATA;
 994             }
 995
 996             /* check for enhanced coupling */
 997             if (s->eac3 && get_bits1(gbc)) {
 998                 /* TODO: parse enhanced coupling strategy info */
 999                 avpriv_request_sample(s->avctx, "Enhanced coupling");
1000                 return AVERROR_PATCHWELCOME;
1001             }
1002
1003             /* determine which channels are coupled */
1004             if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
1005                 s->channel_in_cpl[1] = 1;
1006                 s->channel_in_cpl[2] = 1;
1007             } else {
1008                 for (ch = 1; ch <= fbw_channels; ch++)
1009                     s->channel_in_cpl[ch] = get_bits1(gbc);
1010             }
1011
1012             /* phase flags in use */
1013             if (channel_mode == AC3_CHMODE_STEREO)
1014                 s->phase_flags_in_use = get_bits1(gbc);
1015
1016             /* coupling frequency range */
1017             cpl_start_subband = get_bits(gbc, 4);
1018             cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
1019                                               get_bits(gbc, 4) + 3;
1020             if (cpl_start_subband >= cpl_end_subband) {
1021                 av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
1022                        cpl_start_subband, cpl_end_subband);
1023                 return AVERROR_INVALIDDATA;
1024             }
1025             s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
1026             s->end_freq[CPL_CH]   = cpl_end_subband   * 12 + 37;
1027
1028             decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
1029                                   cpl_end_subband,
1030                                   ff_eac3_default_cpl_band_struct,
1031                                   &s->num_cpl_bands, s->cpl_band_sizes);
1032         } else {
1033             /* coupling not in use */
1034             for (ch = 1; ch <= fbw_channels; ch++) {
1035                 s->channel_in_cpl[ch] = 0;
1036                 s->first_cpl_coords[ch] = 1;
1037             }
1038             s->first_cpl_leak = s->eac3;
1039             s->phase_flags_in_use = 0;
1040         }
1041     } else if (!s->eac3) {
1042         if (!blk) {
1043             av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "
1044                    "be present in block 0\n");
1045             return AVERROR_INVALIDDATA;
1046         } else {
1047             s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
1048         }
1049     }
1050     cpl_in_use = s->cpl_in_use[blk];
1051
1052     /* coupling coordinates */
1053     if (cpl_in_use) {
1054         int cpl_coords_exist = 0;
1055
1056         for (ch = 1; ch <= fbw_channels; ch++) {
1057             if (s->channel_in_cpl[ch]) {
1058                 if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
1059                     int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
1060                     s->first_cpl_coords[ch] = 0;
1061                     cpl_coords_exist = 1;
1062                     master_cpl_coord = 3 * get_bits(gbc, 2);
1063                     for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1064                         cpl_coord_exp = get_bits(gbc, 4);
1065                         cpl_coord_mant = get_bits(gbc, 4);
1066                         if (cpl_coord_exp == 15)
1067                             s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
1068                         else
1069                             s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
1070                         s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
1071                     }
1072                 } else if (!blk) {
1073                     av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
1074                            "be present in block 0\n");
1075                     return AVERROR_INVALIDDATA;
1076                 }
1077             } else {
1078                 /* channel not in coupling */
1079                 s->first_cpl_coords[ch] = 1;
1080             }
1081         }
1082         /* phase flags */
1083         if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
1084             for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1085                 s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
1086             }
1087         }
1088     }
1089
1090     /* stereo rematrixing strategy and band structure */
1091     if (channel_mode == AC3_CHMODE_STEREO) {
1092         if ((s->eac3 && !blk) || get_bits1(gbc)) {
1093             s->num_rematrixing_bands = 4;
1094             if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
1095                 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
1096             } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
1097                 s->num_rematrixing_bands--;
1098             }
1099             for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
1100                 s->rematrixing_flags[bnd] = get_bits1(gbc);
1101         } else if (!blk) {
1102             av_log(s->avctx, AV_LOG_WARNING, "Warning: "
1103                    "new rematrixing strategy not present in block 0\n");
1104             s->num_rematrixing_bands = 0;
1105         }
1106     }
1107
1108     /* exponent strategies for each channel */
1109     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1110         if (!s->eac3)
1111             s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
1112         if (s->exp_strategy[blk][ch] != EXP_REUSE)
1113             bit_alloc_stages[ch] = 3;
1114     }
1115
1116     /* channel bandwidth */
1117     for (ch = 1; ch <= fbw_channels; ch++) {
1118         s->start_freq[ch] = 0;
1119         if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1120             int group_size;
1121             int prev = s->end_freq[ch];
1122             if (s->channel_in_cpl[ch])
1123                 s->end_freq[ch] = s->start_freq[CPL_CH];
1124             else if (s->channel_uses_spx[ch])
1125                 s->end_freq[ch] = s->spx_src_start_freq;
1126             else {
1127                 int bandwidth_code = get_bits(gbc, 6);
1128                 if (bandwidth_code > 60) {
1129                     av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1130                     return AVERROR_INVALIDDATA;
1131                 }
1132                 s->end_freq[ch] = bandwidth_code * 3 + 73;
1133             }
1134             group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1135             s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
1136             if (blk > 0 && s->end_freq[ch] != prev)
1137                 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1138         }
1139     }
1140     if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1141         s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
1142                                     (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1143     }
1144
1145     /* decode exponents for each channel */
1146     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1147         if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1148             s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1149             if (decode_exponents(s, gbc, s->exp_strategy[blk][ch],
1150                                  s->num_exp_groups[ch], s->dexps[ch][0],
1151                                  &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1152                 return AVERROR_INVALIDDATA;
1153             }
1154             if (ch != CPL_CH && ch != s->lfe_ch)
1155                 skip_bits(gbc, 2); /* skip gainrng */
1156         }
1157     }
1158
1159     /* bit allocation information */
1160     if (s->bit_allocation_syntax) {
1161         if (get_bits1(gbc)) {
1162             s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1163             s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1164             s->bit_alloc_params.slow_gain  = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
1165             s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
1166             s->bit_alloc_params.floor  = ff_ac3_floor_tab[get_bits(gbc, 3)];
1167             for (ch = !cpl_in_use; ch <= s->channels; ch++)
1168                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1169         } else if (!blk) {
1170             av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must "
1171                    "be present in block 0\n");
1172             return AVERROR_INVALIDDATA;
1173         }
1174     }
1175
1176     /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1177     if (!s->eac3 || !blk) {
1178         if (s->snr_offset_strategy && get_bits1(gbc)) {
1179             int snr = 0;
1180             int csnr;
1181             csnr = (get_bits(gbc, 6) - 15) << 4;
1182             for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1183                 /* snr offset */
1184                 if (ch == i || s->snr_offset_strategy == 2)
1185                     snr = (csnr + get_bits(gbc, 4)) << 2;
1186                 /* run at least last bit allocation stage if snr offset changes */
1187                 if (blk && s->snr_offset[ch] != snr) {
1188                     bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1189                 }
1190                 s->snr_offset[ch] = snr;
1191
1192                 /* fast gain (normal AC-3 only) */
1193                 if (!s->eac3) {
1194                     int prev = s->fast_gain[ch];
1195                     s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1196                     /* run last 2 bit allocation stages if fast gain changes */
1197                     if (blk && prev != s->fast_gain[ch])
1198                         bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1199                 }
1200             }
1201         } else if (!s->eac3 && !blk) {
1202             av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1203             return AVERROR_INVALIDDATA;
1204         }
1205     }
1206
1207     /* fast gain (E-AC-3 only) */
1208     if (s->fast_gain_syntax && get_bits1(gbc)) {
1209         for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1210             int prev = s->fast_gain[ch];
1211             s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1212             /* run last 2 bit allocation stages if fast gain changes */
1213             if (blk && prev != s->fast_gain[ch])
1214                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1215         }
1216     } else if (s->eac3 && !blk) {
1217         for (ch = !cpl_in_use; ch <= s->channels; ch++)
1218             s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1219     }
1220
1221     /* E-AC-3 to AC-3 converter SNR offset */
1222     if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1223         skip_bits(gbc, 10); // skip converter snr offset
1224     }
1225
1226     /* coupling leak information */
1227     if (cpl_in_use) {
1228         if (s->first_cpl_leak || get_bits1(gbc)) {
1229             int fl = get_bits(gbc, 3);
1230             int sl = get_bits(gbc, 3);
1231             /* run last 2 bit allocation stages for coupling channel if
1232                coupling leak changes */
1233             if (blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1234                 sl != s->bit_alloc_params.cpl_slow_leak)) {
1235                 bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1236             }
1237             s->bit_alloc_params.cpl_fast_leak = fl;
1238             s->bit_alloc_params.cpl_slow_leak = sl;
1239         } else if (!s->eac3 && !blk) {
1240             av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must "
1241                    "be present in block 0\n");
1242             return AVERROR_INVALIDDATA;
1243         }
1244         s->first_cpl_leak = 0;
1245     }
1246
1247     /* delta bit allocation information */
1248     if (s->dba_syntax && get_bits1(gbc)) {
1249         /* delta bit allocation exists (strategy) */
1250         for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1251             s->dba_mode[ch] = get_bits(gbc, 2);
1252             if (s->dba_mode[ch] == DBA_RESERVED) {
1253                 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1254                 return AVERROR_INVALIDDATA;
1255             }
1256             bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1257         }
1258         /* channel delta offset, len and bit allocation */
1259         for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1260             if (s->dba_mode[ch] == DBA_NEW) {
1261                 s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;
1262                 for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
1263                     s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1264                     s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1265                     s->dba_values[ch][seg]  = get_bits(gbc, 3);
1266                 }
1267                 /* run last 2 bit allocation stages if new dba values */
1268                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1269             }
1270         }
1271     } else if (blk == 0) {
1272         for (ch = 0; ch <= s->channels; ch++) {
1273             s->dba_mode[ch] = DBA_NONE;
1274         }
1275     }
1276
1277     /* Bit allocation */
1278     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1279         if (bit_alloc_stages[ch] > 2) {
1280             /* Exponent mapping into PSD and PSD integration */
1281             ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
1282                                       s->start_freq[ch], s->end_freq[ch],
1283                                       s->psd[ch], s->band_psd[ch]);
1284         }
1285         if (bit_alloc_stages[ch] > 1) {
1286             /* Compute excitation function, Compute masking curve, and
1287                Apply delta bit allocation */
1288             if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1289                                            s->start_freq[ch],  s->end_freq[ch],
1290                                            s->fast_gain[ch],   (ch == s->lfe_ch),
1291                                            s->dba_mode[ch],    s->dba_nsegs[ch],
1292                                            s->dba_offsets[ch], s->dba_lengths[ch],
1293                                            s->dba_values[ch],  s->mask[ch])) {
1294                 av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1295                 return AVERROR_INVALIDDATA;
1296             }
1297         }
1298         if (bit_alloc_stages[ch] > 0) {
1299             /* Compute bit allocation */
1300             const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1301                                      ff_eac3_hebap_tab : ff_ac3_bap_tab;
1302             s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1303                                       s->start_freq[ch], s->end_freq[ch],
1304                                       s->snr_offset[ch],
1305                                       s->bit_alloc_params.floor,
1306                                       bap_tab, s->bap[ch]);
1307         }
1308     }
1309
1310     /* unused dummy data */
1311     if (s->skip_syntax && get_bits1(gbc)) {
1312         int skipl = get_bits(gbc, 9);
1313         while (skipl--)
1314             skip_bits(gbc, 8);
1315     }
1316
1317     /* unpack the transform coefficients
1318        this also uncouples channels if coupling is in use. */
1319     decode_transform_coeffs(s, blk);
1320
1321     /* TODO: generate enhanced coupling coordinates and uncouple */
1322
1323     /* recover coefficients if rematrixing is in use */
1324     if (s->channel_mode == AC3_CHMODE_STEREO)
1325         do_rematrixing(s);
1326
1327     /* apply scaling to coefficients (headroom, dynrng) */
1328     for (ch = 1; ch <= s->channels; ch++) {
1329         int audio_channel = 0;
1330         INTFLOAT gain;
1331         if (s->channel_mode == AC3_CHMODE_DUALMONO)
1332             audio_channel = 2-ch;
1333         if (s->heavy_compression && s->compression_exists[audio_channel])
1334             gain = s->heavy_dynamic_range[audio_channel];
1335         else
1336             gain = s->dynamic_range[audio_channel];
1337
1338 #if USE_FIXED
1339         scale_coefs(s->transform_coeffs[ch], s->fixed_coeffs[ch], gain, 256);
1340 #else
1341         if (s->target_level != 0)
1342           gain = gain * s->level_gain[audio_channel];
1343         gain *= 1.0 / 4194304.0f;
1344         s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch],
1345                                                s->fixed_coeffs[ch], gain, 256);
1346 #endif
1347     }
1348
1349     /* apply spectral extension to high frequency bins */
1350     if (CONFIG_EAC3_DECODER && s->spx_in_use) {
1351         ff_eac3_apply_spectral_extension(s);
1352     }
1353
1354     /* downmix and MDCT. order depends on whether block switching is used for
1355        any channel in this block. this is because coefficients for the long
1356        and short transforms cannot be mixed. */
1357     downmix_output = s->channels != s->out_channels &&
1358                      !((s->output_mode & AC3_OUTPUT_LFEON) &&
1359                      s->fbw_channels == s->out_channels);
1360     if (different_transforms) {
1361         /* the delay samples have already been downmixed, so we upmix the delay
1362            samples in order to reconstruct all channels before downmixing. */
1363         if (s->downmixed) {
1364             s->downmixed = 0;
1365             ac3_upmix_delay(s);
1366         }
1367
1368         do_imdct(s, s->channels);
1369
1370         if (downmix_output) {
1371 #if USE_FIXED
1372             ac3_downmix_c_fixed16(s->outptr, s->downmix_coeffs,
1373                               s->out_channels, s->fbw_channels, 256);
1374 #else
1375             s->ac3dsp.downmix(s->outptr, s->downmix_coeffs,
1376                               s->out_channels, s->fbw_channels, 256);
1377 #endif
1378         }
1379     } else {
1380         if (downmix_output) {
1381             s->ac3dsp.AC3_RENAME(downmix)(s->xcfptr + 1, s->downmix_coeffs,
1382                                           s->out_channels, s->fbw_channels, 256);
1383         }
1384
1385         if (downmix_output && !s->downmixed) {
1386             s->downmixed = 1;
1387             s->ac3dsp.AC3_RENAME(downmix)(s->dlyptr, s->downmix_coeffs,
1388                                           s->out_channels, s->fbw_channels, 128);
1389         }
1390
1391         do_imdct(s, s->out_channels);
1392     }
1393
1394     return 0;
1395 }
1396
1397 /**
1398  * Decode a single AC-3 frame.
1399  */
1400 static int ac3_decode_frame(AVCodecContext * avctx, void *data,
1401                             int *got_frame_ptr, AVPacket *avpkt)
1402 {
1403     AVFrame *frame     = data;
1404     const uint8_t *buf = avpkt->data;
1405     int buf_size = avpkt->size;
1406     AC3DecodeContext *s = avctx->priv_data;
1407     int blk, ch, err, ret;
1408     const uint8_t *channel_map;
1409     const SHORTFLOAT *output[AC3_MAX_CHANNELS];
1410     enum AVMatrixEncoding matrix_encoding;
1411     AVDownmixInfo *downmix_info;
1412
1413     /* copy input buffer to decoder context to avoid reading past the end
1414        of the buffer, which can be caused by a damaged input stream. */
1415     if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
1416         // seems to be byte-swapped AC-3
1417         int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1418         s->bdsp.bswap16_buf((uint16_t *) s->input_buffer,
1419                             (const uint16_t *) buf, cnt);
1420     } else
1421         memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1422     buf = s->input_buffer;
1423     /* initialize the GetBitContext with the start of valid AC-3 Frame */
1424     if ((ret = init_get_bits8(&s->gbc, buf, buf_size)) < 0)
1425         return ret;
1426
1427     /* parse the syncinfo */
1428     err = parse_frame_header(s);
1429
1430     if (err) {
1431         switch (err) {
1432         case AAC_AC3_PARSE_ERROR_SYNC:
1433             av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1434             return AVERROR_INVALIDDATA;
1435         case AAC_AC3_PARSE_ERROR_BSID:
1436             av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1437             break;
1438         case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
1439             av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1440             break;
1441         case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
1442             av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1443             break;
1444         case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
1445             /* skip frame if CRC is ok. otherwise use error concealment. */
1446             /* TODO: add support for substreams and dependent frames */
1447             if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
1448                 av_log(avctx, AV_LOG_DEBUG,
1449                        "unsupported frame type %d: skipping frame\n",
1450                        s->frame_type);
1451                 *got_frame_ptr = 0;
1452                 return buf_size;
1453             } else {
1454                 av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1455             }
1456             break;
1457         case AAC_AC3_PARSE_ERROR_CRC:
1458         case AAC_AC3_PARSE_ERROR_CHANNEL_CFG:
1459             break;
1460         default: // Normal AVERROR do not try to recover.
1461             *got_frame_ptr = 0;
1462             return err;
1463         }
1464     } else {
1465         /* check that reported frame size fits in input buffer */
1466         if (s->frame_size > buf_size) {
1467             av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1468             err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
1469         } else if (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL)) {
1470             /* check for crc mismatch */
1471             if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
1472                        s->frame_size - 2)) {
1473                 av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1474                 if (avctx->err_recognition & AV_EF_EXPLODE)
1475                     return AVERROR_INVALIDDATA;
1476                 err = AAC_AC3_PARSE_ERROR_CRC;
1477             }
1478         }
1479     }
1480
1481     /* if frame is ok, set audio parameters */
1482     if (!err) {
1483         avctx->sample_rate = s->sample_rate;
1484         avctx->bit_rate    = s->bit_rate;
1485     }
1486
1487     /* channel config */
1488     if (!err || (s->channels && s->out_channels != s->channels)) {
1489         s->out_channels = s->channels;
1490         s->output_mode  = s->channel_mode;
1491         if (s->lfe_on)
1492             s->output_mode |= AC3_OUTPUT_LFEON;
1493         if (s->channels > 1 &&
1494             avctx->request_channel_layout == AV_CH_LAYOUT_MONO) {
1495             s->out_channels = 1;
1496             s->output_mode  = AC3_CHMODE_MONO;
1497         } else if (s->channels > 2 &&
1498                    avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
1499             s->out_channels = 2;
1500             s->output_mode  = AC3_CHMODE_STEREO;
1501         }
1502
1503         s->loro_center_mix_level   = gain_levels[s->  center_mix_level];
1504         s->loro_surround_mix_level = gain_levels[s->surround_mix_level];
1505         s->ltrt_center_mix_level   = LEVEL_MINUS_3DB;
1506         s->ltrt_surround_mix_level = LEVEL_MINUS_3DB;
1507         /* set downmixing coefficients if needed */
1508         if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1509                 s->fbw_channels == s->out_channels)) {
1510             set_downmix_coeffs(s);
1511         }
1512     } else if (!s->channels) {
1513         av_log(avctx, AV_LOG_ERROR, "unable to determine channel mode\n");
1514         return AVERROR_INVALIDDATA;
1515     }
1516     avctx->channels = s->out_channels;
1517     avctx->channel_layout = avpriv_ac3_channel_layout_tab[s->output_mode & ~AC3_OUTPUT_LFEON];
1518     if (s->output_mode & AC3_OUTPUT_LFEON)
1519         avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1520
1521     /* set audio service type based on bitstream mode for AC-3 */
1522     avctx->audio_service_type = s->bitstream_mode;
1523     if (s->bitstream_mode == 0x7 && s->channels > 1)
1524         avctx->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
1525
1526     /* get output buffer */
1527     frame->nb_samples = s->num_blocks * AC3_BLOCK_SIZE;
1528     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1529         return ret;
1530
1531     /* decode the audio blocks */
1532     channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1533     for (ch = 0; ch < AC3_MAX_CHANNELS; ch++) {
1534         output[ch] = s->output[ch];
1535         s->outptr[ch] = s->output[ch];
1536     }
1537     for (ch = 0; ch < s->channels; ch++) {
1538         if (ch < s->out_channels)
1539             s->outptr[channel_map[ch]] = (SHORTFLOAT *)frame->data[ch];
1540     }
1541     for (blk = 0; blk < s->num_blocks; blk++) {
1542         if (!err && decode_audio_block(s, blk)) {
1543             av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1544             err = 1;
1545         }
1546         if (err)
1547             for (ch = 0; ch < s->out_channels; ch++)
1548                 memcpy(((SHORTFLOAT*)frame->data[ch]) + AC3_BLOCK_SIZE*blk, output[ch], AC3_BLOCK_SIZE*sizeof(SHORTFLOAT));
1549         for (ch = 0; ch < s->out_channels; ch++)
1550             output[ch] = s->outptr[channel_map[ch]];
1551         for (ch = 0; ch < s->out_channels; ch++) {
1552             if (!ch || channel_map[ch])
1553                 s->outptr[channel_map[ch]] += AC3_BLOCK_SIZE;
1554         }
1555     }
1556
1557     av_frame_set_decode_error_flags(frame, err ? FF_DECODE_ERROR_INVALID_BITSTREAM : 0);
1558
1559     /* keep last block for error concealment in next frame */
1560     for (ch = 0; ch < s->out_channels; ch++)
1561         memcpy(s->output[ch], output[ch], AC3_BLOCK_SIZE*sizeof(SHORTFLOAT));
1562
1563     /*
1564      * AVMatrixEncoding
1565      *
1566      * Check whether the input layout is compatible, and make sure we're not
1567      * downmixing (else the matrix encoding is no longer applicable).
1568      */
1569     matrix_encoding = AV_MATRIX_ENCODING_NONE;
1570     if (s->channel_mode == AC3_CHMODE_STEREO &&
1571         s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1572         if (s->dolby_surround_mode == AC3_DSURMOD_ON)
1573             matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
1574         else if (s->dolby_headphone_mode == AC3_DHEADPHONMOD_ON)
1575             matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;
1576     } else if (s->channel_mode >= AC3_CHMODE_2F2R &&
1577                s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1578         switch (s->dolby_surround_ex_mode) {
1579         case AC3_DSUREXMOD_ON: // EX or PLIIx
1580             matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
1581             break;
1582         case AC3_DSUREXMOD_PLIIZ:
1583             matrix_encoding = AV_MATRIX_ENCODING_DPLIIZ;
1584             break;
1585         default: // not indicated or off
1586             break;
1587         }
1588     }
1589     if ((ret = ff_side_data_update_matrix_encoding(frame, matrix_encoding)) < 0)
1590         return ret;
1591
1592     /* AVDownmixInfo */
1593     if ((downmix_info = av_downmix_info_update_side_data(frame))) {
1594         switch (s->preferred_downmix) {
1595         case AC3_DMIXMOD_LTRT:
1596             downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_LTRT;
1597             break;
1598         case AC3_DMIXMOD_LORO:
1599             downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_LORO;
1600             break;
1601         case AC3_DMIXMOD_DPLII:
1602             downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_DPLII;
1603             break;
1604         default:
1605             downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_UNKNOWN;
1606             break;
1607         }
1608         downmix_info->center_mix_level        = gain_levels[s->       center_mix_level];
1609         downmix_info->center_mix_level_ltrt   = gain_levels[s->  center_mix_level_ltrt];
1610         downmix_info->surround_mix_level      = gain_levels[s->     surround_mix_level];
1611         downmix_info->surround_mix_level_ltrt = gain_levels[s->surround_mix_level_ltrt];
1612         if (s->lfe_mix_level_exists)
1613             downmix_info->lfe_mix_level       = gain_levels_lfe[s->lfe_mix_level];
1614         else
1615             downmix_info->lfe_mix_level       = 0.0; // -inf dB
1616     } else
1617         return AVERROR(ENOMEM);
1618
1619     *got_frame_ptr = 1;
1620
1621     return FFMIN(buf_size, s->frame_size);
1622 }
1623
1624 /**
1625  * Uninitialize the AC-3 decoder.
1626  */
1627 static av_cold int ac3_decode_end(AVCodecContext *avctx)
1628 {
1629     AC3DecodeContext *s = avctx->priv_data;
1630     ff_mdct_end(&s->imdct_512);
1631     ff_mdct_end(&s->imdct_256);
1632     av_freep(&s->fdsp);
1633
1634     return 0;
1635 }
1636
1637 #define OFFSET(x) offsetof(AC3DecodeContext, x)
1638 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)