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