encoder.c

Intel开发的IPP库的应用实例

            pCodec->workBuffer[i] = (float)logEValue;
      }
      ippsLn_32f_I(pCodec->workBuffer,pCodec->numChannels);

      /* Discrete Cosine Transform */

      ippsDCTLifter_32f(pCodec->workBuffer, pCodec->pFeatBuffer,pCodec->pDCTLifter);


      /* Append logE after c0 or overwrite c0 */
      pCodec->pFeatBuffer[pCodec->numCepCoeff] = LogEnergy;
      /* Copy in output buffer */
      ippsCopy_32f(pCodec->pFeatBuffer,pFwork,(NUM_CEP_COEFF+1));
      pFwork += (NUM_CEP_COEFF+1);
      pCodec->NumberFrame++;
   }/*  end for  */
   if (StreamEnd){
      ResetAuroraEncoder(pCodec);
      return FrameCounter;
   }
   if (tailSample>0){
      ippsConvert_16s32f(WaveBuffer,pCodec->pWwork+pCodec->curPosition,tailSample);
      ippsCompensateOffset_32f_I(pCodec->pWwork+pCodec->curPosition,
                  tailSample,&(pCodec->pSrc0),pCodec->Dst0,0.999f);
      pCodec->pSrc0 = (float)WaveBuffer[tailSample-1];
      pCodec->Dst0 = pCodec->pWwork[pCodec->curPosition+tailSample-1];
      pCodec->curPosition += tailSample;
     }
   return FrameCounter;
}



/*    WAVEFORM   ->   MULTIFRAME   */
int ApplyAuroraEncoder_WM(AuroraEncoder *pCodec, short *pSrc, int InputLength, unsigned char *pDst,int StreamEnd){

   int i,iCount,k,j;
   short *WaveBuffer;
   int FrameCounter,MultyFrameCounter;
   int tailSample;
   int step;
   float LogEnergy;
   int idx,crc;
   int nullMFrame=0;
   unsigned char *pMFwork;

   MultyFrameCounter=0;
   if (pCodec->EncoderOutput == MULTIFRAME){
      pMFwork =(unsigned char *) pDst/*+FeatureSize*pCodec->NumberFrame*/;
   }
   else {
      printf("\n!!! ERROR: encoder was initialized with another output flag !!!");
      return 0;
   }

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


   FrameCounter = InputLength;

   if (pCodec->EncoderInput==WAVEFORM){
      WaveBuffer = pSrc;
      if (pCodec->curPosition+InputLength >= pCodec->FrameLength){
            FrameCounter = (pCodec->curPosition+InputLength-(pCodec->FrameLength-pCodec->FrameShift)) / pCodec->FrameShift;
            tailSample = (pCodec->curPosition+InputLength-(pCodec->FrameLength-pCodec->FrameShift)) % pCodec->FrameShift;
            step = pCodec->FrameLength - pCodec->curPosition;
      }
      else{
            FrameCounter = 0;
            tailSample = InputLength;
      }
   }
   else {
      printf("\n!!! ERROR: encoder was initialized with another input flag !!!");
      return 0;
   }

   /*   calculate feature   */
   for (iCount=0;iCount<FrameCounter;iCount++){
      /* Offset Compensation*/
      ippsConvert_16s32f(WaveBuffer,pCodec->pWwork+pCodec->curPosition,step);
      ippsCompensateOffset_32f_I(pCodec->pWwork+pCodec->curPosition,
                  step,&(pCodec->pSrc0),pCodec->Dst0,0.999f);

      pCodec->pSrc0 = (float)WaveBuffer[step-1];
      pCodec->Dst0 = pCodec->pWwork[pCodec->FrameLength-1];

      WaveBuffer+=step;

      pCodec->curPosition = pCodec->FrameLength - pCodec->FrameShift;
      step = pCodec->FrameShift;

      /* logE computation */
      LogEnergy = 0.0;

      ippsDotProd_32f(pCodec->pWwork,pCodec->pWwork,pCodec->FrameLength,&LogEnergy);

      if (LogEnergy < logEValue)
         LogEnergy = -50.0f;
      else
         ippsLn_32f_I(&LogEnergy,1);

      /* Pre-emphasis */
      ippsCopyWithPadding_32f(pCodec->pWwork, pCodec->FrameLength, pCodec->workBuffer,pCodec->FFTLength);

      ippsPreemphasize_32f(pCodec->workBuffer, pCodec->FrameLength, EMPHASIS_COEFF);

      pCodec->workBuffer[0] = pCodec->pWwork[0] - EMPHASIS_COEFF * pCodec->preFloat;

      /* Replace WorkBuffer*/
      pCodec->preFloat = pCodec->pWwork[pCodec->FrameShift-1];
      ippsMove_32f(pCodec->pWwork+pCodec->FrameShift, pCodec->pWwork,
      pCodec->FrameLength-pCodec->FrameShift);

      /* Windowing */
      ippsMul_32f_I(pCodec->HammingWindow,pCodec->workBuffer,pCodec->FrameLength);
      /* Mel filtering with FFT and Magnitude spectrum*/

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

      /* Natural logarithm computation */
      for (i = 0; i < pCodec->numChannels; i++){
         if (pCodec->workBuffer[i] < logEValue)
            pCodec->workBuffer[i] = (float)logEValue;
      }
      ippsLn_32f_I(pCodec->workBuffer,pCodec->numChannels);

      /* Discrete Cosine Transform */
      ippsDCTLifter_32f(pCodec->workBuffer, pCodec->pFeatBuffer,pCodec->pDCTLifter);


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

      /*  Quantise  */

      pCodec->pFeatBuffer[pCodec->numCepCoeff]*=(float)pCodec->weight_logE;
      pCodec->pFeatBuffer[pCodec->numCepCoeff-1]*=(float)pCodec->weight_c0;

      for(k=0;k<NUM_CODEBOOK;k++){
         ippsVQ_32f(pCodec->pFeatBuffer+k*2, 2,&j,1,(const IppsCdbkState_32f *)pCodec->ppCdbkState[k]);
         pCodec->pIndexVQBuffer[k]=j;
      }

      idx = (pCodec->iCountFrame/4)*23+6;

      if(pCodec->iCountFrame%4==0){
         pCodec->pFrame->pFrameBuffer[idx]   = (0x3f & pCodec->pIndexVQBuffer[0]);
         pCodec->pFrame->pFrameBuffer[idx]  |= (0xc0 & (pCodec->pIndexVQBuffer[1] << 6));
         pCodec->pFrame->pFrameBuffer[idx+1] = (0x0f & (pCodec->pIndexVQBuffer[1] >> 2));
         pCodec->pFrame->pFrameBuffer[idx+1]|= (0xf0 & (pCodec->pIndexVQBuffer[2] << 4));
         pCodec->pFrame->pFrameBuffer[idx+2] = (0x03 & (pCodec->pIndexVQBuffer[2] >> 4));
         pCodec->pFrame->pFrameBuffer[idx+2]|= (0xfc & (pCodec->pIndexVQBuffer[3] << 2));
         pCodec->pFrame->pFrameBuffer[idx+3] = (0x3f &  pCodec->pIndexVQBuffer[4]);
         pCodec->pFrame->pFrameBuffer[idx+3]|= (0xc0 & (pCodec->pIndexVQBuffer[5] << 6));
         pCodec->pFrame->pFrameBuffer[idx+4] = (0x0f & (pCodec->pIndexVQBuffer[5] >> 2));
         pCodec->pFrame->pFrameBuffer[idx+4]|= (0xf0 & (pCodec->pIndexVQBuffer[6] << 4));
         pCodec->pFrame->pFrameBuffer[idx+5] = (0x0f & (pCodec->pIndexVQBuffer[6] >> 4));
         pCodec->pFrame->pos += 5;
         crc = encodeCRC(&pCodec->pFrame->pFrameBuffer[idx]);
         pCodec->pFrame->pFrameBuffer[idx+11] = (0x0f & crc);
      }

      if(pCodec->iCountFrame%4==1){
         pCodec->pFrame->pFrameBuffer[idx+5]|= (0xf0 & (pCodec->pIndexVQBuffer[0] << 4));
         pCodec->pFrame->pFrameBuffer[idx+6] = (0x03 & (pCodec->pIndexVQBuffer[0] >> 4));
         pCodec->pFrame->pFrameBuffer[idx+6]|= (0xfc & (pCodec->pIndexVQBuffer[1] << 2));
         pCodec->pFrame->pFrameBuffer[idx+7] = (0x3f &  pCodec->pIndexVQBuffer[2]);
         pCodec->pFrame->pFrameBuffer[idx+7]|= (0xc0 & (pCodec->pIndexVQBuffer[3] << 6));
         pCodec->pFrame->pFrameBuffer[idx+8] = (0x0f & (pCodec->pIndexVQBuffer[3] >> 2));
         pCodec->pFrame->pFrameBuffer[idx+8]|= (0xf0 & (pCodec->pIndexVQBuffer[4] << 4));
         pCodec->pFrame->pFrameBuffer[idx+9] = (0x03 & (pCodec->pIndexVQBuffer[4] >> 4));
         pCodec->pFrame->pFrameBuffer[idx+9]|= (0xfc & (pCodec->pIndexVQBuffer[5] << 2));
         pCodec->pFrame->pFrameBuffer[idx+10]= (0xff &  pCodec->pIndexVQBuffer[6]);
         pCodec->pFrame->pos +=6;
         crc = encodeCRC(&pCodec->pFrame->pFrameBuffer[idx]);
         pCodec->pFrame->pFrameBuffer[idx+11] = (0x0f & crc);
      }
      if (pCodec->iCountFrame%4==2){
         pCodec->pFrame->pFrameBuffer[idx+11]|= (0xf0 & (pCodec->pIndexVQBuffer[0] << 4));
         pCodec->pFrame->pFrameBuffer[idx+12] = (0x03 & (pCodec->pIndexVQBuffer[0] >> 4));
         pCodec->pFrame->pFrameBuffer[idx+12]|= (0xfc & (pCodec->pIndexVQBuffer[1] << 2));
         pCodec->pFrame->pFrameBuffer[idx+13] = (0x3f &  pCodec->pIndexVQBuffer[2]);
         pCodec->pFrame->pFrameBuffer[idx+13]|= (0xc0 & (pCodec->pIndexVQBuffer[3] << 6));
         pCodec->pFrame->pFrameBuffer[idx+14] = (0x0f & (pCodec->pIndexVQBuffer[3] >> 2));
         pCodec->pFrame->pFrameBuffer[idx+14]|= (0xf0 & (pCodec->pIndexVQBuffer[4] << 4));
         pCodec->pFrame->pFrameBuffer[idx+15] = (0x03 & (pCodec->pIndexVQBuffer[4] >> 4));
         pCodec->pFrame->pFrameBuffer[idx+15]|= (0xfc & (pCodec->pIndexVQBuffer[5] << 2));
         pCodec->pFrame->pFrameBuffer[idx+16] = (0xff &  pCodec->pIndexVQBuffer[6]);

         pCodec->pFrame->pCRCBuffer[0] = (0x3f &  pCodec->pIndexVQBuffer[0]);
         pCodec->pFrame->pCRCBuffer[0]|= (0xc0 & (pCodec->pIndexVQBuffer[1] << 6));
         pCodec->pFrame->pCRCBuffer[1] = (0x0f & (pCodec->pIndexVQBuffer[1] >> 2));
         pCodec->pFrame->pCRCBuffer[1]|= (0xf0 & (pCodec->pIndexVQBuffer[2] << 4));
         pCodec->pFrame->pCRCBuffer[2] = (0x03 & (pCodec->pIndexVQBuffer[2] >> 4));
         pCodec->pFrame->pCRCBuffer[2]|= (0xfc & (pCodec->pIndexVQBuffer[3] << 2));
         pCodec->pFrame->pCRCBuffer[3] = (0x3f &  pCodec->pIndexVQBuffer[4]);
         pCodec->pFrame->pCRCBuffer[3]|= (0xc0 & (pCodec->pIndexVQBuffer[5] << 6));
         pCodec->pFrame->pCRCBuffer[4] = (0x0f & (pCodec->pIndexVQBuffer[5] >> 2));
         pCodec->pFrame->pCRCBuffer[4]|= (0xf0 & (pCodec->pIndexVQBuffer[6] << 4));
         pCodec->pFrame->pCRCBuffer[5] = (0x0f & (pCodec->pIndexVQBuffer[6] >> 4));
         pCodec->pFrame->pCRCBuffer[6] =0;
         pCodec->pFrame->pCRCBuffer[7] =0;
         pCodec->pFrame->pCRCBuffer[8] =0;
         pCodec->pFrame->pCRCBuffer[9] =0;
         pCodec->pFrame->pCRCBuffer[10] =0;
         pCodec->pFrame->pos +=6;
         crc = encodeCRC(pCodec->pFrame->pCRCBuffer);
         pCodec->pFrame->pFrameBuffer[idx+22] |= (0xf0 & (crc << 4));
      }

      if (pCodec->iCountFrame%4==3){
         pCodec->pFrame->pFrameBuffer[idx+17] = (0x3f &  pCodec->pIndexVQBuffer[0]);
         pCodec->pFrame->pFrameBuffer[idx+17]|= (0xc0 & (pCodec->pIndexVQBuffer[1] << 6));
         pCodec->pFrame->pFrameBuffer[idx+18] = (0x0f & (pCodec->pIndexVQBuffer[1] >> 2));
         pCodec->pFrame->pFrameBuffer[idx+18]|= (0xf0 & (pCodec->pIndexVQBuffer[2] << 4));
         pCodec->pFrame->pFrameBuffer[idx+19] = (0x03 & (pCodec->pIndexVQBuffer[2] >> 4));
         pCodec->pFrame->pFrameBuffer[idx+19]|= (0xfc & (pCodec->pIndexVQBuffer[3] << 2));
         pCodec->pFrame->pFrameBuffer[idx+20] = (0x3f &  pCodec->pIndexVQBuffer[4]);
         pCodec->pFrame->pFrameBuffer[idx+20]|= (0xc0 & (pCodec->pIndexVQBuffer[5] << 6));
         pCodec->pFrame->pFrameBuffer[idx+21] = (0x0f & (pCodec->pIndexVQBuffer[5] >> 2));
         pCodec->pFrame->pFrameBuffer[idx+21]|= (0xf0 & (pCodec->pIndexVQBuffer[6] << 4));
         pCodec->pFrame->pFrameBuffer[idx+22] = (0x0f & (pCodec->pIndexVQBuffer[6] >> 4));

         pCodec->pFrame->pCRCBuffer[5]|= (0xf0 & (pCodec->pIndexVQBuffer[0] << 4));
         pCodec->pFrame->pCRCBuffer[6] = (0x03 & (pCodec->pIndexVQBuffer[0] >> 4));
         pCodec->pFrame->pCRCBuffer[6]|= (0xfc & (pCodec->pIndexVQBuffer[1] << 2));
         pCodec->pFrame->pCRCBuffer[7] = (0x3f &  pCodec->pIndexVQBuffer[2]);
         pCodec->pFrame->pCRCBuffer[7]|= (0xc0 & (pCodec->pIndexVQBuffer[3] << 6));
         pCodec->pFrame->pCRCBuffer[8] = (0x0f & (pCodec->pIndexVQBuffer[3] >> 2));
         pCodec->pFrame->pCRCBuffer[8]|= (0xf0 & (pCodec->pIndexVQBuffer[4] << 4));
         pCodec->pFrame->pCRCBuffer[9] = (0x03 & (pCodec->pIndexVQBuffer[4] >> 4));
         pCodec->pFrame->pCRCBuffer[9]|= (0xfc & (pCodec->pIndexVQBuffer[5] << 2));
         pCodec->pFrame->pCRCBuffer[10]= (0xff &  pCodec->pIndexVQBuffer[6]);

         crc = encodeCRC(pCodec->pFrame->pCRCBuffer);

         pCodec->pFrame->pFrameBuffer[idx+22] |= (0xf0 & (crc << 4));
         pCodec->pFrame->pos +=6;
      }

      pCodec->iCountFrame++;
      if (pCodec->iCountFrame==24){
          madeHeader(pCodec->pFrame,pCodec->mframeCounter);
          MultyFrameCounter++;
          ippsCopy_8u(pCodec->pFrame->pFrameBuffer,pMFwork,NUM_MULTY_BYTE);
          pMFwork += NUM_MULTY_BYTE;
          pCodec->mframeCounter++;
          pCodec->mframeCounter = pCodec->mframeCounter % 16;
          pCodec->iCountFrame=0;
          pCodec->pFrame->pos=6;
          ippsZero_8u(pCodec->pFrame->pFrameBuffer,NUM_MULTY_BYTE);
          pCodec->NumberFrame++;
      }
   }/*  end for  */
   if (StreamEnd){
      if ((pCodec->iCountFrame-1)%2==0)pCodec->iCountFrame+=2;
      if( (pCodec->iCountFrame -1) >= 20) nullMFrame = 1;
      MultyFrameCounter++;
      madeHeader(pCodec->pFrame,pCodec->mframeCounter);
      ippsCopy_8u(pCodec->pFrame->pFrameBuffer,pMFwork,NUM_MULTY_BYTE);
      pCodec->mframeCounter++;
      pMFwork += NUM_MULTY_BYTE;
      pCodec->NumberFrame++;
      if(nullMFrame == 1){
         MultyFrameCounter++;
         madeHeader(pCodec->pFrame,pCodec->mframeCounter);
         ippsZero_8u(pCodec->pFrame->pFrameBuffer+6,NUM_MULTY_BYTE-6);
         ippsCopy_8u(pCodec->pFrame->pFrameBuffer,pMFwork,NUM_MULTY_BYTE);
      }
      ResetAuroraEncoder(pCodec);
      return MultyFrameCounter;
   }
   if (tailSample>0){
      ippsConvert_16s32f(WaveBuffer,pCodec->pWwork+pCodec->curPosition,tailSample);
      ippsCompensateOffset_32f_I(pCodec->pWwork+pCodec->curPosition,
                  tailSample,&(pCodec->pSrc0),pCodec->Dst0,0.999f);
      pCodec->pSrc0 = (float)WaveBuffer[tailSample-1];
      pCodec->Dst0 = pCodec->pWwork[pCodec->curPosition+tailSample-1];
      pCodec->curPosition += tailSample;
   }
   return MultyFrameCounter;
}

/*    WAVEFORM   ->   QUANTIZED   */
int ApplyAuroraEncoder_WQ(AuroraEncoder *pCodec, short *pSrc, int InputLength, unsigned char *pDst,int StreamEnd){

   int i,iCount, k, j;
   short *WaveBuffer;
   int FrameCounter;
   int tailSample;
   int step;
   float LogEnergy;

   unsigned char *pIndexVQ;

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

   if (pCodec->EncoderOutput == QUANTIZED){
      pIndexVQ = (unsigned char*)pDst/*+FeatureSize*pCodec->NumberFrame*/;
   }
   else {
      printf("\n!!! ERROR: encoder was initialized with another output flag !!!");
      return 0;
   }

   FrameCounter = InputLength;

   if (pCodec->EncoderInput==WAVEFORM){
      WaveBuffer = pSrc;
      if (pCodec->curPosition+InputLength >= pCodec->FrameLength){
            FrameCounter = (pCodec->curPosition+InputLength-(pCodec->FrameLength-pCodec->FrameShift)) / pCodec->FrameShift;
            tailSample = (pCodec->curPosition+InputLength-(pCodec->FrameLength-pCodec->FrameShift)) % pCodec->FrameShift;
            step = pCodec->FrameLength - pCodec->curPosition;
      }
      else{
            FrameCounter = 0;
            tailSample = InputLength;