git.sesse.net Git - ffmpeg/blob - libavcodec/ac3dec.c

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