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