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