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

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