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