sbr_freq_tabs.c

audio-video-codecs.rar语音编解码器

}

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

Ipp32s sbrCalcNoiseTab(Ipp32s* fLoFreqTab, Ipp32s nLoBand,
                       Ipp32s bs_noise_bands, Ipp32s k2, Ipp32s kx,
                       Ipp32s* fNoiseTab, Ipp32s* nNoiseBand)
{
  Ipp32s i[100];
  Ipp32s k;

  *nNoiseBand  = GetRatioLog( bs_noise_bands, k2, kx );
  *nNoiseBand = IPP_MAX(1, *nNoiseBand );
  if (*nNoiseBand > 5)
    return SBR_ERR_REQUIREMENTS;

  i[0] = 0;
  for (k = 1; k <= *nNoiseBand; k++)
    i[k] = i[k-1] + ( nLoBand - i[k-1] ) / ( *nNoiseBand + 1 - k );

  for (k = 0; k <= *nNoiseBand; k++)
    fNoiseTab[k] = fLoFreqTab[i[k]];

  return 0;//OK
}

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

#if 1

Ipp32s sbrCalcDerivedFreqTabs(sSBRFeqTabsState* pFTState,
                              Ipp32s bs_xover_band,
                              Ipp32s bs_noise_bands,
                              Ipp32s k2, Ipp32s* kx, Ipp32s* M)
{
  Ipp32s k;
  Ipp32s error = 0;

  /* reset tables */
  for (k = 0; k < 64; k++) {
    pFTState->fNoiseBandTab[k] = pFTState->fLoBandTab[k] = pFTState->fHiBandTab[k] = 0;
  }

  /* update high tabs */
  error = sbrCalcHiFreqTab(pFTState->fMasterBandTab,
                           pFTState->nMasterBand,
                           bs_xover_band,
                           pFTState->fHiBandTab,
                           &(pFTState->nHiBand) );

  if ( error ){
    return SBR_ERR_REQUIREMENTS;
  }

  /* update low tabs */
  sbrCalcLoFreqTab(pFTState->fHiBandTab,
                   pFTState->nHiBand,
                   pFTState->fLoBandTab,
                   &(pFTState->nLoBand) );

  /* intermedia result */
  *M  = pFTState->fHiBandTab[ pFTState->nHiBand ] - pFTState->fHiBandTab[0];
  *kx = pFTState->fHiBandTab[0];

  if (*kx > 32)
    return SBR_ERR_REQUIREMENTS;

  /* update noise bands */
  error = sbrCalcNoiseTab(pFTState->fLoBandTab,
                          pFTState->nLoBand,
                          bs_noise_bands,
                          k2,
                          *kx,
                          pFTState->fNoiseBandTab,
                          &(pFTState->nNoiseBand));

  if ( error ){
    return SBR_ERR_REQUIREMENTS;
  }

  return 0;     // OK
}

#endif

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

Ipp32s sbrCalcLimBandTab(/*
                          * in data
                          */
                         Ipp32s bs_limiter_bands, Ipp32s *fLoBandTab,
                         Ipp32s nLoBand, Ipp32s numPatches,
                         Ipp32s *patchNumSubbands,
                         /*
                          * out data
                          */
                         Ipp32s *fLimBandTab, Ipp32s *nLimBand)
{
  Ipp32s iLimBands = 0;
  Ipp32s patchBorders[200];
  Ipp32s i, k, nrLim;
  Ipp32s inOctaves;
  Ipp32s isEqual;
  Ipp32s UpBound = fLoBandTab[nLoBand];

  ippsZero_8u((Ipp8u *)fLimBandTab, MAX_SIZE_FREQ_TABS * sizeof(Ipp32s));

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

  if (bs_limiter_bands == 0) {
    fLimBandTab[0] = fLoBandTab[0];      // = kx = fHiBandTab[0]
    fLimBandTab[1] = fLoBandTab[nLoBand];
    *nLimBand = 1;

    return 0;   // OK
  }

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

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

/*
 * patch
 */
  patchBorders[numPatches] = fLoBandTab[nLoBand];

  for (k = 0; k <= nLoBand; k++) {
    fLimBandTab[k] = fLoBandTab[k];
  }

  for (k = 1; k < numPatches; k++) {
    fLimBandTab[nLoBand + k] = patchBorders[k];
  }

  nrLim = nLoBand + numPatches - 1;
  ippsSortAscend_32s_I(fLimBandTab, nrLim + 1);

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

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

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

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

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

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

  *nLimBand = nrLim;
// PATCH
  for (k = nrLim + 1; k < MAX_SIZE_FREQ_TABS; k++)
    fLimBandTab[k] = 0;

  return 0;     // OK
}

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

//Ipp32s sbrCalcPatchConstructTab(sSBRDecComState* pSbr, Ipp32s sbrFreqIndx)
Ipp32s sbrCalcPatchConstructTab(Ipp32s* fMasterBandTab,
                                Ipp32s  nMasterBand,
                                Ipp32s  M,
                                Ipp32s  kx,
                                Ipp32s  k0,
                                Ipp32s  sbrFreqIndx,

                                Ipp32s* patchNumSubbandsTab,
                                Ipp32s* patchStartSubbandTab,
                                Ipp32s* numPatches)
{
  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 msb = k0;
  Ipp32s usb = kx;

  *numPatches = 0;
  goalSb = SBR_TABLE_GOAL_SB[ sbrFreqIndx ];

  if (goalSb < kx + M) {
    for (i = 0, k = 0; fMasterBandTab[i] < goalSb; i++) {
      k = i + 1;
    }
  } else
    k = nMasterBand;

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

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

    patchNumSubbandsTab[ *numPatches ] = IPP_MAX(sb - usb, 0);
    patchStartSubbandTab[ *numPatches ] = k0 - odd - patchNumSubbandsTab[ *numPatches ];

    if (patchNumSubbandsTab[ *numPatches ] > 0) {
      msb = usb = sb;

      (*numPatches)++;
    } else
      msb = kx;

    if ((fMasterBandTab[k] - sb) < 3)
      k = nMasterBand;
  } while (sb != (kx + M));
/*
 * end loop
 */

  if ((patchNumSubbandsTab[( *numPatches ) - 1] < 3) && (( *numPatches ) > 1)){
    (*numPatches)--;
  }

  if ( (*numPatches < 0) || (*numPatches > 5) ){
    return SBR_ERR_REQUIREMENTS;
  }

  return 0;     // OK
}

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

Ipp32s sbrCalcPatchConstruct_indxTab(Ipp32s* fMasterTab, Ipp32s nMasterBand, Ipp32s k0,
                                     Ipp32s M, Ipp32s sbrFreqIndx, Ipp32s* idxPatchMap)
{
  Ipp32s goalSb, sb, odd;
  Ipp32s i, k = 0, j;
  Ipp32s SBR_TABLE_GOAL_SB[] = { 21, 23, 32, 43, 46, 64, 85, 93, 128, 171, 186, 256 };
  //Ipp32s  M  = fMasterTab[ nMasterBand ];//pSbr->M;
  Ipp32s kx = fMasterTab[ 0 ];//pSbr->kx;
  //Ipp32s  k0 = pSbr->k0;
  Ipp32s msb = k0;
  Ipp32s usb = kx;
  Ipp32s numPatches = 0;
  Ipp32s x, p, k_0, q;

  Ipp32s patchNumSubbands[MAX_NUM_PATCHES];
  Ipp32s patchStartSubband[MAX_NUM_PATCHES];

  numPatches = 0;
  goalSb = SBR_TABLE_GOAL_SB[ sbrFreqIndx ];

  if (goalSb < kx + M) {
    for (i = 0, k = 0; fMasterTab[i] < goalSb; i++) {
      k = i + 1;
    }
  } else
    k = nMasterBand;

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

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

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

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

      (numPatches)++;
    } else
      msb = kx;

    if ((fMasterTab[k] - sb) < 3)
      k = nMasterBand;
  } while (sb != (kx + M));
  /*
  * end loop
  */

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

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

  /* here special vectors are calculated: simple code */

  // reset

  ippsSet_32s(EMPTY_MAPPING, idxPatchMap, 64);

  /* patch from gp code */
  for(k = 0; k < kx; k++){
    idxPatchMap[k] = k;
  }

  for (i = 0; i < numPatches; i++) {
    k_0 = 0;
    for (q = 0; q < i; q++) {
      k_0 += patchNumSubbands[q];
    }

    k_0 += kx;
    for (x = 0; x < patchNumSubbands[i]; x++) {
      k = k_0 + x;
      p = patchStartSubband[i] + x;
      //----------------
      idxPatchMap[ k ] = p;
      //----------------
    }
  }

  return 0;     // OK
}