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