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