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