git.sesse.net Git - ffmpeg/blob - libavcodec/ac3dec.c

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