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