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