decoder.c

Intel开发的IPP库的应用实例

                       pCodec->Start=0;
                       pCodec->BufferSize+=2;
                    }/*else*/
                 }/*if CRC*/
                 else {
                       if (pCodec->BufferSize>0){
                          for (j=0; j<pCodec->BufferSize;j++){
                             ippsCopy_32f(pPrev,pDst+(NUM_CEP_COEFF+1)*(pCodec->Curr-2-pCodec->BufferSize+j),14);
                             pCodec->iCountFrame++;
                             FrameCounter++;
                          }/*for*/
                          pCodec->BufferData=0;
                          pCodec->BufferSize=0;
                       }/* if */
                       pCodec->Last = pCodec->Prev;pCodec->Prev = pCodec->Curr;
                       pLast = pPrev;pPrev = pCurr;
                       pCodec->iCountFrame+=2;
                       FrameCounter+=2;
                       pCodec->BufferData=0;
                       pCodec->Start=0;

                 }/*else CRC*/
              }/*else Buffer*/
            }/*6 2*/
            else if (FrameNoZero == 4 ){
                  FormVector(pCodec,pCodec->pIndexVQBuffer,pFwork,&vad);
                  *pVad = vad;pVad++;
                  pFwork+=(NUM_CEP_COEFF+1);
                  pCodec->iCountFrame++;
                  FrameCounter++;

                  FormVector(pCodec,pCodec->pIndexVQBuffer,pFwork,&vad);
                  *pVad = vad;pVad++;
                  pFwork+=(NUM_CEP_COEFF+1);
                  pCodec->iCountFrame++;
                  FrameCounter++;

                  pCodec->done = 1;
            }
            else if (FrameNoZero == 0 ){
                   if(pCodec->BufferData){
                       for(j=1; j<=pCodec->BufferSize; j++){
                           ippsCopy_32f(&pLast[16],pDst+(NUM_CEP_COEFF+1)*(pCodec->Prev+j-1),14);
                           pCodec->iCountFrame++;
                           FrameCounter++;
                        }
                   }

                  pCodec->done = 1;
            }
            else if (FrameNoZero == 5){
                  FormVector(pCodec,pCodec->pIndexVQBuffer,pFwork,&vad);
                  *pVad = vad;pVad++;
                  pFwork+=(NUM_CEP_COEFF+1);
                  pCodec->iCountFrame++;
                  FrameCounter++;
                  pCodec->done = 1;

            }
            else if ( FrameNoZero == 1){
                  FormVector(pCodec,pCodec->pIndexVQBuffer,pFwork,&vad);
                  *pVad = vad;pVad++;
                  pFwork+=(NUM_CEP_COEFF+1);
                  pCodec->iCountFrame++;
                  FrameCounter++;
                  for(j=1; j<=pCodec->BufferSize; j++){
                       ippsCopy_32f(pCurr,pDst+(NUM_CEP_COEFF+1)*(pCodec->Prev+j-1),14);
                       pCodec->iCountFrame++;
                       FrameCounter++;
                  }
                  pCodec->done = 1;
            }
           }/* if */
           else{
               switch(FrameNoZero){
               case 0:
               case 4:
                    if(pCodec->BufferData){
                        for(j=1; j<=pCodec->BufferSize; j++){
                           ippsCopy_32f(&pLast[16],pDst+(NUM_CEP_COEFF+1)*(pCodec->Prev+j-1),14);
                           pCodec->iCountFrame++;
                           FrameCounter++;
                        }
                    }
                  pCodec->done = 1;
                  break;
               case 1:
                  FormVector(pCodec,pCodec->pIndexVQBuffer,pFwork,&vad);
                  *pVad = vad;pVad++;
                  pFwork+=(NUM_CEP_COEFF+1);
                  FormVector(pCodec,&pCodec->pIndexVQBuffer[7],pFwork,&vad);
                  *pVad = vad;pVad++;
                  pFwork+=(NUM_CEP_COEFF+1);

                  if(pCodec->BufferData){
                     if(CheckThreshold(pCurr)){
                           pCodec->BufferSize++;
                           for(j=1; j<=pCodec->BufferSize; j++){
                              ippsCopy_32f(&pLast[16],pDst+((NUM_CEP_COEFF+1)*(pCodec->Prev+j-1)),14);
                              pCodec->iCountFrame++;
                              FrameCounter++;
                           }
                           pCodec->BufferSize=0;

                     }
                     else{
                        if(pCodec->BufferSize>0){
                              for(j=1; j<=((pCodec->BufferSize+1)/2); j++){
                                 ippsCopy_32f(&pLast[16],pDst+(NUM_CEP_COEFF+1)*(pCodec->Prev+j-1),14);
                                 pCodec->iCountFrame++;
                                 FrameCounter++;
                              }
                              for(j=(((pCodec->BufferSize+1)/2)+1); j<=pCodec->BufferSize; j++){
                                 ippsCopy_32f(pCurr,pDst+(NUM_CEP_COEFF+1)*(pCodec->Prev+j-1),14);
                                 pCodec->iCountFrame++;
                                 FrameCounter++;
                              }
                        }
                        FrameCounter++;
                        pCodec->iCountFrame++;
                     }
                  }
                  else{
                     /*if(pCodec->BufferSize>0){
                            for(j=1; j<=((pCodec->BufferSize+1)/2); j++){
                               ippsCopy_32f(&pLast[16],FeatureBuffer+(NUM_CEP_COEFF+1)*(FeatureSize*(pCodec->Prev+j-1)),14);
                               FrameCounter++;
                             }
                             for(j=(((pCodec->BufferSize+1)/2)+1); j<=pCodec->BufferSize; j++){
                                ippsCopy_32f(pPrev,FeatureBuffer+FeatureSize*(FeatureSize*(pCodec->Prev+j-1)),14);
                                FrameCounter++;
                             }
                      }*/
                      FrameCounter+=1;
                      pCodec->iCountFrame+=1;

                  }

                  pCodec->done = 1;
                  break;
               case 5:
                  FormVector(pCodec,pCodec->pIndexVQBuffer,pFwork,&vad);
                  *pVad = vad;pVad++;
                  pFwork+=(NUM_CEP_COEFF+1);

                  if(pCodec->BufferData){
                           for(j=1; j<=pCodec->BufferSize; j++){
                              ippsCopy_32f(&pLast[16],pDst+(NUM_CEP_COEFF+1)*pCodec->iCountFrame++,14);
                              FrameCounter++;
                           }
                           ippsCopy_32f(pPrev+(NUM_CEP_COEFF+1),pDst+(NUM_CEP_COEFF+1)*pCodec->iCountFrame++,14);
                           pCodec->BufferSize=0;
                           FrameCounter++;

                  }
                  else{
                      if(CheckThreshold(pPrev)){
                           pCodec->BufferSize+=3;
                           pCodec->iCountFrame-=2;
                           FrameCounter-=2;
                           for(j=1; j<=pCodec->BufferSize; j++){
                              ippsCopy_32f(&pLast[16],pDst+(NUM_CEP_COEFF+1)*pCodec->iCountFrame++,14);
                              FrameCounter++;
                           }
                           pCodec->BufferSize=0;

                      }
                      else{
                          /*if(pCodec->BufferSize > 0){
                              for(j=1; j<=((pCodec->BufferSize+1)/2); j++){
                                 ippsCopy_32f(&pLast[16],pDst+(NUM_CEP_COEFF+1)*pCodec->iCountFrame++,14);
                                 FrameCounter++;
                              }
                              for(j=(((pCodec->BufferSize+1)/2)+1); j<=pCodec->BufferSize; j++){
                                 ippsCopy_32f(pPrev+FeatureSize,pDst+(NUM_CEP_COEFF+1)*pCodec->iCountFrame++,14);
                                 FrameCounter++;
                              }
                              pCodec->BufferSize = 0;
                          }*/
                          ippsCopy_32f(pPrev+(NUM_CEP_COEFF+1),pDst+(NUM_CEP_COEFF+1)*pCodec->iCountFrame++,14);
                          pCodec->iCountFrame++;
                          FrameCounter++;
                      }
                  }
                  pCodec->done = 1;
                  break;
               case 2:
               case 6:
                  FormVector(pCodec,pCodec->pIndexVQBuffer,pFwork,&vad);
                  *pVad = vad;pVad++;
                  pFwork+=(NUM_CEP_COEFF+1);
                  FormVector(pCodec,&pCodec->pIndexVQBuffer[7],pFwork,&vad);
                  *pVad = vad;pVad++;
                  pFwork+=(NUM_CEP_COEFF+1);

                  if(pCodec->BufferData){
                     if(FrameNoZero & 0x4){ /*crc is in error*/
                        pCodec->BufferSize+=2;
                     } /*crc is in error*/
                     else{
                        if(CheckThreshold(pCurr)){
                           pCodec->BufferSize+=2;
                        }
                        else{
                           if(pCodec->BufferSize>0){
                              for(j=1; j<=((pCodec->BufferSize+1)/2); j++){
                                 ippsCopy_32f(&pLast[16],pDst+(NUM_CEP_COEFF+1)*(pCodec->Curr-pCodec->BufferSize+j-1),14);
                                 pCodec->iCountFrame++;
                                 FrameCounter++;
                              }
                              for(j=(((pCodec->BufferSize+1)/2)+1); j<=pCodec->BufferSize; j++){
                                 ippsCopy_32f(pCurr,pDst+(NUM_CEP_COEFF+1)*(pCodec->Curr-pCodec->BufferSize+j-1),14);
                                 FrameCounter++;
                                 pCodec->iCountFrame++;
                              }
                              pCodec->BufferSize = 0;

                           }
                           pCodec->BufferData=0;
                           pCodec->Prev = pCodec->Curr;
                           pCodec->Last = pCodec->Curr;
                           pPrev = pCurr;
                           pLast = pCurr;
                           pCodec->iCountFrame+=2;
                           FrameCounter+=2;
                        }
                     }/*else crc is in error*/
                  }
                  else{
                     if(FrameNoZero & 0x4){ /*crc is in error*/
                        if(CheckThreshold(pPrev)){
                           pCodec->iCountFrame-=2;
                           FrameCounter-=2;

                           pCodec->BufferData=1;
                           pCodec->BufferSize+=4;
                        }
                        else{
                           pLast = pPrev;
                           pCodec->Last = pCodec->Prev;
                           pCodec->Prev=pCodec->Curr;
                           pPrev=pCurr;
                           pCodec->BufferData=1;
                           pCodec->BufferSize+=2;

                        }
                     }
                     else{ /*crc is in error*/
                        pLast = pPrev;
                        pCodec->Last = pCodec->Prev;
                        pCodec->Prev=pCodec->Curr;

                        pPrev=pCurr;
                        pCodec->iCountFrame+=2;
                        FrameCounter+=2;
                     } /*crc is in error*/
                  }

                  break;
               } /* end switch*/
           }/*end if !Start*/
           pCodec->Curr+=2;
           pCurr += ((NUM_CEP_COEFF+1)+(NUM_CEP_COEFF+1));
         }/* end for */
         workBuffer +=144;

      } /* end for */

   } /* end quantinize decoder */
   else {
      printf("\n!!! ERROR: decoder was initialized with another flag !!!");
   }
   if (StreamEnd){
      ResetAuroraDecoder(pCodec);
   }
   return FrameCounter;

}
int ApplyAuroraDecoder_QF(AuroraDecoder *pCodec,unsigned char *pSrc, int InputLength, float * pDst,
                          unsigned char *pDstVad, int StreamEnd){

   int iCount;
   float *pFwork;
   int FrameCounter;
   unsigned char *pIndexVQ;
   unsigned char *pVad;

   pFwork =((float*) pDst)+pCodec->Curr * (NUM_CEP_COEFF+1) ;
   pVad = pDstVad+pCodec->Curr ;
   if (InputLength<=0){
      ResetAuroraDecoder(pCodec);
      return 0;
   }
   FrameCounter = 0;
   if(pCodec->DecoderInput == QUANTIZED){

      FrameCounter = 0;
      pIndexVQ = (unsigned char*)pSrc;

      for (iCount=0;iCount<InputLength;iCount++){
         ippsCopy_8u(pIndexVQ,pCodec->pIndexVQBuffer,NUM_CODEBOOK);
         pVad[iCount] = pIndexVQ[NUM_CODEBOOK];
         ippsFormVectorVQ_8u32f(pCodec->pIndexVQBuffer,NUM_CODEBOOK,pFwork,pCodec->numCepCoeff+1,1,
               (const IppsCdbkState_32f **)pCodec->ppCdbkState,NUM_CODEBOOK);
         pFwork[pCodec->numCepCoeff]/=(float)pCodec->weight_logE;
         pFwork[pCodec->numCepCoeff-1]/=(float)pCodec->weight_c0;
         pFwork+=(NUM_CEP_COEFF+1);
         FrameCounter++;
         pCodec->Curr++;
         pIndexVQ+=NUM_CODEBOOK+1;
      } /* end for */
   } /* end quantinize decoder */
   else {
      printf("\n!!! ERROR: decoder was initialized with another flag !!!");
   }
   if (StreamEnd){
      ResetAuroraDecoder(pCodec);
   }
   return FrameCounter;
}


int  ApplyAuroraDecoder_DerCal(AuroraDecoder *pCodec, float *pSrc, unsigned char * pSrcVad, int InputLength, float *pDst){
   int CountFrame = 0,i;
   float *pTmp;
   if(InputLength<9)return 0;
   pTmp = ippsMalloc_32f(InputLength*40-9+160);
   ippsDeltaDelta_Aurora_32f_D2(pSrc,pTmp,40,InputLength,ippsDeltaBegin);
   CountFrame=0;
   for(i=0;i<InputLength-8;i++){
      if(pSrcVad[i+4]==1){
         ippsCopy_32f(pTmp+i*40+160,pDst+CountFrame*40,40);
         CountFrame++;
      }
   }

   if(pTmp)ippsFree(pTmp);
   return CountFrame;
}