decoder.c

Intel开发的IPP库的应用实例

/*
//
//                  INTEL CORPORATION PROPRIETARY INFORMATION
//     This software is supplied under the terms of a license agreement or
//     nondisclosure agreement with Intel Corporation and may not be copied
//     or disclosed except in accordance with the terms of that agreement.
//          Copyright(c) 2003-2006 Intel Corporation. All Rights Reserved.
//
//     Intel(R) Integrated Performance Primitives Aurora Sample for Windows*
//
//  By downloading and installing this sample, you hereby agree that the
//  accompanying Materials are being provided to you under the terms and
//  conditions of the End User License Agreement for the Intel(R) Integrated
//  Performance Primitives product previously accepted by you. Please refer
//  to the file ippEULA.rtf located in the root directory of your Intel(R) IPP
//  product installation for more information.
//
//  ES 201 108 v1.1.3 is the international standard promoted by ETSI
//   and other organizations. Implementations of these standards, or the standard
//   enabled platforms may require licenses from various entities, including
//  Intel Corporation.
//
*/

#include <malloc.h>
#include <stdio.h>
#include <math.h>

#include "decoderapi.h"
#include "tab_8kHz.inc "
#include "tab_16kHz.inc "
#include "mframe.h"

#define NUM_CHANNELS             23

typedef struct DecoderStruct{
    IppsCdbkState_16s  **ppCdbkState;
    int FeatureStride;
    int numCepCoeff;
    int curPosition;
    AuroraDataType DecoderInput;
    AuroraRate freq;
    double weight_c0;
    double weight_logE;
    unsigned char pIndexVQBuffer[2*NUM_CODEBOOK];
    int iCountFrame;
    int NumberFrame;
    int mframeCounter;
    MFrame *pFrame;
    short crc;
    int BufferData;
    int Curr;
    int Prev;
    int Last;
    int Start;
    int BufferSize;
    int done;

};


void ResetAuroraDecoder(AuroraDecoder *pCodec){
   pCodec->curPosition = 0;
   pCodec->iCountFrame=0;
   pCodec->BufferData=1;
   pCodec->Start=1;
   pCodec->Curr=0;
   pCodec->Prev=0;
   pCodec->Last=0;
   pCodec->BufferSize=0;
   pCodec->done = 0;

}

int InitAuroraDecoder(AuroraDecoder **pCodec, AuroraRate SamplingFrequency,AuroraDataType DecoderInput){
   IppStatus status;
   float startingFeq=0;
   int i;
   short *qCoeffLog, *qCoeff;
   pCodec[0] = malloc(sizeof(AuroraDecoder));
   if (pCodec[0]==NULL) return -1;

   status = ippStsNoErr;
   pCodec[0]->DecoderInput = DecoderInput;
   pCodec[0]->iCountFrame=0;
   pCodec[0]->BufferData=1;
   pCodec[0]->Curr=0;
   pCodec[0]->Prev=0;
   pCodec[0]->Last=0;
   pCodec[0]->Start=1;
   pCodec[0]->BufferSize=0;
   pCodec[0]->done = 0;

   pCodec[0]->pFrame = (MFrame*)ippsMalloc_8u(sizeof(MFrame));
   if ( !((SamplingFrequency == r8KHz) || (SamplingFrequency == r11KHz) || (SamplingFrequency == r16KHz))){
      free(pCodec[0]);
      return -1;
   }
   if (SamplingFrequency == r8KHz){
      pCodec[0]->freq = r8KHz;
      pCodec[0]->weight_c0 = w8kHz_C0;
      pCodec[0]->weight_logE = w8kHz_LE;
      qCoeff = (short*)qCoeff8kHz;
      qCoeffLog = (short*)qCoeff8kHz_Log;

   }
   else if (SamplingFrequency == r11KHz){
      pCodec[0]->freq = r11KHz;
      pCodec[0]->weight_c0 = w8kHz_C0;
      pCodec[0]->weight_logE = w8kHz_LE;
      qCoeff = (short*)qCoeff8kHz;
      qCoeffLog = (short*)qCoeff8kHz_Log;

   }
   else if (SamplingFrequency == r16KHz){
      pCodec[0]->freq = r16KHz;
      pCodec[0]->weight_c0 = w16kHz_C0;
      pCodec[0]->weight_logE = w16kHz_LE;
      qCoeff = (short*)qCoeff16kHz;
      qCoeffLog = (short*)qCoeff16kHz_Log;

   }

   pCodec[0]->numCepCoeff = NUM_CEP_COEFF;

   pCodec[0]->FeatureStride = ((NUM_CEP_COEFF+1)+3)&(~3);

   pCodec[0]->curPosition = 0;

   pCodec[0]->ppCdbkState = (IppsCdbkState_16s  **)ippsMalloc_8u (sizeof(IppsCdbkState_16s  *)*NUM_CODEBOOK);
   if (pCodec[0]->ppCdbkState==NULL){
      printf("Memory not allocated");
      return -1;
   }
   for (i=0; i < 6; i++)
      ippsCdbkInitAlloc_L2_16s(&(pCodec[0]->ppCdbkState[i]),(const short*)(qCoeff+i*128),2,2,64,64,IPP_CDBK_FULL);
   for (i=0; i<256;i++){
      qCoeffLog[i*2+0] = (short)(pCodec[0]->weight_c0 * qCoeffLog[i*2+0]);
      qCoeffLog[i*2+1] = (short)(pCodec[0]->weight_logE * qCoeffLog[i*2+1]);
   }
   ippsCdbkInitAlloc_L2_16s(&(pCodec[0]->ppCdbkState[6]),(const short*)qCoeffLog,2,2,256,256,IPP_CDBK_FULL);
   return 0;
}

void ReleaseAuroraDecoder(AuroraDecoder *pCodec){
   int i;

   if (pCodec){
        if(pCodec->pFrame)ippsFree(pCodec->pFrame);
        if(pCodec->ppCdbkState){
           for (i=0; i<NUM_CODEBOOK; i++){
             if (pCodec->ppCdbkState[i])ippsCdbkFree_16s(pCodec->ppCdbkState[i]);
           }
           ippsFree(pCodec->ppCdbkState);
        }
        free(pCodec);
   }
}

void FormVector(AuroraDecoder* pCodec,unsigned char *pIndexVQBuffer,short *pFwork){
   ippsFormVectorVQ_8u16s(pIndexVQBuffer,NUM_CODEBOOK,pFwork,pCodec->numCepCoeff+1,1,
                        (const IppsCdbkState_16s **)pCodec->ppCdbkState,NUM_CODEBOOK);
   pFwork[pCodec->numCepCoeff] = (short)(pFwork[pCodec->numCepCoeff] / pCodec->weight_logE);
   pFwork[pCodec->numCepCoeff-1] = (short)(pFwork[pCodec->numCepCoeff-1] / pCodec->weight_c0);
}



int ApplyAuroraDecoder_MF(AuroraDecoder *pCodec, unsigned char *pSrc, int InputLength,
                           short *pDst, int StreamEnd){

   int iCount,i,idx,j;
   short *pFwork,*pCurr,*pLast,*pPrev;
   int FrameCounter;


   unsigned char *workBuffer;
   unsigned short crc,crccmp;
   int FrameNoZero;

   pFwork =((short*) pDst)+pCodec->Curr * (NUM_CEP_COEFF+1) ;
   if (InputLength<=0){
      ResetAuroraDecoder(pCodec);
      return 0;
   }
   FrameCounter = 0;

   if(pCodec->DecoderInput == MULTIFRAME){
      pLast = ((short*) pDst)+pCodec->Last * (NUM_CEP_COEFF+1);
      pCurr = ((short*) pDst)+pCodec->Curr * (NUM_CEP_COEFF+1);
      pPrev = ((short*) pDst)+pCodec->Prev * (NUM_CEP_COEFF+1);
      FrameCounter = 0;
      workBuffer = (unsigned char*)pSrc;

      for (iCount=0;iCount<InputLength;iCount++){
         if (pCodec->done) break;
         crc = 0x00ff & (workBuffer[4]);
         crc |= 0xff00 & (workBuffer[5]<<8);

         crccmp = 0x00ff & workBuffer[2];
         crccmp |= 0xff00 & (workBuffer[3]<<8);

         if ( crc != calcCRC(crccmp))
              printf("Warning: Error found in multiframe header: %3d\n",pCodec->iCountFrame+1);
         idx = 6;
         for (i=0; i<12;i++){
            if (pCodec->done) break;
            if (i%2==0){
               pCodec->pIndexVQBuffer[0]  = (0x3f &  workBuffer[idx]);
               pCodec->pIndexVQBuffer[1]  = (0x03 & (workBuffer[idx]>>6));
               pCodec->pIndexVQBuffer[1] |= (0x3c & (workBuffer[idx+1]<<2));
               pCodec->pIndexVQBuffer[2]  = (0x0f & (workBuffer[idx+1]>>4));
               pCodec->pIndexVQBuffer[2] |= (0x30 & (workBuffer[idx+2]<<4));
               pCodec->pIndexVQBuffer[3]  = (0x3f & (workBuffer[idx+2]>>2));
               pCodec->pIndexVQBuffer[4]  = (0x3f &  workBuffer[idx+3]);
               pCodec->pIndexVQBuffer[5]  = (0x03 & (workBuffer[idx+3]>>6));
               pCodec->pIndexVQBuffer[5] |= (0x3c & (workBuffer[idx+4]<<2));
               pCodec->pIndexVQBuffer[6]  = (0x0f & (workBuffer[idx+4]>>4));
               pCodec->pIndexVQBuffer[6] |= (0xf0 & (workBuffer[idx+5]<<4));

               pCodec->pIndexVQBuffer[7]  = (0x0f & (workBuffer[idx+5])>>4);
               pCodec->pIndexVQBuffer[7] |= (0x30 & (workBuffer[idx+6])<<4);
               pCodec->pIndexVQBuffer[8]  = (0x3f & (workBuffer[idx+6]>>2));
               pCodec->pIndexVQBuffer[9]  = (0x3f &  workBuffer[idx+7]);
               pCodec->pIndexVQBuffer[10] = (0x03 & (workBuffer[idx+7]>>6));
               pCodec->pIndexVQBuffer[10]|= (0x3c & (workBuffer[idx+8]<<2));
               pCodec->pIndexVQBuffer[11] = (0x0f & (workBuffer[idx+8]>>4));
               pCodec->pIndexVQBuffer[11]|= (0x30 & (workBuffer[idx+9]<<4));
               pCodec->pIndexVQBuffer[12] = (0x3f & (workBuffer[idx+9]>>2));
               pCodec->pIndexVQBuffer[13] = (0xff &  workBuffer[idx+10]);

               pCodec->crc = (0x0f & workBuffer[idx+11]);
               ippsCopy_8u(workBuffer+idx,pCodec->pFrame->pCRCBuffer,11);

            }/* end if */
            else {
               pCodec->pIndexVQBuffer[0]  = (0x0f & (workBuffer[idx+11])>>4);
               pCodec->pIndexVQBuffer[0] |= (0x30 & (workBuffer[idx+12])<<4);
               pCodec->pIndexVQBuffer[1]  = (0x3f & (workBuffer[idx+12]>>2));
               pCodec->pIndexVQBuffer[2]  = (0x3f &  workBuffer[idx+13]);
               pCodec->pIndexVQBuffer[3]  = (0x03 & (workBuffer[idx+13]>>6));
               pCodec->pIndexVQBuffer[3] |= (0x3c & (workBuffer[idx+14]<<2));
               pCodec->pIndexVQBuffer[4]  = (0x0f & (workBuffer[idx+14]>>4));
               pCodec->pIndexVQBuffer[4] |= (0x30 & (workBuffer[idx+15]<<4));
               pCodec->pIndexVQBuffer[5]  = (0x3f & (workBuffer[idx+15]>>2));
               pCodec->pIndexVQBuffer[6]  = (0xff &  workBuffer[idx+16]);

               pCodec->pIndexVQBuffer[7]  = (0x3f &  workBuffer[idx+17]);
               pCodec->pIndexVQBuffer[8]  = (0x03 & (workBuffer[idx+17]>>6));
               pCodec->pIndexVQBuffer[8] |= (0x3c & (workBuffer[idx+18]<<2));
               pCodec->pIndexVQBuffer[9]  = (0x0f & (workBuffer[idx+18]>>4));
               pCodec->pIndexVQBuffer[9] |= (0x30 & (workBuffer[idx+19]<<4));
               pCodec->pIndexVQBuffer[10] = (0x3f & (workBuffer[idx+19]>>2));
               pCodec->pIndexVQBuffer[11] = (0x3f &  workBuffer[idx+20]);
               pCodec->pIndexVQBuffer[12] = (0x03 & (workBuffer[idx+20]>>6));
               pCodec->pIndexVQBuffer[12]|= (0x3c & (workBuffer[idx+21]<<2));
               pCodec->pIndexVQBuffer[13] = (0x0f & (workBuffer[idx+21]>>4));
               pCodec->pIndexVQBuffer[13]|= (0xf0 & (workBuffer[idx+22]<<4));


               pCodec->crc = (0x0f & (workBuffer[idx+22]>>4));


               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[5] |= (0xf0 & (pCodec->pIndexVQBuffer[7] << 4));
               pCodec->pFrame->pCRCBuffer[6]  = (0x03 & (pCodec->pIndexVQBuffer[7] >> 4));
               pCodec->pFrame->pCRCBuffer[6] |= (0xfc & (pCodec->pIndexVQBuffer[8] << 2));
               pCodec->pFrame->pCRCBuffer[7]  = (0x3f &  pCodec->pIndexVQBuffer[9]);
               pCodec->pFrame->pCRCBuffer[7] |= (0xc0 & (pCodec->pIndexVQBuffer[10] << 6));
               pCodec->pFrame->pCRCBuffer[8]  = (0x0f & (pCodec->pIndexVQBuffer[10] >> 2));
               pCodec->pFrame->pCRCBuffer[8] |= (0xf0 & (pCodec->pIndexVQBuffer[11] << 4));
               pCodec->pFrame->pCRCBuffer[9]  = (0x03 & (pCodec->pIndexVQBuffer[11] >> 4));
               pCodec->pFrame->pCRCBuffer[9] |= (0xfc & (pCodec->pIndexVQBuffer[12] << 2));
               pCodec->pFrame->pCRCBuffer[10] = (0xff &  pCodec->pIndexVQBuffer[13]);

               idx+=23;
            }
           FrameNoZero = CheckFrames(pCodec->pIndexVQBuffer,pCodec->pFrame->pCRCBuffer,pCodec->crc);

           if (pCodec->Start){ /* Start decoding myltyframe*/
            if (FrameNoZero == 6 || FrameNoZero == 2){
              FormVector(pCodec,pCodec->pIndexVQBuffer,pFwork);
              pFwork+=(NUM_CEP_COEFF+1);
              FormVector(pCodec,&pCodec->pIndexVQBuffer[7],pFwork);
              pFwork+=(NUM_CEP_COEFF+1);

              if (pCodec->BufferData){
                 if(FrameNoZero & 0x4){ /* CRC Error */
                    pCodec->BufferSize+=2;
                 }/* if CRC*/
                 else{
                    pCodec->BufferData=0;
                    pPrev = pCurr;
                    pCodec->iCountFrame+=2;
                    FrameCounter+=2;
                    pCodec->Prev = pCodec->Curr;
                 }/* else CRC */
              }/* if BufferData*/
              else {
                 if (FrameNoZero & 0x4){
                    if (CheckThreshold_16s(pPrev)){
                       pCodec->iCountFrame-=2;
                       FrameCounter-=2;
                       pCodec->BufferSize+=4;
                       pCodec->BufferData=1;
                    }/* if tresh */
                    else{
                       if (pCodec->BufferSize>0){
                          for (j=0; j<pCodec->BufferSize;j++){
                             ippsCopy_16s(pPrev,pDst+(NUM_CEP_COEFF+1)*(pCodec->Curr-2-pCodec->BufferSize+j),14);
                             pCodec->iCountFrame++;
                             FrameCounter++;
                          }/*for*/
                          pCodec->BufferData=0;
                          pCodec->BufferSize=0;