sbr_dec_hf_adjust_int.c

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

        //YRe[m + kx] += -0.00815f * POW_MINUS_UNIT[m + kx] * bufSM[m - 1] * SIN_FI_RE[fIndexSineMinus1];
        sumY_64s = MUL32_SBR_32S(xScale, bufSM[m - 1]) * POW_MINUS_UNIT[m + kx] * SIN_FI_RE[fIndexSineMinus1];
        sumY_64s = sumY_64s + YRe[m + kx];

        if (sumY_64s >= (Ipp64s)IPP_MAX_32S )
          YRe[m + kx] = IPP_MAX_32S;
        else if( sumY_64s <= (Ipp64s)IPP_MIN_32S )
          YRe[m + kx] = IPP_MIN_32S;
        else
          YRe[m + kx] = (Ipp32s)(sumY_64s);

      }
      if (M + kx < 64) {
        //YRe[m + kx + 1] = -0.00815f * POW_MINUS_UNIT[m + kx + 1] * bufSM[m] * SIN_FI_RE[fIndexSineMinus1];
        YRe[m + kx + 1] = MUL32_SBR_32S(xScale, bufSM[m]) * POW_MINUS_UNIT[m + kx + 1] * SIN_FI_RE[fIndexSineMinus1];
      }
    }

    if (bufSM[m])
      num_sinusoids++;

    *numSin = num_sinusoids;

    return 0;//OK
}

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

static Ipp32s sbrUpdate_lA(Ipp32s bs_pointer, Ipp32s bs_frame_class, Ipp32s L_E)
{
  Ipp32s  table_lA[3][3] = {
    {-1, -1, -1}, {-1, -1, -1}, {-1, -1, -1}
  };

  Ipp32s  indx1, indx2;
  Ipp32s  lA;

  table_lA[1][1] = table_lA[2][1] = L_E + 1 - bs_pointer;
  table_lA[2][2] = bs_pointer - 1;

  if ((bs_pointer > 1) || (bs_pointer < 0))
    indx1 = 2;
  else
    indx1 = bs_pointer;

  if (bs_frame_class == VARVAR)
    indx2 = 1;
  else
    indx2 = bs_frame_class;

  lA = table_lA[indx1][indx2];

  return lA;
}

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

Ipp32s tmpCLIP_32s32s(Ipp32s InData)
{
  Ipp32s  OutData;

  if (InData > IPP_MAX_32S)
    OutData = IPP_MAX_32S;
  else if (InData < IPP_MIN_32S)
    OutData = IPP_MIN_32S;
  else
    OutData = (Ipp32s)(InData);

  return OutData;

}

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

Ipp32s sbriCheckUpDate(Ipp32s gain_max, Ipp32s sfGainMax, Ipp32s gain,
                       Ipp32s scaleFactorGain)
{
  Ipp32s  flagUpDate = 0;
  Ipp32s  shift;

  if (gain_max != THRESHOLD_GAIN) {
    if (scaleFactorGain >= sfGainMax) {
      shift = IPP_MIN(scaleFactorGain - sfGainMax, 31);
      flagUpDate = ((gain >> shift) > gain_max ? 1 : 0);
    } else {
      shift = IPP_MIN(sfGainMax - scaleFactorGain, 31);
      flagUpDate = (gain > (gain_max >> shift) ? 1 : 0);
    }
  }

  return flagUpDate;
}

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

void sbriAdjustmentHF(Ipp32s** iYBuf, Ipp32s *bufEnvOrig,
                      Ipp32s *bufNoiseOrig, Ipp32s *sfsEOrig,
                      Ipp32s iBufGain[][MAX_NUM_ENV_VAL],
                      Ipp32s iBufNoise[][MAX_NUM_ENV_VAL], sSBRDecComState * comState,
                      Ipp32s *degPatched, Ipp8u *WorkBuffer, Ipp32s reset,
                      Ipp32s ch, Ipp32s decode_mode)
{
  /* VALUES */
  Ipp32s  k, m, n, pos, kl, kh, l, p, i, j, delta_step, delta;
  Ipp32s  sumEOrig, sumECurr, sumSM, sumQM, sumECurrGLim;
  Ipp32s  gainMax, gainBoost, gainFilt, noiseFilt;
  Ipp32s  iStart, iEnd;
  Ipp32s  denum;
  Ipp32s  nResolution;

  Ipp64s  sumE, sumEWoInterpol;

  Ipp32s  bufSM[64];
  Ipp32s  bufQM[64];
  Ipp32s  bufEOrig[64];
  Ipp32s  bufG[64];
  Ipp32s  bufG2[64];

  Ipp32s  bufQMapped[64];
  Ipp32s  bufECurr[64];
  Ipp32s  resolution[2];

  Ipp32s  sfsECurr[64];
  Ipp32s  sfsGain[64];

  Ipp32s  sfInterpolation;
  Ipp32s  sfECurrMax;
  Ipp32s  sfGainBoost;
  Ipp32s  sfGainMax;
  Ipp32s  sfTmp;

  Ipp32s  iECurrWoInterpol;
  Ipp32s  mulQ, mulQQ;
  Ipp32s  data;

  Ipp32s  iLimiterGains = TABLE_LIMIT_GAIN_INT_Q30[comState->sbrHeader.bs_limiter_gains];

  Ipp32s  interpolation = comState->sbrHeader.bs_interpol_freq;
  Ipp32s  fIndexNoise = 0;
  Ipp32s  fIndexSine = 0;

  Ipp32s  hSmoothLen = (comState->sbrHeader.bs_smoothing_mode == 0) ? 4 : 0;
  Ipp32s  hSmoothLenConst = hSmoothLen;

  Ipp32s  kx = comState->kx;
  Ipp32s  M = comState->M;
  Ipp32s  nEnv = comState->sbrFIState[ch].nEnv;
  Ipp32s  nNoiseEnv = comState->sbrFreqTabsState.nNoiseBand;//  N_Q;
  Ipp32s  lA = 0;

  Ipp32s  offset_32s = 64 * sizeof(Ipp32s);

  Ipp32s *pFreqTbl;
  Ipp32s *pEOrigCurrAddress;
  Ipp32s *sineIndxMap;
  Ipp32s *sineIndxMapPrev;
  Ipp32s *F[2];

  //Ipp32s** pYRe = iYBuf + SBR_TIME_HFADJ;
  //Ipp32s** pYIm = iYBufIm + SBR_TIME_HFADJ;
  Ipp32sc** pYcmp = (Ipp32sc**)iYBuf + SBR_TIME_HFADJ;
  Ipp32s** pYre =  iYBuf + SBR_TIME_HFADJ;

  /* LP mode */
  Ipp32s  num_sinusoids = 0;
  Ipp32s  s_mapped[64];

  Ipp32s  maxSfGain = 0;
  Ipp32s  minSfECurr;

  /* freq_state*/
  sSBRFeqTabsState* pFTState = &( comState->sbrFreqTabsState );
  /* frame info */
  sSBRFrameInfoState* pFIState = &( comState->sbrFIState[ch] );
  /* env data */
  sSBREnvDataState*   pEDState = &(comState->sbrEDState[ch] );

  /* CODE */

  F[0] = pFTState->fLoBandTab;// f_TableLow;
  F[1] = pFTState->fHiBandTab;// f_TableHigh;

  resolution[0] = pFTState->nLoBand;// N_low;
  resolution[1] = pFTState->nHiBand;// N_high;

/* set memory */
  sineIndxMap = (Ipp32s *)(WorkBuffer + 5 * offset_32s);
  sineIndxMapPrev = comState->S_index_mapped_prev[ch];

  if (reset) {
    comState->FlagUpdate[ch] = 1;
    comState->indexNoise[ch] = 0;
  }

  ippsZero_32s(sineIndxMap, 64);

  for (i = 0; i < pFTState->nHiBand; i++) {
    m = (pFTState->fHiBandTab[i + 1] + pFTState->fHiBandTab[i]) >> 1;
    sineIndxMap[m - kx] = pEDState->bs_add_harmonic[i];
  }

  lA = sbrUpdate_lA(comState->bs_pointer[ch], comState->bs_frame_class[ch], pFIState->nEnv);

/* main loop */
  for (l = 0; l < nEnv; l++) {
    for (k = 0; k < pFIState->nNoiseEnv; k++) {
      if (pFIState->bordersEnv[l] >= pFIState->bordersNoise[k] &&
          pFIState->bordersEnv[l + 1] <= pFIState->bordersNoise[k + 1])
        break;
    }

    for (i = 0; i < nNoiseEnv; i++) {
      for (m = pFTState->fNoiseBandTab[i]; m < pFTState->fNoiseBandTab[i + 1]; m++) {
        bufQMapped[m - kx] = bufNoiseOrig[pEDState->vSizeNoise[k] + i];
      }
    }

    delta = (l == lA || l == comState->lA_prev[ch]) ? 1 : 0;

    if (decode_mode == HEAAC_HQ_MODE)
      hSmoothLen = (delta ? 0 : hSmoothLenConst);
    else
      hSmoothLen = 0;

/* --------------------------------  Estimation envelope ---------------------------- */
/*
 * new envelope's reset
 */
    pos = 0;
    sfECurrMax = 0;
    nResolution = resolution[pFIState->freqRes[l]];
    pFreqTbl = F[pFIState->freqRes[l]];
    iStart = RATE * pFIState->bordersEnv[l];
    iEnd = RATE * pFIState->bordersEnv[1 + l];
    pEOrigCurrAddress = &bufEnvOrig[pEDState->vSizeEnv[l]];
    sfInterpolation = 0;
    iECurrWoInterpol = 0;

    /* AYA */
    maxSfGain = 0;
    ippsZero_32s( sfsGain, 64 );
    ippsZero_32s( bufG, 64 );
    ippsZero_32s( bufG2, 64 );
    ippsZero_32s( bufECurr, 64 );

    for (p = 0; p < nResolution; p++) {
      kl = pFreqTbl[p];
      kh = pFreqTbl[p + 1];
      delta_step = 0;
      sumEWoInterpol = 0L;

      for (j = kl; j < kh; j++) {
        sumE = 0L;
        for (i = iStart; i < iEnd; i++) {

  // tmp PATCH
          {
            Ipp32s  yRe, yIm;

            if(decode_mode == HEAAC_LP_MODE) {
              yRe = tmpCLIP_32s32s(pYre[i][j] >> 5);
              sumE += MUL64_SBR_64S(yRe, yRe);

            } else { //if (decode_mode == HEAAC_HQ_MODE) {
              yRe = tmpCLIP_32s32s(pYcmp[i][j].re >> 5);
              sumE += MUL64_SBR_64S(yRe, yRe);

              yIm = tmpCLIP_32s32s(pYcmp[i][j].im >> 5);
              sumE += MUL64_SBR_64S(yIm, yIm);
            }

          }
        }
        delta_step = (sineIndxMap[pos] &&
                      (l >= lA || sineIndxMapPrev[pos + kx])) ? 1 : delta_step;

        /*
         * PS: out scaleFactor is negative
         */
        bufECurr[pos] = sbriScale_64s32s(sumE, sfsECurr + pos);

        denum = SBR_TABLE_INVERT[(iEnd - iStart) - 1]; // Q31

        // Q(-sfsECurr[pos]) * Q(31) * Q(-32) = Q(-... - 1)
        bufECurr[pos] = MUL32_SBR_32S(bufECurr[pos], denum);

        sfsECurr[pos] -= 1;

        if (!interpolation) {
          sumEWoInterpol += sumE;
        }

        pos++;
      } // end for (j = kl; j < kh; j++) {

      if (!interpolation) {
        Ipp32s  scaleFactor;

// may be improved
        denum = SBR_TABLE_INVERT[(iEnd - iStart) - 1];       // Q31
        denum = MUL32_SBR_32S(SBR_TABLE_INVERT[(kh - kl) - 1], denum) << 1;

        iECurrWoInterpol = sbriScale_64s32s(sumEWoInterpol, &scaleFactor);
        iECurrWoInterpol = MUL32_SBR_32S(iECurrWoInterpol, denum);
        sfInterpolation = scaleFactor - 1;
      }

      for (k = pos - (kh - kl); k < pos; k++) {
        bufSM[k] = 0;
        bufEOrig[k] = pEOrigCurrAddress[p];

        if (!interpolation) {
          bufECurr[k] = iECurrWoInterpol;
          sfsECurr[k] = sfInterpolation;
        }

/* --------------------------------  Calculation of Level of Add Component ---------------------------- */

        data = (bufQMapped[k] >> 1) + (1 << (SCALE_FACTOR_NOISE_DEQUANT - 1));
        denum = sbriInvWrap_32s_Sf(data, &sfTmp);
        denum <<= 1;

/*
 * convert to Q31
 */
        mulQ = (denum >> (7 - sfTmp));
        mulQQ = MUL32_SBR_32S(denum, bufQMapped[k]) << (1 + sfTmp);

// ------------------------
        if (decode_mode == HEAAC_LP_MODE) {
          //bufECurr[k] <<= 1;
          sfsECurr[k] -= 1;

          if (delta_step)
            s_mapped[k - pos + kh - kx] = 1;
          else
            s_mapped[k - pos + kh - kx] = 0;
        }
// ------------------------
        if ((delta_step) && (sineIndxMap[k] && (l >= lA || sineIndxMapPrev[k + kx]))) {
          bufSM[k] = MUL32_SBR_32S(bufEOrig[k], mulQ) << 1;
        }

        bufG[k] = bufEOrig[k];
        sfsGain[k] = sfsEOrig[l];

        if (delta_step) {
          bufG[k] = MUL32_SBR_32S(bufG[k], mulQQ) << 1;