decamrwb.c

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

    ippsDotProd_16s32s_Sfs( pHFvec, pHFvec,SUBFRAME_SIZE_16k, &tmpSum, -1);
    tmpSum = Add_32s(tmpSum, 1);

    exp = (Ipp16s)(30 - Norm_32s_I(&tmpSum));
    tmp = (Ipp16s)(tmpSum >> 16);

    if (tmp > ener)
    {
        tmp >>= 1;
        exp += 1;
    }
    if (tmp == ener)
        s = (Ipp32s)IPP_MAX_16S << 16;
    else
        s = (Ipp32s)(((Ipp32s)tmp << 15) / (Ipp32s)ener) << 16;
    exp = (Ipp16s)(exp - exp_ener);
    ownInvSqrt_AMRWB_32s16s_I(&s, &exp);
    if ((exp+1) > 0)
        s = ShiftL_32s(s, (Ipp16s)(exp + 1));
    else
        s >>= (-(exp + 1));
    tmp = (Ipp16s)(s >> 16);
    ownMulC_16s_ISfs(tmp, pHFvec, SUBFRAME_SIZE_16k, 15);

    /* find tilt of synthesis speech (tilt: 1=voiced, -1=unvoiced) */
    ippsHighPassFilter_AMRWB_16s_ISfs(pSynthvec, SUBFRAME_SIZE, st->pSHPFiltStateSgnl400, 15);
    ippsDotProd_16s32s_Sfs( pSynthvec, pSynthvec,SUBFRAME_SIZE, &s, -1);
    s = Add_32s(s, 1);

    exp = Norm_32s_I(&s);
    ener = (Ipp16s)(s >> 16);

    ippsDotProd_16s32s_Sfs( pSynthvec, &pSynthvec[1],SUBFRAME_SIZE-1, &s, -1);
    s = Add_32s(s, 1);

    tmp = (Ipp16s)(ShiftL_32s(s, exp)>>16);

    if (tmp > 0)
    {
        if (tmp == ener)
            valFac = IPP_MAX_16S;
        else
            valFac = (Ipp16s)((tmp << 15) / ener);
    } else
        valFac = 0;

    /* modify energy of white noise according to synthesis tilt */
    gain1 = (Ipp16s)(IPP_MAX_16S - valFac);
    gain2 = (Ipp16s)((gain1 * 5) >> 3);
    gain2 = Cnvrt_32s16s(gain2 << 1);

    if (st->siVadHist > 0)
    {
        weight1 = 0;
        weight2 = IPP_MAX_16S;
    } else
    {
        weight1 = IPP_MAX_16S;
        weight2 = 0;
    }
    tmp = Mul_16s_Sfs(weight1, gain1, 15);
    tmp = (Ipp16s)(tmp + Mul_16s_Sfs(weight2, gain2, 15));

    if (tmp) tmp += 1;
    if (tmp < 3277) tmp = 3277;

    if ((mode == IPP_SPCHBR_23850) && (bfi == 0))
    {
        /* HF correction gain */
        valHFGainIndex = pPrmvec;
        valHFCorrGain = HPGainTbl[valHFGainIndex];

        /* HF gain */
        for (i = 0; i < SUBFRAME_SIZE_16k; i++)
            pHFvec[i] = (Ipp16s)(Mul_16s_Sfs(pHFvec[i], valHFCorrGain, 15) << 1);
    } else
        ownMulC_16s_ISfs(tmp, pHFvec, SUBFRAME_SIZE_16k, 15);

    if (((mode == IPP_SPCHBR_6600)||(mode == IPP_SPCHBR_DTX)) && (valDTXState == SPEECH))
    {
        ownIsfExtrapolation(pHfIsfvec);
        ippsISPToLPC_AMRWB_16s(pHfIsfvec, pHFLCPvec, LP_ORDER_16K);

        ippsMulPowerC_NR_16s_Sfs(pHFLCPvec, 29491, pLPCtmp, LP_ORDER_16K+1, 15); /* valFac=0.9 */
        {
            tmp = pLPCtmp[0];
            pLPCtmp[0] >>= 1;
            ippsSynthesisFilter_G729E_16s_I(pLPCtmp, LP_ORDER_16K, pHFvec, SUBFRAME_SIZE_16k, st->asiSynthHighFilt);
            ippsCopy_16s(&pHFvec[SUBFRAME_SIZE_16k-LP_ORDER_16K],st->asiSynthHighFilt,LP_ORDER_16K);
            pLPCtmp[0] = tmp;
        }
    } else
    {
        /* synthesis of noise: 4.8kHz..5.6kHz --> 6kHz..7kHz */
        ippsMulPowerC_NR_16s_Sfs(pLPCvec, 19661, pLPCtmp, LP_ORDER+1, 15); /* valFac=0.6 */
        {
            tmp = pLPCtmp[0];
            pLPCtmp[0] >>= 1;
            ippsSynthesisFilter_G729E_16s_I(pLPCtmp, LP_ORDER, pHFvec, SUBFRAME_SIZE_16k, st->asiSynthHighFilt + (LP_ORDER_16K - LP_ORDER));
            ippsCopy_16s(&pHFvec[SUBFRAME_SIZE_16k-LP_ORDER],st->asiSynthHighFilt + (LP_ORDER_16K - LP_ORDER),LP_ORDER);
            pLPCtmp[0] = tmp;
        }
    }

    /* noise High Pass filtering (1ms of delay) */
    HighPassFIR_AMRWB_16s_ISfs(pHFvec, SUBFRAME_SIZE_16k, st->pSHighPassFIRState);

    if (mode == IPP_SPCHBR_23850)
    {
        /* Low Pass filtering (7 kHz) */
       HighPassFIR_AMRWB_16s_ISfs(pHFvec, SUBFRAME_SIZE_16k, st->pSHighPassFIRState2);
    }
    /* add filtered pHFvec noise to speech synthesis */
    ippsAdd_16s_I(pHFvec, (Ipp16s*)pSynSignal, SUBFRAME_SIZE_16k);

    return;
}
static void ownBits2Prms(const Ipp8u *pBitstream, Ipp16s *pPrms , AMRWB_Rate_t rate)
{
    Ipp32s i;
    Ipp32s nBit = 0;

    for( i = 0; i < NumberPrmsTbl[rate]; i++) {
       pPrms[i] = amrExtractBits( (const Ipp8s **)&pBitstream, &nBit, pNumberBitsTbl[rate][i] );
    }
}

static void ownSynthesisDec_WBE(Ipp16s *pLPCvec, Ipp16s *pExcvec, Ipp16s valQNew,
   Ipp16u *pSynSignal, Ipp16s pPrmvec, Ipp16s *pHfIsfvec, IppSpchBitRate mode,
   Ipp16s valDTXState, AMRWBDecoder_Obj* st, Ipp16s bfi)
{
   IPP_ALIGNED_ARRAY(16, Ipp32s, synHiLo, (LP_ORDER + SUBFRAME_SIZE));
   IPP_ALIGNED_ARRAY(16, Ipp16s, synth, (SUBFRAME_SIZE));
   IPP_ALIGNED_ARRAY(16, Ipp16s, synth_buff, (PITCH_LAG_MAX+2*SUBFRAME_SIZE));
   IPP_ALIGNED_ARRAY(16, Ipp16s, HF, (SUBFRAME_SIZE_16k)); /* High Frequency vector */
   IPP_ALIGNED_ARRAY(16, Ipp16s, Ap, (LP_ORDER_16K+1));
   IPP_ALIGNED_ARRAY(16, Ipp16s, HfA, (LP_ORDER_16K+1));
   IPP_ALIGNED_ARRAY(16, Ipp16s, exc_p, (SUBFRAME_SIZE));
   IPP_ALIGNED_ARRAY(16, Ipp16s, synth_p, (SUBFRAME_SIZE));

   Ipp16s *synth_new, *synth_out;

   Ipp16s HF_corr_gain;
   Ipp16s HF_gain_ind;
   Ipp16s gain1, gain2;
   Ipp16s weight1, weight2;
   Ipp16s gain_hf_p;

   Ipp16s fac, wTmp, exp;
   Ipp16s ener, exp_ener;
   Ipp32s i, dwTmp;

   synth_new = synth_buff + PITCH_LAG_MAX + SUBFRAME_SIZE;
   synth_out = synth_buff + PITCH_LAG_MAX - UP_SAMPL_FILT_DELAY;
   ippsCopy_16s(st->mem_syn_out, synth_buff, (PITCH_LAG_MAX + SUBFRAME_SIZE));


   ippsCopy_32s(st->asiSynthesis, synHiLo, LP_ORDER);
   wTmp = pLPCvec[0];
   pLPCvec[0] = (Ipp16s)(pLPCvec[0] >> (4 + valQNew));
   ippsSynthesisFilter_AMRWBE_16s32s_I(pLPCvec, LP_ORDER, pExcvec, synHiLo+LP_ORDER, SUBFRAME_SIZE);
   pLPCvec[0] = wTmp;
   ippsCopy_32s(synHiLo+SUBFRAME_SIZE, st->asiSynthesis, LP_ORDER);

   ippsDeemphasize_AMRWB_32s16s(PREEMPH_FACTOR>>1, synHiLo+LP_ORDER, synth_new, SUBFRAME_SIZE, &(st->siDeemph));

   ippsHighPassFilter_AMRWB_16s_ISfs(synth_out, SUBFRAME_SIZE, st->pSHPFiltStateSgnlOut, 14);
   //ippsHighPassFilter_AMRWB_16s_ISfs(synth_new, SUBFRAME_SIZE, st->memSigOut, 14);

   ownOversampling_AMRWB_16s(synth_out, SUBFRAME_SIZE, pSynSignal, st->asiOversampFilt);
   //ownOversamp_16k(synth_new, SUBFRAME_SIZE, pSynSignal, st->mem_oversamp);

   if (st->ramp_state > 0) {
      st->ramp_state  = (Ipp16s)(st->ramp_state - 1);

      gain_hf_p = Cnvrt_NR_32s16s((st->gain_hf_plus * tblGainRampHF[st->ramp_state])<<1);

      for (i = 0; i < SUBFRAME_SIZE; i++) {
         exc_p[i] = Cnvrt_NR_32s16s(ShiftL_32s(gain_hf_p*pExcvec[i], 5));
      }

      ownSoftExcitationHF(exc_p, &(st->lp_amp_hf));

      wTmp = st->lpc_hf_plus[0];
      if (valQNew >= 0)
         st->lpc_hf_plus[0] = (Ipp16s)( st->lpc_hf_plus[0] >> valQNew );
      else
         st->lpc_hf_plus[0] = (Ipp16s)( st->lpc_hf_plus[0] << (-valQNew) );
      ippsSynthesisFilter_G729E_16s(st->lpc_hf_plus, 8, exc_p, synth_p, SUBFRAME_SIZE, st->mem_syn_hf_plus);
      ippsCopy_16s(&synth_p[SUBFRAME_SIZE-8], st->mem_syn_hf_plus, 8);
      st->lpc_hf_plus[0] = wTmp;

      ownSmoothEnergyHF(synth_p, &(st->threshold_hf));

      ippsUpsample_AMRWBE_16s(synth_p, HF, SUBFRAME_SIZE_16k, st->mem_oversamp_hf_plus, 1, 0);
   } else {
      ippsCopy_16s(synth_out, synth, SUBFRAME_SIZE);
      //ippsCopy_16s(synth_new, synth, SUBFRAME_SIZE);

      /* generate white noise vector */
      for (i=0; i<SUBFRAME_SIZE_16k; i++)
         HF[i] = (Ipp16s)(Rand_16s(&(st->siHFSeed)) >> 3);

      /* energy of excitation */
      ownScaleSignal_AMRWB_16s_ISfs(pExcvec, SUBFRAME_SIZE, -3);
      valQNew = (Ipp16s)(valQNew - 3);

      ippsDotProd_16s32s_Sfs(pExcvec, pExcvec, SUBFRAME_SIZE, &dwTmp, -1);
      dwTmp = Add_32s(dwTmp, 1);
      exp_ener = (Ipp16s)(30 - Norm_32s_I(&dwTmp));
      ener = (Ipp16s)(dwTmp >> 16);
      exp_ener = (Ipp16s)(exp_ener - (valQNew + valQNew) );

      /* set energy of white noise to energy of excitation */
      ippsDotProd_16s32s_Sfs(HF, HF, SUBFRAME_SIZE_16k, &dwTmp, -1);
      dwTmp = Add_32s(dwTmp, 1);
      exp = (Ipp16s)(30 - Norm_32s_I(&dwTmp));
      wTmp = (Ipp16s)(dwTmp>>16);

      if (wTmp > ener) {
         wTmp = (Ipp16s)(wTmp >> 1);
         exp = (Ipp16s)(exp + 1);
      }
      if (wTmp == ener) {
         dwTmp = (Ipp32s)IPP_MAX_16S << 16;
      } else {
         dwTmp = (Ipp32s)(((Ipp32s)wTmp << 15) / (Ipp32s)ener) << 16;
      }

      exp = (Ipp16s)(exp - exp_ener);
      ownInvSqrt_AMRWB_32s16s_I(&dwTmp, &exp);
      if ((exp+1)>0) {
         dwTmp = ShiftL_32s(dwTmp, (Ipp16u)(exp+1));
      } else {
         dwTmp = dwTmp >> (-(exp+1));
      }
      wTmp = (Ipp16s)(dwTmp>>16);

      for (i = 0; i < SUBFRAME_SIZE_16k; i++)
         HF[i] = (Ipp16s)((HF[i] * wTmp) >> 15);

      /* find tilt of synthesis speech (tilt: 1=voiced, -1=unvoiced) */
      ippsHighPassFilter_AMRWB_16s_ISfs(synth, SUBFRAME_SIZE, st->pSHPFiltStateSgnl400, 15);

      ippsDotProd_16s32s_Sfs(synth, synth, SUBFRAME_SIZE, &dwTmp, -1);
      dwTmp = Add_32s(dwTmp, 1);
      exp = Norm_32s_I(&dwTmp);
      ener = (Ipp16s)(dwTmp >> 16);

      ippsDotProd_16s32s_Sfs(synth, &synth[1], SUBFRAME_SIZE-1, &dwTmp, -1);
      dwTmp = Add_32s(dwTmp, 1);
      wTmp = (Ipp16s)( ShiftL_32s(dwTmp, exp)>>16 );
      if (wTmp > 0) {
         if (wTmp == ener)
            fac = IPP_MAX_16S;
         else
            fac = (Ipp16s)((wTmp << 15) / ener);
      } else {
         fac = 0;
      }

      /* modify energy of white noise according to synthesis tilt */
      gain1 = (Ipp16s)(32767 - fac);
      gain2 = (Ipp16s)((gain1 * 5) >> 3);
      gain2 = Cnvrt_32s16s(gain2 << 1);

      if (st->siVadHist > 0) {
         weight1 = 0;
         weight2 = IPP_MAX_16S;
      } else {
         weight1 = IPP_MAX_16S;
         weight2 = 0;
      }
      wTmp = (Ipp16s)((weight1 * gain1) >> 15);
      wTmp = (Ipp16s)(wTmp + ((weight2 * gain2) >> 15));

      if (wTmp != 0)
         wTmp = (Ipp16s)(wTmp + 1);
      if (wTmp < 3277)
         wTmp = 3277; /* 0.1 in Q15 */

      if ((mode == IPP_SPCHBR_23850) && (bfi == 0)) {
         /* HF correction gain */
         HF_gain_ind = pPrmvec;
         HF_corr_gain = HPGainTbl[HF_gain_ind];

         /* HF gain */
         for (i=0; i<SUBFRAME_SIZE_16k; i++)
            HF[i] = (Ipp16s)(((HF[i] * HF_corr_gain) >> 14 ) & 0xFFFE);
      } else {
         for (i=0; i<SUBFRAME_SIZE_16k; i++)
            HF[i] = (Ipp16s)((HF[i] * wTmp) >> 15);
      }

      if (((mode == IPP_SPCHBR_6600)||(mode == IPP_SPCHBR_DTX)) && (valDTXState == SPEECH)) {
         ownIsfExtrapolation(pHfIsfvec);
         ippsISPToLPC_AMRWB_16s(pHfIsfvec, HfA, LP_ORDER_16K);

         ippsMulPowerC_NR_16s_Sfs(HfA, 29491, Ap, LP_ORDER_16K+1, 15);
         wTmp = Ap[0];
         Ap[0] = (Ipp16s)(Ap[0] >> 1);
         ippsSynthesisFilter_G729E_16s_I(Ap, LP_ORDER_16K, HF, SUBFRAME_SIZE_16k, st->asiSynthHighFilt);
         ippsCopy_16s(&HF[SUBFRAME_SIZE_16k-LP_ORDER_16K], st->asiSynthHighFilt, LP_ORDER_16K);
         Ap[0] = wTmp;
      } else {
         /* synthesis of noise: 4.8kHz..5.6kHz --> 6kHz..7kHz */
         ippsMulPowerC_NR_16s_Sfs(pLPCvec, 19661, Ap, (LP_ORDER+1), 15);
         wTmp = Ap[0];
         Ap[0] = (Ipp16s)( Ap[0] >> 1);
         ippsSynthesisFilter_G729E_16s_I(Ap, LP_ORDER, HF, SUBFRAME_SIZE_16k, st->asiSynthHighFilt+(LP_ORDER_16K-LP_ORDER));
         ippsCopy_16s(&HF[SUBFRAME_SIZE_16k-LP_ORDER], st->asiSynthHighFilt+(LP_ORDER_16K-LP_ORDER), LP_ORDER);
         Ap[0] = wTmp;
      }

      /* noise High Pass filtering (1ms of delay) */
      HighPassFIR_AMRWB_16s_ISfs(HF, SUBFRAME_SIZE_16k, st->pSHighPassFIRState);

      if (mode == IPP_SPCHBR_23850) /* Low Pass filtering (7 kHz) {nb_bits >= NUMBITS23850} */
         HighPassFIR_AMRWB_16s_ISfs(HF, SUBFRAME_SIZE_16k, st->pSHighPassFIRState2);
   }

   /* add filtered HF noise to speech synthesis */
   ippsAdd_16s_I(HF, (Ipp16s*)pSynSignal, SUBFRAME_SIZE_16k);

   ippsCopy_16s(synth_buff+SUBFRAME_SIZE, st->mem_syn_out, (PITCH_LAG_MAX + SUBFRAME_SIZE));
}