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