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