sbrdec_hf_adjust_int.c

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

// may be improved
        denominator = SBR_TABLE_INVERT[(iEnd - iStart) - 1];       // Q31
        denominator =
          MUL32_SBR_32S(SBR_TABLE_INVERT[(kh - kl) - 1],
                              denominator) << 1;
        iECurrWoInterpol = sbrScale_64s32s(sumEWoInterpol, &scaleFactor);
        iECurrWoInterpol = MUL32_SBR_32S(iECurrWoInterpol, denominator);
        scaleFactorInterpolation = scaleFactor - 1;
      }

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

        if (!interpolation) {
          bufECurr[k] = iECurrWoInterpol;
          scaleFactorsECurr[k] = scaleFactorInterpolation;
        }

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

        data = (bufQMapped[k] >> 1) + (1 << (SCALE_FACTOR_NOISE_DEQUANT - 1));
        denominator = ippsInvWrap_32s_Sf(data, &scalef);
        denominator <<= 1;

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

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

        bufG[k] = bufEOrig[k];
        scaleFactorsGain[k] = vScaleFactorsEOrig[l];

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

        } else if (!delta) {
          bufG[k] = MUL32_SBR_32S(bufG[k], mulQ) << 1;
        }
// --------------------
        if (bufECurr[k]) {

          denominator = ippsInvWrap_32s_Sf(bufECurr[k], &scalef);
          bufG[k] = MUL32_SBR_32S(bufG[k], denominator);
          scaleFactorsGain[k] =
            29 + 31 - scalef - scaleFactorsECurr[k] + vScaleFactorsEOrig[l] -
            32;
        }
// --------------------

        bufQM[k] = MUL32_SBR_32S(bufEOrig[k], mulQQ) << 1;
      } // end for (k = pos - (kh - kl); k < pos; k++)

    }   // end for( p = 0;

/* --------------------------------  Calculation of gain ---------------------------- */

    ippsMin_32s(scaleFactorsECurr, pos, &scaleFactorECurrMax);

    for (k = 0; k < sbr_com->N_L; k++) {
      sumEOrig = 0;
      sumECurr = 0;

      for (i = sbr_com->f_TableLim[k] - kx; i < sbr_com->f_TableLim[k + 1] - kx;
           i++) {

        sumEOrig += (bufEOrig[i] >> SCALE_FACTOR_SUM64);

        sumECurr +=
          (bufECurr[i] >> -(scaleFactorECurrMax - scaleFactorsECurr[i]));
        if (sumECurr >> 30) {
          sumECurr >>= 1;
          scaleFactorECurrMax--;
        }
      } // end for(i=...

      scaleFactorGainMax = 30;  // default scaleFactor
      gainMax = iLimiterGains;  // default values

      if ((sumECurr == 0) && (sumEOrig)) {
        gainMax = THRESHOLD_GAIN;
      } else if (sumEOrig == 0) {
        gainMax = 0;
      } else if (gainMax != THRESHOLD_GAIN) {

        data = MUL32_SBR_32S(sumEOrig, gainMax);
/*
 * Q[ vScaleFactorsEOrig[l] - SCALE_FACTOR_SUM64 - 2 ], gainMax = Q30
 */

        denominator = ippsInvWrap_32s_Sf(sumECurr, &scalef);
        gainMax = MUL32_SBR_32S(data, denominator);
/*
 * Q[29 + 31 - scalef - scaleFactorECurrMax + vScaleFactorsEOrig[l] -
 * SCALE_FACTOR_SUM64 - 2 - 32 ]
 */

        scaleFactorGainMax =
          29 + 31 - scalef - scaleFactorECurrMax + (vScaleFactorsEOrig[l] -
          SCALE_FACTOR_SUM64) - 2 - 32;
      }

      sumECurrGLim = 0;
      sumQM = 0;
      sumSM = 0;
      for (i = sbr_com->f_TableLim[k] - kx; i < sbr_com->f_TableLim[k + 1] - kx;
           i++) {

        if ((gainMax != THRESHOLD_GAIN) &&
            sbrCheckUpDate(gainMax, scaleFactorGainMax, bufG[i],
                           scaleFactorsGain[i])) {

  // QM[i] = QM[i] * (g_max / vGain[i]);
  // --------------
  // denominator = ...Q[60 - (scaleFactorsGain[i] + scalef)]
          denominator = ippsInvWrap_32s_Sf(bufG[i], &scalef);

  // data = ...Q[ scaleFactorGainMax - (scaleFactorsGain[i] + scalef) + 28 ]
          data = MUL32_SBR_32S(denominator, gainMax);

          scalef = scaleFactorGainMax + 28 - (scaleFactorsGain[i] + scalef);
          data = sbrChangeScaleFactor(data, scalef, 30);
          bufQM[i] = MUL32_SBR_32S(bufQM[i], data) << 2;
  // --------------

  // G[i] = g_max;
          scaleFactorsGain[i] = scaleFactorGainMax;
          bufG[i] = gainMax;
        }       // end if

        {
          int     sum, shift;

          shift =
            vScaleFactorsEOrig[l] - (scaleFactorsGain[i] +
                                     scaleFactorsECurr[i]);

          if (shift > 0)
            sum = (int)(((Ipp64s)bufG[i] * (Ipp64s)bufECurr[i]) << shift);
          else
            sum = (int)(((Ipp64s)bufG[i] * (Ipp64s)bufECurr[i]) >> -shift);

          sumECurrGLim += (sum >> SCALE_FACTOR_SUM64);
        }

        sumSM += (bufSM[i] >> SCALE_FACTOR_SUM64);

        if (!(bufSM[i] != 0 || delta)) {
          sumQM += (bufQM[i] >> SCALE_FACTOR_SUM64);
        }
//--------------------

      } // for (i = ...; i <

// compensation //
      denominator = (sumECurrGLim >> 1) + (sumSM >> 1) + (sumQM >> 1);
// ------------------------------------------//
      scaleFactorGainBoost = 0; // default values
      gainBoost = THRESHOLD_GAIN_BOOST;
      scalef = 0;

      if ((denominator == 0) && (sumEOrig == 0)) {
        gainBoost = 1 << 28;
      } else if (sumEOrig == 0) {
        gainBoost = 0;
      } else {
        denominator = ippsInvWrap_32s_Sf(denominator, &scalef);
        gainBoost = MUL32_SBR_32S(denominator, sumEOrig) >> 1;
      }

      /* gainBoost = Q(28 - scalef) */
      if (gainBoost > (THRESHOLD_GAIN_BOOST >> scalef)) {

        gainBoost = THRESHOLD_GAIN_BOOST;
        scalef = 0;
      }
      gainBoost <<= scalef;     /* (Q28 - scalef) + scalef = Q28 */

// ------------------------------------------//
      for (i = sbr_com->f_TableLim[k] - kx; i < sbr_com->f_TableLim[k + 1] - kx;
           i++) {

// GainLimBoost
        /* Q(scaleFactorsGain[i]) + Q28 - Q32 + 2 = Q(scaleFactorsGain[i]) - Q2 */
        bufG[i] = MUL32_SBR_32S(bufG[i], gainBoost) << 2;

        bufG[i] =
          ippsSqrtWrap_64s_Sfs(bufG[i], scaleFactorsGain[i] - 2, &scalef);
        bufG[i] =
          sbrChangeScaleFactor(bufG[i], scalef, SCALE_FACTOR_G_LIM_BOOST);

// QMLimBoost
        bufQM[i] = MUL32_SBR_32S(bufQM[i], gainBoost) << 2;

        bufQM[i] =
          ippsSqrtWrap_64s_Sfs(bufQM[i], vScaleFactorsEOrig[l] - 2, &scalef);
        bufQM[i] =
          sbrChangeScaleFactor(bufQM[i], scalef, SCALE_FACTOR_QM_LIM_BOOST);

// SMBoost
        bufSM[i] = MUL32_SBR_32S(bufSM[i], gainBoost) << 2;

        bufSM[i] =
          ippsSqrtWrap_64s_Sfs(bufSM[i], vScaleFactorsEOrig[l] - 2, &scalef);
        bufSM[i] =
          sbrChangeScaleFactor(bufSM[i], scalef, SCALE_FACTOR_SM_BOOST);
      }
    }   // end for(k=0; k<

/* --------------------------------  Assembling ---------------------------- */
    if (sbr_com->FlagUpdate[ch]) {
      for (n = 0; n < 4; n++) {
        ippsCopy_32s(bufG, iBufGain[n], M);
        ippsCopy_32s(bufQM, iBufNoise[n], M);
      }
      sbr_com->FlagUpdate[ch] = 0;
    }

    for (i = RATE * sbr_com->tE[ch][l]; i < RATE * sbr_com->tE[ch][l + 1]; i++) {
      for (m = 0; m < M; m++) {
        iBufGain[4][m] = bufG[m];
        iBufNoise[4][m] = bufQM[m];

        gainFilt = noiseFilt = 0;
        if (hSmoothLen) {
          for (n = 0; n <= 4; n++) {
            gainFilt += MUL32_SBR_32S(iBufGain[n][m], ihSmoothFilter[n]);
            noiseFilt +=
              MUL32_SBR_32S(iBufNoise[n][m], ihSmoothFilter[n]);
          }
          gainFilt <<= 1;
          noiseFilt <<= 1;

        } else {
          gainFilt = iBufGain[4][m];
          noiseFilt = iBufNoise[4][m];
        }

        if (bufSM[m] != 0 || delta) {
          noiseFilt = 0;
        }

        fIndexNoise =
          (sbr_com->indexNoise[ch] + (i - RATE * sbr_com->tE[ch][0]) * M + m +
           1) & 511;
        fIndexSine =
          (sbr_com->indexSine[ch] + i - RATE * sbr_com->tE[ch][0]) & 3;

        {
          int     yRe, yIm;
          int     noiseRe, noiseIm;

  // float f1, f2, f3;

          yRe = pYRe[i][m + kx];
          yIm = pYIm[i][m + kx];

          noiseRe =
            MUL32_SBR_32S(noiseFilt, SBR_TABLE_V_INT_Q30[0][fIndexNoise]);
          noiseIm =
            MUL32_SBR_32S(noiseFilt, SBR_TABLE_V_INT_Q30[1][fIndexNoise]);

          noiseRe >>= (SCALE_FACTOR_QM_LIM_BOOST - 2 - SCALE_FACTOR_QMFA_OUT);
          noiseIm >>= (SCALE_FACTOR_QM_LIM_BOOST - 2 - SCALE_FACTOR_QMFA_OUT);

//--------------------------------------------------
          yRe = MUL32_SBR_32S(yRe, gainFilt);
          yRe <<= (32 - SCALE_FACTOR_G_LIM_BOOST);

          yIm = MUL32_SBR_32S(yIm, gainFilt);
          yIm <<= (32 - SCALE_FACTOR_G_LIM_BOOST);

          yRe =
            (yRe >> 1) + (noiseRe >> 1) +
            (bufSM[m] * SIN_FI_RE[fIndexSine] >> 1);
          yIm =
            (yIm >> 1) + (noiseIm >> 1) +
            (bufSM[m] * POW_MINUS_UNIT[m + kx] * SIN_FI_IM[fIndexSine] >> 1);

  // patch
          if (yRe >= (1 << 30) - 1)
            yRe = 0X7FFFFFFF;
          else if (yRe <= -(1 << 30))
            yRe = -0X7FFFFFFF;
          else
            yRe <<= 1;

          if (yIm >= (1 << 30) - 1)
            yIm = 0X7FFFFFFF;
          else if (yIm <= -(1 << 30))
            yIm = -0X7FFFFFFF;
          else
            yIm <<= 1;

          pYRe[i][m + kx] = yRe;
          pYIm[i][m + kx] = yIm;
//-----------------------------------------------------
        }

      } // end for ( m = 0; m < M; m++ )

      for (n = 0; n < 4; n++) {
        ippsCopy_32s(iBufGain[n + 1], iBufGain[n], 64);
        ippsCopy_32s(iBufNoise[n + 1], iBufNoise[n], 64);
      }

    }   // end for (i = iStart; i < iEnd; i++)

  }     /* end main loop */

/* --------------------------------  update ---------------------------- */
  ippsCopy_32s(sineIndxMap, &(sbr_com->S_index_mapped_prev[ch][kx]), (64 - kx));

  if (lA == LE)
    sbr_com->lA_prev[ch] = 0;
  else
    sbr_com->lA_prev[ch] = -1;

  sbr_com->L_E_prev[ch] = sbr_com->L_E[ch];
  sbr_com->L_Q_prev[ch] = sbr_com->L_Q[ch];

  sbr_com->indexNoise[ch] = fIndexNoise;
  sbr_com->indexSine[ch] = (fIndexSine + 1) & 3;
}

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