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