ffmpeg/libavcodec/ac3dec.c

/* AC3 Audio Decoder.
 *
 * Copyright (c) 2006 Kartikey Mahendra BHATT (bhattkm at gmail dot com).
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <stdio.h>
#include <stddef.h>
#include <math.h>
#include <inttypes.h>
#include <string.h>

#define ALT_BITSTREAM_READER
#include "ac3_decoder.h"
#include "avcodec.h"
#include "bitstream.h"
#include "dsputil.h"
#include "avutil.h"

static const int sampling_rates[3] = { 32000, 44100, 48000 };

static const struct
{
  int bit_rate;
  int frame_sizes[3];
} frame_size_table[38] = {
  { 32, { 96, 69, 64 } },
  { 32, { 96, 70, 64 } },
  { 40, { 120, 87, 80 } },
  { 40, { 120, 88, 80 } },
  { 48, { 144, 104, 96 } },
  { 48, { 144, 105, 96 } },
  { 56, { 168, 121, 112 } },
  { 56, { 168, 122, 112 } },
  { 64, { 192, 139, 128 } },
  { 64, { 192, 140, 128 } },
  { 80, { 240, 174, 160 } },
  { 80, { 240, 175, 160 } },
  { 96, { 288, 208, 192 } },
  { 96, { 288, 209, 192 } },
  { 112, { 336, 243, 224 } },
  { 112, { 336, 244, 224 } },
  { 128, { 384, 278, 256 } },
  { 128, { 384, 279, 256 } },
  { 160, { 480, 348, 320 } },
  { 160, { 480, 349, 320 } },
  { 192, { 576, 417, 384 } },
  { 192, { 576, 418, 384 } },
  { 224, { 672, 487, 448 } },
  { 224, { 672, 488, 448 } },
  { 256, { 768, 557, 512 } },
  { 256, { 768, 558, 512 } },
  { 320, { 960, 696, 640 } },
  { 320, { 960, 697, 640 } },
  { 384, { 1152, 835, 768 } },
  { 384, { 1152, 836, 768 } },
  { 448, { 1344, 975, 896 } },
  { 448, { 1344, 976, 896 } },
  { 512, { 1536, 1114, 1024 } },
  { 512, { 1536, 1115, 1024 } },
  { 576, { 1728, 1253, 1152 } },
  { 576, { 1728, 1254, 1152 } },
  { 640, { 1920, 1393, 1280 } }
};

static int
ac3_decode_init (AVCodecContext * avctx)
{
  AC3DecodeContext *ctx = avctx->priv_data;

  ff_mdct_init (&ctx->mdct_ctx_256, 8, 1);
  ff_mdct_init (&ctx->mdct_ctx_512, 9, 1);
  ctx->samples = av_mallocz (6 * 6 * 256 * sizeof (float));
  if (!(ctx->samples))
    return -1;

  return 0;
}

static int
ac3_synchronize (uint8_t * buf, int buf_size)
{
  int i;

  for (i = 0; i < buf_size - 1; i++)
    if (buf[i] == 0x0b && buf[i + 1] == 0x77)
      return i;

  return -1;
}

//Returns -1 when 'fscod' is not valid;
static int
ac3_parse_sync_info (AC3DecodeContext * ctx)
{
  ac3_sync_info *sync_info = &ctx->sync_info;
  GetBitContext *gb = &ctx->gb;

  sync_info->sync_word = get_bits_long (gb, 16);
  sync_info->crc1 = get_bits_long (gb, 16);
  sync_info->fscod = get_bits_long (gb, 2);
  if (sync_info->fscod == 0x03)
    return -1;
  sync_info->frmsizecod = get_bits_long (gb, 6);
  if (sync_info->frmsizecod >= 0x38)
    return -1;
  sync_info->sampling_rate = sampling_rates[sync_info->fscod];
  sync_info->bit_rate = frame_size_table[sync_info->frmsizecod].bit_rate;
  sync_info->frame_size = frame_size_table[sync_info->frmsizecod].frame_sizes[sync_info->fscod];

  return 0;
}

static const int nfchans_tbl[8] = { 2, 1, 2, 3, 3, 4, 4, 5 };

//Returns -1 when
static int
ac3_parse_bsi (AC3DecodeContext * ctx)
{
  ac3_bsi *bsi = &ctx->bsi;
  uint32_t *flags = &bsi->flags;
  GetBitContext *gb = &ctx->gb;

  *flags = 0;
  bsi->cmixlev = 0;
  bsi->surmixlev = 0;
  bsi->dsurmod = 0;

  bsi->bsid = get_bits_long (gb, 5);
  if (bsi->bsid > 0x08)
    return -1;
  bsi->bsmod = get_bits_long (gb, 3);
  bsi->acmod = get_bits_long (gb, 3);
  if (bsi->acmod & 0x01 && bsi->acmod != 0x01)
    bsi->cmixlev = get_bits_long (gb, 2);
  if (bsi->acmod & 0x04)
    bsi->surmixlev = get_bits_long (gb, 2);
  if (bsi->acmod == 0x02)
    bsi->dsurmod = get_bits_long (gb, 2);
  if (get_bits_long (gb, 1))
    *flags |= AC3_BSI_LFEON;
  bsi->dialnorm = get_bits_long (gb, 5);
  if (get_bits_long (gb, 1)) {
    *flags |= AC3_BSI_COMPRE;
    bsi->compr = get_bits_long (gb, 5);
  }
  if (get_bits_long (gb, 1)) {
    *flags |= AC3_BSI_LANGCODE;
    bsi->langcod = get_bits_long (gb, 8);
  }
  if (get_bits_long (gb, 1)) {
    *flags |= AC3_BSI_AUDPRODIE;
    bsi->mixlevel = get_bits_long (gb, 5);
    bsi->roomtyp = get_bits_long (gb, 2);
  }
  if (bsi->acmod == 0x00) {
    bsi->dialnorm2 = get_bits_long (gb, 5);
    if (get_bits_long (gb, 1)) {
      *flags |= AC3_BSI_COMPR2E;
      bsi->compr2 = get_bits_long (gb, 5);
    }
    if (get_bits_long (gb, 1)) {
      *flags |= AC3_BSI_LANGCOD2E;
      bsi->langcod2 = get_bits_long (gb, 8);
    }
    if (get_bits_long (gb, 1)) {
      *flags |= AC3_BSI_AUDPRODIE;
      bsi->mixlevel2 = get_bits_long (gb, 5);
      bsi->roomtyp2 = get_bits_long (gb, 2);
    }
  }
  if (get_bits_long (gb, 1))
    *flags |= AC3_BSI_COPYRIGHTB;
  if (get_bits_long (gb, 1))
    *flags |= AC3_BSI_ORIGBS;
  if (get_bits_long (gb, 1)) {
    *flags |= AC3_BSI_TIMECOD1E;
    bsi->timecod1 = get_bits_long (gb, 14);
  }
  if (get_bits_long (gb, 1)) {
    *flags |= AC3_BSI_TIMECOD2E;
    bsi->timecod2 = get_bits_long (gb, 14);
  }
  if (get_bits_long (gb, 1)) {
    *flags |= AC3_BSI_ADDBSIE;
    bsi->addbsil = get_bits_long (gb, 6);
    do {
      get_bits_long (gb, 8);
    } while (bsi->addbsil--);
  }

  bsi->nfchans = nfchans_tbl[bsi->acmod];
  return 0;
}

static int bands[16] =
{ 31, 35, 37, 39, 41, 42, 43, 44,
  45, 45, 46, 46, 47, 47, 48, 48 };

static const int diff_exps_M1[128] =
  { -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
     25, 25, 25 };

static const int diff_exps_M2[128] =
  { -2, -2, -2, -2, -2, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2,
    -2, -2, -2, -2, -2, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2,
    -2, -2, -2, -2, -2, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2,
    -2, -2, -2, -2, -2, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2,
    -2, -2, -2, -2, -2, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2,
    25, 25, 25 };

static const int diff_exps_M3[128] =
  { -2, -1, 0, 1, 2, -2, -1, 0, 1, 2, -2, -1, 0, 1, 2, -2, -1, 0, 1, 2, -2, -1, 0, 1, 2,
    -2, -1, 0, 1, 2, -2, -1, 0, 1, 2, -2, -1, 0, 1, 2, -2, -1, 0, 1, 2, -2, -1, 0, 1, 2,
    -2, -1, 0, 1, 2, -2, -1, 0, 1, 2, -2, -1, 0, 1, 2, -2, -1, 0, 1, 2, -2, -1, 0, 1, 2,
    -2, -1, 0, 1, 2, -2, -1, 0, 1, 2, -2, -1, 0, 1, 2, -2, -1, 0, 1, 2, -2, -1, 0, 1, 2,
    -2, -1, 0, 1, 2, -2, -1, 0, 1, 2, -2, -1, 0, 1, 2, -2, -1, 0, 1, 2, -2, -1, 0, 1, 2,
    25, 25, 25 };

/* Decodes the grouped exponents (gexps) and stores them
 * in decoded exponents (dexps).
 */
static int
_decode_exponents (int expstr, int ngrps, uint8_t absexp, uint8_t * gexps, uint8_t * dexps)
{
  int i = 0, exp;
  while (ngrps--) {
    exp = gexps[i++];

    absexp += diff_exps_M1[exp];
    if (absexp > 24)
      return -1;
    if (expstr == AC3_EXPSTR_D45) {
      *(dexps++) = absexp;
      *(dexps++) = absexp;
    }
    else if (expstr == AC3_EXPSTR_D25)
      *(dexps++) = absexp;
    else
      *(dexps++) = absexp;

    absexp += diff_exps_M2[exp];
    if (absexp > 24)
      return -1;
    if (expstr == AC3_EXPSTR_D45) {
      *(dexps++) = absexp;
      *(dexps++) = absexp;
    }
    else if (expstr == AC3_EXPSTR_D25)
      *(dexps++) = absexp;
    else
      *(dexps++) = absexp;

    absexp += diff_exps_M3[exp];
    if (absexp > 24)
      return -1;
    if (expstr == AC3_EXPSTR_D45) {
      *(dexps++) = absexp;
      *(dexps++) = absexp;
    }
    else if (expstr == AC3_EXPSTR_D25)
      *(dexps++) = absexp;
    else
      *(dexps++) = absexp;
  }

  return 0;
}

static int
decode_exponents (AC3DecodeContext * ctx)
{
  ac3_audio_block *ab = &ctx->audio_block;
  int i;
  uint8_t *exps;
  uint8_t *dexps;

  if (ab->flags & AC3_AB_CPLINU && ab->cplexpstr != AC3_EXPSTR_REUSE)
    if (_decode_exponents (ab->cplexpstr, ab->ncplgrps, ab->cplabsexp,
                           ab->cplexps, ab->dcplexps + ab->cplstrtmant))
      return -1;
  for (i = 0; i < ctx->bsi.nfchans; i++)
    if (ab->chexpstr[i] != AC3_EXPSTR_REUSE) {
      exps = ab->exps[i];
      dexps = ab->dexps[i];
      if (_decode_exponents (ab->chexpstr[i], ab->nchgrps[i], exps[0], exps + 1, dexps + 1))
        return -1;
    }
  if (ctx->bsi.flags & AC3_BSI_LFEON && ab->lfeexpstr != AC3_EXPSTR_REUSE)
    if (_decode_exponents (ab->lfeexpstr, 2, ab->lfeexps[0], ab->lfeexps + 1, ab->dlfeexps))
      return -1;
  return 0;
}

static const int16_t slowdec[4] = { 0x0f, 0x11, 0x13, 0x15 }; /* slow decay table */
static const int16_t fastdec[4] = { 0x3f, 0x53, 0x67, 0x7b }; /* fast decay table */
static const int16_t slowgain[4] = { 0x540, 0x4d8, 0x478, 0x410 };   /* slow gain table */
static const int16_t dbpbtab[4] = { 0x000, 0x700, 0x900, 0xb00 };    /* dB/bit table */

static const int16_t floortab[8] =  /* floor table */
{ 0x2f0, 0x2b0, 0x270, 0x230,
  0x1f0, 0x170, 0x0f0, 0xf800 };

static const int16_t fastgain[8] = /* fast gain table */
{ 0x080, 0x100, 0x180, 0x200,
  0x280, 0x300, 0x380, 0x400 };

static const int16_t bndtab[50] = /* start band table */
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
  27, 28, 31, 34, 37, 40, 43, 46, 49, 55, 61, 67, 73, 79, 85, 97, 109, 121, 133, 157, 181, 205, 229 };

static const int16_t bndsz[50] = /* band size table */
{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  1, 1, 1, 3, 3, 3, 3, 3, 3, 3, 6, 6, 6, 6, 6, 6, 12, 12, 12, 12, 24, 24, 24, 24, 24 };

static const int16_t masktab[256] = /* masking table */
{  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
  25, 26, 27, 28, 28, 28, 29, 29, 29, 30, 30, 30, 31, 31, 31, 32, 32, 32, 33, 33, 33, 34, 34, 34, 35,
  35, 35, 35, 35, 35, 36, 36, 36, 36, 36, 36, 37, 37, 37, 37, 37, 37, 38, 38, 38, 38, 38, 38, 39, 39,
  39, 39, 39, 39, 40, 40, 40, 40, 40, 40, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 42, 42, 42,
  42, 42, 42, 42, 42, 42, 42, 42, 42, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 44, 44, 44, 44,
  44, 44, 44, 44, 44, 44, 44, 44, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
  45, 45, 45, 45, 45, 45, 45, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
  46, 46, 46, 46, 46, 46, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
  47, 47, 47, 47, 47, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
  48, 48, 48, 48, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
  49, 49, 49, 0, 0, 0 };

static const int16_t latab[256] = /* log addition table */
{ 0x0040, 0x003f, 0x003e, 0x003d, 0x003c, 0x003b, 0x003a, 0x0039, 0x0038, 0x0037, 0x0036, 0x0035,
  0x0034, 0x0034, 0x0033, 0x0032, 0x0031, 0x0030, 0x002f, 0x002f, 0x002e, 0x002d, 0x002c, 0x002c,
  0x002b, 0x002a, 0x0029, 0x0029, 0x0028, 0x0027, 0x0026, 0x0026, 0x0025, 0x0024, 0x0024, 0x0023,
  0x0023, 0x0022, 0x0021, 0x0021, 0x0020, 0x0020, 0x001f, 0x001e, 0x001e, 0x001d, 0x001d, 0x001c,
  0x001c, 0x001b, 0x001b, 0x001a, 0x001a, 0x0019, 0x0019, 0x0018, 0x0018, 0x0017, 0x0017, 0x0016,
  0x0016, 0x0015, 0x0015, 0x0015, 0x0014, 0x0014, 0x0013, 0x0013, 0x0013, 0x0012, 0x0012, 0x0012,
  0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0010, 0x000f, 0x000f, 0x000f, 0x000e, 0x000e, 0x000e,
  0x000d, 0x000d, 0x000d, 0x000d, 0x000c, 0x000c, 0x000c, 0x000c, 0x000b, 0x000b, 0x000b, 0x000b,
  0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x0009, 0x0009, 0x0009, 0x0009, 0x0009, 0x0008, 0x0008,
  0x0008, 0x0008, 0x0008, 0x0008, 0x0007, 0x0007, 0x0007, 0x0007, 0x0007, 0x0007, 0x0006, 0x0006,
  0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0005,
  0x0005, 0x0005, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004,
  0x0004, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003,
  0x0003, 0x0003, 0x0003, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002,
  0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0001, 0x0001,
  0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
  0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
  0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
  0x0000, 0x0000, 0x0000, 0x0000 };

static const int16_t hth[3][50] = /* hearing threshold table */
{
  {0x04d0, 0x04d0, 0x0440, 0x0400, 0x03e0, 0x03c0, 0x03b0, 0x03b0, 0x03a0, 0x03a0, 0x03a0, 0x03a0,
   0x03a0, 0x0390, 0x0390, 0x0390, 0x0380, 0x0380, 0x0370, 0x0370, 0x0360, 0x0360, 0x0350, 0x0350,
   0x0340, 0x0340, 0x0330, 0x0320, 0x0310, 0x0300, 0x02f0, 0x02f0, 0x02f0, 0x02f0, 0x0300, 0x0310,
   0x0340, 0x0390, 0x03e0, 0x0420, 0x0460, 0x0490, 0x04a0, 0x0440, 0x0440, 0x0400, 0x0520, 0x0800,
   0x0840, 0x0840},
  {0x04f0, 0x04f0, 0x0460, 0x0410, 0x03e0, 0x03d0, 0x03c0, 0x03b0, 0x03b0, 0x03a0, 0x03a0, 0x03a0,
   0x03a0, 0x03a0, 0x0390, 0x0390, 0x0390, 0x0380, 0x0380, 0x0380, 0x0370, 0x0370, 0x0360, 0x0360,
   0x0350, 0x0350, 0x0340, 0x0340, 0x0320, 0x0310, 0x0300, 0x02f0, 0x02f0, 0x02f0, 0x02f0, 0x0300,
   0x0320, 0x0350, 0x0390, 0x03e0, 0x0420, 0x0450, 0x04a0, 0x0490, 0x0460, 0x0440, 0x0480, 0x0630,
   0x0840, 0x0840},
  {0x0580, 0x0580, 0x04b0, 0x0450, 0x0420, 0x03f0, 0x03e0, 0x03d0, 0x03c0, 0x03b0, 0x03b0, 0x03b0,
   0x03a0, 0x03a0, 0x03a0, 0x03a0, 0x03a0, 0x03a0, 0x03a0, 0x03a0, 0x0390, 0x0390, 0x0390, 0x0390,
   0x0380, 0x0380, 0x0380, 0x0370, 0x0360, 0x0350, 0x0340, 0x0330, 0x0320, 0x0310, 0x0300, 0x02f0,
   0x02f0, 0x02f0, 0x0300, 0x0310, 0x0330, 0x0350, 0x03c0, 0x0410, 0x0470, 0x04a0, 0x0460, 0x0440,
   0x0450, 0x04e0}
};

static const uint8_t baptab[64] = /* bit allocation pointer table */
{ 0, 1, 1, 1, 1, 1, 2, 2, 3, 3, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 10,
  10, 10, 10, 11, 11, 11, 11, 12, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 15,
  15, 15, 15, 15, 15, 15, 15, 15 };

static inline int16_t
logadd (int16_t a, int16_t b)
{
  int16_t c = a - b;
  uint8_t address = FFMIN ((ABS (c) >> 1), 255);

  return ((c >= 0) ? (a + latab[address]) : (b + latab[address]));
}

static inline int16_t
calc_lowcomp (int16_t a, int16_t b0, int16_t b1, uint8_t bin)
{
  if (bin < 7) {
    if ((b0 + 256) == b1)
      a = 384;
    else if (b0 > b1)
      a = FFMAX (0, a - 64);
  }
  else if (bin < 20) {
    if ((b0 + 256) == b1)
      a = 320;
    else if (b0 > b1)
      a = FFMAX (0, a - 64);
  }
  else {
    a = FFMAX (0, a - 128);
  }

  return a;
}

/* do the bit allocation for chnl.
 * chnl = 0 to 4 - fbw channel
 * chnl = 5 coupling channel
 * chnl = 6 lfe channel
 */
static int
_do_bit_allocation (AC3DecodeContext * ctx, int chnl)
{
  ac3_audio_block *ab = &ctx->audio_block;
  int16_t sdecay, fdecay, sgain, dbknee, floor;
  int16_t lowcomp, fgain, snroffset, fastleak, slowleak;
  int16_t psd[256], bndpsd[50], excite[50], mask[50], delta;
  uint8_t start, end, bin, i, j, k, lastbin, bndstrt, bndend, begin, deltnseg, band, seg, address;
  uint8_t fscod = ctx->sync_info.fscod;
  uint8_t *exps, *deltoffst, *deltlen, *deltba;
  uint8_t *baps;
  int do_delta = 0;

  /* initialization */
  sdecay = slowdec[ab->sdcycod];
  fdecay = fastdec[ab->fdcycod];
  sgain = slowgain[ab->sgaincod];
  dbknee = dbpbtab[ab->dbpbcod];
  floor = dbpbtab[ab->floorcod];

  if (chnl == 5) {
    start = ab->cplstrtmant;
    end = ab->cplendmant;
    fgain = fastgain[ab->cplfgaincod];
    snroffset = (((ab->csnroffst - 15) << 4) + ab->cplfsnroffst) << 2;
    fastleak = (ab->cplfleak << 8) + 768;
    slowleak = (ab->cplsleak << 8) + 768;
    exps = ab->dcplexps;
    baps = ab->cplbap;
    if (ab->cpldeltbae == 0 || ab->cpldeltbae == 1) {
      do_delta = 1;
      deltnseg = ab->cpldeltnseg;
      deltoffst = ab->cpldeltoffst;
      deltlen = ab->cpldeltlen;
      deltba = ab->cpldeltba;
    }
  }
  else if (chnl == 6) {
    start = 0;
    end = 7;
    lowcomp = 0;
    fgain = fastgain[ab->lfefgaincod];
    snroffset = (((ab->csnroffst - 15) << 4) + ab->lfefsnroffst) << 2;
    exps = ab->dlfeexps;
    baps = ab->lfebap;
  }
  else {
    start = 0;
    end = ab->endmant[chnl];
    lowcomp = 0;
    fgain = fastgain[ab->fgaincod[chnl]];
    snroffset = (((ab->csnroffst - 15) << 4) + ab->fsnroffst[chnl]) << 2;
    exps = ab->dexps[chnl];
    baps = ab->bap[chnl];
    if (ab->deltbae[chnl] == 0 || ab->deltbae[chnl] == 1) {
      do_delta = 1;
      deltnseg = ab->deltnseg[chnl];
      deltoffst = ab->deltoffst[chnl];
      deltlen = ab->deltlen[chnl];
      deltba = ab->deltba[chnl];
    }
  }

  for (bin = start; bin < end; bin++) /* exponent mapping into psd */
    psd[bin] = (3072 - ((int16_t) (exps[bin] << 7)));

  /* psd integration */
  j = start;
  k = masktab[start];
  do {
    lastbin = FFMIN (bndtab[k] + bndsz[k], end);
    bndpsd[k] = psd[j];
    j++;
    for (i = j; i < lastbin; i++) {
      bndpsd[k] = logadd (bndpsd[k], psd[j]);
      j++;
    }
    k++;
  } while (end > lastbin);

  /* compute the excite function */
  bndstrt = masktab[start];
  bndend = masktab[end - 1] + 1;
  if (bndstrt == 0) {
    lowcomp = calc_lowcomp (lowcomp, bndpsd[0], bndpsd[1], 0);
    excite[0] = bndpsd[0] - fgain - lowcomp;
    lowcomp = calc_lowcomp (lowcomp, bndpsd[1], bndpsd[2], 1);
    excite[1] = bndpsd[1] - fgain - lowcomp;
    begin = 7;
    for (bin = 2; bin < 7; bin++) {
      if (bndend != 7 || bin != 6)
        lowcomp = calc_lowcomp (lowcomp, bndpsd[bin], bndpsd[bin + 1], bin);
      fastleak = bndpsd[bin] - fgain;
      slowleak = bndpsd[bin] - sgain;
      excite[bin] = fastleak - lowcomp;
      if (bndend != 7 || bin != 6)
        if (bndpsd[bin] <= bndpsd[bin + 1]) {
          begin = bin + 1;
          break;
        }
    }
    for (bin = begin; bin < (FFMIN (bndend, 22)); bin++) {
      if (bndend != 7 || bin != 6)
        lowcomp = calc_lowcomp (lowcomp, bndpsd[bin], bndpsd[bin + 1], bin);
      fastleak -= fdecay;
      fastleak = FFMAX (fastleak, bndpsd[bin] - fgain);
      slowleak -= sdecay;
      slowleak = FFMAX (slowleak, bndpsd[bin] - sgain);
      excite[bin] = FFMAX (fastleak - lowcomp, slowleak);
    }
    begin = 22;
  }
  else {
    begin = bndstrt;
  }
  for (bin = begin; bin < bndend; bin++) {
    fastleak -= fdecay;
    fastleak = FFMAX (fastleak, bndpsd[bin] - fgain);
    slowleak -= sdecay;
    slowleak = FFMAX (slowleak, bndpsd[bin] - sgain);
    excite[bin] = FFMAX (fastleak, slowleak);
  }

  /* compute the masking curve */
  for (bin = bndstrt; bin < bndend; bin++) {
    if (bndpsd[bin] < dbknee)
      excite[bin] += ((dbknee - bndpsd[bin]) >> 2);
    mask[bin] = FFMAX (excite[bin], hth[fscod][bin]);
  }

  /* apply the delta bit allocation */
  if (do_delta) {
    band = 0;
    for (seg = 0; seg < deltnseg + 1; seg++) {
      band += deltoffst[seg];
      if (deltba[seg] >= 4)
        delta = (deltba[seg] - 3) << 7;
      else
        delta = (deltba[seg] - 4) << 7;
      for (k = 0; k < deltlen[seg]; k++) {
        mask[band] += delta;
        band++;
      }
    }
  }

  /*compute the bit allocation */
  i = start;
  j = masktab[start];
  do {
    lastbin = FFMIN (bndtab[j] + bndsz[j], end);
    mask[j] -= snroffset;
    mask[j] -= floor;
    if (mask[j] < 0)
      mask[j] = 0;
    mask[j] &= 0x1fe0;
    mask[j] += floor;
    for (k = i; k < lastbin; k++) {
      address = (psd[i] - mask[j]) >> 5;
      address = FFMIN (63, (FFMAX (0, address)));
      baps[i] = baptab[address];
      i++;
    }
    j++;
  } while (end > lastbin);

  return 0;
}

static int
do_bit_allocation (AC3DecodeContext * ctx, int flags)
{
  ac3_audio_block *ab = &ctx->audio_block;
  int i, snroffst = 0;

  if (!flags) /* bit allocation is not required */
    return 0;

  if (ab->flags & AC3_AB_SNROFFSTE) { /* check whether snroffsts are zero */
    snroffst += ab->csnroffst;
    if (ab->flags & AC3_AB_CPLINU)
      snroffst += ab->cplfsnroffst;
    for (i = 0; i < ctx->bsi.nfchans; i++)
      snroffst += ab->fsnroffst[i];
    if (ctx->bsi.flags & AC3_BSI_LFEON)
      snroffst += ab->lfefsnroffst;
    if (!snroffst) {
      memset (ab->cplbap, 0, sizeof (ab->cplbap));
      for (i = 0; i < ctx->bsi.nfchans; i++)
        memset (ab->bap[i], 0, sizeof (ab->bap[i]));
      memset (ab->lfebap, 0, sizeof (ab->lfebap));

      return 0;
    }
  }

  /* perform bit allocation */
  if ((ab->flags & AC3_AB_CPLINU) && (flags & 64))
    if (_do_bit_allocation (ctx, 5))
      return -1;
  for (i = 0; i < ctx->bsi.nfchans; i++)
    if (flags & (1 << i))
      if (_do_bit_allocation (ctx, i))
        return -1;
  if ((ctx->bsi.flags & AC3_BSI_LFEON) && (flags & 32))
    if (_do_bit_allocation (ctx, 6))
      return -1;

  return 0;
}

/* table for exponent to scale_factor mapping
 * scale_factor[i] = 2 ^ -(i + 15)
 */
static const float scale_factors[25] = {
  0.000030517578125000000000000000000000000,
  0.000015258789062500000000000000000000000,
  0.000007629394531250000000000000000000000,
  0.000003814697265625000000000000000000000,
  0.000001907348632812500000000000000000000,
  0.000000953674316406250000000000000000000,
  0.000000476837158203125000000000000000000,
  0.000000238418579101562500000000000000000,
  0.000000119209289550781250000000000000000,
  0.000000059604644775390625000000000000000,
  0.000000029802322387695312500000000000000,
  0.000000014901161193847656250000000000000,
  0.000000007450580596923828125000000000000,
  0.000000003725290298461914062500000000000,
  0.000000001862645149230957031250000000000,
  0.000000000931322574615478515625000000000,
  0.000000000465661287307739257812500000000,
  0.000000000232830643653869628906250000000,
  0.000000000116415321826934814453125000000,
  0.000000000058207660913467407226562500000,
  0.000000000029103830456733703613281250000,
  0.000000000014551915228366851806640625000,
  0.000000000007275957614183425903320312500,
  0.000000000003637978807091712951660156250,
  0.000000000001818989403545856475830078125
};

static const int16_t l3_q_tab[3] = { /* 3-level quantization table */
  (-2 << 15) / 3, 0, (2 << 15) / 3
};

static const int16_t l5_q_tab[5] = { /* 5-level quantization table */
  (-4 << 15) / 5, (-2 << 15) / 5, 0, (2 << 15) / 5, (4 << 15) / 5
};

static const int16_t l7_q_tab[7] = { /* 7-level quantization table */
  (-6 << 15) / 7, (-4 << 15) / 7, (-2 << 15) / 7, 0,
  (2 << 15) / 7, (4 << 15) / 7, (6 << 15) / 7
};

static const int16_t l11_q_tab[11] = { /* 11-level quantization table */
  (-10 << 15) / 11, (-8 << 15) / 11, (-6 << 15) / 11, (-4 << 15) / 11, (-2 << 15) / 11, 0,
  (2 << 15) / 11, (4 << 15) / 11, (6 << 15) / 11, (8 << 15) / 11, (10 << 15) / 11
};

static const int16_t l15_q_tab[15] = { /* 15-level quantization table */
  (-14 << 15) / 15, (-12 << 15) / 15, (-10 << 15) / 15, (-8 << 15) / 15,
  (-6 << 15) / 15, (-4 << 15) / 15, (-2 << 15) / 15, 0,
  (2 << 15) / 15, (4 << 15) / 15, (6 << 15) / 15, (8 << 15) / 15,
  (10 << 15) / 15, (12 << 15) / 15, (14 << 15) / 15
};

static const uint8_t qntztab[16] = { 0, 5, 7, 3, 7, 4, 5, 6, 7, 8, 9, 10, 12, 12, 14, 16 };

static inline float
to_float (uint8_t exp, int16_t mantissa)
{
  return ((float) (mantissa * scale_factors[exp]));
}

typedef struct
{ /* grouped mantissas for 3-level 5-leve and 11-level quantization */
  uint8_t gcodes[3];
  uint8_t gcptr;
} mant_group;

/* Get the transform coefficients for particular channel */
static int
_get_transform_coeffs (uint8_t * exps, uint8_t * bap, float *samples,
                       int start, int end, int dith_flag, GetBitContext * gb)
{
  int16_t mantissa;
  int i;
  int gcode;
  mant_group l3_grp, l5_grp, l11_grp;

  for (i = 0; i < 3; i++)
    l3_grp.gcodes[i] = l5_grp.gcodes[i] = l11_grp.gcodes[i] = -1;
  l3_grp.gcptr = l5_grp.gcptr = 3;
  l11_grp.gcptr = 2;

  i = 0;
  while (i < start)
    samples[i++] = 0;

  for (i = start; i < end; i++) {
    switch (bap[i]) {
    case 0:
      if (!dith_flag)
        mantissa = 0;
      else
        mantissa = gen_dither ();
      samples[i] = to_float (exps[i], mantissa);
      break;

    case 1:
      if (l3_grp.gcptr > 2) {
        gcode = get_bits_long (gb, qntztab[1]);
        if (gcode > 26)
          return -1;
        l3_grp.gcodes[0] = gcode / 9;
        l3_grp.gcodes[1] = (gcode % 9) / 3;
        l3_grp.gcodes[2] = (gcode % 9) % 3;
        l3_grp.gcptr = 0;
      }
      mantissa = l3_q_tab[l3_grp.gcodes[l3_grp.gcptr++]];
      samples[i] = to_float (exps[i], mantissa);
      break;

    case 2:
      if (l5_grp.gcptr > 2) {
        gcode = get_bits_long (gb, qntztab[2]);
        if (gcode > 124)
          return -1;
        l5_grp.gcodes[0] = gcode / 25;
        l5_grp.gcodes[1] = (gcode % 25) / 5;
        l5_grp.gcodes[2] = (gcode % 25) % 5;
        l5_grp.gcptr = 0;
      }
      mantissa = l5_q_tab[l5_grp.gcodes[l5_grp.gcptr++]];
      samples[i] = to_float (exps[i], mantissa);
      break;

    case 3:
      mantissa = get_bits_long (gb, qntztab[3]);
      if (mantissa > 6)
        return -1;
      mantissa = l7_q_tab[mantissa];
      samples[i] = to_float (exps[i], mantissa);
      break;

    case 4:
      if (l11_grp.gcptr > 1) {
        gcode = get_bits_long (gb, qntztab[4]);
        if (gcode > 120)
          return -1;
        l11_grp.gcodes[0] = gcode / 11;
        l11_grp.gcodes[1] = gcode % 11;
      }
      mantissa = l11_q_tab[l11_grp.gcodes[l11_grp.gcptr++]];
      samples[i] = to_float (exps[i], mantissa);
      break;

    case 5:
      mantissa = get_bits_long (gb, qntztab[5]);
      if (mantissa > 14)
        return -1;
      mantissa = l15_q_tab[mantissa];
      break;

    default:
      mantissa = get_bits_long (gb, qntztab[bap[i]]) << (16 - qntztab[bap[i]]);
      samples[i] = to_float (exps[i], mantissa);
      break;
    }
  }

  i = end;
  while (i < 256)
    samples[i++] = 0;

  return 0;
}

static int
uncouple_channels (AC3DecodeContext * ctx)
{
  ac3_audio_block *ab = &ctx->audio_block;
  int ch, sbnd, bin;
  int index;
  float (*samples)[256];
  int16_t mantissa;

  samples = (float (*)[256]) (ab->ab_samples);
  samples += (ctx->bsi.flags & AC3_BSI_LFEON) ? 256 : 0;

  /* uncouple channels */
  for (ch = 0; ch < ctx->bsi.nfchans; ch++)
    if (ab->chincpl & (1 << ch))
      for (sbnd = ab->cplbegf; sbnd < 3 + ab->cplendf; sbnd++)
        for (bin = 0; bin < 12; bin++) {
          index = sbnd * 12 + bin + 37;
          samples[ch][index] = ab->cplcoeffs[index] * ab->cplco[ch][sbnd] * 8;
        }

  /* generate dither if required */
  for (ch = 0; ch < ctx->bsi.nfchans; ch++)
    if ((ab->chincpl & (1 << ch)) && (ab->dithflag & (1 << ch)))
      for (index = 0; index < ab->endmant[ch]; index++)
        if (!ab->bap[ch][index]) {
          mantissa = gen_dither ();
          samples[ch][index] = to_float (ab->dexps[ch][index], mantissa);
        }

  return 0;
}

static int
get_transform_coeffs (AC3DecodeContext * ctx)
{
  int i;
  ac3_audio_block *ab = &ctx->audio_block;
  float *samples = ab->ab_samples;
  int got_cplchan = 0;
  int dithflag = 0;

  samples += (ctx->bsi.flags & AC3_BSI_LFEON) ? 256 : 0;
  for (i = 0; i < ctx->bsi.nfchans; i++) {
    if ((ab->flags & AC3_AB_CPLINU) && (ab->chincpl & (1 << i)))
      dithflag = 0; /* don't generate dither until channels are decoupled */
    else
      dithflag = ab->dithflag & (1 << i);
    /* transform coefficients for individual channel */
    if (_get_transform_coeffs (ab->dexps[i], ab->bap[i], samples + (i * 256),
                               0, ab->endmant[i], dithflag, &ctx->gb))
      return -1;
    /* tranform coefficients for coupling channels */
    if ((ab->flags & AC3_AB_CPLINU) && (ab->chincpl & (1 << i)) && !got_cplchan) {
      if (_get_transform_coeffs (ab->dcplexps, ab->cplbap, ab->cplcoeffs,
                                 ab->cplstrtmant, ab->cplendmant, 0, &ctx->gb))
        return -1;
      got_cplchan = 1;
    }
  }

  /* uncouple the channels from the coupling channel */
  if (ab->flags & AC3_AB_CPLINU)
    if (uncouple_channels (ctx))
      return -1;

  return 0;
}

/* generate coupling co-ordinates for each coupling subband
 * from coupling co-ordinates of each band and coupling band
 * structure information
 */
static int
generate_coupling_coordinates (AC3DecodeContext * ctx)
{
  ac3_audio_block *ab = &ctx->audio_block;
  uint8_t exp, mstrcplco;
  int16_t mant;
  uint32_t cplbndstrc = (1 << ab->ncplsubnd) >> 1;
  int ch, bnd, sbnd;
  float cplco;

  if (ab->cplcoe)
    for (ch = 0; ch < ctx->bsi.nfchans; ch++)
      if (ab->cplcoe & (1 << ch)) {
        mstrcplco = 3 * ab->mstrcplco[ch];
        sbnd = ab->cplbegf;
        for (bnd = 0; bnd < ab->ncplbnd; bnd++) {
          exp = ab->cplcoexp[ch][bnd];
          if (exp == 15)
            mant = ab->cplcomant[ch][bnd] <<= 14;
          else
            mant = (ab->cplcomant[ch][bnd] | 0x10) << 13;
          cplco = to_float (exp + mstrcplco, mant);
          if (ctx->bsi.acmod == 0x02 && (ab->flags & AC3_AB_PHSFLGINU) && ch == 1
              && (ab->phsflg & (1 << bnd)))
            cplco = -cplco; /* invert the right channel */
          ab->cplco[ch][sbnd++] = cplco;
          while (cplbndstrc & ab->cplbndstrc) {
            cplbndstrc >>= 1;
            ab->cplco[ch][sbnd++] = cplco;
          }
          cplbndstrc >>= 1;
        }
      }

  return 0;
}

static int
ac3_parse_audio_block (AC3DecodeContext * ctx, int index)
{
  ac3_audio_block *ab = &ctx->audio_block;
  int nfchans = ctx->bsi.nfchans;
  int acmod = ctx->bsi.acmod;
  int i, bnd, rbnd, grp, seg;
  GetBitContext *gb = &ctx->gb;
  uint32_t *flags = &ab->flags;
  int bit_alloc_flags = 0;

  *flags = 0;
  ab->blksw = 0;
  for (i = 0; i < nfchans; i++) /*block switch flag */
    ab->blksw |= get_bits_long (gb, 1) << i;
  ab->dithflag = 0;
  for (i = 0; i < nfchans; i++) /* dithering flag */
    ab->dithflag |= get_bits_long (gb, 1) << i;
  if (get_bits_long (gb, 1)) { /* dynamic range */
    *flags |= AC3_AB_DYNRNGE;
    ab->dynrng = get_bits_long (gb, 8);
  }
  if (acmod == 0x00) { /* dynamic range 1+1 mode */
    if (get_bits_long (gb, 1)) {
      *flags |= AC3_AB_DYNRNG2E;
      ab->dynrng2 = get_bits_long (gb, 8);
    }
  }
  ab->chincpl = 0;
  if (get_bits_long (gb, 1)) { /* coupling strategy */
    *flags |= AC3_AB_CPLSTRE;
    ab->cplbndstrc = 0;
    if (get_bits_long (gb, 1)) { /* coupling in use */
      *flags |= AC3_AB_CPLINU;
    for (i = 0; i < nfchans; i++)
      ab->chincpl |= get_bits_long (gb, 1) << i;
    if (acmod == 0x02)
      if (get_bits_long (gb, 1)) /* phase flag in use */
        *flags |= AC3_AB_PHSFLGINU;
    ab->cplbegf = get_bits_long (gb, 4);
    ab->cplendf = get_bits_long (gb, 4);
    if ((ab->ncplsubnd = 3 + ab->cplendf - ab->cplbegf) < 0)
      return -1;
    ab->ncplbnd = ab->ncplsubnd;
    for (i = 0; i < ab->ncplsubnd - 1; i++) /* coupling band structure */
      if (get_bits_long (gb, 1)) {
        ab->cplbndstrc |= 1 << i;
        ab->ncplbnd--;
      }
    }
  }
  if (*flags & AC3_AB_CPLINU) {
    ab->cplcoe = 0;
    for (i = 0; i < nfchans; i++)
      if (ab->chincpl & (1 << i))
        if (get_bits_long (gb, 1)) { /* coupling co-ordinates */
          ab->cplcoe |= 1 << i;
          ab->mstrcplco[i] = get_bits_long (gb, 2);
          for (bnd = 0; bnd < ab->ncplbnd; bnd++) {
            ab->cplcoexp[i][bnd] = get_bits_long (gb, 4);
            ab->cplcomant[i][bnd] = get_bits_long (gb, 4);
          }
        }
  }
  ab->phsflg = 0;
  if ((acmod == 0x02) && (*flags & AC3_AB_PHSFLGINU) && (ab->cplcoe & 1 || ab->cplcoe & (1 << 1))) {
    for (bnd = 0; bnd < ab->ncplbnd; bnd++)
      if (get_bits_long (gb, 1))
        ab->phsflg |= 1 << bnd;
  }
  generate_coupling_coordinates (ctx);
  ab->rematflg = 0;
  if (acmod == 0x02) /* rematrixing */
    if (get_bits_long (gb, 1)) {
      *flags |= AC3_AB_REMATSTR;
      if (ab->cplbegf > 2 || !(*flags & AC3_AB_CPLINU))
        for (rbnd = 0; rbnd < 4; rbnd++)
          ab->rematflg |= get_bits_long (gb, 1) << bnd;
      else if (ab->cplbegf > 0 && ab->cplbegf <= 2 && *flags & AC3_AB_CPLINU)
        for (rbnd = 0; rbnd < 3; rbnd++)
          ab->rematflg |= get_bits_long (gb, 1) << bnd;
      else if (!(ab->cplbegf) && *flags & AC3_AB_CPLINU)
        for (rbnd = 0; rbnd < 2; rbnd++)
          ab->rematflg |= get_bits_long (gb, 1) << bnd;
    }
  if (*flags & AC3_AB_CPLINU) /* coupling exponent strategy */
    ab->cplexpstr = get_bits_long (gb, 2);
  for (i = 0; i < nfchans; i++) /* channel exponent strategy */
    ab->chexpstr[i] = get_bits_long (gb, 2);
  if (ctx->bsi.flags & AC3_BSI_LFEON) /* lfe exponent strategy */
    ab->lfeexpstr = get_bits_long (gb, 1);
  for (i = 0; i < nfchans; i++) /* channel bandwidth code */
    if (ab->chexpstr[i] != AC3_EXPSTR_REUSE)
      if (!(ab->chincpl & (1 << i))) {
        ab->chbwcod[i] = get_bits_long (gb, 6);
        if (ab->chbwcod[i] > 60)
          return -1;
      }
  if (*flags & AC3_AB_CPLINU)
    if (ab->cplexpstr != AC3_EXPSTR_REUSE) {/* coupling exponents */
      bit_alloc_flags |= 64;
      ab->cplabsexp = get_bits_long (gb, 4) << 1;
      ab->cplstrtmant = (ab->cplbegf * 12) + 37;
      ab->cplendmant = ((ab->cplendmant + 3) * 12) + 37;
      ab->ncplgrps = (ab->cplendmant - ab->cplstrtmant) / (3 << (ab->cplexpstr - 1));
      for (grp = 0; grp < ab->ncplgrps; grp++)
        ab->cplexps[grp] = get_bits_long (gb, 7);
    }
  for (i = 0; i < nfchans; i++) /* fbw channel exponents */
    if (ab->chexpstr[i] != AC3_EXPSTR_REUSE) {
      bit_alloc_flags |= 1 << i;
      if (ab->chincpl & (1 << i))
        ab->endmant[i] = (ab->cplbegf * 12) + 37;
      else
        ab->endmant[i] = ((ab->chbwcod[i] + 3) * 12) + 37;
      ab->nchgrps[i] =
        (ab->endmant[i] + (3 << (ab->chexpstr[i] - 1)) - 4) / (3 << (ab->chexpstr[i] - 1));
      ab->exps[i][0] = ab->dexps[i][0] = get_bits_long (gb, 4);
      for (grp = 1; grp <= ab->nchgrps[i]; grp++)
        ab->exps[i][grp] = get_bits_long (gb, 7);
      ab->gainrng[i] = get_bits_long (gb, 2);
    }
  if (ctx->bsi.flags & AC3_BSI_LFEON) /* lfe exponents */
    if (ab->lfeexpstr != AC3_EXPSTR_REUSE) {
      bit_alloc_flags |= 32;
      ab->lfeexps[0] = ab->dlfeexps[0] = get_bits_long (gb, 4);
      ab->lfeexps[1] = get_bits_long (gb, 7);
      ab->lfeexps[2] = get_bits_long (gb, 7);
    }
  if (decode_exponents (ctx)) /* decode the exponents for this block */
    return -1;
  if (get_bits_long (gb, 1)) { /* bit allocation information */
    *flags |= AC3_AB_BAIE;
    bit_alloc_flags |= 127;
    ab->sdcycod = get_bits_long (gb, 2);
    ab->fdcycod = get_bits_long (gb, 2);
    ab->sgaincod = get_bits_long (gb, 2);
    ab->dbpbcod = get_bits_long (gb, 2);
    ab->floorcod = get_bits_long (gb, 3);
  }
  if (get_bits_long (gb, 1)) { /* snroffset */
    *flags |= AC3_AB_SNROFFSTE;
    bit_alloc_flags |= 127;
    ab->csnroffst = get_bits_long (gb, 6);
    if (*flags & AC3_AB_CPLINU) { /* couling fine snr offset and fast gain code */
      ab->cplfsnroffst = get_bits_long (gb, 4);
      ab->cplfgaincod = get_bits_long (gb, 3);
    }
    for (i = 0; i < nfchans; i++) { /* channel fine snr offset and fast gain code */
      ab->fsnroffst[i] = get_bits_long (gb, 4);
      ab->fgaincod[i] = get_bits_long (gb, 3);
    }
    if (ctx->bsi.flags & AC3_BSI_LFEON) { /* lfe fine snr offset and fast gain code */
      ab->lfefsnroffst = get_bits_long (gb, 4);
      ab->lfefgaincod = get_bits_long (gb, 3);
    }
  }
  if (*flags & AC3_AB_CPLINU)
    if (get_bits_long (gb, 1)) { /* coupling leak information */
      bit_alloc_flags |= 64;
      *flags |= AC3_AB_CPLLEAKE;
      ab->cplfleak = get_bits_long (gb, 3);
      ab->cplsleak = get_bits_long (gb, 3);
    }
  if (get_bits_long (gb, 1)) { /* delta bit allocation information */
    *flags |= AC3_AB_DELTBAIE;
    bit_alloc_flags |= 127;
    if (*flags & AC3_AB_CPLINU) {
      ab->cpldeltbae = get_bits_long (gb, 2);
      if (ab->cpldeltbae == AC3_DBASTR_RESERVED)
        return -1;
    }
    for (i = 0; i < nfchans; i++) {
      ab->deltbae[i] = get_bits_long (gb, 2);
      if (ab->deltbae[i] == AC3_DBASTR_RESERVED)
        return -1;
    }
    if (*flags & AC3_AB_CPLINU)
      if (ab->cpldeltbae == AC3_DBASTR_NEW) { /*coupling delta offset, len and bit allocation */
    ab->cpldeltnseg = get_bits_long (gb, 3);
    for (seg = 0; seg <= ab->cpldeltnseg; seg++) {
      ab->cpldeltoffst[seg] = get_bits_long (gb, 5);
      ab->cpldeltlen[seg] = get_bits_long (gb, 4);
      ab->cpldeltba[seg] = get_bits_long (gb, 3);
    }
      }
    for (i = 0; i < nfchans; i++)
      if (ab->deltbae[i] == AC3_DBASTR_NEW) {/*channel delta offset, len and bit allocation */
    ab->deltnseg[i] = get_bits_long (gb, 3);
    for (seg = 0; seg <= ab->deltnseg[i]; seg++) {
      ab->deltoffst[i][seg] = get_bits_long (gb, 5);
      ab->deltlen[i][seg] = get_bits_long (gb, 4);
      ab->deltba[i][seg] = get_bits_long (gb, 3);
    }
      }
  }
  if (do_bit_allocation (ctx, bit_alloc_flags)) /* perform the bit allocation */
    return -1;
  if (get_bits_long (gb, 1)) { /* unused dummy data */
    *flags |= AC3_AB_SKIPLE;
    ab->skipl = get_bits_long (gb, 9);
    while (ab->skipl) {
      get_bits_long (gb, 8);
      ab->skipl--;
    }
  }
  /* point ab_samples to the right place within smaples */
  if (!index)
    ab->ab_samples = ctx->samples;
  else {
    ab->ab_samples = ctx->samples + (i * nfchans * 256);
    ab->ab_samples += ((ctx->bsi.flags & AC3_BSI_LFEON) ? 256 : 0);
  }
  /* unpack the transform coefficients
   * this also uncouples channels if coupling is in use.
   */
  if (get_transform_coeffs (ctx))
    return -1;

  return 0;
}


static int
ac3_decode_frame (AVCodecContext * avctx, void *data, int *data_size, uint8_t * buf, int buf_size)
{
  AC3DecodeContext *ctx = avctx->priv_data;
  int frame_start;
  int i;

  //Synchronize the frame.
  frame_start = ac3_synchronize (buf, buf_size);
  if (frame_start == -1) {
    *data_size = 0;
    return -1;
  }

  //Initialize the GetBitContext with the start of valid AC3 Frame.
  init_get_bits (&(ctx->gb), buf + frame_start, (buf_size - frame_start) * 8);

  //Parse the syncinfo.
  //If 'fscod' is not valid the decoder shall mute as per the standard.
  if (ac3_parse_sync_info (ctx)) {
    *data_size = 0;
    return -1;
  }

  //Check for the errors.
  /*if (ac3_error_check(ctx))
     {
     *data_size = 0;
     return -1;
     } */

  //Parse the BSI.
  //If 'bsid' is not valid decoder shall not decode the audio as per the standard.
  if (ac3_parse_bsi (ctx)) {
    *data_size = 0;
    return -1;
  }

  //Parse the Audio Blocks.
  for (i = 0; i < 6; i++)
    if (ac3_parse_audio_block (ctx, i)) {
      *data_size = 0;
      return -1;
    }

  return 0;
}