encoder.c

Intel开发的IPP库的应用实例

            pOutputBuffer[Count*(NUM_CODEBOOK+1)+NUM_CODEBOOK] = 0;

         ippsMove_32f(pCodec->pFeatCyclicBuf+(pCodec->numCepCoeff+1),pCodec->pFeatCyclicBuf,(pCodec->numCepCoeff+1)*6);
         Count++;
      }
      ResetAuroraEncoder(pCodec);
   }
   if(pCodec->freq == r11KHz){
      ippsFree(pTmp);
   }
   return Count;
}

int CreateMultyFrame(AuroraEncoder *pCodec){
   int crc,MultyFrameCounter=0;
   int idx = (pCodec->iCountFrame/4)*23+6;

   if (pCodec->iCountFrame==0){
      pCodec->pFrame->pos=6;
      ippsZero_8u(pCodec->pFrame->pFrameBuffer,NUM_MULTI_BYTE);
   }

   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++;
      pCodec->mframeCounter++;
      pCodec->mframeCounter = pCodec->mframeCounter % 16;
      pCodec->NumberFrame++;
      pCodec->iCountFrame=0;
   }
   return MultyFrameCounter;
}



/*    WAVEFORM   ->   MULTIFRAME   */
int ApplyAuroraEncoder_WM(AuroraEncoder *pCodec, short *pInputSignal, int InputLength, unsigned char *pOutputBuffer,int StreamEnd){
   int FrameCounter=0, Count=0,nullMFrame=0,l;
   int tcur = 0, tc, i,j;
   float pNoiseDst[FRAMESHIFT*4];
   char flagVAD;

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

   if ( (pCodec->EncoderOutput != MULTIFRAME) && (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;

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

   if(FrameCounter){
      /* Start process wavebuffer */
      Count = 0;
      tc=1+pCodec->noise.Cur_TPrpocess; FrameCounter += pCodec->noise.Cur_TPrpocess;
      for( ; tc < FrameCounter; tc++,pCodec->noise.Cur_TPrpocess++,pCodec->NumberFrame++){
         if(pCodec->freq == r16KHz){
            ippsLowHighFilter_Aurora_32f(pCodec->noise.pBStateBig+480,
               pBState_1+FRAMESHIFT*3, pCodec->noise.s16.dataHP+480, 160, FIRCoef, FILTERLENGTH);
            ippsMove_32f(pCodec->noise.pBStateBig+160,pCodec->noise.pBStateBig,FILTERLENGTH+480);
         }
         else{
            ippsCopy_32f(pCodec->noise.pBStateBig+append+pCodec->noise.start,
               pBState_1+pCodec->noise.start,pCodec->noise.end);
         }

         /* VAD for noise estimation (VADNest) */
         flagVAD = VADNest(&pCodec->noise.vad,tc,pBState_1+FRAMESHIFT);

         /* perfom noise reduction */
         DoNoiseReduction(pCodec,pCodec->noise.pBStateBuf,tc,pFFTOut,pNoiseDst,&tcur,pMelBank,pDen,flagVAD);

         ippsVADDecision_Aurora_32f(pMelBank,pDen,pCodec->noise.vad.nbSpeechFrame,vad,pCodec->pVadMem);

         if(tcur){
            CeptstrumCalculate(pCodec,pNoiseDst,tc);
            ippsCopy_32f(pCodec->pFeatBuffer,pCodec->pFeatCyclicBuf+(pCodec->numCepCoeff+1)*6,pCodec->numCepCoeff+1);
            if( vad[0]!=IPP_PREPARE ){
               pCodec->pFeatCyclicBuf[pCodec->numCepCoeff]*=(float)pCodec->weight_logE;
               pCodec->pFeatCyclicBuf[pCodec->numCepCoeff-1]*=(float)pCodec->weight_c0;

               for(i=0;i<NUM_CODEBOOK;i++){
                  ippsVQ_32f(pCodec->pFeatCyclicBuf+i*2, 2,&j,1,(const IppsCdbkState_32f *)pCodec->ppCdbkState[i]);
                  pCodec->pIndexVQBuffer[i]=j;
               }
               if(vad[0]==IPP_VOICE)
                  pCodec->pIndexVQBuffer[5] = (pCodec->pIndexVQBuffer[5]<<1) | 1;
               else if(vad[0]==IPP_UNVOICE)
                  pCodec->pIndexVQBuffer[5] = (pCodec->pIndexVQBuffer[5]<<1) | 0;
               if(CreateMultyFrame(pCodec)==1){
                  ippsCopy_8u(pCodec->pFrame->pFrameBuffer,pOutputBuffer+Count*NUM_MULTI_BYTE,NUM_MULTI_BYTE);
                  Count++;
               }
            }
            ippsMove_32f(pCodec->pFeatCyclicBuf+(pCodec->numCepCoeff+1),pCodec->pFeatCyclicBuf,(pCodec->numCepCoeff+1)*6);
         }
         /* Shift  buffers */
         ippsMove_32f(pCodec->noise.pBStateBuf+FRAMESHIFT,pCodec->noise.pBStateBuf,11*FRAMESHIFT);

         /* Forming first buffer */
         if(pCodec->noise.tail >= pCodec->FrameShift){
            CopyBuffers(pCodec,pTmp+InputLength-pCodec->noise.tail,3*pCodec->FrameShift,pCodec->FrameShift);
            pCodec->noise.tail -= pCodec->FrameShift;
         }

         if(pCodec->freq == r16KHz){
            ippsMove_32f(pCodec->noise.s16.dataHP+80,pCodec->noise.s16.dataHP,480);
            ippsMove_32f(pCodec->noise.pFFT+FFTSIZE,pCodec->noise.pFFT,FFTSIZE*4);
         }
      }
      if(pCodec->noise.tail>0 && pCodec->noise.tail<pCodec->FrameShift){
         CopyBuffers(pCodec,pTmp+InputLength-pCodec->noise.tail,3*pCodec->FrameShift,pCodec->noise.tail);
      }
   }
   if (StreamEnd){
      while(1){
         ippsVADFlush_Aurora_32f(vad,pCodec->pVadMem);
         if(vad[0]==IPP_PREPARE)break;

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

         for(i=0;i<NUM_CODEBOOK;i++){
            ippsVQ_32f(pCodec->pFeatCyclicBuf+i*2, 2,&j,1,(const IppsCdbkState_32f *)pCodec->ppCdbkState[i]);
            pCodec->pIndexVQBuffer[i]=j;
         }
         if(vad[0]==IPP_VOICE)
            pCodec->pIndexVQBuffer[5] = (pCodec->pIndexVQBuffer[5]<<1) | 1;
         else if(vad[0]==IPP_UNVOICE)
            pCodec->pIndexVQBuffer[5] = (pCodec->pIndexVQBuffer[5]<<1) | 0;

         if(CreateMultyFrame(pCodec)==1){
            ippsCopy_8u(pCodec->pFrame->pFrameBuffer,pOutputBuffer+Count*NUM_MULTI_BYTE,NUM_MULTI_BYTE);
            Count++;
         }
         ippsMove_32f(pCodec->pFeatCyclicBuf+(pCodec->numCepCoeff+1),pCodec->pFeatCyclicBuf,(pCodec->numCepCoeff+1)*6);
      }

      if ((pCodec->iCountFrame-1)%2==0)pCodec->iCountFrame+=2;
      if( (pCodec->iCountFrame -1) >= 20) nullMFrame = 1;
      madeHeader(pCodec->pFrame,pCodec->mframeCounter);
      ippsCopy_8u(pCodec->pFrame->pFrameBuffer,pOutputBuffer+Count*NUM_MULTI_BYTE,NUM_MULTI_BYTE);
      pCodec->mframeCounter++;
      pCodec->NumberFrame++;
      Count++;
      if(nullMFrame == 1){
         madeHeader(pCodec->pFrame,pCodec->mframeCounter);
         ippsZero_8u(pCodec->pFrame->pFrameBuffer+6,NUM_MULTI_BYTE-6);
         ippsCopy_8u(pCodec->pFrame->pFrameBuffer,pOutputBuffer+Count*NUM_MULTI_BYTE,NUM_MULTI_BYTE);
         Count++;
      }

      ResetAuroraEncoder(pCodec);
   }
   if(pCodec->freq == r11KHz){
      ippsFree(pTmp);
   }
   return Count;
}

/*    WAVEFORM   ->   WAVEFORM   */
int  ApplyAuroraEncoder_WW(AuroraEncoder *pCodec, short *pInputSignal, int InputLength,
                           short *pOutputBuffer,int StreamEnd){
   int FrameCounter=0;
   int tcur = 0, tc;
   float pDst[FRAMESHIFT*4];
   short *pTmp;
   short *pInTmp;
   float pFFT[FFTSIZE];
   char flagVAD;
   float *pBState_2 = pCodec->noise.pBStateBuf+320;
   float *pBState_1 = pBState_2+320;
   float pDen[FFTSPEC];
   float pMelBank[NUM_CHANNELS+2];
   IppStatus status;
   int vad;
   if ( (pCodec->EncoderOutput != WAVEFORM) && (pCodec->EncoderInput != WAVEFORM)){
      printf("\n!!! ERROR: encoder was initialized with another output flag !!!");
      return 0;
   }

   if (InputLength<=0){
      FrameCo