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

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