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