git.sesse.net Git - ffmpeg/blob - libavcodec/ac3dec.c

   1 /*
   2  * AC-3 Audio Decoder
   3  * This code was developed as part of Google Summer of Code 2006.
   4  * E-AC-3 support was added as part of Google Summer of Code 2007.
   5  *
   6  * Copyright (c) 2006 Kartikey Mahendra BHATT (bhattkm at gmail dot com)
   7  * Copyright (c) 2007-2008 Bartlomiej Wolowiec <bartek.wolowiec@gmail.com>
   8  * Copyright (c) 2007 Justin Ruggles <justin.ruggles@gmail.com>
   9  *
  10  * This file is part of FFmpeg.
  11  *
  12  * FFmpeg is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU Lesser General Public
  14  * License as published by the Free Software Foundation; either
  15  * version 2.1 of the License, or (at your option) any later version.
  16  *
  17  * FFmpeg is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20  * Lesser General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU Lesser General Public
  23  * License along with FFmpeg; if not, write to the Free Software
  24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  25  */
  26
  27 #include <stdio.h>
  28 #include <stddef.h>
  29 #include <math.h>
  30 #include <string.h>
  31
  32 #include "libavutil/channel_layout.h"
  33 #include "libavutil/crc.h"
  34 #include "libavutil/downmix_info.h"
  35 #include "libavutil/opt.h"
  36 #include "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)>>8)*181)>>8) - 5931008;
 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             if (bap > 15) {
 533                 av_log(s->avctx, AV_LOG_ERROR, "bap %d is invalid in plain AC-3\n", bap);
 534                 bap = 15;
 535             }
 536             mantissa = get_sbits(gbc, quantization_tab[bap]);
 537             mantissa <<= 24 - quantization_tab[bap];
 538             break;
 539         }
 540         coeffs[freq] = mantissa >> exps[freq];
 541     }
 542 }
 543
 544 /**
 545  * Remove random dithering from coupling range coefficients with zero-bit
 546  * mantissas for coupled channels which do not use dithering.
 547  * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
 548  */
 549 static void remove_dithering(AC3DecodeContext *s) {
 550     int ch, i;
 551
 552     for (ch = 1; ch <= s->fbw_channels; ch++) {
 553         if (!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
 554             for (i = s->start_freq[CPL_CH]; i < s->end_freq[CPL_CH]; i++) {
 555                 if (!s->bap[CPL_CH][i])
 556                     s->fixed_coeffs[ch][i] = 0;
 557             }
 558         }
 559     }
 560 }
 561
 562 static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,
 563                                        mant_groups *m)
 564 {
 565     if (!s->channel_uses_aht[ch]) {
 566         ac3_decode_transform_coeffs_ch(s, ch, m);
 567     } else {
 568         /* if AHT is used, mantissas for all blocks are encoded in the first
 569            block of the frame. */
 570         int bin;
 571         if (!blk && CONFIG_EAC3_DECODER)
 572             ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
 573         for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
 574             s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
 575         }
 576     }
 577 }
 578
 579 /**
 580  * Decode the transform coefficients.
 581  */
 582 static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
 583 {
 584     int ch, end;
 585     int got_cplchan = 0;
 586     mant_groups m;
 587
 588     m.b1 = m.b2 = m.b4 = 0;
 589
 590     for (ch = 1; ch <= s->channels; ch++) {
 591         /* transform coefficients for full-bandwidth channel */
 592         decode_transform_coeffs_ch(s, blk, ch, &m);
 593         /* transform coefficients for coupling channel come right after the
 594            coefficients for the first coupled channel*/
 595         if (s->channel_in_cpl[ch])  {
 596             if (!got_cplchan) {
 597                 decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
 598                 calc_transform_coeffs_cpl(s);
 599                 got_cplchan = 1;
 600             }
 601             end = s->end_freq[CPL_CH];
 602         } else {
 603             end = s->end_freq[ch];
 604         }
 605         do
 606             s->fixed_coeffs[ch][end] = 0;
 607         while (++end < 256);
 608     }
 609
 610     /* zero the dithered coefficients for appropriate channels */
 611     remove_dithering(s);
 612 }
 613
 614 /**
 615  * Stereo rematrixing.
 616  * reference: Section 7.5.4 Rematrixing : Decoding Technique
 617  */
 618 static void do_rematrixing(AC3DecodeContext *s)
 619 {
 620     int bnd, i;
 621     int end, bndend;
 622
 623     end = FFMIN(s->end_freq[1], s->end_freq[2]);
 624
 625     for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) {
 626         if (s->rematrixing_flags[bnd]) {
 627             bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd + 1]);
 628             for (i = ff_ac3_rematrix_band_tab[bnd]; i < bndend; i++) {
 629                 int tmp0 = s->fixed_coeffs[1][i];
 630                 s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
 631                 s->fixed_coeffs[2][i]  = tmp0 - s->fixed_coeffs[2][i];
 632             }
 633         }
 634     }
 635 }
 636
 637 /**
 638  * Inverse MDCT Transform.
 639  * Convert frequency domain coefficients to time-domain audio samples.
 640  * reference: Section 7.9.4 Transformation Equations
 641  */
 642 static inline void do_imdct(AC3DecodeContext *s, int channels)
 643 {
 644     int ch;
 645
 646     for (ch = 1; ch <= channels; ch++) {
 647         if (s->block_switch[ch]) {
 648             int i;
 649             float *x = s->tmp_output + 128;
 650             for (i = 0; i < 128; i++)
 651                 x[i] = s->transform_coeffs[ch][2 * i];
 652             s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
 653             s->fdsp.vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
 654                                        s->tmp_output, s->window, 128);
 655             for (i = 0; i < 128; i++)
 656                 x[i] = s->transform_coeffs[ch][2 * i + 1];
 657             s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch - 1], x);
 658         } else {
 659             s->imdct_512.imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
 660             s->fdsp.vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
 661                                        s->tmp_output, s->window, 128);
 662             memcpy(s->delay[ch - 1], s->tmp_output + 128, 128 * sizeof(float));
 663         }
 664     }
 665 }
 666
 667 /**
 668  * Upmix delay samples from stereo to original channel layout.
 669  */
 670 static void ac3_upmix_delay(AC3DecodeContext *s)
 671 {
 672     int channel_data_size = sizeof(s->delay[0]);
 673     switch (s->channel_mode) {
 674     case AC3_CHMODE_DUALMONO:
 675     case AC3_CHMODE_STEREO:
 676         /* upmix mono to stereo */
 677         memcpy(s->delay[1], s->delay[0], channel_data_size);
 678         break;
 679     case AC3_CHMODE_2F2R:
 680         memset(s->delay[3], 0, channel_data_size);
 681     case AC3_CHMODE_2F1R:
 682         memset(s->delay[2], 0, channel_data_size);
 683         break;
 684     case AC3_CHMODE_3F2R:
 685         memset(s->delay[4], 0, channel_data_size);
 686     case AC3_CHMODE_3F1R:
 687         memset(s->delay[3], 0, channel_data_size);
 688     case AC3_CHMODE_3F:
 689         memcpy(s->delay[2], s->delay[1], channel_data_size);
 690         memset(s->delay[1], 0, channel_data_size);
 691         break;
 692     }
 693 }
 694
 695 /**
 696  * Decode band structure for coupling, spectral extension, or enhanced coupling.
 697  * The band structure defines how many subbands are in each band.  For each
 698  * subband in the range, 1 means it is combined with the previous band, and 0
 699  * means that it starts a new band.
 700  *
 701  * @param[in] gbc bit reader context
 702  * @param[in] blk block number
 703  * @param[in] eac3 flag to indicate E-AC-3
 704  * @param[in] ecpl flag to indicate enhanced coupling
 705  * @param[in] start_subband subband number for start of range
 706  * @param[in] end_subband subband number for end of range
 707  * @param[in] default_band_struct default band structure table
 708  * @param[out] num_bands number of bands (optionally NULL)
 709  * @param[out] band_sizes array containing the number of bins in each band (optionally NULL)
 710  */
 711 static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
 712                                   int ecpl, int start_subband, int end_subband,
 713                                   const uint8_t *default_band_struct,
 714                                   int *num_bands, uint8_t *band_sizes)
 715 {
 716     int subbnd, bnd, n_subbands, n_bands=0;
 717     uint8_t bnd_sz[22];
 718     uint8_t coded_band_struct[22];
 719     const uint8_t *band_struct;
 720
 721     n_subbands = end_subband - start_subband;
 722
 723     /* decode band structure from bitstream or use default */
 724     if (!eac3 || get_bits1(gbc)) {
 725         for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
 726             coded_band_struct[subbnd] = get_bits1(gbc);
 727         }
 728         band_struct = coded_band_struct;
 729     } else if (!blk) {
 730         band_struct = &default_band_struct[start_subband+1];
 731     } else {
 732         /* no change in band structure */
 733         return;
 734     }
 735
 736     /* calculate number of bands and band sizes based on band structure.
 737        note that the first 4 subbands in enhanced coupling span only 6 bins
 738        instead of 12. */
 739     if (num_bands || band_sizes ) {
 740         n_bands = n_subbands;
 741         bnd_sz[0] = ecpl ? 6 : 12;
 742         for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
 743             int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
 744             if (band_struct[subbnd - 1]) {
 745                 n_bands--;
 746                 bnd_sz[bnd] += subbnd_size;
 747             } else {
 748                 bnd_sz[++bnd] = subbnd_size;
 749             }
 750         }
 751     }
 752
 753     /* set optional output params */
 754     if (num_bands)
 755         *num_bands = n_bands;
 756     if (band_sizes)
 757         memcpy(band_sizes, bnd_sz, n_bands);
 758 }
 759
 760 /**
 761  * Decode a single audio block from the AC-3 bitstream.
 762  */
 763 static int decode_audio_block(AC3DecodeContext *s, int blk)
 764 {
 765     int fbw_channels = s->fbw_channels;
 766     int channel_mode = s->channel_mode;
 767     int i, bnd, seg, ch;
 768     int different_transforms;
 769     int downmix_output;
 770     int cpl_in_use;
 771     GetBitContext *gbc = &s->gbc;
 772     uint8_t bit_alloc_stages[AC3_MAX_CHANNELS] = { 0 };
 773
 774     /* block switch flags */
 775     different_transforms = 0;
 776     if (s->block_switch_syntax) {
 777         for (ch = 1; ch <= fbw_channels; ch++) {
 778             s->block_switch[ch] = get_bits1(gbc);
 779             if (ch > 1 && s->block_switch[ch] != s->block_switch[1])
 780                 different_transforms = 1;
 781         }
 782     }
 783
 784     /* dithering flags */
 785     if (s->dither_flag_syntax) {
 786         for (ch = 1; ch <= fbw_channels; ch++) {
 787             s->dither_flag[ch] = get_bits1(gbc);
 788         }
 789     }
 790
 791     /* dynamic range */
 792     i = !s->channel_mode;
 793     do {
 794         if (get_bits1(gbc)) {
 795             /* Allow asymmetric application of DRC when drc_scale > 1.
 796                Amplification of quiet sounds is enhanced */
 797             float range = dynamic_range_tab[get_bits(gbc, 8)];
 798             if (range > 1.0 || s->drc_scale <= 1.0)
 799                 s->dynamic_range[i] = powf(range, s->drc_scale);
 800             else
 801                 s->dynamic_range[i] = range;
 802         } else if (blk == 0) {
 803             s->dynamic_range[i] = 1.0f;
 804         }
 805     } while (i--);
 806
 807     /* spectral extension strategy */
 808     if (s->eac3 && (!blk || get_bits1(gbc))) {
 809         s->spx_in_use = get_bits1(gbc);
 810         if (s->spx_in_use) {
 811             int dst_start_freq, dst_end_freq, src_start_freq,
 812                 start_subband, end_subband;
 813
 814             /* determine which channels use spx */
 815             if (s->channel_mode == AC3_CHMODE_MONO) {
 816                 s->channel_uses_spx[1] = 1;
 817             } else {
 818                 for (ch = 1; ch <= fbw_channels; ch++)
 819                     s->channel_uses_spx[ch] = get_bits1(gbc);
 820             }
 821
 822             /* get the frequency bins of the spx copy region and the spx start
 823                and end subbands */
 824             dst_start_freq = get_bits(gbc, 2);
 825             start_subband  = get_bits(gbc, 3) + 2;
 826             if (start_subband > 7)
 827                 start_subband += start_subband - 7;
 828             end_subband    = get_bits(gbc, 3) + 5;
 829             if (end_subband   > 7)
 830                 end_subband   += end_subband   - 7;
 831             dst_start_freq = dst_start_freq * 12 + 25;
 832             src_start_freq = start_subband  * 12 + 25;
 833             dst_end_freq   = end_subband    * 12 + 25;
 834
 835             /* check validity of spx ranges */
 836             if (start_subband >= end_subband) {
 837                 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
 838                        "range (%d >= %d)\n", start_subband, end_subband);
 839                 return AVERROR_INVALIDDATA;
 840             }
 841             if (dst_start_freq >= src_start_freq) {
 842                 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
 843                        "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
 844                 return AVERROR_INVALIDDATA;
 845             }
 846
 847             s->spx_dst_start_freq = dst_start_freq;
 848             s->spx_src_start_freq = src_start_freq;
 849             s->spx_dst_end_freq   = dst_end_freq;
 850
 851             decode_band_structure(gbc, blk, s->eac3, 0,
 852                                   start_subband, end_subband,
 853                                   ff_eac3_default_spx_band_struct,
 854                                   &s->num_spx_bands,
 855                                   s->spx_band_sizes);
 856         } else {
 857             for (ch = 1; ch <= fbw_channels; ch++) {
 858                 s->channel_uses_spx[ch] = 0;
 859                 s->first_spx_coords[ch] = 1;
 860             }
 861         }
 862     }
 863
 864     /* spectral extension coordinates */
 865     if (s->spx_in_use) {
 866         for (ch = 1; ch <= fbw_channels; ch++) {
 867             if (s->channel_uses_spx[ch]) {
 868                 if (s->first_spx_coords[ch] || get_bits1(gbc)) {
 869                     float spx_blend;
 870                     int bin, master_spx_coord;
 871
 872                     s->first_spx_coords[ch] = 0;
 873                     spx_blend = get_bits(gbc, 5) * (1.0f/32);
 874                     master_spx_coord = get_bits(gbc, 2) * 3;
 875
 876                     bin = s->spx_src_start_freq;
 877                     for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
 878                         int bandsize;
 879                         int spx_coord_exp, spx_coord_mant;
 880                         float nratio, sblend, nblend, spx_coord;
 881
 882                         /* calculate blending factors */
 883                         bandsize = s->spx_band_sizes[bnd];
 884                         nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
 885                         nratio = av_clipf(nratio, 0.0f, 1.0f);
 886                         nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
 887                                                        // to give unity variance
 888                         sblend = sqrtf(1.0f - nratio);
 889                         bin += bandsize;
 890
 891                         /* decode spx coordinates */
 892                         spx_coord_exp  = get_bits(gbc, 4);
 893                         spx_coord_mant = get_bits(gbc, 2);
 894                         if (spx_coord_exp == 15) spx_coord_mant <<= 1;
 895                         else                     spx_coord_mant += 4;
 896                         spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
 897                         spx_coord = spx_coord_mant * (1.0f / (1 << 23));
 898
 899                         /* multiply noise and signal blending factors by spx coordinate */
 900                         s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
 901                         s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
 902                     }
 903                 }
 904             } else {
 905                 s->first_spx_coords[ch] = 1;
 906             }
 907         }
 908     }
 909
 910     /* coupling strategy */
 911     if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
 912         memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
 913         if (!s->eac3)
 914             s->cpl_in_use[blk] = get_bits1(gbc);
 915         if (s->cpl_in_use[blk]) {
 916             /* coupling in use */
 917             int cpl_start_subband, cpl_end_subband;
 918
 919             if (channel_mode < AC3_CHMODE_STEREO) {
 920                 av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
 921                 return AVERROR_INVALIDDATA;
 922             }
 923
 924             /* check for enhanced coupling */
 925             if (s->eac3 && get_bits1(gbc)) {
 926                 /* TODO: parse enhanced coupling strategy info */
 927                 avpriv_request_sample(s->avctx, "Enhanced coupling");
 928                 return AVERROR_PATCHWELCOME;
 929             }
 930
 931             /* determine which channels are coupled */
 932             if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
 933                 s->channel_in_cpl[1] = 1;
 934                 s->channel_in_cpl[2] = 1;
 935             } else {
 936                 for (ch = 1; ch <= fbw_channels; ch++)
 937                     s->channel_in_cpl[ch] = get_bits1(gbc);
 938             }
 939
 940             /* phase flags in use */
 941             if (channel_mode == AC3_CHMODE_STEREO)
 942                 s->phase_flags_in_use = get_bits1(gbc);
 943
 944             /* coupling frequency range */
 945             cpl_start_subband = get_bits(gbc, 4);
 946             cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
 947                                               get_bits(gbc, 4) + 3;
 948             if (cpl_start_subband >= cpl_end_subband) {
 949                 av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
 950                        cpl_start_subband, cpl_end_subband);
 951                 return AVERROR_INVALIDDATA;
 952             }
 953             s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
 954             s->end_freq[CPL_CH]   = cpl_end_subband   * 12 + 37;
 955
 956             decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
 957                                   cpl_end_subband,
 958                                   ff_eac3_default_cpl_band_struct,
 959                                   &s->num_cpl_bands, s->cpl_band_sizes);
 960         } else {
 961             /* coupling not in use */
 962             for (ch = 1; ch <= fbw_channels; ch++) {
 963                 s->channel_in_cpl[ch] = 0;
 964                 s->first_cpl_coords[ch] = 1;
 965             }
 966             s->first_cpl_leak = s->eac3;
 967             s->phase_flags_in_use = 0;
 968         }
 969     } else if (!s->eac3) {
 970         if (!blk) {
 971             av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "
 972                    "be present in block 0\n");
 973             return AVERROR_INVALIDDATA;
 974         } else {
 975             s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
 976         }
 977     }
 978     cpl_in_use = s->cpl_in_use[blk];
 979
 980     /* coupling coordinates */
 981     if (cpl_in_use) {
 982         int cpl_coords_exist = 0;
 983
 984         for (ch = 1; ch <= fbw_channels; ch++) {
 985             if (s->channel_in_cpl[ch]) {
 986                 if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
 987                     int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
 988                     s->first_cpl_coords[ch] = 0;
 989                     cpl_coords_exist = 1;
 990                     master_cpl_coord = 3 * get_bits(gbc, 2);
 991                     for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
 992                         cpl_coord_exp = get_bits(gbc, 4);
 993                         cpl_coord_mant = get_bits(gbc, 4);
 994                         if (cpl_coord_exp == 15)
 995                             s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
 996                         else
 997                             s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
 998                         s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
 999                     }
1000                 } else if (!blk) {
1001                     av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
1002                            "be present in block 0\n");
1003                     return AVERROR_INVALIDDATA;
1004                 }
1005             } else {
1006                 /* channel not in coupling */
1007                 s->first_cpl_coords[ch] = 1;
1008             }
1009         }
1010         /* phase flags */
1011         if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
1012             for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1013                 s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
1014             }
1015         }
1016     }
1017
1018     /* stereo rematrixing strategy and band structure */
1019     if (channel_mode == AC3_CHMODE_STEREO) {
1020         if ((s->eac3 && !blk) || get_bits1(gbc)) {
1021             s->num_rematrixing_bands = 4;
1022             if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
1023                 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
1024             } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
1025                 s->num_rematrixing_bands--;
1026             }
1027             for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
1028                 s->rematrixing_flags[bnd] = get_bits1(gbc);
1029         } else if (!blk) {
1030             av_log(s->avctx, AV_LOG_WARNING, "Warning: "
1031                    "new rematrixing strategy not present in block 0\n");
1032             s->num_rematrixing_bands = 0;
1033         }
1034     }
1035
1036     /* exponent strategies for each channel */
1037     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1038         if (!s->eac3)
1039             s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
1040         if (s->exp_strategy[blk][ch] != EXP_REUSE)
1041             bit_alloc_stages[ch] = 3;
1042     }
1043
1044     /* channel bandwidth */
1045     for (ch = 1; ch <= fbw_channels; ch++) {
1046         s->start_freq[ch] = 0;
1047         if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1048             int group_size;
1049             int prev = s->end_freq[ch];
1050             if (s->channel_in_cpl[ch])
1051                 s->end_freq[ch] = s->start_freq[CPL_CH];
1052             else if (s->channel_uses_spx[ch])
1053                 s->end_freq[ch] = s->spx_src_start_freq;
1054             else {
1055                 int bandwidth_code = get_bits(gbc, 6);
1056                 if (bandwidth_code > 60) {
1057                     av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1058                     return AVERROR_INVALIDDATA;
1059                 }
1060                 s->end_freq[ch] = bandwidth_code * 3 + 73;
1061             }
1062             group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1063             s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
1064             if (blk > 0 && s->end_freq[ch] != prev)
1065                 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1066         }
1067     }
1068     if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1069         s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
1070                                     (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1071     }
1072
1073     /* decode exponents for each channel */
1074     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1075         if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1076             s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1077             if (decode_exponents(gbc, s->exp_strategy[blk][ch],
1078                                  s->num_exp_groups[ch], s->dexps[ch][0],
1079                                  &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1080                 av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
1081                 return AVERROR_INVALIDDATA;
1082             }
1083             if (ch != CPL_CH && ch != s->lfe_ch)
1084                 skip_bits(gbc, 2); /* skip gainrng */
1085         }
1086     }
1087
1088     /* bit allocation information */
1089     if (s->bit_allocation_syntax) {
1090         if (get_bits1(gbc)) {
1091             s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1092             s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1093             s->bit_alloc_params.slow_gain  = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
1094             s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
1095             s->bit_alloc_params.floor  = ff_ac3_floor_tab[get_bits(gbc, 3)];
1096             for (ch = !cpl_in_use; ch <= s->channels; ch++)
1097                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1098         } else if (!blk) {
1099             av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must "
1100                    "be present in block 0\n");
1101             return AVERROR_INVALIDDATA;
1102         }
1103     }
1104
1105     /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1106     if (!s->eac3 || !blk) {
1107         if (s->snr_offset_strategy && get_bits1(gbc)) {
1108             int snr = 0;
1109             int csnr;
1110             csnr = (get_bits(gbc, 6) - 15) << 4;
1111             for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1112                 /* snr offset */
1113                 if (ch == i || s->snr_offset_strategy == 2)
1114                     snr = (csnr + get_bits(gbc, 4)) << 2;
1115                 /* run at least last bit allocation stage if snr offset changes */
1116                 if (blk && s->snr_offset[ch] != snr) {
1117                     bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1118                 }
1119                 s->snr_offset[ch] = snr;
1120
1121                 /* fast gain (normal AC-3 only) */
1122                 if (!s->eac3) {
1123                     int prev = s->fast_gain[ch];
1124                     s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1125                     /* run last 2 bit allocation stages if fast gain changes */
1126                     if (blk && prev != s->fast_gain[ch])
1127                         bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1128                 }
1129             }
1130         } else if (!s->eac3 && !blk) {
1131             av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1132             return AVERROR_INVALIDDATA;
1133         }
1134     }
1135
1136     /* fast gain (E-AC-3 only) */
1137     if (s->fast_gain_syntax && get_bits1(gbc)) {
1138         for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1139             int prev = s->fast_gain[ch];
1140             s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1141             /* run last 2 bit allocation stages if fast gain changes */
1142             if (blk && prev != s->fast_gain[ch])
1143                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1144         }
1145     } else if (s->eac3 && !blk) {
1146         for (ch = !cpl_in_use; ch <= s->channels; ch++)
1147             s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1148     }
1149
1150     /* E-AC-3 to AC-3 converter SNR offset */
1151     if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1152         skip_bits(gbc, 10); // skip converter snr offset
1153     }
1154
1155     /* coupling leak information */
1156     if (cpl_in_use) {
1157         if (s->first_cpl_leak || get_bits1(gbc)) {
1158             int fl = get_bits(gbc, 3);
1159             int sl = get_bits(gbc, 3);
1160             /* run last 2 bit allocation stages for coupling channel if
1161                coupling leak changes */
1162             if (blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1163                 sl != s->bit_alloc_params.cpl_slow_leak)) {
1164                 bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1165             }
1166             s->bit_alloc_params.cpl_fast_leak = fl;
1167             s->bit_alloc_params.cpl_slow_leak = sl;
1168         } else if (!s->eac3 && !blk) {
1169             av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must "
1170                    "be present in block 0\n");
1171             return AVERROR_INVALIDDATA;
1172         }
1173         s->first_cpl_leak = 0;
1174     }
1175
1176     /* delta bit allocation information */
1177     if (s->dba_syntax && get_bits1(gbc)) {
1178         /* delta bit allocation exists (strategy) */
1179         for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1180             s->dba_mode[ch] = get_bits(gbc, 2);
1181             if (s->dba_mode[ch] == DBA_RESERVED) {
1182                 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1183                 return AVERROR_INVALIDDATA;
1184             }
1185             bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1186         }
1187         /* channel delta offset, len and bit allocation */
1188         for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1189             if (s->dba_mode[ch] == DBA_NEW) {
1190                 s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;
1191                 for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
1192                     s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1193                     s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1194                     s->dba_values[ch][seg]  = get_bits(gbc, 3);
1195                 }
1196                 /* run last 2 bit allocation stages if new dba values */
1197                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1198             }
1199         }
1200     } else if (blk == 0) {
1201         for (ch = 0; ch <= s->channels; ch++) {
1202             s->dba_mode[ch] = DBA_NONE;
1203         }
1204     }
1205
1206     /* Bit allocation */
1207     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1208         if (bit_alloc_stages[ch] > 2) {
1209             /* Exponent mapping into PSD and PSD integration */
1210             ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
1211                                       s->start_freq[ch], s->end_freq[ch],
1212                                       s->psd[ch], s->band_psd[ch]);
1213         }
1214         if (bit_alloc_stages[ch] > 1) {
1215             /* Compute excitation function, Compute masking curve, and
1216                Apply delta bit allocation */
1217             if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1218                                            s->start_freq[ch],  s->end_freq[ch],
1219                                            s->fast_gain[ch],   (ch == s->lfe_ch),
1220                                            s->dba_mode[ch],    s->dba_nsegs[ch],
1221                                            s->dba_offsets[ch], s->dba_lengths[ch],
1222                                            s->dba_values[ch],  s->mask[ch])) {
1223                 av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1224                 return AVERROR_INVALIDDATA;
1225             }
1226         }
1227         if (bit_alloc_stages[ch] > 0) {
1228             /* Compute bit allocation */
1229             const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1230                                      ff_eac3_hebap_tab : ff_ac3_bap_tab;
1231             s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1232                                       s->start_freq[ch], s->end_freq[ch],
1233                                       s->snr_offset[ch],
1234                                       s->bit_alloc_params.floor,
1235                                       bap_tab, s->bap[ch]);
1236         }
1237     }
1238
1239     /* unused dummy data */
1240     if (s->skip_syntax && get_bits1(gbc)) {
1241         int skipl = get_bits(gbc, 9);
1242         while (skipl--)
1243             skip_bits(gbc, 8);
1244     }
1245
1246     /* unpack the transform coefficients
1247        this also uncouples channels if coupling is in use. */
1248     decode_transform_coeffs(s, blk);
1249
1250     /* TODO: generate enhanced coupling coordinates and uncouple */
1251
1252     /* recover coefficients if rematrixing is in use */
1253     if (s->channel_mode == AC3_CHMODE_STEREO)
1254         do_rematrixing(s);
1255
1256     /* apply scaling to coefficients (headroom, dynrng) */
1257     for (ch = 1; ch <= s->channels; ch++) {
1258         float gain = 1.0 / 4194304.0f;
1259         if (s->channel_mode == AC3_CHMODE_DUALMONO) {
1260             gain *= s->dynamic_range[2 - ch];
1261         } else {
1262             gain *= s->dynamic_range[0];
1263         }
1264         s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch],
1265                                                s->fixed_coeffs[ch], gain, 256);
1266     }
1267
1268     /* apply spectral extension to high frequency bins */
1269     if (s->spx_in_use && CONFIG_EAC3_DECODER) {
1270         ff_eac3_apply_spectral_extension(s);
1271     }
1272
1273     /* downmix and MDCT. order depends on whether block switching is used for
1274        any channel in this block. this is because coefficients for the long
1275        and short transforms cannot be mixed. */
1276     downmix_output = s->channels != s->out_channels &&
1277                      !((s->output_mode & AC3_OUTPUT_LFEON) &&
1278                      s->fbw_channels == s->out_channels);
1279     if (different_transforms) {
1280         /* the delay samples have already been downmixed, so we upmix the delay
1281            samples in order to reconstruct all channels before downmixing. */
1282         if (s->downmixed) {
1283             s->downmixed = 0;
1284             ac3_upmix_delay(s);
1285         }
1286
1287         do_imdct(s, s->channels);
1288
1289         if (downmix_output) {
1290             s->ac3dsp.downmix(s->outptr, s->downmix_coeffs,
1291                               s->out_channels, s->fbw_channels, 256);
1292         }
1293     } else {
1294         if (downmix_output) {
1295             s->ac3dsp.downmix(s->xcfptr + 1, s->downmix_coeffs,
1296                               s->out_channels, s->fbw_channels, 256);
1297         }
1298
1299         if (downmix_output && !s->downmixed) {
1300             s->downmixed = 1;
1301             s->ac3dsp.downmix(s->dlyptr, s->downmix_coeffs, s->out_channels,
1302                               s->fbw_channels, 128);
1303         }
1304
1305         do_imdct(s, s->out_channels);
1306     }
1307
1308     return 0;
1309 }
1310
1311 /**
1312  * Decode a single AC-3 frame.
1313  */
1314 static int ac3_decode_frame(AVCodecContext * avctx, void *data,
1315                             int *got_frame_ptr, AVPacket *avpkt)
1316 {
1317     AVFrame *frame     = data;
1318     const uint8_t *buf = avpkt->data;
1319     int buf_size = avpkt->size;
1320     AC3DecodeContext *s = avctx->priv_data;
1321     int blk, ch, err, ret;
1322     const uint8_t *channel_map;
1323     const float *output[AC3_MAX_CHANNELS];
1324     enum AVMatrixEncoding matrix_encoding;
1325     AVDownmixInfo *downmix_info;
1326
1327     /* copy input buffer to decoder context to avoid reading past the end
1328        of the buffer, which can be caused by a damaged input stream. */
1329     if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
1330         // seems to be byte-swapped AC-3
1331         int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1332         s->dsp.bswap16_buf((uint16_t *)s->input_buffer, (const uint16_t *)buf, cnt);
1333     } else
1334         memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1335     buf = s->input_buffer;
1336     /* initialize the GetBitContext with the start of valid AC-3 Frame */
1337     init_get_bits(&s->gbc, buf, buf_size * 8);
1338
1339     /* parse the syncinfo */
1340     err = parse_frame_header(s);
1341
1342     if (err) {
1343         switch (err) {
1344         case AAC_AC3_PARSE_ERROR_SYNC:
1345             av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1346             return AVERROR_INVALIDDATA;
1347         case AAC_AC3_PARSE_ERROR_BSID:
1348             av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1349             break;
1350         case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
1351             av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1352             break;
1353         case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
1354             av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1355             break;
1356         case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
1357             /* skip frame if CRC is ok. otherwise use error concealment. */
1358             /* TODO: add support for substreams and dependent frames */
1359             if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
1360                 av_log(avctx, AV_LOG_WARNING, "unsupported frame type : "
1361                        "skipping frame\n");
1362                 *got_frame_ptr = 0;
1363                 return buf_size;
1364             } else {
1365                 av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1366             }
1367             break;
1368         case AAC_AC3_PARSE_ERROR_CRC:
1369         case AAC_AC3_PARSE_ERROR_CHANNEL_CFG:
1370             break;
1371         default: // Normal AVERROR do not try to recover.
1372             *got_frame_ptr = 0;
1373             return err;
1374         }
1375     } else {
1376         /* check that reported frame size fits in input buffer */
1377         if (s->frame_size > buf_size) {
1378             av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1379             err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
1380         } else if (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL)) {
1381             /* check for crc mismatch */
1382             if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
1383                        s->frame_size - 2)) {
1384                 av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1385                 if (avctx->err_recognition & AV_EF_EXPLODE)
1386                     return AVERROR_INVALIDDATA;
1387                 err = AAC_AC3_PARSE_ERROR_CRC;
1388             }
1389         }
1390     }
1391
1392     /* if frame is ok, set audio parameters */
1393     if (!err) {
1394         avctx->sample_rate = s->sample_rate;
1395         avctx->bit_rate    = s->bit_rate;
1396     }
1397
1398     /* channel config */
1399     if (!err || (s->channels && s->out_channels != s->channels)) {
1400         s->out_channels = s->channels;
1401         s->output_mode  = s->channel_mode;
1402         if (s->lfe_on)
1403             s->output_mode |= AC3_OUTPUT_LFEON;
1404         if (s->channels > 1 &&
1405             avctx->request_channel_layout == AV_CH_LAYOUT_MONO) {
1406             s->out_channels = 1;
1407             s->output_mode  = AC3_CHMODE_MONO;
1408         } else if (s->channels > 2 &&
1409                    avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
1410             s->out_channels = 2;
1411             s->output_mode  = AC3_CHMODE_STEREO;
1412         }
1413
1414         s->loro_center_mix_level   = gain_levels[s->  center_mix_level];
1415         s->loro_surround_mix_level = gain_levels[s->surround_mix_level];
1416         s->ltrt_center_mix_level   = LEVEL_MINUS_3DB;
1417         s->ltrt_surround_mix_level = LEVEL_MINUS_3DB;
1418         /* set downmixing coefficients if needed */
1419         if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1420                 s->fbw_channels == s->out_channels)) {
1421             set_downmix_coeffs(s);
1422         }
1423     } else if (!s->channels) {
1424         av_log(avctx, AV_LOG_ERROR, "unable to determine channel mode\n");
1425         return AVERROR_INVALIDDATA;
1426     }
1427     avctx->channels = s->out_channels;
1428     avctx->channel_layout = avpriv_ac3_channel_layout_tab[s->output_mode & ~AC3_OUTPUT_LFEON];
1429     if (s->output_mode & AC3_OUTPUT_LFEON)
1430         avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1431
1432     /* set audio service type based on bitstream mode for AC-3 */
1433     avctx->audio_service_type = s->bitstream_mode;
1434     if (s->bitstream_mode == 0x7 && s->channels > 1)
1435         avctx->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
1436
1437     /* get output buffer */
1438     frame->nb_samples = s->num_blocks * AC3_BLOCK_SIZE;
1439     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1440         return ret;
1441
1442     /* decode the audio blocks */
1443     channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1444     for (ch = 0; ch < AC3_MAX_CHANNELS; ch++) {
1445         output[ch] = s->output[ch];
1446         s->outptr[ch] = s->output[ch];
1447     }
1448     for (ch = 0; ch < s->channels; ch++) {
1449         if (ch < s->out_channels)
1450             s->outptr[channel_map[ch]] = (float *)frame->data[ch];
1451     }
1452     for (blk = 0; blk < s->num_blocks; blk++) {
1453         if (!err && decode_audio_block(s, blk)) {
1454             av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1455             err = 1;
1456         }
1457         if (err)
1458             for (ch = 0; ch < s->out_channels; ch++)
1459                 memcpy(((float*)frame->data[ch]) + AC3_BLOCK_SIZE*blk, output[ch], sizeof(**output) * AC3_BLOCK_SIZE);
1460         for (ch = 0; ch < s->out_channels; ch++)
1461             output[ch] = s->outptr[channel_map[ch]];
1462         for (ch = 0; ch < s->out_channels; ch++) {
1463             if (!ch || channel_map[ch])
1464                 s->outptr[channel_map[ch]] += AC3_BLOCK_SIZE;
1465         }
1466     }
1467
1468     av_frame_set_decode_error_flags(frame, err ? FF_DECODE_ERROR_INVALID_BITSTREAM : 0);
1469
1470     /* keep last block for error concealment in next frame */
1471     for (ch = 0; ch < s->out_channels; ch++)
1472         memcpy(s->output[ch], output[ch], sizeof(**output) * AC3_BLOCK_SIZE);
1473
1474     /*
1475      * AVMatrixEncoding
1476      *
1477      * Check whether the input layout is compatible, and make sure we're not
1478      * downmixing (else the matrix encoding is no longer applicable).
1479      */
1480     matrix_encoding = AV_MATRIX_ENCODING_NONE;
1481     if (s->channel_mode == AC3_CHMODE_STEREO &&
1482         s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1483         if (s->dolby_surround_mode == AC3_DSURMOD_ON)
1484             matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
1485         else if (s->dolby_headphone_mode == AC3_DHEADPHONMOD_ON)
1486             matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;
1487     } else if (s->channel_mode >= AC3_CHMODE_2F2R &&
1488                s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1489         switch (s->dolby_surround_ex_mode) {
1490         case AC3_DSUREXMOD_ON: // EX or PLIIx
1491             matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
1492             break;
1493         case AC3_DSUREXMOD_PLIIZ:
1494             matrix_encoding = AV_MATRIX_ENCODING_DPLIIZ;
1495             break;
1496         default: // not indicated or off
1497             break;
1498         }
1499     }
1500     if ((ret = ff_side_data_update_matrix_encoding(frame, matrix_encoding)) < 0)
1501         return ret;
1502
1503     /* AVDownmixInfo */
1504     if ((downmix_info = av_downmix_info_update_side_data(frame))) {
1505         switch (s->preferred_downmix) {
1506         case AC3_DMIXMOD_LTRT:
1507             downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_LTRT;
1508             break;
1509         case AC3_DMIXMOD_LORO:
1510             downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_LORO;
1511             break;
1512         case AC3_DMIXMOD_DPLII:
1513             downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_DPLII;
1514             break;
1515         default:
1516             downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_UNKNOWN;
1517             break;
1518         }
1519         downmix_info->center_mix_level        = gain_levels[s->       center_mix_level];
1520         downmix_info->center_mix_level_ltrt   = gain_levels[s->  center_mix_level_ltrt];
1521         downmix_info->surround_mix_level      = gain_levels[s->     surround_mix_level];
1522         downmix_info->surround_mix_level_ltrt = gain_levels[s->surround_mix_level_ltrt];
1523         if (s->lfe_mix_level_exists)
1524             downmix_info->lfe_mix_level       = gain_levels_lfe[s->lfe_mix_level];
1525         else
1526             downmix_info->lfe_mix_level       = 0.0; // -inf dB
1527     } else
1528         return AVERROR(ENOMEM);
1529
1530     *got_frame_ptr = 1;
1531
1532     return FFMIN(buf_size, s->frame_size);
1533 }
1534
1535 /**
1536  * Uninitialize the AC-3 decoder.
1537  */
1538 static av_cold int ac3_decode_end(AVCodecContext *avctx)
1539 {
1540     AC3DecodeContext *s = avctx->priv_data;
1541     ff_mdct_end(&s->imdct_512);
1542     ff_mdct_end(&s->imdct_256);
1543
1544     return 0;
1545 }
1546
1547 #define OFFSET(x) offsetof(AC3DecodeContext, x)
1548 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)
1549 static const AVOption options[] = {
1550     { "drc_scale", "percentage of dynamic range compression to apply", OFFSET(drc_scale), AV_OPT_TYPE_FLOAT, {.dbl = 1.0}, 0.0, 6.0, PAR },
1551
1552 {"dmix_mode", "Preferred Stereo Downmix Mode", OFFSET(preferred_stereo_downmix), AV_OPT_TYPE_INT, {.i64 = -1 }, -1, 2, 0, "dmix_mode"},
1553 {"ltrt_cmixlev",   "Lt/Rt Center Mix Level",   OFFSET(ltrt_center_mix_level),    AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
1554 {"ltrt_surmixlev", "Lt/Rt Surround Mix Level", OFFSET(ltrt_surround_mix_level),  AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
1555 {"loro_cmixlev",   "Lo/Ro Center Mix Level",   OFFSET(loro_center_mix_level),    AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
1556 {"loro_surmixlev", "Lo/Ro Surround Mix Level", OFFSET(loro_surround_mix_level),  AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
1557
1558     { NULL},
1559 };
1560
1561 static const AVClass ac3_decoder_class = {
1562     .class_name = "AC3 decoder",
1563     .item_name  = av_default_item_name,
1564     .option     = options,
1565     .version    = LIBAVUTIL_VERSION_INT,
1566 };
1567
1568 AVCodec ff_ac3_decoder = {
1569     .name           = "ac3",
1570     .long_name      = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
1571     .type           = AVMEDIA_TYPE_AUDIO,
1572     .id             = AV_CODEC_ID_AC3,
1573     .priv_data_size = sizeof (AC3DecodeContext),
1574     .init           = ac3_decode_init,
1575     .close          = ac3_decode_end,
1576     .decode         = ac3_decode_frame,
1577     .capabilities   = CODEC_CAP_DR1,
1578     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1579                                                       AV_SAMPLE_FMT_NONE },
1580     .priv_class     = &ac3_decoder_class,
1581 };
1582
1583 #if CONFIG_EAC3_DECODER
1584 static const AVClass eac3_decoder_class = {
1585     .class_name = "E-AC3 decoder",
1586     .item_name  = av_default_item_name,
1587     .option     = options,
1588     .version    = LIBAVUTIL_VERSION_INT,
1589 };
1590
1591 AVCodec ff_eac3_decoder = {
1592     .name           = "eac3",
1593     .long_name      = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
1594     .type           = AVMEDIA_TYPE_AUDIO,
1595     .id             = AV_CODEC_ID_EAC3,
1596     .priv_data_size = sizeof (AC3DecodeContext),
1597     .init           = ac3_decode_init,
1598     .close          = ac3_decode_end,
1599     .decode         = ac3_decode_frame,
1600     .capabilities   = CODEC_CAP_DR1,
1601     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1602                                                       AV_SAMPLE_FMT_NONE },
1603     .priv_class     = &eac3_decoder_class,
1604 };
1605 #endif