sbr_enc_sin_estimation_fp.c

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

/*//////////////////////////////////////////////////////////////////////////////
//
//                  INTEL CORPORATION PROPRIETARY INFORMATION
//     This software is supplied under the terms of a license agreement or
//     nondisclosure agreement with Intel Corporation and may not be copied
//     or disclosed except in accordance with the terms of that agreement.
//          Copyright(c) 2006 Intel Corporation. All Rights Reserved.
//
*/

#include <ipps.h>
#include <ippac.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include "aac_status.h"
#include "sbr_freq_tabs.h"
#include "sbr_enc_settings.h"
#include "sbr_enc_api_fp.h"
#include "sbr_enc_own_fp.h"

#ifdef SBR_NEED_LOG
#include "sbr_enc_dbg.h"
#endif

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

static Ipp32s
sbrencDiffEst(Ipp32f* bufT, Ipp32f* bufDiff, Ipp32s* indxMapTab, Ipp32s* pFreqTab, Ipp32s nBand)
{
  Ipp32s m, k, idx, kStart, kEnd;
  Ipp32f maxOrigT, maxSbrT;

  for(m = 0; m < nBand; m++){
    kStart = pFreqTab[m];
    kEnd   = pFreqTab[m+1];

    maxOrigT = maxSbrT = 0.0f;
    for(k = kStart; k < kEnd; k++){
      maxOrigT = ( bufT[k] > maxOrigT ) ? bufT[k] : maxOrigT;

      idx = indxMapTab[k];
      if ( idx != EMPTY_MAPPING ){
        maxSbrT = ( bufT[ idx ] > maxSbrT ) ? bufT[ idx ] : maxSbrT;
      }
    }

    maxSbrT = IPP_MAX( 1.0f, maxSbrT );

    bufDiff[m] = maxOrigT;

    if ( maxSbrT > 1.0f ){
      bufDiff[m] /= maxSbrT;
    }
  }

  return 0;//OK
}

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

static Ipp32s
sbrencSfmEst(Ipp32f* bufT, Ipp32f* bufSfm, Ipp32s* pFreqTab, Ipp32s nBand)
{
  Ipp32s m, k, kStart, kEnd;
  Ipp32f accSum, accMul;
  Ipp32f deg, denum;
  Ipp32f dist;

  for(m = 0; m < nBand; m++ ){
    kStart = pFreqTab[ m ];
    kEnd   = pFreqTab[ m + 1 ];

    accSum = 0.0f;
    accMul = 1.0f;

    bufSfm[m] = 1.0f;

    dist = (Ipp32f)( kEnd - kStart );
    if (dist < 2.0f ) continue;

    deg = 1.0f / dist;

    for(k = kStart; k < kEnd; k++){
      accSum += bufT[k];
      accMul *= bufT[k];
    }

    if ( (Ipp64f)accMul * accMul > 0.0f ) {
      denum = (Ipp32f)pow(accMul, -deg);
      bufSfm[m] = accSum * deg * denum;

      /* patch from 3GPP: p.29, instead forward val use invert val */
      bufSfm[m] = 1.f / bufSfm[m];
    }
  }

  return 0; //OK
}

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

static Ipp32s
sbrencCalcInDataSinEst(Ipp32f bufT[][64],
                       Ipp32f bufDiff[][64],
                       Ipp32f bufSfmOrig[][64],
                       Ipp32f bufSfmSBR[][64],
                       Ipp32s* indxMapTab,
                       Ipp32s* pFreqTab,
                       Ipp32s nBand)
{
  Ipp32s est, k, idx;
  Ipp32f tmpBuf[64];
//  Ipp32s p;
  Ipp32s i, iStart, iEnd;

  /* up-date buffer */
  for(est =  0 ; est < 2; est++){
    ippsCopy_32f(bufDiff[est + 2],    bufDiff[est],    64);
    ippsCopy_32f(bufSfmOrig[est + 2], bufSfmOrig[est], 64);
    ippsCopy_32f(bufSfmSBR[est + 2],  bufSfmSBR[est],  64);
  }

  /* AYA log */
#ifdef SBR_NEED_LOG
  fprintf(logFile, "\nSinesEstimation\n");
  fprintf(logFile, "\nDiff    origSfm    sbrSfm\n");
#endif

  /* detection input data */
  for(est = 2; est < 4; est++){
    /* AYA log */
#ifdef SBR_NEED_LOG
    fprintf(logFile, "band = %i\n", est);
#endif

    sbrencDiffEst( bufT[ est ], bufDiff[ est ], indxMapTab, pFreqTab, nBand );

    sbrencSfmEst( bufT[ est ], bufSfmOrig[ est ], pFreqTab, nBand );

    ippsZero_32f(tmpBuf, 64);
    for(k = 0; k < nBand; k++){
      iStart = pFreqTab[k];
      iEnd   = pFreqTab[k+1];
      for(i=iStart; i<iEnd; i++){

        idx = indxMapTab[i];
        if ( idx != EMPTY_MAPPING){
          tmpBuf[i] = bufT[est][ idx ];
        }
      }
    }

    sbrencSfmEst( tmpBuf, bufSfmSBR[ est ], pFreqTab, nBand );

    /* AYA */
#ifdef SBR_NEED_LOG
    for(p=0; p<nBand; p++){
      fprintf(logFile, "%15.10f %15.10f %15.10f\n", bufDiff[ est ][p], bufSfmOrig[ est ][p], bufSfmSBR[ est ][p]);
    }
#endif

  }

  return 0;//OK
}

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

static Ipp32s
sbrencIsDetectNewToneAllow(sSBRFrameInfoState *pFrameInfo,

                           Ipp32s* prevTranFrame,
                           Ipp32s* prevTranPos,
                           Ipp32s* prevTranFlag,

                           Ipp32s tranPosOffset,
                           Ipp32s tranFlag,
                           Ipp32s tranPos)
{
  Ipp32s tranFrame, result;

  const Ipp32s SBR_TIME_SLOTS = 16;
  Ipp32s criterion1, criterion2, criterion3;

  /* init */
  tranFrame = 0;

  /* calc criterion */
  criterion1 = tranFlag;
  criterion2 = (pFrameInfo->bordersEnv[pFrameInfo->nEnv] - (tranPos + tranPosOffset) > 0 ) ? 1 : 0;
  criterion3 = !(*prevTranFlag) || (*prevTranFrame);

  if( (criterion1 && criterion2) || !(criterion1 || criterion3) ) {
    tranFrame = 1;
  }

  /* init */
  result = 0;

  /* calc criterion */
  criterion1 = tranFrame;
  criterion2 = *prevTranFrame;
  criterion3 = (DELTA_TIME - abs(pFrameInfo->bordersEnv[0] - (*prevTranPos + tranPosOffset - SBR_TIME_SLOTS)) > 0) ? 1 : 0;

  /* decision */
  if ( criterion1 || criterion2 && criterion3 ){
     result = 1;
  }

  /* up-date */
  *prevTranFlag  = tranFlag;
  *prevTranFrame = tranFrame;
  *prevTranPos   = tranPos;

  return result;
}

/**************************************************************************/
static Ipp32s
sbrencDetectionSinEst(Ipp32f* bufT,
                      Ipp32f* bufDiff,
                      Ipp32s* detVec,
                      Ipp32s* pFreqTab,
                      Ipp32s  nBand,
                      Ipp32f* bufSfmOrig,
                      Ipp32f* bufSfmSBR,

                      sSBRGuideData guideState,
                      sSBRGuideData guideNewState)
{
  Ipp32f tmpThres = 0.f, origThres = 0.f;
  Ipp32s criterion1 = 0, criterion2 = 0, criterion3 = 0;
  Ipp32s iStart = 0, iEnd = 0;

  Ipp32s band = 0;
  Ipp32s i = 0;

  /* ******************************
   * detection algorithm: step 1
   * ****************************** */
  for(band = 0; band < nBand; band++){
    if (guideState.bufGuideDiff[band]) {

      tmpThres = IPP_MAX(DECAY_GUIDE_DIFF*guideState.bufGuideDiff[band],THR_DIFF_GUIDE);
    } else {

      tmpThres = THR_DIFF;
    }

    tmpThres = IPP_MIN(tmpThres, THR_DIFF);

    if(bufDiff[band] > tmpThres){

      detVec[band] = 1;
      guideNewState.bufGuideDiff[band] = bufDiff[band];
    } else {

      if(guideState.bufGuideDiff[band]){

        guideState.bufGuideOrig[band] = THR_TONE_GUIDE;
      }
    }
  }

  /* ******************************
  * detection algorithm: step 2
  * ****************************** */
  for(band = 0; band < nBand; band++){

    iStart = pFreqTab[band];
    iEnd = pFreqTab[band+1];

    origThres   = IPP_MAX(guideState.bufGuideOrig[band] * DECAY_GUIDE_ORIG, THR_TONE_GUIDE );

    origThres   = IPP_MIN(origThres, THR_TONE);

    if(guideState.bufGuideOrig[band]){

      for(i = iStart; i < iEnd; i++){

        if(bufT[i] > origThres){

          detVec[band] = 1;
          guideNewState.bufGuideOrig[band] = bufT[i];
        }
      }
    }
  }

  /* ******************************
   * detection algorithm: step 3
   * ****************************** */
  origThres   = THR_TONE;

  for(band = 0; band < nBand; band++){

    iStart = pFreqTab[band];
    iEnd = pFreqTab[band+1];

    if(iEnd -iStart > 1){

      for(i = iStart; i < iEnd; i++){

        /* get criterion */
        criterion1 = (bufT[i]       > origThres)      ? 1 : 0;
        criterion2 = (bufSfmSBR[band]  > THR_SFM_SBR ) ? 1 : 0;
        criterion3 = (bufSfmOrig[band] < THR_SFM_ORIG) ? 1 : 0;

        if(criterion1 && criterion2 && criterion3){

          detVec[band] = 1;
          guideNewState.bufGuideOrig[band] = bufT[i];
        }
      }
    } else {

      if(band < nBand -1){

        //iStart = pFreqTab[band];

        criterion1 = (bufT[iStart]     > THR_TONE )     ? 1 : 0;

        if(band){

          criterion2 = (bufDiff[+1]  < INV_THR_TONE ) ? 1 : 0;
          criterion3 = (bufDiff[band-1] < INV_THR_TONE ) ? 1 : 0;

          if(criterion1 && ( criterion2 || criterion3) ){

              detVec[band] = 1;
              guideNewState.bufGuideOrig[band] = bufT[iStart];
          }
        } else {

          criterion2 = (bufDiff[band+1] < INV_THR_TONE) ? 1 : 0;

          if(criterion1 && criterion2){

              detVec[band] = 1;
              guideNewState.bufGuideOrig[band] = bufT[iStart];
          }
        }
      }
    }
  }

  return 0;//OK

}

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

static Ipp32s
sbrencTransientCorrection(Ipp32f bufT[][64],
                          Ipp32s bufDetection[][64],
                          Ipp32s* pFreqTab,
                          Ipp32s nBand,
                          sSBRGuideData state,
                          Ipp32s start,
                          Ipp32s stop)
{
  Ipp32f maxVal1, maxVal2;
  Ipp32s maxPos1, maxPos2;

  Ipp32s i, est;
  Ipp32s iStart, iEnd, iStart2, iEnd2;
  Ipp32s criterion;
  Ipp32s bs_add_harmonic[MAX_NUM_FREQ_COEFFS];

  ippsZero_32s(bs_add_harmonic, MAX_NUM_FREQ_COEFFS);

  for(est = start; est < stop; est++){

    for(i=0;i<nBand-1;i++){

      bs_add_harmonic[i] = bs_add_harmonic[i] || bufDetection[est][i];
    }
  }

  for(i = 0; i < nBand-1; i++){
    iStart = pFreqTab[i];
    iEnd   = pFreqTab[i+1];

    criterion = bs_add_harmonic[i] && bs_add_harmonic[i+1];
    if ( !criterion ) continue;

    iStart = pFreqTab[i];
    iEnd   = pFreqTab[i+1];

    maxPos1 = iStart;
    maxVal1 = bufT[start][iStart];

    iStart2 = pFreqTab[i+1];
    iEnd2   = pFreqTab[i+2];

    maxPos2 = iStart2;
    maxVal2 = bufT[start][iStart2];

    for(est = start; est < stop; est++){

      if ( iEnd - iStart > 1 ) {
        ippsMaxIndx_32f(bufT[est] + iStart, iEnd - iStart, &maxVal1, &maxPos1);
      }

      if ( iEnd2 - iStart2 > 1 ) {
        ippsMaxIndx_32f(bufT[est] + iStart2, iEnd2 - iStart2, &maxVal2, &maxPos2);
      }
    }

    if(maxPos2 < 2 + maxPos1){

      if(maxVal1 - maxVal2 > 0){

        state.bufGuideDetect[i+1] = 0;
        state.bufGuideOrig[i+1]     = 0;