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, 1.0);
 198     ff_mdct_init(&s->imdct_512, 9, 1, 1.0);
 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_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_bands,
 739                                   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_bands)
 777         *num_bands = n_bands;
 778     if (band_sizes)
 779         memcpy(band_sizes, bnd_sz, n_bands);
 780 }
 781
 782 /**
 783  * Decode a single audio block from the AC-3 bitstream.
 784  */
 785 static int decode_audio_block(AC3DecodeContext *s, int blk)
 786 {
 787     int fbw_channels = s->fbw_channels;
 788     int channel_mode = s->channel_mode;
 789     int i, bnd, seg, ch;
 790     int different_transforms;
 791     int downmix_output;
 792     int cpl_in_use;
 793     GetBitContext *gbc = &s->gbc;
 794     uint8_t bit_alloc_stages[AC3_MAX_CHANNELS];
 795
 796     memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);
 797
 798     /* block switch flags */
 799     different_transforms = 0;
 800     if (s->block_switch_syntax) {
 801         for (ch = 1; ch <= fbw_channels; ch++) {
 802             s->block_switch[ch] = get_bits1(gbc);
 803             if(ch > 1 && s->block_switch[ch] != s->block_switch[1])
 804                 different_transforms = 1;
 805         }
 806     }
 807
 808     /* dithering flags */
 809     if (s->dither_flag_syntax) {
 810         for (ch = 1; ch <= fbw_channels; ch++) {
 811             s->dither_flag[ch] = get_bits1(gbc);
 812         }
 813     }
 814
 815     /* dynamic range */
 816     i = !(s->channel_mode);
 817     do {
 818         if(get_bits1(gbc)) {
 819             s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)]-1.0) *
 820                                   s->avctx->drc_scale)+1.0;
 821         } else if(blk == 0) {
 822             s->dynamic_range[i] = 1.0f;
 823         }
 824     } while(i--);
 825
 826     /* spectral extension strategy */
 827     if (s->eac3 && (!blk || get_bits1(gbc))) {
 828         if (get_bits1(gbc)) {
 829             ff_log_missing_feature(s->avctx, "Spectral extension", 1);
 830             return -1;
 831         }
 832         /* TODO: parse spectral extension strategy info */
 833     }
 834
 835     /* TODO: spectral extension coordinates */
 836
 837     /* coupling strategy */
 838     if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
 839         memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
 840         if (!s->eac3)
 841             s->cpl_in_use[blk] = get_bits1(gbc);
 842         if (s->cpl_in_use[blk]) {
 843             /* coupling in use */
 844             int cpl_start_subband, cpl_end_subband;
 845
 846             if (channel_mode < AC3_CHMODE_STEREO) {
 847                 av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
 848                 return -1;
 849             }
 850
 851             /* check for enhanced coupling */
 852             if (s->eac3 && get_bits1(gbc)) {
 853                 /* TODO: parse enhanced coupling strategy info */
 854                 ff_log_missing_feature(s->avctx, "Enhanced coupling", 1);
 855                 return -1;
 856             }
 857
 858             /* determine which channels are coupled */
 859             if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
 860                 s->channel_in_cpl[1] = 1;
 861                 s->channel_in_cpl[2] = 1;
 862             } else {
 863                 for (ch = 1; ch <= fbw_channels; ch++)
 864                     s->channel_in_cpl[ch] = get_bits1(gbc);
 865             }
 866
 867             /* phase flags in use */
 868             if (channel_mode == AC3_CHMODE_STEREO)
 869                 s->phase_flags_in_use = get_bits1(gbc);
 870
 871             /* coupling frequency range */
 872             /* TODO: modify coupling end freq if spectral extension is used */
 873             cpl_start_subband = get_bits(gbc, 4);
 874             cpl_end_subband   = get_bits(gbc, 4) + 3;
 875             if (cpl_start_subband >= cpl_end_subband) {
 876                 av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
 877                        cpl_start_subband, cpl_end_subband);
 878                 return -1;
 879             }
 880             s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
 881             s->end_freq[CPL_CH]   = cpl_end_subband   * 12 + 37;
 882
 883             decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
 884                                   cpl_end_subband,
 885                                   ff_eac3_default_cpl_band_struct,
 886                                   s->cpl_band_struct, &s->num_cpl_bands, NULL);
 887         } else {
 888             /* coupling not in use */
 889             for (ch = 1; ch <= fbw_channels; ch++) {
 890                 s->channel_in_cpl[ch] = 0;
 891                 s->first_cpl_coords[ch] = 1;
 892             }
 893             s->first_cpl_leak = s->eac3;
 894             s->phase_flags_in_use = 0;
 895         }
 896     } else if (!s->eac3) {
 897         if(!blk) {
 898             av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must be present in block 0\n");
 899             return -1;
 900         } else {
 901             s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
 902         }
 903     }
 904     cpl_in_use = s->cpl_in_use[blk];
 905
 906     /* coupling coordinates */
 907     if (cpl_in_use) {
 908         int cpl_coords_exist = 0;
 909
 910         for (ch = 1; ch <= fbw_channels; ch++) {
 911             if (s->channel_in_cpl[ch]) {
 912                 if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
 913                     int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
 914                     s->first_cpl_coords[ch] = 0;
 915                     cpl_coords_exist = 1;
 916                     master_cpl_coord = 3 * get_bits(gbc, 2);
 917                     for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
 918                         cpl_coord_exp = get_bits(gbc, 4);
 919                         cpl_coord_mant = get_bits(gbc, 4);
 920                         if (cpl_coord_exp == 15)
 921                             s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
 922                         else
 923                             s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
 924                         s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
 925                     }
 926                 } else if (!blk) {
 927                     av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must be present in block 0\n");
 928                     return -1;
 929                 }
 930             } else {
 931                 /* channel not in coupling */
 932                 s->first_cpl_coords[ch] = 1;
 933             }
 934         }
 935         /* phase flags */
 936         if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
 937             for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
 938                 s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
 939             }
 940         }
 941     }
 942
 943     /* stereo rematrixing strategy and band structure */
 944     if (channel_mode == AC3_CHMODE_STEREO) {
 945         if ((s->eac3 && !blk) || get_bits1(gbc)) {
 946             s->num_rematrixing_bands = 4;
 947             if(cpl_in_use && s->start_freq[CPL_CH] <= 61)
 948                 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
 949             for(bnd=0; bnd<s->num_rematrixing_bands; bnd++)
 950                 s->rematrixing_flags[bnd] = get_bits1(gbc);
 951         } else if (!blk) {
 952             av_log(s->avctx, AV_LOG_ERROR, "new rematrixing strategy must be present in block 0\n");
 953             return -1;
 954         }
 955     }
 956
 957     /* exponent strategies for each channel */
 958     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
 959         if (!s->eac3)
 960             s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
 961         if(s->exp_strategy[blk][ch] != EXP_REUSE)
 962             bit_alloc_stages[ch] = 3;
 963     }
 964
 965     /* channel bandwidth */
 966     for (ch = 1; ch <= fbw_channels; ch++) {
 967         s->start_freq[ch] = 0;
 968         if (s->exp_strategy[blk][ch] != EXP_REUSE) {
 969             int group_size;
 970             int prev = s->end_freq[ch];
 971             if (s->channel_in_cpl[ch])
 972                 s->end_freq[ch] = s->start_freq[CPL_CH];
 973             else {
 974                 int bandwidth_code = get_bits(gbc, 6);
 975                 if (bandwidth_code > 60) {
 976                     av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
 977                     return -1;
 978                 }
 979                 s->end_freq[ch] = bandwidth_code * 3 + 73;
 980             }
 981             group_size = 3 << (s->exp_strategy[blk][ch] - 1);
 982             s->num_exp_groups[ch] = (s->end_freq[ch]+group_size-4) / group_size;
 983             if(blk > 0 && s->end_freq[ch] != prev)
 984                 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
 985         }
 986     }
 987     if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
 988         s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
 989                                     (3 << (s->exp_strategy[blk][CPL_CH] - 1));
 990     }
 991
 992     /* decode exponents for each channel */
 993     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
 994         if (s->exp_strategy[blk][ch] != EXP_REUSE) {
 995             s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
 996             if (decode_exponents(gbc, s->exp_strategy[blk][ch],
 997                                  s->num_exp_groups[ch], s->dexps[ch][0],
 998                                  &s->dexps[ch][s->start_freq[ch]+!!ch])) {
 999                 av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
1000                 return -1;
1001             }
1002             if(ch != CPL_CH && ch != s->lfe_ch)
1003                 skip_bits(gbc, 2); /* skip gainrng */
1004         }
1005     }
1006
1007     /* bit allocation information */
1008     if (s->bit_allocation_syntax) {
1009         if (get_bits1(gbc)) {
1010             s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1011             s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1012             s->bit_alloc_params.slow_gain  = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
1013             s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
1014             s->bit_alloc_params.floor  = ff_ac3_floor_tab[get_bits(gbc, 3)];
1015             for(ch=!cpl_in_use; ch<=s->channels; ch++)
1016                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1017         } else if (!blk) {
1018             av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must be present in block 0\n");
1019             return -1;
1020         }
1021     }
1022
1023     /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1024     if(!s->eac3 || !blk){
1025         if(s->snr_offset_strategy && get_bits1(gbc)) {
1026             int snr = 0;
1027             int csnr;
1028             csnr = (get_bits(gbc, 6) - 15) << 4;
1029             for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1030                 /* snr offset */
1031                 if (ch == i || s->snr_offset_strategy == 2)
1032                     snr = (csnr + get_bits(gbc, 4)) << 2;
1033                 /* run at least last bit allocation stage if snr offset changes */
1034                 if(blk && s->snr_offset[ch] != snr) {
1035                     bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1036                 }
1037                 s->snr_offset[ch] = snr;
1038
1039                 /* fast gain (normal AC-3 only) */
1040                 if (!s->eac3) {
1041                     int prev = s->fast_gain[ch];
1042                     s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1043                     /* run last 2 bit allocation stages if fast gain changes */
1044                     if(blk && prev != s->fast_gain[ch])
1045                         bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1046                 }
1047             }
1048         } else if (!s->eac3 && !blk) {
1049             av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1050             return -1;
1051         }
1052     }
1053
1054     /* fast gain (E-AC-3 only) */
1055     if (s->fast_gain_syntax && get_bits1(gbc)) {
1056         for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1057             int prev = s->fast_gain[ch];
1058             s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1059             /* run last 2 bit allocation stages if fast gain changes */
1060             if(blk && prev != s->fast_gain[ch])
1061                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1062         }
1063     } else if (s->eac3 && !blk) {
1064         for (ch = !cpl_in_use; ch <= s->channels; ch++)
1065             s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1066     }
1067
1068     /* E-AC-3 to AC-3 converter SNR offset */
1069     if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1070         skip_bits(gbc, 10); // skip converter snr offset
1071     }
1072
1073     /* coupling leak information */
1074     if (cpl_in_use) {
1075         if (s->first_cpl_leak || get_bits1(gbc)) {
1076             int fl = get_bits(gbc, 3);
1077             int sl = get_bits(gbc, 3);
1078             /* run last 2 bit allocation stages for coupling channel if
1079                coupling leak changes */
1080             if(blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1081                        sl != s->bit_alloc_params.cpl_slow_leak)) {
1082                 bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1083             }
1084             s->bit_alloc_params.cpl_fast_leak = fl;
1085             s->bit_alloc_params.cpl_slow_leak = sl;
1086         } else if (!s->eac3 && !blk) {
1087             av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must be present in block 0\n");
1088             return -1;
1089         }
1090         s->first_cpl_leak = 0;
1091     }
1092
1093     /* delta bit allocation information */
1094     if (s->dba_syntax && get_bits1(gbc)) {
1095         /* delta bit allocation exists (strategy) */
1096         for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1097             s->dba_mode[ch] = get_bits(gbc, 2);
1098             if (s->dba_mode[ch] == DBA_RESERVED) {
1099                 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1100                 return -1;
1101             }
1102             bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1103         }
1104         /* channel delta offset, len and bit allocation */
1105         for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1106             if (s->dba_mode[ch] == DBA_NEW) {
1107                 s->dba_nsegs[ch] = get_bits(gbc, 3);
1108                 for (seg = 0; seg <= s->dba_nsegs[ch]; seg++) {
1109                     s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1110                     s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1111                     s->dba_values[ch][seg] = get_bits(gbc, 3);
1112                 }
1113                 /* run last 2 bit allocation stages if new dba values */
1114                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1115             }
1116         }
1117     } else if(blk == 0) {
1118         for(ch=0; ch<=s->channels; ch++) {
1119             s->dba_mode[ch] = DBA_NONE;
1120         }
1121     }
1122
1123     /* Bit allocation */
1124     for(ch=!cpl_in_use; ch<=s->channels; ch++) {
1125         if(bit_alloc_stages[ch] > 2) {
1126             /* Exponent mapping into PSD and PSD integration */
1127             ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
1128                                       s->start_freq[ch], s->end_freq[ch],
1129                                       s->psd[ch], s->band_psd[ch]);
1130         }
1131         if(bit_alloc_stages[ch] > 1) {
1132             /* Compute excitation function, Compute masking curve, and
1133                Apply delta bit allocation */
1134             if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1135                                            s->start_freq[ch], s->end_freq[ch],
1136                                            s->fast_gain[ch], (ch == s->lfe_ch),
1137                                            s->dba_mode[ch], s->dba_nsegs[ch],
1138                                            s->dba_offsets[ch], s->dba_lengths[ch],
1139                                            s->dba_values[ch], s->mask[ch])) {
1140                 av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1141                 return -1;
1142             }
1143         }
1144         if(bit_alloc_stages[ch] > 0) {
1145             /* Compute bit allocation */
1146             const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1147                                      ff_eac3_hebap_tab : ff_ac3_bap_tab;
1148             ff_ac3_bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1149                                       s->start_freq[ch], s->end_freq[ch],
1150                                       s->snr_offset[ch],
1151                                       s->bit_alloc_params.floor,
1152                                       bap_tab, s->bap[ch]);
1153         }
1154     }
1155
1156     /* unused dummy data */
1157     if (s->skip_syntax && get_bits1(gbc)) {
1158         int skipl = get_bits(gbc, 9);
1159         while(skipl--)
1160             skip_bits(gbc, 8);
1161     }
1162
1163     /* unpack the transform coefficients
1164        this also uncouples channels if coupling is in use. */
1165     decode_transform_coeffs(s, blk);
1166
1167     /* TODO: generate enhanced coupling coordinates and uncouple */
1168
1169     /* TODO: apply spectral extension */
1170
1171     /* recover coefficients if rematrixing is in use */
1172     if(s->channel_mode == AC3_CHMODE_STEREO)
1173         do_rematrixing(s);
1174
1175     /* apply scaling to coefficients (headroom, dynrng) */
1176     for(ch=1; ch<=s->channels; ch++) {
1177         float gain = s->mul_bias / 4194304.0f;
1178         if(s->channel_mode == AC3_CHMODE_DUALMONO) {
1179             gain *= s->dynamic_range[ch-1];
1180         } else {
1181             gain *= s->dynamic_range[0];
1182         }
1183         s->dsp.int32_to_float_fmul_scalar(s->transform_coeffs[ch], s->fixed_coeffs[ch], gain, 256);
1184     }
1185
1186     /* downmix and MDCT. order depends on whether block switching is used for
1187        any channel in this block. this is because coefficients for the long
1188        and short transforms cannot be mixed. */
1189     downmix_output = s->channels != s->out_channels &&
1190                      !((s->output_mode & AC3_OUTPUT_LFEON) &&
1191                      s->fbw_channels == s->out_channels);
1192     if(different_transforms) {
1193         /* the delay samples have already been downmixed, so we upmix the delay
1194            samples in order to reconstruct all channels before downmixing. */
1195         if(s->downmixed) {
1196             s->downmixed = 0;
1197             ac3_upmix_delay(s);
1198         }
1199
1200         do_imdct(s, s->channels);
1201
1202         if(downmix_output) {
1203             s->dsp.ac3_downmix(s->output, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
1204         }
1205     } else {
1206         if(downmix_output) {
1207             s->dsp.ac3_downmix(s->transform_coeffs+1, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
1208         }
1209
1210         if(downmix_output && !s->downmixed) {
1211             s->downmixed = 1;
1212             s->dsp.ac3_downmix(s->delay, s->downmix_coeffs, s->out_channels, s->fbw_channels, 128);
1213         }
1214
1215         do_imdct(s, s->out_channels);
1216     }
1217
1218     return 0;
1219 }
1220
1221 /**
1222  * Decode a single AC-3 frame.
1223  */
1224 static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size,
1225                             AVPacket *avpkt)
1226 {
1227     const uint8_t *buf = avpkt->data;
1228     int buf_size = avpkt->size;
1229     AC3DecodeContext *s = avctx->priv_data;
1230     int16_t *out_samples = (int16_t *)data;
1231     int blk, ch, err;
1232     const uint8_t *channel_map;
1233     const float *output[AC3_MAX_CHANNELS];
1234
1235     /* initialize the GetBitContext with the start of valid AC-3 Frame */
1236     if (s->input_buffer) {
1237         /* copy input buffer to decoder context to avoid reading past the end
1238            of the buffer, which can be caused by a damaged input stream. */
1239         memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1240         init_get_bits(&s->gbc, s->input_buffer, buf_size * 8);
1241     } else {
1242         init_get_bits(&s->gbc, buf, buf_size * 8);
1243     }
1244
1245     /* parse the syncinfo */
1246     *data_size = 0;
1247     err = parse_frame_header(s);
1248
1249     /* check that reported frame size fits in input buffer */
1250     if(s->frame_size > buf_size) {
1251         av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1252         err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
1253     }
1254
1255     /* check for crc mismatch */
1256     if(err != AAC_AC3_PARSE_ERROR_FRAME_SIZE && avctx->error_recognition >= FF_ER_CAREFUL) {
1257         if(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2], s->frame_size-2)) {
1258             av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1259             err = AAC_AC3_PARSE_ERROR_CRC;
1260         }
1261     }
1262
1263     if(err && err != AAC_AC3_PARSE_ERROR_CRC) {
1264         switch(err) {
1265             case AAC_AC3_PARSE_ERROR_SYNC:
1266                 av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1267                 return -1;
1268             case AAC_AC3_PARSE_ERROR_BSID:
1269                 av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1270                 break;
1271             case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
1272                 av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1273                 break;
1274             case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
1275                 av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1276                 break;
1277             case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
1278                 /* skip frame if CRC is ok. otherwise use error concealment. */
1279                 /* TODO: add support for substreams and dependent frames */
1280                 if(s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
1281                     av_log(avctx, AV_LOG_ERROR, "unsupported frame type : skipping frame\n");
1282                     return s->frame_size;
1283                 } else {
1284                     av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1285                 }
1286                 break;
1287             default:
1288                 av_log(avctx, AV_LOG_ERROR, "invalid header\n");
1289                 break;
1290         }
1291     }
1292
1293     /* if frame is ok, set audio parameters */
1294     if (!err) {
1295         avctx->sample_rate = s->sample_rate;
1296         avctx->bit_rate = s->bit_rate;
1297
1298         /* channel config */
1299         s->out_channels = s->channels;
1300         s->output_mode = s->channel_mode;
1301         if(s->lfe_on)
1302             s->output_mode |= AC3_OUTPUT_LFEON;
1303         if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&
1304                 avctx->request_channels < s->channels) {
1305             s->out_channels = avctx->request_channels;
1306             s->output_mode  = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1307             s->channel_layout = ff_ac3_channel_layout_tab[s->output_mode];
1308         }
1309         avctx->channels = s->out_channels;
1310         avctx->channel_layout = s->channel_layout;
1311
1312         /* set downmixing coefficients if needed */
1313         if(s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1314                 s->fbw_channels == s->out_channels)) {
1315             set_downmix_coeffs(s);
1316         }
1317     } else if (!s->out_channels) {
1318         s->out_channels = avctx->channels;
1319         if(s->out_channels < s->channels)
1320             s->output_mode  = s->out_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1321     }
1322
1323     /* decode the audio blocks */
1324     channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1325     for (ch = 0; ch < s->out_channels; ch++)
1326         output[ch] = s->output[channel_map[ch]];
1327     for (blk = 0; blk < s->num_blocks; blk++) {
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         s->dsp.float_to_int16_interleave(out_samples, output, 256, s->out_channels);
1333         out_samples += 256 * s->out_channels;
1334     }
1335     *data_size = s->num_blocks * 256 * avctx->channels * sizeof (int16_t);
1336     return s->frame_size;
1337 }
1338
1339 /**
1340  * Uninitialize the AC-3 decoder.
1341  */
1342 static av_cold int ac3_decode_end(AVCodecContext *avctx)
1343 {
1344     AC3DecodeContext *s = avctx->priv_data;
1345     ff_mdct_end(&s->imdct_512);
1346     ff_mdct_end(&s->imdct_256);
1347
1348     av_freep(&s->input_buffer);
1349
1350     return 0;
1351 }
1352
1353 AVCodec ac3_decoder = {
1354     .name = "ac3",
1355     .type = CODEC_TYPE_AUDIO,
1356     .id = CODEC_ID_AC3,
1357     .priv_data_size = sizeof (AC3DecodeContext),
1358     .init = ac3_decode_init,
1359     .close = ac3_decode_end,
1360     .decode = ac3_decode_frame,
1361     .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
1362 };
1363
1364 AVCodec eac3_decoder = {
1365     .name = "eac3",
1366     .type = CODEC_TYPE_AUDIO,
1367     .id = CODEC_ID_EAC3,
1368     .priv_data_size = sizeof (AC3DecodeContext),
1369     .init = ac3_decode_init,
1370     .close = ac3_decode_end,
1371     .decode = ac3_decode_frame,
1372     .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
1373 };