sbr_dec_hf_adjust_fp.c

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

  sSBREnvDataState*   pEDState = &(comState->sbrEDState[ch] );

  //Ipp32f yRe, yIm;

/*
 * CODES
 */
  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 */
  bufSM = (Ipp32f *)(WorkBuffer + 0 * offset_32f);
  bufQM = (Ipp32f *)(WorkBuffer + 1 * offset_32f);
  bufECurr = (Ipp32f *)(WorkBuffer + 2 * offset_32f);
  bufEOrig = (Ipp32f *)(WorkBuffer + 3 * offset_32f);
  bufG = (Ipp32f *)(WorkBuffer + 4 * offset_32f);
  sineIndxMap = (Ipp32s *)(WorkBuffer + 5 * offset_32f);
  sineIndxMapPrev = comState->S_index_mapped_prev[ch];

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

  ippsZero_8u((Ipp8u *)sineIndxMap, 64 * sizeof(Ipp32s));
  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 ---------------------------- */
    pos = 0;
    nResolution = resolution[pFIState->freqRes[l]];
    pFreqTbl = F[pFIState->freqRes[l]];
    iStart = RATE * pFIState->bordersEnv[l];
    iEnd = RATE * pFIState->bordersEnv[1 + l];

    for (p = 0; p < nResolution; p++) {
      kl = pFreqTbl[p];
      kh = pFreqTbl[p + 1];
      delta_step = 0;
      sumEWoInterpol = 0.0f;
      for (j = kl; j < kh; j++) {
        energ = 0.0f;
        for (i = iStart; i < iEnd; i++) {

          /*
          energ += YRe[i][j] * YRe[i][j];

          if (decode_mode == HEAAC_HQ_MODE) {
            energ += YIm[i][j] * YIm[i][j];
          }
          */
          ////////
          if(decode_mode == HEAAC_LP_MODE) {
            energ += pYre[i][j] * pYre[i][j];

          } else { //if (decode_mode == HEAAC_HQ_MODE) {
            energ += pYcmp[i][j].re * pYcmp[i][j].re + pYcmp[i][j].im * pYcmp[i][j].im;
          }
          ////////

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

        bufECurr[pos] = energ;
        if( 0 != iEnd - iStart ){
          bufECurr[pos] /= (iEnd - iStart);
        }

        if (!interpolation){
          sumEWoInterpol += bufECurr[pos] / (kh - kl);
        }

        pos++;
      }

      for (k = pos - (kh - kl); k < pos; k++) {
        bufSM[k] = 0;
        bufEOrig[k] = bufEnvOrig[pEDState->vSizeEnv[l] + p];

        if (!interpolation)
          bufECurr[k] = sumEWoInterpol;

        mulQ = 1.0f / (1.0f + bufQMapped[k]);
        mulQQ = bufQMapped[k] * mulQ;

        if (decode_mode == HEAAC_LP_MODE) {
          bufECurr[k] *= 2.0f;

          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] = bufEOrig[k] * mulQ;
        }

        bufG[k] = bufEOrig[k];

        if (delta_step) {
          bufG[k] = bufG[k] * mulQQ;

        } else if (!delta) {
          bufG[k] = bufG[k] * mulQ;
        }

        bufG[k] /= (bufECurr[k] + 1);

        bufQM[k] = bufEOrig[k] * mulQQ;

      } // end for(k=
    }   // end for(p=

/* --------------------------------  Calculation of gain ---------------------------- */
    for (k = 0; k < pFTState->nLimBand; k++) {
      sumEOrig = sumECurr = EPS0;
      for (i = pFTState->fLimBandTab[k] - kx; i < pFTState->fLimBandTab[k + 1] - kx;
           i++) {
        sumEOrig += bufEOrig[i];
        sumECurr += bufECurr[i];
      }

      g_max_temp = sumEOrig / sumECurr * (LimiterGains * LimiterGains);
      gainMax = IPP_MIN(1.0e5f * 1.0e5f, g_max_temp);

      denum = EPS0;
      for (i = pFTState->fLimBandTab[k] - kx; i < pFTState->fLimBandTab[k + 1] - kx;
           i++) {
        if (gainMax <= bufG[i]) {
          bufQM[i] = bufQM[i] * (gainMax / bufG[i]);
          bufG[i] = gainMax;
        }

        denum += bufG[i] * bufECurr[i] + bufSM[i];
        if (!(bufSM[i] != 0.0f || delta))
          denum += bufQM[i];
      }

      boost_gain = sumEOrig / denum;
      boost_gain = IPP_MIN(boost_gain, 1.584893192f * 1.584893192f);

      for (i = pFTState->fLimBandTab[k] - kx; i < pFTState->fLimBandTab[k + 1] - kx;
           i++) {
        bufG[i] = (Ipp32f)sqrt(bufG[i] * boost_gain);
        bufQM[i] = (Ipp32f)sqrt(bufQM[i] * boost_gain);
        bufSM[i] = (Ipp32f)sqrt(bufSM[i] * boost_gain);
      }
    }

    if (decode_mode == HEAAC_LP_MODE) {
      sbrAliasReduction(degPatched, bufECurr, bufG, s_mapped, kx, M);
    }

/* --------------------------------  Assembling ---------------------------- */
    if (comState->FlagUpdate[ch]) {
      for (n = 0; n < 4; n++) {
        ippsCopy_32f(bufG, BufGain[n], M);
        ippsCopy_32f(bufQM, BufNoise[n], M);
      }
      comState->FlagUpdate[ch] = 0;
    }

    for (i = iStart; i < iEnd; i++) {
      for (m = 0; m < M; m++) {
        BufGain[4][m] = bufG[m];
        BufNoise[4][m] = bufQM[m];

        if (decode_mode == HEAAC_LP_MODE) {
          num_sinusoids = 0;
        }

        gainFilt = noiseFilt = 0.0f;

        if (hSmoothLen) {
          for (n = 0; n <= 4; n++) {
            gainFilt += BufGain[n][m] * hSmoothFilter[n];
            noiseFilt += BufNoise[n][m] * hSmoothFilter[n];
          }
        } else {
          gainFilt = BufGain[4][m];
          noiseFilt = BufNoise[4][m];
        }

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

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

        if(decode_mode == HEAAC_HQ_MODE) {

          pYcmp[i][m + kx].re = pYcmp[i][m + kx].re * gainFilt +
                                noiseFilt * SBR_TABLE_V[0][fIndexNoise] +
                                bufSM[m] * SIN_FI_RE[fIndexSine];

          pYcmp[i][m + kx].im = pYcmp[i][m + kx].im * gainFilt +
                                noiseFilt * SBR_TABLE_V[1][fIndexNoise] +
                                bufSM[m] * POW_MINUS_UNIT[m + kx] * SIN_FI_IM[fIndexSine];

        } else {//if (decode_mode == HEAAC_LP_MODE) {

          pYre[i][m + kx] = pYre[i][m + kx] * gainFilt +
                                noiseFilt * SBR_TABLE_V[0][fIndexNoise] +
                                bufSM[m] * SIN_FI_RE[fIndexSine];

          sbrSinAdd_LP_32f(pYre, comState->indexSine[ch], i, pFIState->bordersEnv[0],
                           m, kx, bufSM, M, &num_sinusoids);
        }

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

      for (n = 0; n < 4; n++) {
        ippsCopy_32f(BufGain[n + 1], BufGain[n], 64);
        ippsCopy_32f(BufNoise[n + 1], BufNoise[n], 64);
      }
    }   // end for (i = iStart; i < iEnd; i++)
//
  }     /* end main loop */

/* --------------------------------  update ---------------------------- */
  ippsCopy_8u((const Ipp8u *)sineIndxMap, (Ipp8u *)&(sineIndxMapPrev[kx]),
              (64 - kx) * sizeof(Ipp32s));

  if (lA == nEnv)
    comState->lA_prev[ch] = 0;
  else
    comState->lA_prev[ch] = -1;

  pFIState->nEnvPrev = pFIState->nEnv;
  //comState->L_Q_prev[ch] = comState->L_Q[ch];
  pFIState->nNoiseEnvPrev = pFIState->nNoiseEnv;

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

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