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

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