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