sbrdec_freq_tables.c

这是在PCA下的基于IPP库示例代码例子,在网上下了IPP的库之后,设置相关参数就可以编译该代码.

    *k2 = UMC_MIN(64, stopMin + SBR_TABLE_STOP_DK[sbrFreqIndx][bs_stop_freq] );

  }else if (bs_stop_freq == 14){
    *k2 = UMC_MIN(64, 2 * (*k0));

  }else if (bs_stop_freq == 15){
    *k2 = UMC_MIN(64, 3 * (*k0));

  }

// check
  if (((*k2) - (*k0) < 0) || (FreqSbr < 32000) && ((*k2) - (*k0) > 48) ||
      (FreqSbr == 44000) && ((*k2) - (*k0) > 35) || (FreqSbr >= 48000) &&
      ((*k2) - (*k0) > 32))
    return SBR_ERR_REQUIREMENTS;

  return 0;     // OK
}

/********************************************************************/

Ipp32s sbrCalcMasterFreqBandTable(Ipp32s k0, Ipp32s k2, Ipp32s bs_freq_scale,
                               Ipp32s bs_alter_scale, Ipp32s *f_master, Ipp32s *N_master)
{
  Ipp32s     error = 0;

  if (bs_freq_scale == 0)
    error = sbrCalcMasterFreq1(k0, k2, bs_alter_scale, f_master, N_master);
  else
    error =
      sbrCalcMasterFreq2(k0, k2, bs_freq_scale, bs_alter_scale, f_master,
                         N_master);

  return error;
}

/********************************************************************/

Ipp32s sbrCalcDerivedFreqTables(Ipp32s bs_xover_band, Ipp32s bs_noise_bands,
                                Ipp32s k2, sSbrDecCommon* pSbr)
{
  Ipp32s     k, indx;
  Ipp32s     i[100];
  Ipp32s     operand1, operand2;

  for (k = 0; k < 64; k++) {
    pSbr->f_TableNoise[k] = pSbr->f_TableLow[k] = pSbr->f_TableHigh[k] = 0;
  }

  pSbr->N_high = pSbr->N_master - bs_xover_band;
  if (pSbr->N_high < 0)
    return SBR_ERR_REQUIREMENTS;

  operand1 = pSbr->N_high >> 1;
  operand2 = operand1 << 1;
  pSbr->N_low = operand1 + (pSbr->N_high) - operand2;

  for (k = 0; k <= pSbr->N_high; k++)
    pSbr->f_TableHigh[k] = pSbr->f_master[k + bs_xover_band];

  pSbr->M = pSbr->f_TableHigh[ pSbr->N_high ] - pSbr->f_TableHigh[0];
  pSbr->kx = pSbr->f_TableHigh[0];

  if (pSbr->kx > 32)
    return SBR_ERR_REQUIREMENTS;

  indx = (pSbr->N_high) & 1;

  pSbr->f_TableLow[0] = pSbr->f_TableHigh[0];
  for (k = 1; k <= pSbr->N_low; k++)
    pSbr->f_TableLow[k] = pSbr->f_TableHigh[2 * k - indx];

  pSbr->N_Q  = GetRatioLog( bs_noise_bands, k2, pSbr->kx );
  pSbr->N_Q = UMC_MAX(1, pSbr->N_Q );
  if (pSbr->N_Q > 5)
    return SBR_ERR_REQUIREMENTS;

  i[0] = 0;
  for (k = 1; k <= pSbr->N_Q; k++)
    i[k] = i[k-1] + ( pSbr->N_low - i[k-1] ) / ( pSbr->N_Q + 1 - k );

  for (k = 0; k <= pSbr->N_Q; k++)
    pSbr->f_TableNoise[k] = pSbr->f_TableLow[i[k]];

  return 0;     // OK
}

/********************************************************************/

Ipp32s sbrCalcLimiterFreqBandTable(
                         /*
                          * in data
                          */
                                 Ipp32s bs_limiter_bands, Ipp32s *f_TableLow,
                                 Ipp32s N_low, Ipp32s numPatches,
                                 Ipp32s *patchNumSubbands,
                         /*
                          * out data
                          */
                                 Ipp32s *f_TableLim, Ipp32s *N_L)
{
  Ipp32s     iLimBands = 0;
  Ipp32s     patchBorders[200];
  Ipp32s     i, k, nrLim;
  Ipp32s     inOctaves;
  Ipp32s     isEqual;
  Ipp32s     UpBound = f_TableLow[N_low];

  ippsZero_8u((Ipp8u *)f_TableLim, MAX_SIZE_FREQ_TBLS * sizeof(Ipp32s));

  if (bs_limiter_bands < 0)
    return SBR_ERR_REQUIREMENTS; // problem bs_limiter_bands is < 0;

  if (bs_limiter_bands == 0) {
    f_TableLim[0] = f_TableLow[0];      // = kx = f_TableHigh[0]
    f_TableLim[1] = f_TableLow[N_low];
    *N_L = 1;

    return 0;   // OK
  }

  iLimBands = iTABLE_LIMITER_BANDS_PER_OCTAVE[bs_limiter_bands - 1];
  patchBorders[0] = f_TableLow[0];      // patchBorders[0] = kx;

  for (k = 1; k < numPatches; k++)
    patchBorders[k] = patchBorders[k - 1] + patchNumSubbands[k - 1];

/*
 * patch
 */
  patchBorders[numPatches] = f_TableLow[N_low];

  for (k = 0; k <= N_low; k++) {
    f_TableLim[k] = f_TableLow[k];
  }

  for (k = 1; k < numPatches; k++) {
    f_TableLim[N_low + k] = patchBorders[k];
  }

  nrLim = N_low + numPatches - 1;
  ippsSortAscend_32s_I(f_TableLim, nrLim + 1);

  for (k = 1; k <= nrLim; k++) {

      //nOctaves = log((double)(f_TableLim[k]) / (f_TableLim[k - 1])) / log2;
      inOctaves = ( SBR_TABLE_LOG2[ f_TableLim[k] ] -  SBR_TABLE_LOG2[ f_TableLim[k-1] ]) >> 14;
      inOctaves *= iLimBands;

     //if (nOctaves * limBands < 0.49) {
      if ( inOctaves < 131533373 ){

      if (f_TableLim[k] == f_TableLim[k - 1]) {
        f_TableLim[k] = UpBound;
        ippsSortAscend_32s_I(f_TableLim, nrLim + 1);
        nrLim--;
        k--;
        continue;
      }

      isEqual = 0;
      for (i = 0; i <= numPatches; i++) {
        if (f_TableLim[k] == patchBorders[i]) {
          isEqual = 1;
          break;
        }
      }
      if (!isEqual) {
        f_TableLim[k] = UpBound;
        ippsSortAscend_32s_I(f_TableLim, nrLim + 1);
        nrLim--;
        k--;
        continue;
      }

      isEqual = 0;
      for (i = 0; i <= numPatches; i++) {
        if (f_TableLim[k - 1] == patchBorders[i]) {
          isEqual = 1;
          break;
        }
      }
      if (!isEqual) {
        f_TableLim[k - 1] = UpBound;
        ippsSortAscend_32s_I(f_TableLim, nrLim + 1);
        nrLim--;
        k--;
        continue;
      }
    }
  }

  *N_L = nrLim;
// PATCH
  for (k = nrLim + 1; k < MAX_SIZE_FREQ_TBLS; k++)
    f_TableLim[k] = 0;

  return 0;     // OK
}

/********************************************************************/

Ipp32s sbrPatchConstruction(sSbrDecCommon* pSbr, Ipp32s sbrFreqIndx)
{


  Ipp32s     goalSb, sb, odd;
  Ipp32s     i, k, j;
  Ipp32s     SBR_TABLE_GOAL_SB[] = { 21, 23, 32, 43, 46, 64, 85, 93, 128, 171, 186, 256 };
  Ipp32s     M  = pSbr->M;
  Ipp32s     kx = pSbr->kx;
  Ipp32s     k0 = pSbr->k0;
  Ipp32s     msb = k0;
  Ipp32s     usb = kx;

  pSbr->numPatches = 0;
  goalSb = SBR_TABLE_GOAL_SB[ sbrFreqIndx ];

  if (goalSb < kx + M) {
    for (i = 0, k = 0; pSbr->f_master[i] < goalSb; i++) {
      k = i + 1;
    }
  } else
    k = pSbr->N_master;

/*
 * start loop
 */
  do {
    j = k + 1;

    do {
      j--;
      sb = pSbr->f_master[j];
      odd = (sb - 2 + k0) & 1;
    } while (sb > (k0 - 1 + msb - odd));

    pSbr->patchNumSubbands[pSbr->numPatches] = UMC_MAX(sb - usb, 0);
    pSbr->patchStartSubband[pSbr->numPatches] =
      k0 - odd - pSbr->patchNumSubbands[pSbr->numPatches];

    if (pSbr->patchNumSubbands[pSbr->numPatches] > 0) {
      msb = usb = sb;

      (pSbr->numPatches)++;
    } else
      msb = kx;

    if ((pSbr->f_master[k] - sb) < 3)
      k = pSbr->N_master;
  } while (sb != (kx + M));
/*
 * end loop
 */

  if ((pSbr->patchNumSubbands[(pSbr->numPatches) - 1] < 3) && ((pSbr->numPatches) > 1))
    (pSbr->numPatches)--;

  if ( (pSbr->numPatches < 0) || (pSbr->numPatches > 5) )
    return SBR_ERR_REQUIREMENTS;

  return 0;     // OK
}

/********************************************************************/
/* EOF */