utilamrwb.c

audio-video-codecs.rar语音编解码器

    valExp -= 1;
    sTmp <<= valExp;
    tmp2 <<= valExp2;
    valCoeff = (Ipp16s)((sTmp << 15) / tmp2);
    valExp = (Ipp16s)(valExp2 - valExp);

    for (i = LP_ORDER - 1; i < (LP_ORDER_16K - 1); i++)
    {
        sTmp = (Ipp16s)(((pHfIsf[i] - pHfIsf[i - 1]) * valCoeff) >> 15);
        if (valExp > 0)
            pIsfDiffvec[i - (LP_ORDER - 1)] = (Ipp16s)(sTmp << valExp);
        else
            pIsfDiffvec[i - (LP_ORDER - 1)] = (Ipp16s)(sTmp >> (-valExp));
    }

    for (i = LP_ORDER; i < (LP_ORDER_16K - 1); i++)
    {
        sTmp = (Ipp16s)((pIsfDiffvec[i - (LP_ORDER - 1)] + pIsfDiffvec[i - LP_ORDER]) - 1280);
        if (sTmp < 0)
        {
            if (pIsfDiffvec[i - (LP_ORDER - 1)] > pIsfDiffvec[i - LP_ORDER])
                pIsfDiffvec[i - LP_ORDER] = (Ipp16s)(1280 - pIsfDiffvec[i - (LP_ORDER - 1)]);
            else
                pIsfDiffvec[i - (LP_ORDER - 1)] = (Ipp16s)(1280 - pIsfDiffvec[i - LP_ORDER]);
        }
    }
    for (i = LP_ORDER-1; i < (LP_ORDER_16K-1); i++)
        pHfIsf[i] = (Ipp16s)(Add_16s(pHfIsf[i-1], pIsfDiffvec[i-(LP_ORDER-1)]));

    ownMulC_16s_ISfs(26214, pHfIsf, LP_ORDER_16K-1, 15);

    ippsISFToISP_AMRWB_16s(pHfIsf, pHfIsf, LP_ORDER_16K);

    return;
}

Ipp16s ownGpClip(Ipp16s *pMem)
{
    Ipp16s clip;

    clip = 0;
    if ((pMem[0] < THRESH_DISTANCE_ISF) && (pMem[1] > THRESH_GAIN_PITCH))
        clip = 1;

    return (clip);
}

void ownCheckGpClipIsf(Ipp16s *pIsfvec, Ipp16s *pMem)
{
    Ipp16s valDist, valDistMin;
    Ipp32s i;

    valDistMin = (Ipp16s)(pIsfvec[1] - pIsfvec[0]);
    for (i = 2; i < LP_ORDER - 1; i++)
    {
        valDist = (Ipp16s)(pIsfvec[i] - pIsfvec[i - 1]);
        if (valDist < valDistMin) valDistMin = valDist;
    }

    valDist = (Ipp16s)((26214 * pMem[0] + 6554 * valDistMin) >> 15);
    if (valDist > MAX_DISTANCE_ISF) valDist = MAX_DISTANCE_ISF;
    pMem[0] = valDist;
}

void ownCheckGpClipPitchGain(Ipp16s valPitchGain, Ipp16s *pMem)
{
    Ipp16s valGain;
    Ipp32s s;

    s = 29491 * pMem[1];
    s += 3277 * valPitchGain;
    valGain = (Ipp16s)(s>>15);

    if (valGain < MIN_GAIN_PITCH) valGain = MIN_GAIN_PITCH;
    pMem[1] = valGain;
}

void ownSynthesisFilter_AMRWB_16s32s_ISfs
       ( const Ipp16s *pSrcLpc, Ipp32s valLpcOrder, const Ipp16s *pSrcExcitation,
         Ipp32s *pSrcDstSignal, Ipp32s len, Ipp32s scaleFactor )
{
//    IPP_BAD_PTR3_RET(pSrcLpc, pSrcExcitation, pSrcDstSignal);
//    IPP_BAD_SIZE_RET(valLpcOrder);
//    IPP_BAD_SIZE_RET(len);

    {
      Ipp32s i, j, s, s1;
      Ipp16s sTmp;
      for (i = 0; i < len; i++)
      {
        s = 0;
        for (j = 1; j <= valLpcOrder; j++) {
           sTmp = (Ipp16s)((pSrcDstSignal[i - j]>>4)&0x0FFF);
           s -= sTmp * pSrcLpc[j];
        }

        s >>= 11;

        s1 = pSrcExcitation[i] * pSrcLpc[0];

        for (j = 1; j <= valLpcOrder; j++)
            s1 -= (pSrcDstSignal[i - j]>>16) * pSrcLpc[j];

        s = Add_32s(s, Mul2_32s(s1));
        s = ShiftL_32s(s, (Ipp16u)scaleFactor);

        pSrcDstSignal[i] = s;
      }
    }
}

#define NC16k_AMRWB 10
#define ownLSPPolinomials(pLSP,shift, pPolinom,len,ScaleFactor)\
{\
    Ipp16s ownHigh, ownLow;\
    Ipp32s ownI, ownJ, n, k, valTmp;\
\
    pPolinom[0] = 1 << (21 + ScaleFactor);\
    pPolinom[1] = (-pLSP[0+shift]) << (7 + ScaleFactor);\
\
    for(ownI=2,k=2; ownI<=len; ownI++,k+=2){\
        pPolinom[ownI] = pPolinom[ownI-2];\
        for(ownJ=1,n=ownI; ownJ<ownI; ownJ++,n--) {\
            ownHigh = (Ipp16s)(pPolinom[n-1] >> 16);\
            ownLow = (Ipp16s)((pPolinom[n-1] >> 1) & 0x7fff);\
            valTmp = ownHigh * pLSP[k+shift] + ((ownLow * pLSP[k+shift])>>15);\
            pPolinom[n] -= 4*valTmp;\
            pPolinom[n] += pPolinom[n-2];\
        }\
        pPolinom[n] -=  pLSP[k+shift] << (7 + ScaleFactor);\
    }\
}

#define GetLPCFromPoli(pDstLpc,len,lenBy2,f1,f2,scaleFactor,RoundOperation,tmax)\
{\
   Ipp32s i_GetLPCFromPoli,j_GetLPCFromPoli;\
   Ipp32s lTemporaryVar;\
\
   pDstLpc[0] = 4096;\
   tmax = 1;\
   for (i_GetLPCFromPoli = 1, j_GetLPCFromPoli = len - 1; i_GetLPCFromPoli < lenBy2; i_GetLPCFromPoli++, j_GetLPCFromPoli--) {\
      lTemporaryVar = Add_32s(f1[i_GetLPCFromPoli],f2[i_GetLPCFromPoli]);\
      tmax |= lTemporaryVar;\
      pDstLpc[i_GetLPCFromPoli] = RoundOperation((lTemporaryVar + (1 << scaleFactor)) >> (scaleFactor+1));\
\
      lTemporaryVar = f1[i_GetLPCFromPoli] - f2[i_GetLPCFromPoli];\
      tmax |= Abs_32s(lTemporaryVar);\
      pDstLpc[j_GetLPCFromPoli] = RoundOperation((lTemporaryVar + (1 << scaleFactor)) >> (scaleFactor+1));\
   }\
}

void ownISPToLPC_AMRWB_16s
       ( const Ipp16s *pSrcIsp, Ipp16s *pDstLpc, Ipp32s len, Ipp32s adaptive_scaling )
{
    Ipp16s sHighPart, sLowPart, sq, sq_sug;
    Ipp32s i, j, nc, iTmp, tmax;
    IPP_ALIGNED_ARRAY(16, Ipp32s, f1, NC16k_AMRWB + 1);
    IPP_ALIGNED_ARRAY(16, Ipp32s, f2, NC16k_AMRWB);

//    IPP_BAD_PTR2_RET(pSrcIsp, pDstLpc)
//    IPP_BAD_SIZE_RET(len);
//    IPP_BADARG_RET( (len > 20), ippStsSizeErr )

    nc = len >> 1;
    if (nc > 8) {
        ownLSPPolinomials(pSrcIsp,0,f1,nc,0);
        ippsLShiftC_32s_I(2, f1, nc);
        f1[nc] = ShiftL_32s(f1[nc], 2);
        ownLSPPolinomials(pSrcIsp,1,f2,nc-1,0);
        ippsLShiftC_32s_I(2, f2, nc);
    } else {
        ownLSPPolinomials(pSrcIsp,0,f1,nc,2);
        ownLSPPolinomials(pSrcIsp,1,f2,nc-1,2);
    }

    for (i = nc - 1; i > 1; i--) {
        f2[i] -= f2[i - 2];
    }

    for (i = 0; i < nc; i++) {
        Unpack_32s(f1[i], &sHighPart, &sLowPart);
        iTmp = Mpy_32_16(sHighPart, sLowPart, pSrcIsp[len - 1]);
        f1[i] = Add_32s(f1[i], iTmp);

        Unpack_32s(f2[i], &sHighPart, &sLowPart);
        iTmp = Mpy_32_16(sHighPart, sLowPart, pSrcIsp[len - 1]);
        f2[i] -= iTmp;
    }
    GetLPCFromPoli(pDstLpc,len,nc,f1,f2,11,(Ipp16s),tmax);

    /* rescale data if overflow has occured and reprocess the loop */

    if ( adaptive_scaling == 1 )
       sq = (Ipp16s)(4 - Exp_32s(tmax));
    else
       sq = 0;

    if (sq > 0)
    {
      sq_sug = (Ipp16s)(sq + 12);
      for (i = 1, j = (len - 1); i < nc; i++, j--)
        {
          iTmp = Add_32s(f1[i], f2[i]);
          pDstLpc[i] = (Ipp16s)((iTmp + (1 << (sq_sug-1))) >> sq_sug);

          iTmp = f1[i] - f2[i];
          pDstLpc[j] = (Ipp16s)((iTmp + (1 << (sq_sug-1))) >> sq_sug);
        }
      pDstLpc[0] >>= sq;
    }
    else
    {
      sq_sug = 12;
      sq     = 0;
    }

    Unpack_32s(f1[nc], &sHighPart, &sLowPart);
    iTmp = Mpy_32_16(sHighPart, sLowPart, pSrcIsp[len - 1]);

    iTmp = Add_32s(f1[nc], iTmp);
    pDstLpc[nc] = (Ipp16s)((iTmp + (1 << 11)) >> sq_sug);

    pDstLpc[len] = ShiftR_NR_16s(pSrcIsp[len - 1], (Ipp16s)(sq+3));
}

void ownSoftExcitationHF(Ipp16s *exc_hf, Ipp32s *mem)
{
   Ipp32s lp_amp, Ltmp, Ltmp1;
   Ipp16s i, hi, lo;

   lp_amp = *mem;

   for (i=0; i<SUBFRAME_SIZE; i++) {
      Ltmp = ShiftL_32s(Abs_16s(exc_hf[i]),15);/* clearing sign bit*/

      Unpack_32s(Ltmp, &hi, &lo);
      Ltmp1 = Mpy_32_16(hi, lo, 655);

      Unpack_32s(lp_amp, &hi, &lo);
      lp_amp = Add_32s(Ltmp1, Mpy_32_16(hi, lo, 32112));

      Ltmp = Ltmp - ShiftL_32s(lp_amp,1);

      if (Ltmp <= 0) {
         Ltmp = 0;
      } else {
         lp_amp = Add_32s(lp_amp, (Ltmp>>1));
         if (exc_hf[i] >= 0) {
            exc_hf[i]= Sub_16s(exc_hf[i], Mul2_16s(Cnvrt_NR_32s16s(Ltmp)));
         } else {
            exc_hf[i] = Add_16s(exc_hf[i], Mul2_16s(Cnvrt_NR_32s16s(Ltmp)));
         }
      }
   }
   *mem = lp_amp;
}

void ownSmoothEnergyHF(Ipp16s *HF, Ipp32s *threshold)
{
   Ipp32s Ltmp, Lener;
   Ipp16s i, HF_tmp[SUBFRAME_SIZE], hi, lo;
   Ipp16s exp_ener, exp_tmp, frac_ener, frac_tmp;

   ippsCopy_16s(HF, HF_tmp, SUBFRAME_SIZE);
   ownScaleSignal_AMRWB_16s_ISfs(HF_tmp, SUBFRAME_SIZE, -2); /* <14 bits -> <12 bits */

   Lener = 1;
   for (i=0; i<SUBFRAME_SIZE; i++) {
      Ltmp = Mul2_32s(HF_tmp[i] * HF_tmp[i]);
      Lener = Add_32s(Lener, Ltmp);
   }

   Ltmp = Lener;

   if (Ltmp < (*threshold)) { /* add 1.5 dB and saturate to threshold */
      Unpack_32s(Ltmp, &hi, &lo);
      Ltmp = ShiftL_32s(Mpy_32_16(hi, lo, 23169),1);
      if (Ltmp > (*threshold) ) {
         Ltmp = *threshold;
      }
   } else { /* substract 1.5 dB and saturate to threshold */
      Unpack_32s(Ltmp, &hi, &lo);
      Ltmp = Mpy_32_16(hi, lo, 23174);
      if (Ltmp < (*threshold)) {
         Ltmp = *threshold;
      }
   }
   /* set the threshold for next subframer to the current modified energy */
   *threshold = Ltmp;

   if(Ltmp == 0) {
      Ltmp = 1;
   }

   /* apply correction scale factor to HF signal */
   exp_ener = Norm_32s_I(&Lener);
   frac_ener = (Ipp16s)(Lener >> 16);

   exp_tmp = Norm_32s_I(&Ltmp);
   frac_tmp = (Ipp16s)(Ltmp >> 16);

   if(frac_ener > frac_tmp) {
      frac_ener =  (Ipp16s)(frac_ener >> 1);
      exp_ener = (Ipp16s)(exp_ener - 1);
   }

   if (frac_ener == frac_tmp) {
      frac_tmp = IPP_MAX_16S;
   } else {
      frac_tmp = (Ipp16s)((frac_ener << 15) / frac_tmp);
   }
   exp_tmp = (Ipp16s)(exp_ener - exp_tmp);

   exp_ener = (Ipp16s)(exp_tmp - 1);
   Ltmp = ((Ipp32s)frac_tmp)<<16;
   ownInvSqrt_AMRWB_32s16s_I(&Ltmp, &exp_tmp);

   frac_tmp = Cnvrt_NR_32s16s(Ltmp);
   exp_tmp = (Ipp16s)(1 + exp_tmp + exp_ener);

   if (exp_tmp <= 0) {
      for (i=0; i<SUBFRAME_SIZE; i++) {
         Ltmp  = Mul2_32s(HF[i] * frac_tmp);
         HF[i] = Cnvrt_NR_32s16s(Ltmp >> (-exp_tmp));
      }
   } else {
      for (i=0; i<SUBFRAME_SIZE; i++) {
         Ltmp  = Mul2_32s(HF[i] * frac_tmp);
         HF[i] = Cnvrt_NR_32s16s(ShiftL_32s(Ltmp, exp_tmp));
      }
   }
}