encoder.c

Intel开发的IPP库的应用实例

      pCodec[0]->ppCdbkState = (IppsCdbkState_16s  **)ippsMalloc_8u (sizeof(IppsCdbkState_16s  *)*NUM_CODEBOOK);
      if(pCodec[0]->ppCdbkState==NULL){
         ReleaseAuroraEncoder(pCodec[0]);
         return -1;
      }

      for (i=0; i < 5; i++)
         ippsCdbkInitAlloc_L2_16s(&(pCodec[0]->ppCdbkState[i]),(const Ipp16s*)(qCoeff+i*128),2,2,64,64,IPP_CDBK_FULL);

      ippsCdbkInitAlloc_L2_16s(&(pCodec[0]->ppCdbkState[5]),(const Ipp16s*)qCoeffVad,2,2,32,32,IPP_CDBK_FULL);
      for (i=0; i<256;i++){
         qCoeffLog[i*2+0] = (qCoeffLog[i*2+0] * (Ipp32s)pCodec[0]->weight_c0)>>11;
         qCoeffLog[i*2+1] = (qCoeffLog[i*2+1] * (Ipp32s)pCodec[0]->weight_logE)>>11;
      }
      ippsCdbkInitAlloc_L2_16s(&(pCodec[0]->ppCdbkState[6]),(const Ipp16s*)qCoeffLog,2,2,256,256,IPP_CDBK_FULL);
   }

   return 0;
}


void ReleaseAuroraEncoder(AuroraEncoder *pCodec){
   int i;

   if (pCodec){
      if(pCodec->pVadMem)ippsFree(pCodec->pVadMem);
      if(pCodec->FirCoeff16sAlign)ippsFree(pCodec->FirCoeff16sAlign);
      if(pCodec->noise.pIDCT)ippsFree(pCodec->noise.pIDCT);
      if(pCodec->noise.ctxFFT)   ippsFFTFree_R_32s(pCodec->noise.ctxFFT);
      if(pCodec->ctxFFT)   ippsFFTFree_R_32s(pCodec->ctxFFT);
      if(pCodec->noise.pFBank)   ippsFBankFree_16s(pCodec->noise.pFBank);
      if(pCodec->noise.s16.pFBank16)   ippsFBankFree_16s(pCodec->noise.s16.pFBank16);
      if(pCodec->pFrame)ippsFree(pCodec->pFrame);
      if(pCodec->pFeatBuffer)ippsFree(pCodec->pFeatBuffer);
      if(pCodec->pFeatCyclicBuf)ippsFree(pCodec->pFeatCyclicBuf);
      if(pCodec->HammingWindow)ippsFree(pCodec->HammingWindow);
      if(pCodec->workBuffer) ippsFree(pCodec->workBuffer);
      if(pCodec->pBuffer32s) ippsFree(pCodec->pBuffer32s);
      if(pCodec->pFBank) ippsFree(pCodec->pFBank);
      if(pCodec->pDCTLifter) ippsDCTLifterFree_16s(pCodec->pDCTLifter);
      if(pCodec->ppCdbkState){
         for (i=0; i<NUM_CODEBOOK; i++){
            if (pCodec->ppCdbkState[i])ippsCdbkFree_16s(pCodec->ppCdbkState[i]);
         }
         ippsFree(pCodec->ppCdbkState);
      }
      if(pCodec->s11.ppState){
         if(pCodec->s11.ppState[0])
            ippsResamplePolyphaseFixedFree_16s(pCodec->s11.ppState[0]);
         ippsFree(pCodec->s11.ppState);
         if(pCodec->s11.p11)ippsFree(pCodec->s11.p11);
      }
      free(pCodec);
      pCodec = NULL;
   }
}


void SpecSubFilterBank (AuroraEncoder *pCodec, Ipp32s *pDataInOut, Ipp32s *pHPBands, int t ){

  int i;
  int flagVAD;
  float lambdaNSE;
  Ipp32s Elog, Eloglowtrack;

  Eloglowtrack = pCodec->noise.s16.vad16.Eloglowtrack;

  if (t < NB_FRAME_THRESHOLD_NSE)
    lambdaNSE = pLambdaNSE[t-1];
  else
    lambdaNSE = LAMBDA_NSE;

  Elog = 0;
  for (i=0 ; i<KFB16 ; i++)
    Elog += pDataInOut[i];

  Elog = SATURATE_32s(((Ipp64s)Elog<<7));
  if (Elog > 0)
    ippsLn_32s_ISfs(&Elog,1,-10);
  else
    Elog = -7074;                          /* +10 */

  if (((Elog - Eloglowtrack) < 1229) || (t < 10)){
     if (t < 10){
        Eloglowtrack = (Ipp32s)((1 - lambdaNSE) * Elog + lambdaNSE * Eloglowtrack);
     }else{
        if (Elog < Eloglowtrack)
           Eloglowtrack = ((328 * Elog + 16056 * Eloglowtrack)>>14);
        else
           Eloglowtrack = ((82 * Elog + 16302 * Eloglowtrack)>>14);
     }
  }

  if ((Elog - Eloglowtrack) > 2253){
     flagVAD = 1;
     pCodec->noise.s16.vad16.nbSpeechFrame++;
  }else{
     if (pCodec->noise.s16.vad16.nbSpeechFrame > MIN_SPEECH_FRAME_HANGOVER)
      pCodec->noise.s16.vad16.hangOver = 5;
      pCodec->noise.s16.vad16.nbSpeechFrame = 0;
      if (pCodec->noise.s16.vad16.hangOver != 0){
         pCodec->noise.s16.vad16.hangOver--;
         flagVAD = 1;
      } else
         flagVAD = 0;
  }

  if (flagVAD == 0){
     for (i=0 ; i<KFB16 ; i++){
        pCodec->noise.s16.vad16.pNoise16 [i] = (Ipp32s)((1-lambdaNSE) * pCodec->noise.s16.vad16.pNoise16 [i] + lambdaNSE * pDataInOut [i]);
     }
  }

  for (i=0 ; i<KFB16 ; i++){
     pHPBands[i] = SATURATE_32s(IPP_MAX( ((Ipp64s)pDataInOut [i]<<10) -
            1536 * (Ipp64s)pCodec->noise.s16.vad16.pNoise16 [i], 102 * (Ipp64s)pDataInOut [i])>>10);
  }
  pCodec->noise.s16.vad16.Eloglowtrack = Eloglowtrack;
  pCodec->noise.s16.vad16.flagVAD = flagVAD;

}

/* For CEPSTRUM calculation */

void CeptstrumCalculate(AuroraEncoder *pCodec, short *pSrc, int tc){
   int i,j;
   Ipp32s pFBank32s[3],avr32s;
   Ipp16s pFFT16sL[FFTSIZE];
   Ipp16s pFFT16sH[FFTSIZE];
   Ipp32s pFFT32s[FFTSIZE+2];
   Ipp32s pBuffer32s[130];
   Ipp32s pMelBank32sL[KFB16];
   Ipp32s pMelBank32sH[KFB16];
   Ipp32s pHPBands32s[3];

   Ipp64s le64;
   Ipp32s LogEnergy;

   LogEnergy = 0;

   ippsDotProd_16s64s(pSrc,pSrc,WAVEFORMSIZE,&le64);
   LogEnergy = SATURATE_32s(le64>>4);

   /* Pre-emphasis */
   ippsCopyWithPadding_16s(pSrc, WAVEFORMSIZE, pCodec->workBuffer,pCodec->FFTLength);
   ippsZero_16s((Ipp16s*)pCodec->pBuffer32s,pCodec->FFTLength<<1);

   ippsPreemphasize_16s(pCodec->workBuffer, WAVEFORMSIZE, 0.9f);

   pCodec->workBuffer[0] = (Ipp16s)((pSrc[0] - 0.9f * pCodec->preFloat));
   pCodec->preFloat = pSrc[FRAMESHIFT-1];

   /* Windowing */
   ippsMul_16s32s_Sfs(pCodec->HammingWindow,pCodec->workBuffer,pCodec->pBuffer32s,WAVEFORMSIZE,10);

   /* Mel filtering with FFT and Magnitude spectrum*/
   ippsFFTFwd_RToCCS_32s_Sfs(pCodec->pBuffer32s,pCodec->pBuffer32s,pCodec->ctxFFT,6,NULL);         /* 0 */

   pCodec->pBuffer32s[0] = SATURATE_32s( ((Ipp64s)pCodec->pBuffer32s[0] * (Ipp64s)pCodec->pBuffer32s[0]));

   for (i=1,j=2; i<(FFTSIZE>>1) ; i++,j+=2)
      pCodec->pBuffer32s[i] = SATURATE_32s( ((Ipp64s)pCodec->pBuffer32s[j] * (Ipp64s)pCodec->pBuffer32s[j] +
      (Ipp64s)pCodec->pBuffer32s[j+1] * (Ipp64s)pCodec->pBuffer32s[j+1]));
   pCodec->pBuffer32s[i] = SATURATE_32s( ((Ipp64s)pCodec->pBuffer32s[j] * (Ipp64s)pCodec->pBuffer32s[j]) );

   if(pCodec->freq == r16KHz){

      ippsMul_16s32s_Sfs(winHannCoeffQ14, pCodec->noise.s16.dataHP, pFFT32s, WINHANNSIZE, 8);
      ippsZero_16s((Ipp16s*)(pFFT32s+WINHANNSIZE), (FFTSIZE-WINHANNSIZE+2)<<1);

      ippsFFTFwd_RToCCS_32s_Sfs(pFFT32s,pFFT32s,pCodec->noise.ctxFFT,7,NULL);
      pFFT32s[1] = pFFT32s[FFTSIZE];

      ippsSmoothedPowerSpectrumAurora_32s_Sfs(pFFT32s,pFFT32s,FFTSIZE,4);

      for(i=0; i<(FFTSIZE>>2)+1;i++){
         pFFT16sL[i] = (Ipp16s)(pFFT32s[i]%(1<<14));
         pFFT16sH[i] = (Ipp16s)(pFFT32s[i]/(1<<14));
      }

      ippsEvalFBank_16s32s_Sfs(pFFT16sL,pMelBank32sL,pCodec->noise.s16.pFBank16,-4);
      ippsEvalFBank_16s32s_Sfs(pFFT16sH,pMelBank32sH,pCodec->noise.s16.pFBank16,-18);
      ippsAdd_32s_ISfs(pMelBank32sH,pMelBank32sL,KFB16,0);

      SpecSubFilterBank(pCodec,pMelBank32sL,pHPBands32s,tc-4);

      for(i=0; i<130;i++){
         pBuffer32s[i] = SATURATE_32s(((Ipp64s)pCodec->pBuffer32s[i]<<4));
      }

      ippsHighBandCoding_Aurora_32s_Sfs(pMelBank32sL,pCodec->noise.pFFT,pBuffer32s,pFBank32s,-7);

   }

   ippsEvalFBank_32s_Sfs(pCodec->pBuffer32s,pCodec->pBuffer32s,
      (const IppsFBankState_32s *)pCodec->pFBank,0);


   if(pCodec->freq == r16KHz){
      for (i=0; i<3; i++){
         pCodec->pBuffer32s[i+NUM_CHANNELS] = (Ipp32s)((243 * (Ipp64s)pHPBands32s[i])>>11);
      }
      for (i=0 ; i<3 ; i++)
         pFBank32s [i] += 82;
   }

   /* Natural logarithm computation */
   for (i = 0; i < pCodec->numChannels+3; i++){
      if (pCodec->pBuffer32s[i] <= 0)
         pCodec->pBuffer32s[i] = -50;
      else{
         ippsLn_32s_ISfs(&pCodec->pBuffer32s[i],1,-7);
         pCodec->pBuffer32s[i]+=355;
      }
   }

   if(pCodec->freq == r16KHz){
      pCodec->pBuffer32s[NUM_CHANNELS]     = (Ipp32s)((90 * (Ipp64s)pFBank32s[0] + 38 * pCodec->pBuffer32s[NUM_CHANNELS])>>7);
      pCodec->pBuffer32s[NUM_CHANNELS + 1] = (Ipp32s)((90 * (Ipp64s)pFBank32s[1] + 38 * pCodec->pBuffer32s[NUM_CHANNELS + 1])>>7);
      pCodec->pBuffer32s[NUM_CHANNELS + 2] = (Ipp32s)((90 * (Ipp64s)pFBank32s[2] + 38 * pCodec->pBuffer32s[NUM_CHANNELS + 2])>>7);

      avr32s = pCodec->pBuffer32s[NUM_CHANNELS-1] + pCodec->pBuffer32s[NUM_CHANNELS];

      pCodec->pBuffer32s[NUM_CHANNELS - 1] = (77 * pCodec->pBuffer32s [NUM_CHANNELS - 1] + 26 * avr32s)>>7;
      pCodec->pBuffer32s[NUM_CHANNELS]     = (77 * pCodec->pBuffer32s [NUM_CHANNELS] + 26 * avr32s)>>7;

      pFBank32s[0] = (pCodec->pBuffer32s [NUM_CHANNELS    ] - 82)>>7;
      pFBank32s[1] = (pCodec->pBuffer32s [NUM_CHANNELS + 1] - 82)>>7;
      pFBank32s[2] = (pCodec->pBuffer32s [NUM_CHANNELS + 2] - 82)>>7;

      ippsExp_32s_ISfs(pFBank32s,3,0);

      LogEnergy += ((pFBank32s[0]+pFBank32s[1]+pFBank32s[2])>>4);
   }
   if (LogEnergy <= 0)
      LogEnergy = -50;
   else{
      ippsLn_32s_ISfs(&LogEnergy,1,-6);
      LogEnergy+=177;           /*Correction 177*/
   }

   /* Discrete Cosine Transform */
   for(i=0; i<pCodec->numChannels+3;i++){
         pFFT16sL[i] = (Ipp16s)(pCodec->pBuffer32s[i]%(1<<14));
         pFFT16sH[i] = (Ipp16s)(pCodec->pBuffer32s[i]/(1<<14));
   }

   ippsDCTLifter_16s_Sfs(pFFT16sL, pFFT16sL,pCodec->pDCTLifter,1);
   ippsDCTLifter_16s_Sfs(pFFT16sH, pFFT16sH,pCodec->pDCTLifter,-13);

   ippsAdd_16s(pFFT16sL,pFFT16sH,pCodec->pFeatBuffer,pCodec->numCepCoeff);

   /* Append logE after c0 */
   pCodec->pFeatBuffer[pCodec->numCepCoeff] = LogEnergy;

   /* Blind Equalization */
   ippsBlindEqualization_Aurora_16s(RefCep,pCodec->pFeatBuffer,pCodec->bias,NUM_CEP_COEFF-1,LogEnergy);
}


/*    WAVEFORM   ->   FEATURE   */
int ApplyAuroraEncoder_WF(AuroraEncoder *pCodec, short *pInputSignal, int InputLength,
                          short *pOutputBuffer, unsigned char *pVadDst, int StreamEnd){
   int FrameCounter=0, Count=0;
   int tcur = 0, tc,l;
   Ipp16s pNoiseDst[200];

   char flagVAD;
   short *pTmp;
   short *pInTmp;
   Ipp16s *pBState_2 = pCodec->noise.pBStateBuf+320;
   Ipp16s *pBState_1 = pBState_2+320;
   Ipp32s *pFFTOut = pCodec->noise.pFFT+FFTSIZE*4;
   Ipp16s pDen[FFTSPEC];
   Ipp16s pMelBank[NUM_CHANNELS+2];
   IppVADDecision_Aurora vad[1];
   IppStatus status;

   if ( (pCodec->EncoderOutput != FEATURE) && (pCodec->EncoderInput != WAVEFORM)){
      printf("\n!!! ERROR: encoder was initialized with another output flag !!!");
      return 0;
   }

   if (InputLength<=0){
      FrameCounter=0;
      ResetAuroraEncoder(pCodec);
      return FrameCounter;
   }
   pTmp = pInputSignal;

   if(pCodec->freq == r11KHz){
      FrameCounter = (InputLength + pCodec->s11.lastread) / 11;
      pTmp = ippsMalloc_16s(FrameCounter * 8 + 4);
      FrameCounter=0;
      if(InputLength + pCodec->s11.lastread >pCodec->s11.len){
         pCodec->s11.len = InputLength + pCodec->s11.lastread;
         pInTmp = ippsMalloc_16s(pCodec->s11.len);

         ippsCopy_16s(pCodec->s11.p11,pInTmp,pCodec->s11.lastread);

         ippsFree(pCodec->s11.p11);
         pCodec->s11.p11 = pInTmp;

      }

      ippsCopy_16s(pInputSignal,pCodec->s11.p11 + pCodec->s11.lastread, InputLength);

      pCodec->s11.lastread+=InputLength;

      InputLength=0;
      status = ippsResamplePolyphaseFixed_16s(pCodec->s11.ppState[0],pCodec->s11.p11,
         (pCodec->s11.lastread-pCodec->s11.history-(int)pCodec->s11.time),
                     (short*)pTmp,0.98f,&pCodec->s11.time,&InputLength);
      if(status==ippStsNoErr){
         ippsMove_16s(pCodec->s11.p11+(int)pCodec->s11.time-pCodec->s11.history,
            pCodec->s11.p11,(pCodec->s11.lastread+pCodec->s11.history-(int)pCodec->s11.time));


         pCodec->s11.lastread-=(int)pCodec->s11.time-pCodec->s11.history;
         pCodec->s11.time-=(int)pCodec->s11.time-pCodec->s11.history;