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