encgsmfr.c

这是在PCA下的基于IPP库示例代码例子,在网上下了IPP的库之后,设置相关参数就可以编译该代码.

      wBuf[26] =(uchar)( ((NcVal[3] & 0x7F) << 1)  | ((bcVal[3] >> 1) & 0x1));

      wBuf[22] =(uchar)( ((xMc[28] & 0x3) << 6)| ((xMc[29] & 0x7) << 3)| (xMc[30] & 0x7));
      wBuf[6]  =(uchar)( ((bcVal[0] & 0x1) << 7)   | ((Mc[0] & 0x3) << 5)   | ((xmax[0] >> 1) & 0x1F));
      wBuf[23] =(uchar)( ((xMc[31] & 0x7) << 5)| ((xMc[32] & 0x7) << 2)| ((xMc[33] >> 1) & 0x3));
      wBuf[13] =(uchar)( ((bcVal[1] & 0x1) << 7)   | ((Mc[1] & 0x3) << 5)   | ((xmax[1] >> 1) & 0x1F));
      wBuf[24] =(uchar)( ((xMc[33] & 0x1) << 7)| ((xMc[34] & 0x7) << 4)| ((xMc[35] & 0x7) << 1)| ((xMc[36] >> 2) & 0x1));
      wBuf[20] =(uchar)( ((bcVal[2] & 0x1) << 7)   | ((Mc[2] & 0x3) << 5)   | ((xmax[2] >> 1) & 0x1F));
      wBuf[25] =(uchar)( ((xMc[36] & 0x3) << 6)| ((xMc[37] & 0x7) << 3)| (xMc[38] & 0x7));
      wBuf[27] =(uchar)( ((bcVal[3] & 0x1) << 7)   | ((Mc[3] & 0x3) << 5)   | ((xmax[3] >> 1) & 0x1F));

      wBuf[29] =(uchar)( ((xMc[41] & 0x3) << 6)| ((xMc[42] & 0x7) << 3)| (xMc[43] & 0x7));
      wBuf[7]  =(uchar)( ((xmax[0] & 0x1) << 7)| ((xMc[0] & 0x7) << 4) | ((xMc[1] & 0x7) << 1) | ((xMc[2] >> 2) & 0x1));
      wBuf[30] =(uchar)( ((xMc[44] & 0x7) << 5)| ((xMc[45] & 0x7) << 2)| ((xMc[46] >> 1) & 0x3));
      wBuf[14] =(uchar)( ((xmax[1] & 0x1) << 7)| ((xMc[13] & 0x7) << 4)| ((xMc[14] & 0x7) << 1) | ((xMc[15] >> 2) & 0x1));
      wBuf[31] =(uchar)( ((xMc[46] & 0x1) << 7)| ((xMc[47] & 0x7) << 4)| ((xMc[48] & 0x7) << 1)| ((xMc[49] >> 2) & 0x1));
      wBuf[21] =(uchar)( ((xmax[2] & 0x1) << 7)| ((xMc[26] & 0x7) << 4)| ((xMc[27] & 0x7) << 1) | ((xMc[28] >> 2) & 0x1));
      wBuf[32] =(uchar)( ((xMc[49] & 0x3) << 6)| ((xMc[50] & 0x7) << 3)| (xMc[51] & 0x7));
      wBuf[28] =(uchar)( ((xmax[3] & 0x1) << 7)| ((xMc[39] & 0x7) << 4)| ((xMc[40] & 0x7) << 1) | ((xMc[41] >> 2) & 0x1));
   }
   return APIGSMFR_StsNoErr;
}
static void saveParm(short *pSrc,short *pDst,int *index,int len)
{
   ippsCopy_16s(pSrc,&pDst[(*index)*len],len);
      ++*index;
      if(*index>3)
         *index=0;
}
/* LAR averaging */
static void larAverage(short *saveLAR,short *LAR,int len)
{
 int i,
     TmpL;
   for( i=0;i<len;++i)
   {
      TmpL = 2;
      TmpL += saveLAR[i];
      TmpL += saveLAR[i+8];
      TmpL += saveLAR[i+16];
      TmpL += saveLAR[i+24];

      TmpL = TmpL >> 2;
      LAR[i] = (short)TmpL;
    }
}

static void xmaxAverage(short *saveXMax,short *xmax)
{
  int  sum;
   ippsSum_16s32s_Sfs(saveXMax, 16,&sum,0);
   *xmax = (short)((sum+8) >> 4);
}

static void acfEnComp(GSMFREncoder_Obj *encoderObj,const int *L_ACF){
  short normacf,
        normprod;
  short sacf[9];
  int   i,L_tmp;
    if ( encoderObj->scalauto < 0 )
      encoderObj->scalvad = 0;
   else
      encoderObj->scalvad = (short)encoderObj->scalauto;  /* keep scalvad for( use in subclause 3.2 */

   if ( L_ACF[0] == 0 )
   {
      encoderObj->e_pvad = -32768;
      encoderObj->m_pvad = 0;
      encoderObj->e_acf0 = -32768;
      encoderObj->m_acf0 = 0;
      return;
   }

   normacf = Exp_32s_Pos( L_ACF[0] );

   Shift_32s16s(L_ACF,sacf,9,19-normacf);
   encoderObj->e_acf0 = 32+(short)(encoderObj->scalvad << 1 );
   encoderObj->e_acf0 = encoderObj->e_acf0-normacf;
   encoderObj->m_acf0 = sacf[0] << 3;

   encoderObj->e_pvad = encoderObj->e_acf0+14;
   encoderObj->e_pvad -= encoderObj->normrvad;
   L_tmp = 0;
   for( i = 1;i<9;++i){
      L_tmp +=  2*sacf[i]*encoderObj->rvad[i];
   }
   L_tmp += sacf[0]*encoderObj->rvad[0];
   if ( L_tmp <1 )
      L_tmp = 1;
   normprod = Exp_32s_Pos( L_tmp );
   encoderObj->e_pvad -= normprod;
   encoderObj->m_pvad = (( L_tmp<< normprod )) >> 16;
}
static void acfEverag(GSMFREncoder_Obj *encoderObj,const int *L_ACF)
{
  short  scal;
  int    i,L_tmp;
   scal = 10 - (short)(encoderObj->scalvad << 1);
   for(i = 0;i<9;++i)
   {
      L_tmp = L_ACF[i] >> scal;
      encoderObj->L_av0[i] = encoderObj->L_sacf[i] + L_tmp;
      encoderObj->L_av0[i] = encoderObj->L_sacf[i+9] + encoderObj->L_av0[i];
      encoderObj->L_av0[i] = encoderObj->L_sacf[i+18] + encoderObj->L_av0[i];
      encoderObj->L_sacf[ encoderObj->pt_sacf + i ] = L_tmp;
      encoderObj->L_av1[i] = encoderObj->L_sav0[ encoderObj->pt_sav0 + i ];
      encoderObj->L_sav0[ encoderObj->pt_sav0 + i] = encoderObj->L_av0[i];
   }

   if ( encoderObj->pt_sacf == 18 )
      encoderObj->pt_sacf = 0;
   else
      encoderObj->pt_sacf =  encoderObj->pt_sacf+9;

   if ( encoderObj->pt_sav0 == 27 )
      encoderObj->pt_sav0 = 0;
   else
      encoderObj->pt_sav0 += 9;
}
static void spectComp(GSMFREncoder_Obj *encoderObj){
  int   i,L_SUMp,L_tmp,L_dm;
  short tmp,divshift,shift,sav0[9];
   if ( encoderObj->L_av0[0] == 0 ){
      for( i = 0 ;i< 9;++i){
         sav0[i] = 4095;
      }
   }else{
      shift = Exp_32s_Pos( encoderObj->L_av0[0] );
      Shift_32s16s(encoderObj->L_av0,sav0,9,19-shift);
   }
   L_SUMp = 0;
   for( i = 1 ;i< 9;++i){
      L_SUMp += 2* encoderObj->rav1[i]* sav0[i];
   }

   if ( L_SUMp < 0 )
      L_tmp = -L_SUMp;
   else
      L_tmp = L_SUMp;

   if ( L_tmp == 0 ){
      L_dm  = 0;
      shift = 0;
   }
   else
   {
      sav0[0] = sav0[0]<< 3;
      shift = Exp_32s_Pos( L_tmp );
      tmp  = (L_tmp<< shift )>>16;
      if ( sav0[0] >= tmp ){
         divshift = 0;
         tmp = ((int)tmp<<15)/ sav0[0];
      }
      else
      {
         divshift = 1;
         tmp -= sav0[0];
         tmp = ((int)tmp<<15)/sav0[0];
      }
      if( divshift == 1 )
         L_dm = 32768;
      else
         L_dm = 0;

      L_dm = ( L_dm + tmp)<<1;
      if( L_SUMp < 0 )
         L_dm = -L_dm;
   }

   L_dm = L_dm<<14;
   L_dm = L_dm>> shift;
   L_dm +=  encoderObj->rav1[0] << 11;
   L_dm = L_dm>> encoderObj->normrav1;

   L_tmp   = L_dm - encoderObj->L_lastdm;
   encoderObj->L_lastdm = L_dm;

   if ( L_tmp < 0 )
      L_tmp = -L_tmp;

   L_tmp -= 3277;


   if ( L_tmp < 0 )
      encoderObj->stat = 1;
   else
      encoderObj->stat = 0;
}

static void periodDetect(GSMFREncoder_Obj *encoderObj)
{
  int   tmp;
   tmp = encoderObj->oldlagcount+encoderObj->veryoldlagcount;

   if ( tmp >= 4 )
      encoderObj->ptch = 1;
   else
      encoderObj->ptch = 0;
}
static void threshAdapt(GSMFREncoder_Obj *encoderObj){
  short  E_PTH=19,M_PTH=18750,
         E_MARGIN=27,M_MARGIN=19531,
         E_PLEV=20,M_PLEV=25000,
         e_tmp;
  int    comp, L_tmp, m_tmp,comp2,tmp;

   comp = 0;
   if ( encoderObj->e_acf0 < E_PTH )
      comp = 1;
   if ( encoderObj->e_acf0 == E_PTH )
      if ( encoderObj->m_acf0 < M_PTH )
         comp =1;
   if ( comp == 1 ){
      encoderObj->e_thvad = E_PLEV;
      encoderObj->m_thvad = M_PLEV;
      return;
   }

   comp = 0;
   if ( encoderObj->ptch == 1 )  comp = 1;
   if ( encoderObj->stat == 0 )  comp = 1;
   if ( encoderObj->tone == 1 )  comp = 1;
   if ( comp == 1 )
   {
      encoderObj->adaptcount = 0;
      return;
   }

   encoderObj->adaptcount++;
   if ( encoderObj->adaptcount < 9 )
      return;

   encoderObj->m_thvad -= (short)(encoderObj->m_thvad >> 5 );
   if ( encoderObj->m_thvad < 16384)
   {
      encoderObj->m_thvad = encoderObj->m_thvad<<1;
      --encoderObj->e_thvad;
   }

   L_tmp =  encoderObj->m_pvad + encoderObj->m_pvad;
   L_tmp += encoderObj->m_pvad;
   L_tmp = L_tmp>>1;
   e_tmp = encoderObj->e_pvad + 1;
   if ( L_tmp > 32767 )
   {
      L_tmp = L_tmp>> 1;
      e_tmp += 1;
   }
   m_tmp = L_tmp;


   comp = 0;
   if ( encoderObj->e_thvad < e_tmp) comp = 1;
   if (encoderObj->e_thvad == e_tmp)
      if (encoderObj->m_thvad < m_tmp) comp =1;


   if ( comp == 1 ){
      L_tmp = encoderObj->m_thvad + (encoderObj->m_thvad>> 4);
      if ( L_tmp > 32767 )
      {
         encoderObj->m_thvad = L_tmp >> 1;
         encoderObj->e_thvad += 1;
      }
      else
         encoderObj->m_thvad = L_tmp;
      comp2 = 0;
      if ( e_tmp < encoderObj->e_thvad)
         comp2 = 1;
      if (e_tmp == encoderObj->e_thvad)
         if (m_tmp<encoderObj->m_thvad)
            comp2 = 1;
      if ( comp2 == 1 ){
         encoderObj->e_thvad = e_tmp;
         encoderObj->m_thvad = m_tmp;
      }
   }

   if ( encoderObj->e_pvad == E_MARGIN ){
      L_tmp = encoderObj->m_pvad + M_MARGIN;
      m_tmp = L_tmp >> 1;
      e_tmp = encoderObj->e_pvad + 1;
   }
   else
   {
      if ( encoderObj->e_pvad > E_MARGIN )
      {
         tmp = encoderObj->e_pvad - E_MARGIN;
         tmp = M_MARGIN >> tmp;
         L_tmp = encoderObj->m_pvad + tmp;
         if ( L_tmp > 32767)
         {
            e_tmp = encoderObj->e_pvad + 1;
            m_tmp = L_tmp >> 1;
         }
         else
         {
            e_tmp = encoderObj->e_pvad;
            m_tmp = L_tmp;
         }
      }
      else
      {
         tmp = E_MARGIN - encoderObj->e_pvad;
         tmp = encoderObj->m_pvad >> tmp;
         L_tmp = M_MARGIN + tmp;
         if (L_tmp > 32767)
         {
            e_tmp = E_MARGIN + 1;
            m_tmp = L_tmp >> 1;
         }
         else
         {
            e_tmp = E_MARGIN;
            m_tmp = L_tmp;
         }
      }
   }

   comp = 0;
   if ( encoderObj->e_thvad > e_tmp)     comp = 1;
   if (encoderObj->e_thvad == e_tmp)
      if (encoderObj->m_thvad > m_tmp)   comp =1;

   if ( comp == 1 ){
      encoderObj->e_thvad = e_tmp;
      encoderObj->m_thvad = m_tmp;
   }

   encoderObj->normrvad  = encoderObj->normrav1;
   ippsCopy_16s(encoderObj->rav1,encoderObj->rvad,9);
   encoderObj->adaptcount = 9;
}

static void vadDecision(GSMFREncoder_Obj *encoderObj){
   encoderObj->vvad = 0;
   if (encoderObj->e_pvad >  encoderObj->e_thvad){
      encoderObj->vvad = 1;
   }
   if (encoderObj->e_pvad == encoderObj->e_thvad)
      if (encoderObj->m_pvad > encoderObj->m_thvad)
         encoderObj->vvad =1;
}

static void vadHangoverAdd(GSMFREncoder_Obj *encoderObj){
   if ( encoderObj->vvad == 1 )
      encoderObj->burstcount++;
   else{
      encoderObj->burstcount = 0;
   }
   if ( encoderObj->burstcount >= 3 ){
      encoderObj->hangcount =  5;
      encoderObj->burstcount = 3;
   }
   encoderObj->vad = encoderObj->vvad;
   if ( encoderObj->hangcount >= 0 ){
      encoderObj->vad = 1;
      --encoderObj->hangcount;
   }
}

static void periodUpdate(GSMFREncoder_Obj *encoderObj,short lags[4])
{
  int    i,j;
  short  minlag,maxlag,smallag,tmp;
   encoderObj->lagcount = 0;

   for( i = 0;i<4;++i)
   {
      if ( encoderObj->oldlag > lags[i] )
      {
         minlag = lags[i];
         maxlag = encoderObj->oldlag;
      }
      else
      {
         minlag = encoderObj->oldlag;
         maxlag = lags[i] ;
      }
      smallag = maxlag;
      for( j = 0;j<3;++j)
      {
         if (smallag >= minlag)
            smallag -= minlag;
      }
      tmp = minlag - smallag;
      if ( tmp < smallag )
         smallag = tmp;
      if ( smallag < 2 )
         encoderObj->lagcount++;
      encoderObj->oldlag = lags[i];
   }

   encoderObj->veryoldlagcount = encoderObj->oldlagcount;
   encoderObj->oldlagcount     = encoderObj->lagcount;
}
static int toneDetect(GSMFREncoder_Obj *encoderObj)
{
  int L_acfh[5],autoScale;
  int i, L_tmp,L_den,L_num;
  short sofh[160],a[3],rc[5] ,tmp,prederr ;
   ippsMul_NR_16s_Sfs( encoderObj->sof,hann,sofh,160,15);
   AutoCorr1(sofh,160,L_acfh, 5,&autoScale);
   ippsLShiftC_32s_I(1,L_acfh,5);
   ippsSchur_GSMFR_32s16s(L_acfh,&rc[1],4 );
   tmp = rc[1] >> 2;
   a[1] = tmp + (short)(((int)rc[2]* (int)tmp + 16384)>>15);
   a[2] = rc[2] >> 2;

   L_den = 2*a[1]*a[1];

   L_tmp = a[2]<< 16;
   L_num = L_tmp - L_den;
   if ( L_num <1 )
   {
      encoderObj->tone = 0;
      return 0;
   }

   if ( a[1] < 0)
   {
      tmp = L_den >> 16;
      L_den = tmp*6378;
      L_tmp = L_num - L_den;
      if ( L_tmp < 0 )
      {
         encoderObj->tone = 0;
         return 0;
      }
   }
   prederr = 32767;
   for( i=1;i<5;++i)
   {
      tmp = Mul_16s_Sfs ( rc[i], rc[i],15 );
      tmp = 32767 - tmp;
      prederr = Mul_16s_Sfs( prederr, tmp,15 );
   }
   tmp = prederr - 1464;
   if ( tmp < 0 )
      encoderObj->tone = 1;
   else
      encoderObj->tone = 0;
   return 0;
}