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