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

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