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