encamrwb.c

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

        if (valPitchLag < SUBFRAME_SIZE) {
            ippsHarmonicFilter_NR_16s(PITCH_SHARP_FACTOR, valPitchLag, &pFixCdbkvec[valPitchLag], &pFixCdbkvec[valPitchLag], SUBFRAME_SIZE-valPitchLag);
        }

        ippsGainQuant_AMRWB_16s(pAdptTgtPitch, pFltAdptvec, (valQNew + valShift), pFixCdbkvec, pFltAdpt2vec, pGainCoeff,
                  st->asiGainQuant, &valPitchGain, &valCodeGain, valClipFlag, (short*)pPrm, SUBFRAME_SIZE, irate);
        pPrm += 1;

        /* test quantized gain of pitch for pitch clipping algorithm */
        ownCheckGpClipPitchGain(valPitchGain, st->asiGainPitchClip);

        z = ShiftL_32s(valCodeGain, valQNew);
        valScaleCodeGain = Cnvrt_NR_32s16s(z);

        /* find voice factor (1=voiced, -1=unvoiced) */

        ippsCopy_16s(&pExc[valSubFrame], pExc2vec, SUBFRAME_SIZE);
        ownScaleSignal_AMRWB_16s_ISfs(pExc2vec, SUBFRAME_SIZE, valShift);

        valVoiceFac = ownVoiceFactor(pExc2vec, valShift, valPitchGain, pFixCdbkvec, valScaleCodeGain, SUBFRAME_SIZE);

        /* tilt of code for next subframe: 0.5=voiced, 0=unvoiced */

        st->siTiltCode = (valVoiceFac >> 2) + 8192;

        z = valScaleCodeGain * pFltAdpt2vec[SUBFRAME_SIZE - 1];
        z <<= (5 + valShift);
        z = Negate_32s(z);
        z += pAdptTgtPitch[SUBFRAME_SIZE - 1] * 16384;
        z -= pFltAdptvec[SUBFRAME_SIZE - 1] * valPitchGain;
        z <<= (2 - valShift);
        st->siSpeechWgt = Cnvrt_NR_32s16s(z);

        if (irate == IPP_SPCHBR_23850)
            ippsCopy_16s(&pExc[valSubFrame], pExc2vec, SUBFRAME_SIZE);

        ippsInterpolateC_NR_16s(pFixCdbkvec, valScaleCodeGain, 7,
            &pExc[valSubFrame], valPitchGain, 2, &pExc[valSubFrame], SUBFRAME_SIZE);

        {
           short tmp;
           tmp = pLPCQuant[0];
           pLPCQuant[0] >>= 1;
           ippsSynthesisFilter_G729E_16s(pLPCQuant, LP_ORDER,  &pExc[valSubFrame], pSynthvec, SUBFRAME_SIZE, st->asiSynthesis);
           ippsCopy_16s(&pSynthvec[SUBFRAME_SIZE-LP_ORDER],st->asiSynthesis,LP_ORDER);
           pLPCQuant[0] = tmp;
        }

        if (irate == IPP_SPCHBR_23850)
        {
            L_Extract(valCodeGain, &valScaleCodeGain, &valCodeGainLow);

            /* noise enhancer */
            tmp = 16384 - (valVoiceFac >> 1);        /* 1=unvoiced, 0=voiced */
            valFac = Mul_16s_Sfs(valStabFac, tmp, 15);

            z = valCodeGain;

            if (z < st->iNoiseEnhancerThres)
            {
                z += Mpy_32_16(valScaleCodeGain, valCodeGainLow, 6226);
                if (z > st->iNoiseEnhancerThres) z = st->iNoiseEnhancerThres;
            } else
            {
                z = Mpy_32_16(valScaleCodeGain, valCodeGainLow, 27536);
                if (z < st->iNoiseEnhancerThres) z = st->iNoiseEnhancerThres;
            }
            st->iNoiseEnhancerThres = z;

            valCodeGain = Mpy_32_16(valScaleCodeGain, valCodeGainLow, (short)(IPP_MAX_16S - valFac));
            L_Extract(z, &valScaleCodeGain, &valCodeGainLow);
            valCodeGain += Mpy_32_16(valScaleCodeGain, valCodeGainLow, valFac);

            /* pitch enhancer */
            tmp = (valVoiceFac >> 3) + 4096; /* 0.25=voiced, 0=unvoiced */

            pSrcCoeff[0] = 1;
            pSrcCoeff[1] = tmp;
            ippsHighPassFilter_Direct_AMRWB_16s(pSrcCoeff, pFixCdbkvec, pFixCdbkExcvec, SUBFRAME_SIZE, 0);

            /* build excitation */

            valScaleCodeGain = Cnvrt_NR_32s16s(valCodeGain << valQNew);
            ippsInterpolateC_NR_16s(pFixCdbkExcvec, valScaleCodeGain, 7,
                pExc2vec, valPitchGain, 2, pExc2vec,SUBFRAME_SIZE);
            valCorrGain = ownSynthesis(pLPCQuant, pExc2vec, valQNew, &src[valSubFrame * 5 / 4], st);
            *(pPrm)++ = valCorrGain;
        }
        pLPCUnQuant += (LP_ORDER + 1);
        pLPCQuant += (LP_ORDER + 1);
    }                                      /* end of subframe loop */

    ownPrms2Bits(pPrmvec,dst,*rate);

    ippsCopy_16s(&pSpeechOldvec[FRAME_SIZE], st->asiSpeechOld, SPEECH_SIZE - FRAME_SIZE);
    ippsCopy_16s(&pWgtSpchOldvec[FRAME_SIZE / OPL_DECIM], st->asiWspOld, PITCH_LAG_MAX / OPL_DECIM);
    ippsCopy_16s(&pExcOldvec[FRAME_SIZE], st->asiExcOld, PITCH_LAG_MAX + INTERPOL_LEN);

    return APIAMRWB_StsNoErr;
}

/* Synthesis of signal at 16kHz with pHighFreqvec extension */
static short ownSynthesis(short *pLPCQuantvec, short *pExc, short valQNew,
                          const unsigned short *pSynthSignal, AMRWBEncoder_Obj *st)
{
    short valFac, tmp, valExp;
    short valEner, valExpEner;
    int i, z, sfs;

    IPP_ALIGNED_ARRAY( 16, int, pSynthHighvec, LP_ORDER + SUBFRAME_SIZE);
    IPP_ALIGNED_ARRAY( 16, short, pSynthvec, SUBFRAME_SIZE);
    IPP_ALIGNED_ARRAY( 16, short, pHighFreqvec, SUBFRAME_SIZE_16k);
    IPP_ALIGNED_ARRAY( 16, short, pLPCvec, LP_ORDER + 1);
    IPP_ALIGNED_ARRAY( 16, short, pHighFreqSpchvec, SUBFRAME_SIZE_16k);

    short valHPEstGain, valHPCalcGain, valHPCorrGain;
    short valDistMin, valDist;
    short valHPGainIndex = 0;
    short valGainCoeff, valAdptGain;
    short valWeight, valWeight2;

    /* speech synthesis */
    ippsCopy_16s((short*)st->aiSynthMem, (short*)pSynthHighvec, LP_ORDER*2);
    tmp = pLPCQuantvec[0];
    sfs = Exp_16s(tmp) - 2;
    pLPCQuantvec[0] >>= (4 + valQNew);
    if (sfs)
        ownSynthesisFilter_AMRWB_16s32s_ISfs(pLPCQuantvec, LP_ORDER, pExc, pSynthHighvec + LP_ORDER, SUBFRAME_SIZE, sfs + 3);
    else
        ippsSynthesisFilter_AMRWB_16s32s_I(pLPCQuantvec, LP_ORDER, pExc, pSynthHighvec + LP_ORDER, SUBFRAME_SIZE);
    pLPCQuantvec[0] = tmp;

    ippsCopy_16s((short*)(&pSynthHighvec[SUBFRAME_SIZE]), (short*)st->aiSynthMem, LP_ORDER*2);
    ippsDeemphasize_AMRWB_32s16s(PREEMPH_FACTOR>>1, pSynthHighvec + LP_ORDER, pSynthvec, SUBFRAME_SIZE, &(st->siDeemph));
    ippsHighPassFilter_AMRWB_16s_ISfs(pSynthvec, SUBFRAME_SIZE, st->pSHPFiltStateSgnlOut, 14);

    /* Original speech signal as reference for high band gain quantisation */
    ippsCopy_16s((short*)pSynthSignal,pHighFreqSpchvec,SUBFRAME_SIZE_16k);

    /* pHighFreqvec noise synthesis */

    for (i = 0; i < SUBFRAME_SIZE_16k; i++)
        pHighFreqvec[i] = (Random(&(st->siHFSeed)) >> 3);

    /* energy of excitation */

    ownScaleSignal_AMRWB_16s_ISfs(pExc, SUBFRAME_SIZE, -3);
    valQNew -= 3;

    ippsDotProd_16s32s_Sfs( pExc, pExc,SUBFRAME_SIZE, &z, -1);
    z = Add_32s(z, 1);

    valExpEner = (30 - Norm_32s_I(&z));
    valEner = z >> 16;

    valExpEner -= (valQNew + valQNew);

    /* set energy of white noise to energy of excitation */

    ippsDotProd_16s32s_Sfs( pHighFreqvec, pHighFreqvec,SUBFRAME_SIZE_16k, &z, -1);
    z = Add_32s(z, 1);

    valExp = (30 - Norm_32s_I(&z));
    tmp = z >> 16;

    if (tmp > valEner)
    {
        tmp >>= 1;
        valExp += 1;
    }
    if (tmp == valEner)
        z = (int)IPP_MAX_16S << 16;
    else
        z = (int)(((int)tmp << 15) / (int)valEner) << 16;
    valExp -= valExpEner ;
    ownInvSqrt_AMRWB_32s16s_I(&z, &valExp);
    if ((valExp+1) >= 0)
        z = ShiftL_32s(z, (short)(valExp + 1));
    else
        z >>= (-(valExp + 1));
    tmp = (short)(z >> 16);

    ownMulC_16s_ISfs(tmp, pHighFreqvec, 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, &z, -1);
    z = Add_32s(z, 1);

    valExp = Norm_32s_I(&z);
    valEner = z>>16;

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

    tmp = ShiftL_32s(z, valExp) >> 16;
    if (tmp > 0)
    {
        if (tmp == valEner)
            valFac = IPP_MAX_16S;
        else
            valFac = (short)(((int)tmp << 15) / (int)valEner);
    } else
        valFac = 0;

    /* modify energy of white noise according to synthesis tilt */
    valGainCoeff = IPP_MAX_16S - valFac;
    valAdptGain = Cnvrt_32s16s((valGainCoeff * 5) >> 2);

    if (st->siVadHist > 0)
    {
        valWeight = 0;
        valWeight2 = IPP_MAX_16S;
    } else
    {
        valWeight = IPP_MAX_16S;
        valWeight2 = 0;
    }
    tmp = Mul_16s_Sfs(valWeight, valGainCoeff, 15);
    tmp += Mul_16s_Sfs(valWeight2, valAdptGain, 15);

    if (tmp != 0) tmp += 1;
    valHPEstGain = tmp;

    if (valHPEstGain < 3277) valHPEstGain = 3277;

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

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

    /* filtering of the original signal */
    HighPassFIR_AMRWB_16s_ISfs(pHighFreqSpchvec, SUBFRAME_SIZE_16k, st->pSHPFIRState2);

    /* check the gain difference */
    ownScaleSignal_AMRWB_16s_ISfs(pHighFreqSpchvec, SUBFRAME_SIZE_16k, -1);

    ippsDotProd_16s32s_Sfs( pHighFreqSpchvec, pHighFreqSpchvec,SUBFRAME_SIZE_16k, &z, -1);
    z = Add_32s(z, 1);

    valExpEner = (30 - Norm_32s_I(&z));
    valEner = z >> 16;

    /* set energy of white noise to energy of excitation */
    ippsDotProd_16s32s_Sfs( pHighFreqvec, pHighFreqvec,SUBFRAME_SIZE_16k, &z, -1);
    z = Add_32s(z, 1);

    valExp = (30 - Norm_32s_I(&z));
    tmp = z >> 16;

    if (tmp > valEner)
    {
        tmp >>= 1;
        valExp += 1;
    }
    if (tmp == valEner)
        z = (int)IPP_MAX_16S << 16;
    else
        z = (int)(((int)tmp << 15) / (int)valEner) << 16;
    valExp -= valExpEner;
    ownInvSqrt_AMRWB_32s16s_I(&z, &valExp);
    if (valExp > 0)
        z = ShiftL_32s(z, valExp);
    else
        z >>= (-valExp);
    valHPCalcGain = (short)(z >> 16);

    z = st->dtxEncState.siHangoverCount * 4681;
    st->siAlphaGain = Mul_16s_Sfs(st->siAlphaGain, (short)z, 15);

    if (st->dtxEncState.siHangoverCount > 6)
        st->siAlphaGain = IPP_MAX_16S;
    valHPEstGain >>= 1;
    valHPCorrGain  = Mul_16s_Sfs(valHPCalcGain, st->siAlphaGain, 15);
    valHPCorrGain += Mul_16s_Sfs((short)(IPP_MAX_16S - st->siAlphaGain), valHPEstGain, 15);

    /* Quantise the correction gain */
    valDistMin = IPP_MAX_16S;
    for (i = 0; i < 16; i++)
    {
        valDist = Mul_16s_Sfs((short)(valHPCorrGain - HPGainTbl[i]), (short)(valHPCorrGain - HPGainTbl[i]), 15);
        if (valDistMin > valDist)
        {
            valDistMin = valDist;
            valHPGainIndex = i;
        }
    }

    valHPCorrGain = HPGainTbl[valHPGainIndex];

    /* return the quantised gain index when using the highest mode, otherwise zero */
    return (valHPGainIndex);
}
static char* ownPar2Ser( int valPrm, char *pBitStreamvec, int valNumBits )
{
    int i;
    short tmp;
    char *TempPnt = pBitStreamvec + valNumBits -1;

    for ( i = 0 ; i < valNumBits ; i ++ ) {
        tmp = (short) (valPrm & 0x1);
        valPrm >>= 1;
        *TempPnt-- = (char)tmp;
    }

    return (pBitStreamvec + valNumBits);
}

static void ownPrms2Bits(const short* pPrms, unsigned char *pBitstream, AMRWB_Rate_t rate)
{
    char *pBsp;
    int i, tmp, valSht, valBitCnt = 0;
    IPP_ALIGNED_ARRAY(16, char, pBitStreamvec, NB_BITS_MAX);
    unsigned char *pBits = (unsigned char*)pBitstream;

    pBsp = pBitStreamvec ;

    for( i = 0; i < NumberPrmsTbl[rate]; i++) {
       valBitCnt += pNumberBitsTbl[rate][i];
       tmp = pPrms[i];
       pBsp = ownPar2Ser( tmp, pBsp, pNumberBitsTbl[rate][i] );
    }

    /* Clear the output vector */
    ippsZero_8u((Ipp8u*)pBitstream, (valBitCnt+7)/8);
    valSht  = (valBitCnt + 7) / 8 * 8 - valBitCnt;

    for ( i = 0 ; i < valBitCnt; i ++ ) {
        pBits[i/8] <<= 1;
        if (pBitStreamvec[i]) pBits[i/8]++;
    }
    pBits[(valBitCnt-1)/8] <<= valSht;

    return;
}