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

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