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

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