parser.cpp

ac3的解码程序

        samples[ch][endmant] = 0;
      while (++endmant < 256);

    }

    if (lfeon)
    {
      memset(samples[nfchans], 0, sizeof(samples[nfchans]));
      for (n = lfeinfo.strtmant; n < lfeinfo.endmant; n++)
        get_coef(samples[nfchans][n], lfeinfo.exp[n], lfeinfo.bap[n], 0);
    }
  }

  /////////////////////////////////////////////////////////////
  // Rematrixing
  /////////////////////////////////////////////////////////////

  if (acmod == MODE_STEREO) 
  {
    int bin = 13;
    int bnd = 0;
    int band_end = 0;
    int last_bin = min(chinfo[0].endmant, chinfo[1].endmant);
    int remat = rematflg;
    do
    {
      if (!(remat & 1))
      {
        remat >>= 1;
        bin = rematrix_band[bnd++];
        continue;
      }
      remat >>= 1;
      band_end = rematrix_band[bnd++];

      if (band_end > last_bin)
        band_end = last_bin;

      do 
      {
        sample_t tmp0 = samples[0][bin];
        sample_t tmp1 = samples[1][bin];
        samples[0][bin] = tmp0 + tmp1;
        samples[1][bin] = tmp0 - tmp1;
      } while (++bin < band_end);
    } while (bin < last_bin);
  }

  return 0;
}










int 
Parser::parse_exponents (int expstr, int ngrps, exp_t exponent, exp_t *dest)
{
  int exps;

  while (ngrps--) 
  {
    exps = bitstream.get (7);

    exponent += exp_1[exps];
    if (exponent > 24)
      return 1;

    switch (expstr) 
    {
      case EXP_D45:
        *(dest++) = exponent;
        *(dest++) = exponent;
      case EXP_D25:
        *(dest++) = exponent;
      case EXP_D15:
        *(dest++) = exponent;
    }            

    exponent += exp_2[exps];
    if (exponent > 24)
      return 1;

    switch (expstr) 
    {
      case EXP_D45:
        *(dest++) = exponent;
        *(dest++) = exponent;
      case EXP_D25:
        *(dest++) = exponent;
      case EXP_D15:
        *(dest++) = exponent;
    }

    exponent += exp_3[exps];
    if (exponent > 24)
      return 1;

    switch (expstr) 
    {
      case EXP_D45:
        *(dest++) = exponent;
        *(dest++) = exponent;
      case EXP_D25:
        *(dest++) = exponent;
      case EXP_D15:
        *(dest++) = exponent;
    }
  }     
  return 0;
}










int 
Parser::parse_deltba (int8_t *deltba)
{
  int deltnseg, deltlen, delta, j;

  memset (deltba, 0, 50);

  deltnseg = bitstream.get (3);
  j = 0;
  do 
  {
    j += bitstream.get (5);
    deltlen = bitstream.get (4);
    delta = bitstream.get (3);
    delta -= (delta >= 4) ? 3 : 4;
    if (!deltlen)
      continue;
    if (j + deltlen >= 50)
      return 1;
    while (deltlen--)
      deltba[j++] = delta;
  } while (deltnseg--);

  return 0;
}










inline bool
Parser::is_zero_snr_offsets ()
{
  if ((csnroffst) ||
      (chincpl && cplinfo.fsnroffst >> 3) ||
      (lfeon   && lfeinfo.fsnroffst >> 3))
    return false;

  for (int i = 0; i < ACMOD_NFCHANS(acmod); i++)
    if (chinfo[i].fsnroffst >> 3)
      return false;
  return true;
}









///////////////////bit allocate///////////////////////////////

static const int hthtab[3][50] = {
    {0x730, 0x730, 0x7c0, 0x800, 0x820, 0x840, 0x850, 0x850, 0x860, 0x860,
     0x860, 0x860, 0x860, 0x870, 0x870, 0x870, 0x880, 0x880, 0x890, 0x890,
     0x8a0, 0x8a0, 0x8b0, 0x8b0, 0x8c0, 0x8c0, 0x8d0, 0x8e0, 0x8f0, 0x900,
     0x910, 0x910, 0x910, 0x910, 0x900, 0x8f0, 0x8c0, 0x870, 0x820, 0x7e0,
     0x7a0, 0x770, 0x760, 0x7a0, 0x7c0, 0x7c0, 0x6e0, 0x400, 0x3c0, 0x3c0},
    {0x710, 0x710, 0x7a0, 0x7f0, 0x820, 0x830, 0x840, 0x850, 0x850, 0x860,
     0x860, 0x860, 0x860, 0x860, 0x870, 0x870, 0x870, 0x880, 0x880, 0x880,
     0x890, 0x890, 0x8a0, 0x8a0, 0x8b0, 0x8b0, 0x8c0, 0x8c0, 0x8e0, 0x8f0,
     0x900, 0x910, 0x910, 0x910, 0x910, 0x900, 0x8e0, 0x8b0, 0x870, 0x820,
     0x7e0, 0x7b0, 0x760, 0x770, 0x7a0, 0x7c0, 0x780, 0x5d0, 0x3c0, 0x3c0},
    {0x680, 0x680, 0x750, 0x7b0, 0x7e0, 0x810, 0x820, 0x830, 0x840, 0x850,
     0x850, 0x850, 0x860, 0x860, 0x860, 0x860, 0x860, 0x860, 0x860, 0x860,
     0x870, 0x870, 0x870, 0x870, 0x880, 0x880, 0x880, 0x890, 0x8a0, 0x8b0,
     0x8c0, 0x8d0, 0x8e0, 0x8f0, 0x900, 0x910, 0x910, 0x910, 0x900, 0x8f0,
     0x8d0, 0x8b0, 0x840, 0x7f0, 0x790, 0x760, 0x7a0, 0x7c0, 0x7b0, 0x720}
};

static const int8_t baptab[305] = {
    16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
    16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
    16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
    16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
    16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
    16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, /* 93 padding elems */

    16, 16, 16, 16, 16, 16, 16, 16, 16, 14, 14, 14, 14, 14, 14, 14,
    14, 12, 12, 12, 12, 11, 11, 11, 11, 10, 10, 10, 10,  9,  9,  9,
     9,  8,  8,  8,  8,  7,  7,  7,  7,  6,  6,  6,  6,  5,  5,  5,
     5,  4,  4, -3, -3,  3,  3,  3, -2, -2, -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,  0,  0,  0,  0,  0,  0,  0,  0,  0,
     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
     0,  0,  0,  0                                      /* 148 padding elems */
};

static const int bndtab[30] = {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, 253};

static const int8_t latab[256] = {
    -64, -63, -62, -61, -60, -59, -58, -57, -56, -55, -54, -53,
    -52, -52, -51, -50, -49, -48, -47, -47, -46, -45, -44, -44,
    -43, -42, -41, -41, -40, -39, -38, -38, -37, -36, -36, -35,
    -35, -34, -33, -33, -32, -32, -31, -30, -30, -29, -29, -28,
    -28, -27, -27, -26, -26, -25, -25, -24, -24, -23, -23, -22,
    -22, -21, -21, -21, -20, -20, -19, -19, -19, -18, -18, -18,
    -17, -17, -17, -16, -16, -16, -15, -15, -15, -14, -14, -14,
    -13, -13, -13, -13, -12, -12, -12, -12, -11, -11, -11, -11,
    -10, -10, -10, -10, -10,  -9,  -9,  -9,  -9,  -9,  -8,  -8,
     -8,  -8,  -8,  -8,  -7,  -7,  -7,  -7,  -7,  -7,  -6,  -6,
     -6,  -6,  -6,  -6,  -6,  -6,  -5,  -5,  -5,  -5,  -5,  -5,
     -5,  -5,  -4,  -4,  -4,  -4,  -4,  -4,  -4,  -4,  -4,  -4,
     -4,  -3,  -3,  -3,  -3,  -3,  -3,  -3,  -3,  -3,  -3,  -3,
     -3,  -3,  -3,  -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,  -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,   0,   0,   0,   0,   0,   0,
      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
      0,   0,   0,   0
};

#define UPDATE_LEAK()           \
do {                            \
    fastleak += fdecay;         \
    if (fastleak > psd + fgain) \
        fastleak = psd + fgain; \
    slowleak += sdecay;         \
    if (slowleak > psd + sgain) \
        slowleak = psd + sgain; \
} while (0)

#define COMPUTE_MASK()                          \
do {                                            \
    if (psd > dbknee)                           \
        mask -= (psd - dbknee) >> 2;            \
    if (mask > hth [i >> halfrate])             \
        mask = hth [i >> halfrate];             \
    mask -= snroffset + 128 * deltba[i];        \
    mask = (mask > 0) ? 0 : ((-mask) >> 5);     \
    mask -= floor;                              \
} while (0)

const int masktab[256] = 
{  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, 00, 00, 00 };



void 
Parser::bit_allocate (chinfo_t &chinfo)
{
  const int slowgain[4] = {0x540, 0x4d8, 0x478, 0x410};
  const int dbpbtab[4]  = {0xc00, 0x500, 0x300, 0x100};
  const int floortab[8] = {0x910, 0x950, 0x990, 0x9d0,
                           0xa10, 0xa90, 0xb10, 0x1400};

  int i, j;

  int fdecay, fgain, sdecay, sgain, dbknee, floor, snroffset;
  int psd, mask;
  const int8_t * deltba;
  const int * hth;


  fdecay = (63 + 20 * ((bai >> 7) & 3)) >> halfrate;       // fdcycod
  fgain = chinfo.fgain;
//  fgain = 128 + 128 * (ba->bai & 7);                     // fgaincod
  sdecay = (15 + 2 * (bai >> 9)) >> halfrate;              // sdcycod
  sgain = slowgain[(bai >> 5) & 3];                        // sgaincod
  dbknee = dbpbtab[(bai >> 3) & 3];                        // dbpbcod
  hth = hthtab[fscod];
  /*
   * if there is no delta bit allocation, make deltba point to an area
   * known to contain zeroes. baptab+156 here.
   */
  deltba = (chinfo.deltbae == DELTA_BIT_NONE) ? baptab + 156 : chinfo.deltba;
  floor = floortab[bai & 7];                               // floorcod
  snroffset = 960 - 64 * csnroffst - 4 * chinfo.fsnroffst + floor;
  floor >>= 5;

  int start = chinfo.strtmant;
  int end = chinfo.endmant;
  int fastleak = chinfo.fastleak;
  int slowleak = chinfo.slowleak;


  int8_t *bap = chinfo.bap;
  exp_t  *exp = chinfo.exp;


  i = masktab[chinfo.strtmant];
  j = start;
  if (start == 0) // not the coupling channel 
  {   
    int lowcomp;

    lowcomp = 0;
    j = end - 1;
    do 
    {
      if (i < j) 
      {
        if (exp[i+1] == exp[i] - 2)
          lowcomp = 384;
        else if (lowcomp && (exp[i+1] > exp[i]))
          lowcomp -= 64;
      }
      psd = 128 * exp[i];
      mask = psd + fgain + lowcomp;
      COMPUTE_MASK ();
      bap[i] = (baptab+156)[mask + 4 * exp[i]];
      i++;
    } while ((i < 3) || ((i < 7) && (exp[i] > exp[i-1])));
    fastleak = psd + fgain;
    slowleak = psd + sgain;

    while (i < 7) 
    {
      if (i < j) 
      {
        if (exp[i+1] == exp[i] - 2)
          lowcomp = 384;
        else if (lowcomp && (exp[i+1] > exp[i]))
          lowcomp -= 64;
      }
      psd = 128 * exp[i];
      UPDATE_LEAK ();
      mask = ((fastleak + lowcomp < slowleak) ?
              fastleak + lowcomp : slowleak);
      COMPUTE_MASK ();
      bap[i] = (baptab+156)[mask + 4 * exp[i]];
      i++;
    }

    if (end == 7)   /* lfe channel */
      return;

    do 
    {
      if (exp[i+1] == exp[i] - 2)
        lowcomp = 320;
      else if (lowcomp && (exp[i+1] > exp[i]))
        lowcomp -= 64;
      psd = 128 * exp[i];
      UPDATE_LEAK ();
      mask = ((fastleak + lowcomp < slowleak) ?
              fastleak + lowcomp : slowleak);
      COMPUTE_MASK ();
      bap[i] = (baptab+156)[mask + 4 * exp[i]];
      i++;
    } while (i < 20);

    while (lowcomp > 128) /* two iterations maximum */
    {         
      lowcomp -= 128;
      psd = 128 * exp[i];
      UPDATE_LEAK ();
      mask = ((fastleak + lowcomp < slowleak) ?
              fastleak + lowcomp : slowleak);
      COMPUTE_MASK ();
      bap[i] = (baptab+156)[mask + 4 * exp[i]];
      i++;
    }
    j = i;
  }

  do 
  {
    int startband, endband;

    startband = j;
    endband = ((bndtab-20)[i] < end) ? (bndtab-20)[i] : end;
    psd = 128 * exp[j++];
    while (j < endband) 
    {
      int next, delta;

      next = 128 * exp[j++];
      delta = next - psd;
      switch (delta >> 9) 
      {
        case -6: case -5: case -4: case -3: case -2:
          psd = next;
          break;
        case -1:
          psd = next + latab[(-delta) >> 1];
          break;
        case 0:
          psd += latab[delta >> 1];
          break;
      }
    }
    /* minpsd = -289 */
    UPDATE_LEAK ();
    mask = (fastleak < slowleak) ? fastleak : slowleak;
    COMPUTE_MASK ();
    i++;
    j = startband;
    do 
    {
        /* max(mask+4*exp)=147=-(minpsd+fgain-deltba-snroffset)>>5+4*exp */
        /* min(mask+4*exp)=-56=-(sgain-deltba-snroffset)>>5 */
        bap[j] = (baptab+156)[mask + 4 * exp[j]];
    } while (++j < endband);
  } while (j < end);
}