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