owng729.c

G.729 and G.723.1 codecs x86 (and x86_64) Linux and FreeBSD source code for Asterisk open source PBX

    order -= 15;
    ippsMulC_NR_16s_Sfs(pSrc,tmp1,pDst,len,15);
    if(order<0) {
        ippsLShiftC_16s_I(-order,pDst,len);
    } else if(order>0) {
        Ipp16s const1=(Ipp16s)(1<<(order-1));
        ippsAddC_16s_I(const1,pDst,len);
        /* ippsRShiftC_NR_16s_I() */
        ippsRShiftC_16s_I(order,pDst,len);
    }
}

Ipp32s ComfortNoiseExcitation_G729B_16s_I(const Ipp16s *pSrc, const Ipp16s *pPos,
                                       const Ipp16s *pSign, Ipp16s val, Ipp16s val1,
                                       Ipp16s *pSrcDst, Ipp16s *pSrcDst1, Ipp16s *shiftDst){
    Ipp16s i, j, tmp1, tmp2, max, high, low, tmp3;
    Ipp16s x1, x2, x3 = (Ipp16s)(val1<<1);
    Ipp16s sVal0, sVal1, sVal2, sVal3;
    Ipp32s   L_tmp, L_tmp1, L_tmp2, order, deltaSign = 1;

    ippsMulC_NR_16s_ISfs(x3,pSrcDst,LP_SUBFRAME_DIM,15);
    ippsAdd_16s_ISfs(pSrc,pSrcDst,LP_SUBFRAME_DIM,0);
    ippsMax_16s(pSrcDst,LP_SUBFRAME_DIM,&tmp1);
    ippsMin_16s(pSrcDst,LP_SUBFRAME_DIM,&tmp2);
    if(tmp2==IPP_MIN_16S)
        tmp2++;
    if(tmp2<0)
        tmp2 = (Ipp16s)(-tmp2);
    max = (Ipp16s)(IPP_MAX(tmp1,tmp2));
    if(max == 0)
        order = 0;
    else {
        order = 3 - Exp_16s(max);
        if(order < 0)
            order = 0;
    }
    ippsRShiftC_16s(pSrcDst,order,shiftDst, LP_SUBFRAME_DIM);
    ippsDotProd_16s32s_Sfs(shiftDst,shiftDst, LP_SUBFRAME_DIM, &L_tmp1, 0);
    L_tmp1 <<= 1;

    tmp3 = 0;
    for(i=0; i<4; i++) {
        j = pPos[i];
        if(pSign[i] == 0) {
            tmp3 = (Ipp16s)(tmp3 - (pSrcDst[j] >> order));
        } else {
            tmp3 = (Ipp16s)(tmp3 + (pSrcDst[j] >> order));
        }
    }

    L_tmp   = val * LP_SUBFRAME_DIM;
    L_tmp >>= 5;
    L_tmp2  = val * L_tmp;
    tmp1    = (Ipp16s)(order<<1);
    L_tmp   = L_tmp2 >> tmp1;
    L_tmp  -= L_tmp1;
    tmp3  >>= 1;
    L_tmp  += (tmp3 * tmp3)<<1;
    order++;
    if(L_tmp < 0) {
        sVal0 = Abs_16s(pSrc[pPos[0]]); sVal1 = Abs_16s(pSrc[pPos[1]]);
        sVal2 = Abs_16s(pSrc[pPos[2]]); sVal3 = Abs_16s(pSrc[pPos[3]]);
        ippsCopy_16s(pSrc, pSrcDst, LP_SUBFRAME_DIM);
        tmp1 = (Ipp16s)(sVal0 | sVal1);
        tmp2 = (Ipp16s)(sVal2 | sVal3);
        tmp1 = (Ipp16s)(tmp1 | tmp2);
        order = ((tmp1 & BWF_HARMONIC) == 0) ? 1 : 2;

        for(tmp3=i=0; i<4; i++) {
            tmp1 = (Ipp16s)(pSrc[pPos[i]] >> order);
            if(pSign[i] == 0) {
                tmp3 = (Ipp16s)(tmp3 - tmp1);
            } else {
                tmp3 = (Ipp16s)(tmp3 + tmp1);
            }
        }
        high   = (Ipp16s)(L_tmp2>>15);
        low    = (Ipp16s)(L_tmp2 & IPP_MAX_16S);
        L_tmp  = high * 24576 + ((low*24576)>>15);
        tmp1   = (Ipp16s)(2 * order - 2);
        L_tmp  = L_tmp >> tmp1;
        L_tmp += 2 * tmp3 * tmp3;
        deltaSign = -1;
    }

    tmp2 = (Ipp16s)ownSqrt_32s(L_tmp>>1);
    x1   = (Ipp16s)(tmp2 - tmp3);
    x2   = (Ipp16s)(-(tmp3 + tmp2));
    sVal1 = Abs_16s(x1);
    sVal2 = Abs_16s(x2);
    if(sVal2 < sVal1)
        x1 = x2;
    tmp1 = (Ipp16s)(2 - order);
    if(tmp1>=0)
        pSrcDst1[0] = ShiftR_NR_16s(x1, tmp1);
    else
        pSrcDst1[0] = ShiftL_16s((Ipp16s)x1, (Ipp16u)(-tmp1));
    if(pSrcDst1[0] > 5000)
        pSrcDst1[0] = 5000;
    else
        if(pSrcDst1[0] < -5000)
            pSrcDst1[0] = -5000;

    for(i=0; i<4; i++) {
        j = pPos[i];
        if(pSign[i] != 0) {
            pSrcDst[j] = (Ipp16s)(pSrcDst[j] + pSrcDst1[0]);
        } else {
            pSrcDst[j] = (Ipp16s)(pSrcDst[j] - pSrcDst1[0]);
        }
    }
    return deltaSign;
}
void RandomCodebookParm_G729B_16s(Ipp16s *pSeed, Ipp16s *pPos, Ipp16s *pSign,
                                  Ipp16s *pGain, Ipp16s* delay){
    Ipp16s tmp1, tmp2;
    Ipp16s fractal;

    /* generate random adaptive codebook & fixed codebook parameters */
    tmp1 = Rand_16s(pSeed);
    fractal = (Ipp16s)((tmp1 & 3) - 1);
    if(fractal == 2)
        fractal = 0;

    tmp1   >>= 2;
    delay[0] = (Ipp16s)((tmp1 & 0x003f) + 40);

    tmp1  >>= 6;
    tmp2    = (Ipp16s)(tmp1 & 7);
    pPos[0] = (Ipp16s)(5 * tmp2);

    tmp1   >>= 3;
    pSign[0] = (Ipp16s)(tmp1 & 1);

    tmp1  >>= 1;
    tmp2    = (Ipp16s)(tmp1 & 7);
    pPos[1] = (Ipp16s)(5 * tmp2 + 1);

    tmp1   >>= 3;
    pSign[1] = (Ipp16s)(tmp1 & 1);
    tmp1     = Rand_16s(pSeed);
    tmp2     = (Ipp16s)(tmp1 & 7);
    pPos[2]  = (Ipp16s)(5 * tmp2 + 2);

    tmp1   >>= 3;
    pSign[2] = (Ipp16s)(tmp1 & 1);

    tmp1  >>= 1;
    tmp2    = (Ipp16s)(tmp1 & 0x000f);
    pPos[3] = (Ipp16s)((tmp2 & 1) + 3);
    tmp2    = (Ipp16s)((tmp2>>1) & 7);
    pPos[3] = (Ipp16s)(pPos[3] + 5 * tmp2);

    tmp1   >>= 4;
    pSign[3] = (Ipp16s)(tmp1 & 1);
    delay[1] = fractal;
    *pGain   = (Ipp16s)(Rand_16s(pSeed) & 0x1fff);
}

static Ipp16s ownQuantizeEnergy(Ipp32s val, Ipp16s order, Ipp16s *pDst) {
    Ipp16s exp, fractal, tmp, tmp1, index;
    Log2_G729(val, &exp, &fractal);
    tmp1 = (Ipp16s)(exp - order);
    tmp = (Ipp16s)(tmp1 << 10);
    tmp = (Ipp16s)(tmp + ((fractal + 0x10)>>5));
    if(tmp <= -2721) {/* 8 dB */
        pDst[0] = -12;
        return 0;
    }
    if(tmp > 22111) { /* 65 dB */
        pDst[0] = 66;
        return 31;
    }
    if(tmp <= 4762) { /* 14 dB */
        tmp += 3401;
        index = (Ipp16s)((tmp * 24)>>15);
        if(index < 1)
            index = 1;
        pDst[0] = (Ipp16s)((index<<2) - 8);
        return index;
    }
    tmp -= 340;
    index = (Ipp16s)(((tmp*193)>>17) - 1);
    if(index < 6)
        index = 6;
    pDst[0] = (Ipp16s)((index<<1) + 4);
    return(index);
}
/* ///////////////////////////////////////////////////////////////////////////////////////
//  Name:    QuantSIDGain_G729B_16s
//  Purpose:
//  Parameters:
//   pSrc      array of energies
//   pSrcSfs   corresponding scaling factors
//   len       number of energies
//   pDst      decoded energies in dB
//   pIndx     SID gain quantization index
*/
void QuantSIDGain_G729B_16s (const Ipp16s *pSrc, const Ipp16s *pSrcSfs,
                             Ipp32s len, Ipp16s *pDst, Ipp32s *pDstIndx){
    Ipp16s i,order,temp,high,low;
    Ipp32s   val;
    if(len == 0) {
        val = *pSrc;

        if(pSrcSfs[0]<0)
            val >>= - pSrcSfs[0];
        else
            val <<=  pSrcSfs[0];
        order  = 0;
        high = (Ipp16s)(val >> 16);
        low  = (Ipp16s)((val>>1)&IPP_MAX_16S);
        val  = high *  t[0] + ((low * t[0])>>15);
    } else {
        ippsMin_16s(pSrcSfs,len,&order);
        order = (Ipp16s)(order + 16 - t1[len]);
        val = 0;
        for(i=0; i<len; i++) {
            temp = (Ipp16s)(order - pSrcSfs[i]);
            val += (pSrc[i]<<temp);
        }
        high = (Ipp16s)(val >> 16);
        low  = (Ipp16s)((val>>1)&IPP_MAX_16S);
        val  = high *  t[i] + (((low * t[i] >> 1) & 0xffff8000)>>14);
    }

    *pDstIndx = ownQuantizeEnergy(val, order, pDst);

}
void Sum_G729_16s_Sfs(const Ipp16s *pSrc, const Ipp16s *pSrcSfs,
                      Ipp16s *pDst, Ipp16s *pDSfs, Ipp32s len, Ipp32s* pSum) {

    Ipp16s sfs, order;
    Ipp16s i, j;
    sfs = pSrcSfs[0];
    for(i=1; i<len; i++) {
        if(pSrcSfs[i] < sfs)
            sfs = pSrcSfs[i];
    }
    for(j=0; j<LPF_DIM+1; j++) {
        pSum[j] = 0;
    }
    sfs += 14;
    for(i=0; i<len; i++) {
        order = (Ipp16s)(sfs - pSrcSfs[i]);
        if(order<0) {
            for(j=0; j<LPF_DIM+1; j++) {
                pSum[j] += pSrc[(LPF_DIM+1)*i+j] >> -order;
            }
        } else {
            for(j=0; j<LPF_DIM+1; j++) {
                pSum[j] += pSrc[(LPF_DIM+1)*i+j] << order;
            }
        }
    }
    order = Norm_32s_I(&pSum[0]);
    pDst[0] = (Ipp16s)(pSum[0]>>16);
    for(i=1; i<=LPF_DIM; i++) {
        pDst[i] = (Ipp16s)((pSum[i]<<order)>>16);
    }
    order -= 16;
    *pDSfs = (Ipp16s)(sfs + order);

}

void VADMusicDetection(G729Codec_Type codecType,Ipp32s autoCorr,Ipp16s expAutoCorr,Ipp16s *pRc,
                       Ipp16s *lags, Ipp16s *pgains,Ipp16s stat_flg,Ipp16s *Vad,Ipp8s* pVADmem) {
    Ipp16s i, j, exp, fractal, tmp, tmp1, tmp2, tmp3, flag1, flag2, flag,
            pderr=IPP_MAX_16S, logE , spectrDist, threshold;
    Ipp32s   L_tmp;
    VADmemory_Obj *vadMem = (VADmemory_Obj*)pVADmem;
    for(i=0; i<4; i++) {
        j = (Ipp16s)((pRc[i] * pRc[i])>>15);
        j = (Ipp16s)(IPP_MAX_16S - j);
        pderr = (Ipp16s)((pderr * j)>>15);
    }
    L_tmp = 2*(autoCorr>>16)*pderr + 2*((((autoCorr>>1)&0x7fff)*pderr)>>15);
    Log2_G729(L_tmp, &exp, &fractal);
    L_tmp = 9864*exp + ((fractal*9864)>>15);
    i = (Ipp16s)(expAutoCorr - 2);
    L_tmp += 9864 * i;
    L_tmp = ShiftL_32s(L_tmp,12);
    logE = (Ipp16s)((L_tmp>>16) - 4875);
    L_tmp = 0;
    for(i=0; i<10; i++) {
        j = (Ipp16s)(vadMem->musicRC[i] - pRc[i]);
        L_tmp += j * j;
    }
    if(L_tmp > IPP_MAX_32S/2)
        spectrDist = IPP_MAX_32S >> 16;
    else
        spectrDist = (Ipp16s)(L_tmp>>15);
    if( *Vad == 0 ) {
        for(i=0; i<10; i++) {
            L_tmp = COEFF1 * vadMem->musicRC[i];
            L_tmp += PITCH_SHARP_MIN * pRc[i];
            vadMem->musicRC[i] = (Ipp16s)(L_tmp>>15);
        }
        L_tmp = COEFF1 * vadMem->musicSEMean;
        L_tmp += PITCH_SHARP_MIN * logE;
        vadMem->musicSEMean = (Ipp16s)(L_tmp>>15);
    }
    /* flag determination */
    tmp3=0; L_tmp=0;
    for(i=0; i<5; i++) {
        L_tmp += pgains[i] * 6554;
        tmp3 = (Ipp16s)(tmp3 + lags[i]);
    }
    L_tmp = (L_tmp>>15) * 6554;
    L_tmp += vadMem->MeanPgain * 26214;
    vadMem->MeanPgain = (Ipp16s)(L_tmp>>15);
    L_tmp = 0;
    for(i=0; i<5; i++) {
        j = (Ipp16s)(lags[i] << 2);
        j = (Ipp16s)(j + lags[i]);
        j = (Ipp16s)(j - tmp3);
        L_tmp += j * j;
    }
    if(L_tmp > 256)
        tmp2 = IPP_MAX_32S>>16;
    else
        tmp2 = (Ipp16s)(L_tmp<<7);
    if( codecType == G729D_CODEC)
        threshold = 11960;
    else
        threshold = 10322;
    if(vadMem->MeanPgain > threshold)
        flag2 =1;
    else
        flag2 =0;
    if( (tmp2 < 21632)  && (vadMem->MeanPgain > 7373))
        flag1 =1;
    else
        flag1 =0;
    flag= (Ipp16s)(((vadMem->VADPrev & (flag1 | flag2))| (flag2)));
    if( (pRc[1] <= 14746) && (pRc[1] >= 0) && (vadMem->MeanPgain < BWF_HARMONIC_E))
        vadMem->conscCounterFlagR++;
    else
        vadMem->conscCounterFlagR =0;
    if( (stat_flg == 1) && (*Vad == 1))
        vadMem->musicCounter += 256;
    if( (vadMem->frameCounter & 0x003f) == 0) {
        if( vadMem->frameCounter == 64)
            vadMem->musicMCounter = vadMem->musicCounter;
        else {
            L_tmp = COEFF1 * vadMem->musicMCounter;
            L_tmp += PITCH_SHARP_MIN * vadMem->musicCounter;
            vadMem->musicMCounter = (Ipp16s)(L_tmp>>15);
        }
    }
    if( vadMem->musicCounter == 0)
        vadMem->conscCounter++;
    else
        vadMem->conscCounter = 0;
    if(  ((vadMem->conscCounter > 500) || (vadMem->conscCounterFlagR > 150))) vadMem->musicMCounter = 0;

    if( (vadMem->frameCounter & 0x003f) == 0) {
        vadMem->musicCounter = 0;
    }

    if( flag== 1 )
        vadMem->count_pflag += 256;

    if( (vadMem->frameCounter & 0x003f) == 0) {
        if( vadMem->frameCounter == 64)
            vadMem->Mcount_pflag = vadMem->count_pflag;
        else {
            if(vadMem->count_pflag > 6400) {
                tmp1 = N0_98;
                tmp = 655;
            } else
                if(vadMem->count_pflag > 5120) {
                tmp1 = 31130;
                tmp = 1638;
            } else {
                tmp1 = COEFF1;
                tmp = PITCH_SHARP_MIN;
            }
            L_tmp = tmp1 * vadMem->Mcount_pflag;
            L_tmp += tmp * vadMem->count_pflag;
            vadMem->Mcount_pflag = (Ipp16s)(L_tmp>>15);
        }
    }
    if( vadMem->count_pflag == 0)
        vadMem->conscCounterFlagP++;
    else
        vadMem->conscCounterFlagP = 0;

    if(((vadMem->conscCounterFlagP > 100) || (vadMem->conscCounterFlagR > 150))) vadMem->Mcount_pflag = 0;


    if( (vadMem->frameCounter & 0x003f) == 0)
        vadMem->count_pflag = 0;

    if(codecType == G729E_CODEC) {
        if( (spectrDist > 4915) && (logE > (vadMem->musicSEMean + 819)) && (vadMem->VADPrevEnergy > 10240) )
            *Vad =1;
        else if( ((spectrDist > 12452) || (logE > (vadMem->musicSEMean + 819))) &&
                 (vadMem->VADPrevEnergy > 10240) )
            *Vad =1;
        else if( ( (vadMem->Mcount_pflag > 2560) || (vadMem->musicMCounter > 280) || (vadMem->frameCounter < 64))
                 && (vadMem->VADPrevEnergy > 1433))
            *Vad =1;
    }
    return;
}
void SynthesisFilterOvf_G729_16s_I(const Ipp16s * pLPC, Ipp16s * pSrcDst,
                                   Ipp32s len, Ipp8s * pMemUpdated,Ipp32s histLen) {
    Ipp32s nTaps;
    SynthesisFilterState *SynFltSt;

    SynFltSt=(SynthesisFilterState*)pMemUpdated;
    nTaps = SynFltSt->nTaps;
    if(!histLen)
        ippsSynthesisFilter_G729E_16s_I(pLPC,30, pSrcDst, len, SynFltSt->buffer);
    else
        ippsSynthesisFilterLow_NR_16s_ISfs(pLPC,pSrcDst, len, 12, SynFltSt->buffer+histLen);
    ippsCopy_16s((pSrcDst+len-nTaps), SynFltSt->buffer, nTaps);
}

IppStatus SynthesisFilter_G729_16s (const Ipp16s * pLPC, const Ipp16s * pSrc,
                                    Ipp16s * pDst, Ipp32s len, Ipp8s * pMemUpdated,Ipp32s histLen) {
    Ipp32s nTaps;