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