encoder.c

Intel开发的IPP库的应用实例

   if ( !((SamplingFrequency == r8KHz) || (SamplingFrequency == r11KHz) || (SamplingFrequency == r16KHz))){
      free(pCodec[0]);
      return -1;
   }
   if (SamplingFrequency == r8KHz){
      FrameLength = FRAME_LENGTH_8KHz;
      FrameShift = FRAME_SHIFT_8KHz;
      startingFeq = STARTING_FREQ;
      pCodec[0]->freq = r8KHz;
      Frequency = 8000.0f;
      pCodec[0]->weight_c0 = w8kHz_C0;
      pCodec[0]->weight_logE = w8kHz_LE;
      qCoeff = (float*)qCoeff8kHz;
      qCoeffVad = (float*)qCoeff8kHzVAD;
      qCoeffLog = (float*)qCoeff8kHz_Log;
      pCodec[0]->pFrame->sampRate = 0;
   }
   else if (SamplingFrequency == r11KHz){
      FrameLength = FRAME_LENGTH_8KHz;
      FrameShift = FRAME_SHIFT_8KHz;
      startingFeq = STARTING_FREQ;
      pCodec[0]->freq = r11KHz;
      Frequency = 8000.0f;
      pCodec[0]->weight_c0 = w8kHz_C0;
      pCodec[0]->weight_logE =  w8kHz_LE;
      qCoeff = (float*)qCoeff8kHz;
      qCoeffVad = (float*)qCoeff16kHzVAD;
      qCoeffLog = (float*)qCoeff8kHz_Log;
      pCodec[0]->pFrame->sampRate = 1;

      pCodec[0]->s11.time = (Ipp64f)pCodec[0]->s11.history;
      pCodec[0]->s11.lastread = pCodec[0]->s11.history;
      pCodec[0]->s11.ppState = (IppsResamlingPolyphaseFixed_16s**)ippsMalloc_8u(sizeof(IppsResamlingPolyphaseFixed_16s*));
      if(pCodec[0]->s11.ppState==NULL){
         ReleaseAuroraEncoder(pCodec[0]);
         return -1;
      }

      if(ippsResamplePolyphaseFixedInitAlloc_16s(pCodec[0]->s11.ppState,
         11025,8000,2*(pCodec[0]->s11.history), 0.95f, 9.0f,ippAlgHintFast)!=ippStsNoErr){
         ReleaseAuroraEncoder(pCodec[0]);
         return -1;
      }

      pCodec[0]->s11.p11 = ippsMalloc_16s(pCodec[0]->s11.len);
      if(pCodec[0]->s11.p11==NULL){
         ReleaseAuroraEncoder(pCodec[0]);
         return -1;
      }

      ippsZero_16s((short*)pCodec[0]->s11.p11,pCodec[0]->s11.len);
   }
   else if (SamplingFrequency == r16KHz){
      FrameLength = FRAME_LENGTH_16KHz;
      FrameShift = FRAME_SHIFT_16KHz;
      startingFeq = STARTING_FREQ;
      pCodec[0]->freq = r16KHz;
      Frequency = 8000.0f;
      pCodec[0]->weight_c0 = w16kHz_C0;
      pCodec[0]->weight_logE =  w16kHz_LE;
      qCoeff = (float*)(qCoeff16kHz);
      qCoeffVad = (float*)qCoeff16kHzVAD;
      qCoeffLog = (float*)qCoeff16kHz_Log;
      pCodec[0]->pFrame->sampRate = 3;
      ippsZero_32f(pCodec[0]->noise.s16.dataHP,560);
      pCodec[0]->noise.s16.vad16.nbSpeechFrame=0;
      pCodec[0]->noise.s16.vad16.Eloglowtrack=0;
      pCodec[0]->noise.s16.vad16.flagVAD=0;
      pCodec[0]->noise.s16.vad16.hangOver = 0;
      pCodec[0]->noise.s16.vad16.pNoise16[0]=0.0f;
      pCodec[0]->noise.s16.vad16.pNoise16[1]=0.0f;
      pCodec[0]->noise.s16.vad16.pNoise16[2]=0.0f;
   }

   pCodec[0]->FrameLength = FrameLength;
   pCodec[0]->FrameShift = FrameShift;
   pCodec[0]->Dst0 = 0.0;
   pCodec[0]->pSrc0 = 0.0;
   pCodec[0]->preFloat = 0.0;
   pCodec[0]->numChannels = NUM_CHANNELS;
   pCodec[0]->numCepCoeff = NUM_CEP_COEFF;

   /* Init for noise reduction block */
   /* initialisation of winHanning coefficient */
   ippsZero_32f(pCodec[0]->noise.pBStateBig,640+FILTERLENGTH);

   for(i=0; i<WINHANNSIZE; i++){
        pCodec[0]->noise.winHannCoeff[i] = 0.5f-0.5f*(float)cos(IPP_2PI*(i+0.5f)/WINHANNSIZE);
   }
   for( i=0; i<FL; i++){
      pCodec[0]->noise.winHannFilter[FL-i-1]=0.5f-0.5f*(float)cos(IPP_2PI*(i+0.5f)/FL);
   }

   if(ippsMelFBankInitAllocLow_Aurora_32f(&pCodec[0]->noise.pFBank)!=ippStsNoErr){
      ReleaseAuroraEncoder(pCodec[0]);
      return -1;
   }
   if(ippsFFTInitAlloc_R_32f(&(pCodec[0]->noise.ctxFFT),FFTORDER,
      IPP_FFT_NODIV_BY_ANY,ippAlgHintAccurate)!=ippStsNoErr){
      ReleaseAuroraEncoder(pCodec[0]);
      return -1;
   }

   if(ippsFBankGetCenters_32f(pCodec[0]->noise.pFBank,pCenters)!=ippStsNoErr){
      ReleaseAuroraEncoder(pCodec[0]);
      return -1;
   }
   /* Set MelFB coefficient */
    pFCentres[0] = 0;

    for( i = 1; i<=NUM_CHANNELS; i++){
      ippsFBankGetCoeffs_32f(pCodec[0]->noise.pFBank,i+1,pCoeff);
        norm=0.0f;
        for(j=0; j<=pCenters[i+2]-1-pCenters[i]+1;j++){
         norm += pCoeff[j] * 8000 * (float)(j+pCenters[i]) /(2*(FFTSPEC-1));
      }
      pFCentres[i] = norm;
    }

   pFCentres[NUM_CHANNELS+1] = 8000/2;

   /* for 16KHz */
   pCodec[0]->noise.s16.pFBank16 = NULL;
   if (SamplingFrequency == r16KHz){
      append=FILTERLENGTH-1;
      if(ippsMelFBankInitAllocHigh_Aurora_32f(&pCodec[0]->noise.s16.pFBank16)!=ippStsNoErr){
         ReleaseAuroraEncoder(pCodec[0]);
         return -1;
      }
   }
    /* Mel IDCT */
    pDFK[0] = (pFCentres[1]-pFCentres[0])/8000;
    for(k=1; k<=NUM_CHANNELS; k++)
      pDFK[k] = (pFCentres[k+1]-pFCentres[k-1])/8000;
   pDFK[NUM_CHANNELS+1] = (pFCentres[NUM_CHANNELS+1]-pFCentres[NUM_CHANNELS])/8000;
   pCodec[0]->noise.pIDCT = (float**)ippsMalloc_8u((NUM_CHANNELS+2)*(sizeof(float*)+(NUM_CHANNELS+2)*sizeof(float)));
   if(pCodec[0]->noise.pIDCT==NULL){
      ReleaseAuroraEncoder(pCodec[0]);
      return -1;
   }

   pTmp=(float*)(pCodec[0]->noise.pIDCT+(NUM_CHANNELS+2));
   for(k=0; k<=NUM_CHANNELS+1; k++,pTmp+=(NUM_CHANNELS+2)){
      pCodec[0]->noise.pIDCT[k] = pTmp;
        for(n=0; n <= NUM_CHANNELS+1; n++)
            pCodec[0]->noise.pIDCT[k][n] = (float)cos( (IPP_2PI * (float)k * pFCentres[n])/8000 ) * pDFK[n];
   }
   ippsZero_32f(pCodec[0]->noise.pPSDprev_1,FFTSPEC);
    ippsZero_32f(pCodec[0]->noise.pPSDprev_2,FFTSPEC);
   ippsZero_32f(pCodec[0]->noise.pDenPrev_1,FFTSPEC);
   ippsZero_32f(pCodec[0]->noise.pDenPrev_2,FFTSPEC);
    ippsSet_32f((float)EPS,pCodec[0]->noise.pNoiseTnPrev_1,FFTSPEC);
    ippsSet_32f((float)EPS*EPS,pCodec[0]->noise.pNoisePrev_2,FFTSPEC);
    ippsSet_32f((float)EPS,pCodec[0]->noise.pNoiseTn,FFTSPEC);
    ippsZero_32f(pCodec[0]->noise.pBStateBuf, 960);

    pCodec[0]->noise.Eden=pCodec[0]->noise.Eden1=pCodec[0]->noise.Eden2=0.0f;
    pCodec[0]->noise.SNRlowPrev=0.0f;
   pCodec[0]->noise.agfPrev=0.8f;
   pCodec[0]->noise.pSrc0 = pCodec[0]->noise.Dst0=0.0f;
   pCodec[0]->noise.Cur_TPrpocess=0;
   pCodec[0]->noise.tail=0;
   pCodec[0]->noise.start=0;
   pCodec[0]->noise.end=0;
   pCodec[0]->noise.vad.nbSpeechFrame=0;
   pCodec[0]->noise.vad.Eloglowtrack=0;
   pCodec[0]->noise.vad.flagVAD=0;
   pCodec[0]->noise.vad.hangOver = 0;
   /* End init for noise reduction block */

   ippsZero_32f(pCodec[0]->bias,NUM_CEP_COEFF-1);
   if (EncoderInput==WAVEFORM){
      pCodec[0]->HammingWindow = ippsMalloc_32f(WINHANNSIZE);
      if(pCodec[0]->HammingWindow==NULL){
         ReleaseAuroraEncoder(pCodec[0]);
         return -1;
      }

      ippsZero_32f(pCodec[0]->HammingWindow,WINHANNSIZE);
      for (i = 0; i < WINHANNSIZE; i++)
           pCodec[0]->HammingWindow[i] = (float)(0.54f - 0.46f * cos (IPP_2PI * ((float)i+0.5f) / WINHANNSIZE));
   }
   pCodec[0]->pFrame->pos=6;
   pCodec[0]->curPosition = 0;
   pCodec[0]->EncoderOutput = EncoderOutput;

   if (EncoderInput==WAVEFORM){
      if(ippsMelFBankInitAlloc_32f(&pCodec[0]->pFBank,&pCodec[0]->FFTOrder,WAVEFORMSIZE,Frequency,
         startingFeq, Frequency/2,NUM_CHANNELS,1127.0,700,IPP_FBANK_FREQWGT)!=ippStsNoErr){
         ReleaseAuroraEncoder(pCodec[0]);
         return -1;
      }

      if(ippsFFTInitAlloc_R_32f(&(pCodec[0]->ctxFFT),pCodec[0]->FFTOrder,
         IPP_FFT_NODIV_BY_ANY,ippAlgHintAccurate)!=ippStsNoErr){
         ReleaseAuroraEncoder(pCodec[0]);
         return -1;
      }

      pCodec[0]->FFTLength = 1<<pCodec[0]->FFTOrder;
      pCodec[0]->workBuffer = ippsMalloc_32f(pCodec[0]->FFTLength);
      if(pCodec[0]->workBuffer==NULL){
         ReleaseAuroraEncoder(pCodec[0]);
         return -1;
      }

      if (SamplingFrequency == r16KHz){
         if(ippsDCTLifterInitAlloc_MulC0_32f(&pCodec[0]->pDCTLifter,
            NUM_CHANNELS+KFB16,pLiftCoeff,NUM_CEP_COEFF-1)!=ippStsNoErr){
            ReleaseAuroraEncoder(pCodec[0]);
            return -1;
         }
      }
      else{
         if(ippsDCTLifterInitAlloc_MulC0_32f(&pCodec[0]->pDCTLifter,
            NUM_CHANNELS,pLiftCoeff,NUM_CEP_COEFF-1)!=ippStsNoErr){
            ReleaseAuroraEncoder(pCodec[0]);
            return -1;
         }
      }
   }
   if (EncoderOutput == QUANTIZED || EncoderOutput == MULTIFRAME){
      ippsZero_8u(pCodec[0]->pIndexVQBuffer,2*NUM_CODEBOOK);
      pCodec[0]->ppCdbkState = (IppsCdbkState_32f  **)ippsMalloc_8u (sizeof(IppsCdbkState_32f  *)*NUM_CODEBOOK);
      if(pCodec[0]->ppCdbkState==NULL){
         ReleaseAuroraEncoder(pCodec[0]);
         return -1;
      }

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

      ippsCdbkInitAlloc_L2_32f(&(pCodec[0]->ppCdbkState[5]),(const float*)qCoeffVad,2,2,32,32,IPP_CDBK_FULL);
      for (i=0; i<256;i++){
         qCoeffLog[i*2+0] *= (float)pCodec[0]->weight_c0;
         qCoeffLog[i*2+1] *= (float)pCodec[0]->weight_logE;
      }
      ippsCdbkInitAlloc_L2_32f(&(pCodec[0]->ppCdbkState[6]),(const float*)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->noise.pIDCT)ippsFree(pCodec->noise.pIDCT);
      if(pCodec->noise.ctxFFT)   ippsFFTFree_R_32f(pCodec->noise.ctxFFT);
      if(pCodec->ctxFFT)   ippsFFTFree_R_32f(pCodec->ctxFFT);
      if(pCodec->noise.pFBank)   ippsFBankFree_32f(pCodec->noise.pFBank);
      if(pCodec->noise.s16.pFBank16)   ippsFBankFree_32f(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->pFBank) ippsFBankFree_32f(pCodec->pFBank);
      if(pCodec->pDCTLifter) ippsDCTLifterFree_32f(pCodec->pDCTLifter);
      if(pCodec->ppCdbkState){
         for (i=0; i<NUM_CODEBOOK; i++){
            if (pCodec->ppCdbkState[i])ippsCdbkFree_32f(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;
   }
}

/* For CEPSTRUM calculation */
void CeptstrumCalculate(AuroraEncoder *pCodec, float *pSrc, int tc){
   float LogEnergy;
   int i,j;
   float pFBank16[3],avr;
   float pFFT16[FFTSIZE];
   float pMelBank[KFB16];
   float pHPBands[3];

   LogEnergy = 0.0;

   ippsDotProd_32f(pSrc,pSrc,WAVEFORMSIZE,&LogEnergy);

   /* Pre-emphasis */
   ippsCopyWithPadding_32f(pSrc, WAVEFORMSIZE, pCodec->workBuffer,pCodec->FFTLength);

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

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

   /* Windowing */
   ippsMul_32f_I(pCodec->HammingWindow,pCodec->workBuffer,WAVEFORMSIZE);

   /* Mel filtering with FFT and Magnitude spectrum*/
   ippsFFTFwd_RToCCS_32f(pCodec->workBuffer,pCodec->workBuffer,pCodec->ctxFFT,NULL);

   pCodec->workBuffer[0] = pCodec->workBuffer[0] * pCodec->workBuffer[0];
   for (i=1,j=2; i<(FFTSIZE>>1) ; i++,j+=2)
      pCodec->workBuffer[i] = (pCodec->workBuffer[j] * pCodec->workBuffer[j] + pCodec->workBuffer[j+1] * pCodec->workBuffer[j+1]);
   pCodec->workBuffer[i] = pCodec->workBuffer[j] * pCodec->workBuffer[j];


   if(pCodec->freq == r16KHz){
      ippsMul_32f(pCodec->noise.winHannCoeff, pCodec->noise.s16.dataHP, pFFT16, WINHANNSIZE);

      ippsZero_32f(pFFT16+WINHANNSIZE, FFTSIZE-WINHANNSIZE);

      ippsFFTFwd_RToPerm_32f(pFFT16,pFFT16,pCodec->noise.ctxFFT,NULL);
      ippsSmoothedPowerSpectrumAurora_32f(pFFT16,pFFT16,FFTSIZE);

      ippsEvalFBank_32f(pFFT16,pMelBank,pCodec->noise.s16.pFBank16);

      SpecSubHighFreqBands(pCodec,pMelBank,pHPBands,tc-4);

      ippsHighBandCoding_Aurora_32f(pMelBank,pCodec->noise.pFFT,pCodec->workBuffer,pFBank16);

   }

   ippsEvalFBank_32f(pCodec->workBuffer,pCodec->workBuffer,pCodec->pFBank);

   if(pCodec->freq == r16KHz){
      for (i=0; i<3; i++){
         pCodec->workBuffer[i+NUM_CHANNELS] = 1.9f * pHPBands[i];
      }
      for (i=0 ; i<3 ; i++)
         pFBank16 [i] += 0.641854f;
   }

   /* Natural logarithm computation */
   for (i = 0; i < pCodec->numChannels+3; i++){