encoder.c

Intel开发的IPP库的应用实例

   int i,k,n;
   short *qCoeffLog, *qCoeff,*qCoeffVad;
   float pLiftCoeff[NUM_CEP_COEFF-1] = {1.0f,1.0f,1.0f,1.0f,1.0f,1.0f,1.0f,1.0f,1.0f,1.0f,1.0f,1.0f,};
/*   float pFCentres[NUM_CHANNELS+2+2];
   float norm;
   float pDFK[NUM_CHANNELS+2+2];
   float pCoeff[65];*/
   Ipp16s *pTmp;

   int size;
   int pCenters[NUM_CHANNELS+2+2];

   pCodec[0] = (AuroraEncoder*)malloc(sizeof(AuroraEncoder));
   if (pCodec[0]==NULL) return -1;
   status = ippStsNoErr;
   pCodec[0]->pFBank = NULL;
   pCodec[0]->ctxFFT = NULL;
   pCodec[0]->EncoderInput = EncoderInput;
   pCodec[0]->pDCTLifter = NULL;
   pCodec[0]->workBuffer = NULL;
   pCodec[0]->ppCdbkState = NULL;
   pCodec[0]->pFeatBuffer = NULL;
   pCodec[0]->pFeatCyclicBuf = NULL;
   pCodec[0]->HammingWindow = NULL;
   pCodec[0]->pFeatBuffer = NULL;
   pCodec[0]->pFeatCyclicBuf = NULL;
   ippsVADGetBufSize_Aurora_16s(&n);
   pCodec[0]->pVadMem = NULL;
   pCodec[0]->VadFrame = 0;
   pCodec[0]->iCountFrame = 0;
   pCodec[0]->mframeCounter = 1;
   pCodec[0]->NumberFrame = 0;
   pCodec[0]->s11.ppState = NULL;
   pCodec[0]->s11.p11 = NULL;
   pCodec[0]->pFrame = NULL;
   pCodec[0]->noise.ctxFFT = NULL;
   pCodec[0]->noise.pFBank = NULL;
   pCodec[0]->noise.pIDCT = NULL;
   pCodec[0]->noise.s16.pFBank16 = NULL;
   pCodec[0]->pBuffer32s = NULL;
   pCodec[0]->FirCoeff16sAlign = NULL;
   pCodec[0]->pFrame = (MFrame*)ippsMalloc_8u(sizeof(MFrame));
   if(pCodec[0]->pFrame==NULL){
      ReleaseAuroraEncoder(pCodec[0]);
      return -1;
   }

   pCodec[0]->pFeatBuffer = ippsMalloc_16s(NUM_CEP_COEFF+1);
   if(pCodec[0]->pFeatBuffer==NULL){
      ReleaseAuroraEncoder(pCodec[0]);
      return -1;
   }

   pCodec[0]->pFeatCyclicBuf = ippsMalloc_16s((NUM_CEP_COEFF+1)*7);
   if(pCodec[0]->pFeatCyclicBuf==NULL){
      ReleaseAuroraEncoder(pCodec[0]);
      return -1;
   }

   pCodec[0]->pVadMem = ippsMalloc_8u(n);
   if(pCodec[0]->pVadMem==NULL){
      ReleaseAuroraEncoder(pCodec[0]);
      return -1;
   }

   if(ippsVADInit_Aurora_16s(pCodec[0]->pVadMem)!=ippStsNoErr){
      ReleaseAuroraEncoder(pCodec[0]);
      return -1;
   }


   pCodec[0]->s11.history = 33;
   pCodec[0]->s11.len = (pCodec[0]->s11.history+3)*2;

   if ( !((SamplingFrequency == r8KHz) || (SamplingFrequency == r11KHz) || (SamplingFrequency == r16KHz))){
      free(pCodec[0]);
      return -1;
   }
   if (SamplingFrequency == r8KHz){
      FrameLength = FRAME_LEN_8;
      FrameShift = FRAME_SHIFT_8;
      startingFeq = STARTING_FREQ;
      pCodec[0]->freq = r8KHz;
      Frequency = 8000.0f;
      pCodec[0]->weight_c0 = w8kHz_C0;
      pCodec[0]->weight_logE = w8kHz_LE;
      qCoeff = (Ipp16s*)qCoeff8kHz;
      qCoeffVad = (Ipp16s*)qCoeff8kHzVAD;
      qCoeffLog = (Ipp16s*)qCoeff8kHz_Log;
      pCodec[0]->pFrame->sampRate = 0;
   }
   else if (SamplingFrequency == r11KHz){
      FrameLength = FRAME_LEN_8;
      FrameShift = FRAME_SHIFT_8;
      startingFeq = STARTING_FREQ;
      pCodec[0]->freq = r11KHz;
      Frequency = 8000.0f;
      pCodec[0]->weight_c0 = w8kHz_C0;
      pCodec[0]->weight_logE =  w8kHz_LE;
      qCoeff = (Ipp16s*)qCoeff8kHz;
      qCoeffVad = (Ipp16s*)qCoeff16kHzVAD;
      qCoeffLog = (Ipp16s*)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_LEN_16;
      FrameShift = FRAME_SHIFT_16;
      startingFeq = STARTING_FREQ;
      pCodec[0]->freq = r16KHz;
      Frequency = 8000.0f;
      pCodec[0]->weight_c0 = w16kHz_C0;
      pCodec[0]->weight_logE = w16kHz_LE;
      qCoeff = (Ipp16s*)(qCoeff16kHz);
      qCoeffVad = (Ipp16s*)qCoeff16kHzVAD;
      qCoeffLog = (Ipp16s*)qCoeff16kHz_Log;
      pCodec[0]->pFrame->sampRate = 3;
      ippsZero_16s(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;
      pCodec[0]->noise.s16.vad16.pNoise16[1]=0;
      pCodec[0]->noise.s16.vad16.pNoise16[2]=0;
      pCodec[0]->FirCoeff16sAlign = ippsMalloc_16s(FILTERLENGTH);
      if(pCodec[0]->FirCoeff16sAlign==NULL){
         ReleaseAuroraEncoder(pCodec[0]);
         return -1;
      }
      ippsCopy_16s(FIRCoef,pCodec[0]->FirCoeff16sAlign,FILTERLENGTH);
   }

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

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

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

   if(ippsMelFBankInitAllocLow_Aurora_16s(&pCodec[0]->noise.pFBank)!=ippStsNoErr){
      ReleaseAuroraEncoder(pCodec[0]);
      return -1;
   }


   if(ippsFBankGetCenters_16s(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_16s(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;
*/
   /* Mel IDCT */
   pCodec[0]->noise.pIDCT = (Ipp16s**)ippsMalloc_8u((NUM_CHANNELS+2)*(sizeof(Ipp16s*)+(NUM_CHANNELS+2)*sizeof(Ipp16s)));

   if(pCodec[0]->noise.pIDCT==NULL){
      ReleaseAuroraEncoder(pCodec[0]);
      return -1;
   }
/*
   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;
*/
   pTmp=(Ipp16s*)(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;
      ippsCopy_16s(pIDCTCoeff[k],pCodec[0]->noise.pIDCT[k],NUM_CHANNELS+2);
/*      for(n=0; n <= NUM_CHANNELS+1; n++)
         pCodec[0]->noise.pIDCT[k][n] = (Ipp16s)(32768.f*cos( (IPP_2PI * (float)k * pFCentres[n])/8000 ) * pDFK[n]);*/
   }

   /* for 16KHz */
   pCodec[0]->noise.s16.pFBank16 = NULL;
   if (SamplingFrequency == r16KHz){
      append=FILTERLENGTH-1;
      if(ippsMelFBankInitAllocHigh_Aurora_16s(&pCodec[0]->noise.s16.pFBank16)!=ippStsNoErr){
         ReleaseAuroraEncoder(pCodec[0]);
         return -1;
      }
   }

   ippsZero_16s((Ipp16s*)pCodec[0]->noise.pPSDprev_1,FFTSPEC<<1);
   ippsZero_16s((Ipp16s*)pCodec[0]->noise.pPSDprev_2,FFTSPEC<<1);
   ippsZero_16s(pCodec[0]->noise.pDenPrev_1,FFTSPEC);
   ippsZero_16s(pCodec[0]->noise.pDenPrev_2,FFTSPEC);
   ippsSet_16s(0,pCodec[0]->noise.pNoiseTnPrev_1,FFTSPEC);
   ippsSet_16s(0,(Ipp16s*)pCodec[0]->noise.pNoisePrev_2,FFTSPEC<<1);
   ippsSet_16s(0,pCodec[0]->noise.pNoiseTn,FFTSPEC);
   ippsZero_16s(pCodec[0]->noise.pBStateBuf, 960);


   pCodec[0]->noise.Eden=pCodec[0]->noise.Eden1=pCodec[0]->noise.Eden2=0;
   pCodec[0]->noise.SNRlowPrev32s=0;
   pCodec[0]->noise.agfPrev32s=819;
   pCodec[0]->noise.pSrc0 = pCodec[0]->noise.Dst0=0;
   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_16s(pCodec[0]->bias,NUM_CEP_COEFF-1);
   if (EncoderInput==WAVEFORM){
      pCodec[0]->HammingWindow = ippsMalloc_16s(WINHANNSIZE);
      if(pCodec[0]->HammingWindow==NULL){
         ReleaseAuroraEncoder(pCodec[0]);
         return -1;
      }

      ippsCopy_16s(pHammingWindow,pCodec[0]->HammingWindow,WINHANNSIZE);
/*      ippsZero_16s(pCodec[0]->HammingWindow,WINHANNSIZE);
      for (i = 0; i < WINHANNSIZE; i++)
           pCodec[0]->HammingWindow[i] = (Ipp16s)((0.54f - 0.46f * cos (IPP_2PI * ((float)i+0.5f) / WINHANNSIZE))*16384);*/

   }
   pCodec[0]->pFrame->pos=6;
   pCodec[0]->curPosition = 0;
   pCodec[0]->EncoderOutput = EncoderOutput;

   if (EncoderInput==WAVEFORM){
      if(ippsMelFBankGetSize_32s(WAVEFORMSIZE, NUM_CHANNELS,IPP_FBANK_FREQWGT, &size)!=ippStsNoErr){
         ReleaseAuroraEncoder(pCodec[0]);
         return -1;
      }

      pCodec[0]->pFBank = ippsMalloc_8u(size);
      if(pCodec[0]->pFBank==NULL){
         ReleaseAuroraEncoder(pCodec[0]);
         return -1;
      }

      if(ippsMelFBankInit_32s( (IppsFBankState_32s*) pCodec[0]->pFBank, &pCodec[0]->FFTOrder,
         WAVEFORMSIZE, (int)Frequency, (int)startingFeq, (int)Frequency/2, NUM_CHANNELS, 36929536, 22937600,IPP_FBANK_FREQWGT)!=ippStsNoErr){
         ReleaseAuroraEncoder(pCodec[0]);
         return -1;
      }

      if(ippsFFTInitAlloc_R_32s(&(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_16s(pCodec[0]->FFTLength);
      if(pCodec[0]->workBuffer==NULL){
         ReleaseAuroraEncoder(pCodec[0]);
         return -1;
      }

      pCodec[0]->pBuffer32s = ippsMalloc_32s(pCodec[0]->FFTLength);
      if(pCodec[0]->pBuffer32s==NULL){
         ReleaseAuroraEncoder(pCodec[0]);
         return -1;
      }


      if (SamplingFrequency == r16KHz)
         status = ippsDCTLifterInitAlloc_MulC0_16s(&pCodec[0]->pDCTLifter,NUM_CHANNELS+KFB16,pLiftCoeff,NUM_CEP_COEFF-1);
      else
         status = ippsDCTLifterInitAlloc_MulC0_16s(&pCodec[0]->pDCTLifter,NUM_CHANNELS,pLiftCoeff,NUM_CEP_COEFF-1);
      if(status!=ippStsNoErr){
         ReleaseAuroraEncoder(pCodec[0]);
         return -1;
      }
   }

   if (EncoderOutput == QUANTIZED || EncoderOutput == MULTIFRAME){
      ippsZero_8u(pCodec[0]->pIndexVQBuffer,2*NUM_CODEBOOK);