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