decamrwb.c

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

      ippsInterpolateC_NR_G729_16s_Sfs(st->asiIspOld, 18022, pIspvec,14746, pIspTmp, LP_ORDER, 15);
      ippsISPToLPC_AMRWB_16s(pIspTmp, pLPCvec, LP_ORDER);

      ippsInterpolateC_NR_G729_16s_Sfs(st->asiIspOld,  6554, pIspvec,26214, pIspTmp, LP_ORDER, 15);
      ippsISPToLPC_AMRWB_16s(pIspTmp, &pLPCvec[LP_ORDER + 1], LP_ORDER);

      ippsInterpolateC_NR_G729_16s_Sfs(st->asiIspOld,  1311, pIspvec,31457, pIspTmp, LP_ORDER, 15);
      ippsISPToLPC_AMRWB_16s(pIspTmp, &pLPCvec[2*(LP_ORDER + 1)], LP_ORDER);

      /* 4th subframe: pLPCvec (frac=1.0) */

      ippsISPToLPC_AMRWB_16s(pIspvec, &pLPCvec[3*(LP_ORDER + 1)], LP_ORDER);
      ippsCopy_16s(pIspvec, st->asiIspOld, LP_ORDER);
    }

    /* Check stability on pIsfvec : distance between old st->asiIsfOld and current pIsfvec */
    valStabFac = ownChkStab(pIsfvec, st->asiIsfOld, LP_ORDER-1);
    ippsCopy_16s(st->asiIsfOld, pIsftmp, LP_ORDER);
    ippsCopy_16s(pIsfvec, st->asiIsfOld, LP_ORDER);

    pLPC = pLPCvec;                               /* pointer to interpolated LPC parameters */

    for (valSubFrame = 0,subFrame=0; valSubFrame < FRAME_SIZE; valSubFrame += SUBFRAME_SIZE,subFrame++)
    {
        valAdptIndex = *(pPrms)++;
        ippsAdaptiveCodebookDecode_AMRWB_16s(valAdptIndex, &valFracPitchLag, &pExcvec[valSubFrame],
            &valIntPitchLag, pPrevIntPitchLagBounds, subFrame, bfi, unusableFrame, irate,st->pSAdaptCdbkDecState);

        if (unusableFrame)
        {
            valSelect = 1;
        } else
        {
            if ((irate == IPP_SPCHBR_6600)||(irate == IPP_SPCHBR_8850)||(irate == IPP_SPCHBR_DTX))
                valSelect = 0;
            else
                valSelect = *(pPrms)++;
        }

        if (valSelect == 0)
        {
            /* find pitch excitation with lp filter */
            pSrcCoeff[0] = 20972;
            pSrcCoeff[1] = -5898;
            ippsHighPassFilter_Direct_AMRWB_16s(pSrcCoeff, &pExcvec[valSubFrame], pFixedCodevec, SUBFRAME_SIZE, 1);
            ippsCopy_16s(pFixedCodevec, &pExcvec[valSubFrame], SUBFRAME_SIZE);
        }

        if (unusableFrame != 0)
        {
            for (i = 0; i < SUBFRAME_SIZE; i++)
            {
                pFixedCodevec[i] = (Ipp16s)(Rand_16s(&(st->siSeed)) >> 3);
            }
        } else {
           ippsAlgebraicCodebookDecode_AMRWB_16s((Ipp16s*)pPrms, pFixedCodevec, irate);
           if ((irate == IPP_SPCHBR_6600)||(irate == IPP_SPCHBR_DTX))
               pPrms += 1;
           else if ((irate == IPP_SPCHBR_8850) || (irate == IPP_SPCHBR_12650) ||
               (irate == IPP_SPCHBR_14250) || (irate == IPP_SPCHBR_15850))
               pPrms += 4;
           else
               pPrms += 8;
        }

        tmp = 0;
        ippsPreemphasize_AMRWB_16s_ISfs (st->siTiltCode, pFixedCodevec, SUBFRAME_SIZE, 14, &tmp);

        tmp = valIntPitchLag;
        if (valFracPitchLag > 2) tmp += 1;

        if (tmp < SUBFRAME_SIZE) {
            ippsHarmonicFilter_NR_16s(PITCH_SHARP_FACTOR, tmp, &pFixedCodevec[tmp], &pFixedCodevec[tmp], SUBFRAME_SIZE-tmp);
        }

        ippsDotProd_16s32s_Sfs(pFixedCodevec, pFixedCodevec,SUBFRAME_SIZE, &s, -1);
        s = Add_32s(s, 1);

        exp = (Ipp16s)(6 - Norm_32s_I(&s));  /* exponent = 0..30 */
        ownInvSqrt_AMRWB_32s16s_I(&s, &exp);

        if ((exp - 3) > 0)
            valInvEnergy = (Ipp16s)(ShiftL_32s(s,(Ipp16s)(exp - 3)) >> 16);
        else
            valInvEnergy = (Ipp16s)(s >> (16 + 3 - exp));

        if (bfi != 0)
        {
            tmp = ownMedian5(&st->asiCodeGainPast[2]);
            valPastPitchGain = tmp;

            if (valPastPitchGain > 15565) valPastPitchGain = 15565;

            if (unusableFrame != 0)
               valPitchGain = Mul_16s_Sfs(PCoeffDownUnusableTbl[st->siBFHState], valPastPitchGain, 15);
            else
               valPitchGain = Mul_16s_Sfs(PCoeffDownUsableTbl[st->siBFHState], valPastPitchGain, 15);

            tmp = ownMedian5(&st->asiQuantGainPast[2]);

            if (st->siVadHist > 2)
            {
               valPastCodeGain = tmp;
            } else
            {
               if (unusableFrame != 0)
                  valPastCodeGain = Mul_16s_Sfs(CCoeffDownUnusableTbl[st->siBFHState], tmp, 15);
               else
                  valPastCodeGain = Mul_16s_Sfs(CCoeffDownUsableTbl[st->siBFHState], tmp, 15);
            }
        }

        valAdptIndex = *(pPrms)++;
        ippsDecodeGain_AMRWB_16s(valAdptIndex, valInvEnergy, &valPitchGain, &valCodeGain, bfi,
            st->siBfiPrev, st->asiQuantEnerPast, &st->siCodeGainPrev, &valPastCodeGain, irate);

        if (bfi == 0) {
            valPastPitchGain = valPitchGain;
            ippsAdaptiveCodebookDecodeUpdate_AMRWB_16s(valPitchGain, valIntPitchLag, st->pSAdaptCdbkDecState);
            st->siOldPitchLag = valIntPitchLag;       /* save duplicate for WB<->WB+ */
            st->siOldPitchLagFrac = 0;    /* Remove fraction in case of BFI */
        }

        ippsMove_16s(&st->asiQuantGainPast[1],st->asiQuantGainPast, 4);
        st->asiQuantGainPast[4] = valPastCodeGain;

        ippsMove_16s(&st->asiCodeGainPast[1],st->asiCodeGainPast, 4);
        st->asiCodeGainPast[4] = valPastPitchGain;

        ippsMin_16s(st->asiScaleFactorMax, 4, &tmp);
        if (tmp > MAX_SCALE_FACTOR) tmp = MAX_SCALE_FACTOR;

        valQNew = 0;
        s = valCodeGain;

        while ((s < 0x08000000) && (valQNew < tmp))
        {
            s <<= 1;
            valQNew += 1;
        }
        valGainCode = Cnvrt_NR_32s16s(s);

        ownScaleSignal_AMRWB_16s_ISfs(pExcvec + valSubFrame - (PITCH_LAG_MAX + INTERPOL_LEN),
            PITCH_LAG_MAX + INTERPOL_LEN + SUBFRAME_SIZE, (Ipp16s)(valQNew - st->siScaleFactorOld));
        st->siScaleFactorOld = valQNew;

        ippsCopy_16s(&pExcvec[valSubFrame], pExcvec2, SUBFRAME_SIZE);
        ownScaleSignal_AMRWB_16s_ISfs(pExcvec2, SUBFRAME_SIZE, -3);

        /* post processing of excitation elements */

        if ((irate == IPP_SPCHBR_6600)||(irate == IPP_SPCHBR_8850)||(irate == IPP_SPCHBR_DTX))
        {
            valPitchSharp = Cnvrt_32s16s(valPitchGain << 1);
            if (valPitchSharp > 16384)
            {
                for (i = 0; i < SUBFRAME_SIZE; i++)
                {
                    tmp = Mul_16s_Sfs(pExcvec2[i], valPitchSharp, 15);
                    pExctmp[i] = Cnvrt_NR_32s16s(tmp * valPitchGain);
                }
            }
        } else
            valPitchSharp = 0;

        valVoiceFac = ownVoiceFactor(pExcvec2, -3, valPitchGain, pFixedCodevec, valGainCode, SUBFRAME_SIZE);

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

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

        ippsCopy_16s(&pExcvec[valSubFrame], pExcvec2, SUBFRAME_SIZE);
        ippsInterpolateC_NR_16s(pFixedCodevec, valGainCode, 7,
            &pExcvec[valSubFrame], valPitchGain, 2, &pExcvec[valSubFrame],SUBFRAME_SIZE);

        /* find maximum value of excitation for next scaling */
        valMax = 1;
        for (i = 0; i < SUBFRAME_SIZE; i++)
        {
            tmp = Abs_16s(pExcvec[i + valSubFrame]);
            if (tmp > valMax) valMax = tmp;
        }

        /* tmp = scaling possible according to valMax value of excitation */
        tmp = (Ipp16s)(Exp_16s(valMax) + valQNew - 1);

        st->asiScaleFactorMax[3] = st->asiScaleFactorMax[2];
        st->asiScaleFactorMax[2] = st->asiScaleFactorMax[1];
        st->asiScaleFactorMax[1] = st->asiScaleFactorMax[0];
        st->asiScaleFactorMax[0] = tmp;

        Unpack_32s(valCodeGain, &valGainCode, &valGainCodeLow);
        if ((irate == IPP_SPCHBR_6600) || (irate == IPP_SPCHBR_DTX))
            j = 0;
        else if (irate == IPP_SPCHBR_8850)
            j = 1;
        else
            j = 2;

        ownPhaseDisp(valGainCode, valPitchGain, pFixedCodevec, j, st->asiPhaseDisp);

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

        s = valCodeGain;
        if (s < st->iNoiseEnhancerThres)
        {
            s += Mpy_32_16(valGainCode, valGainCodeLow, 6226);
            if (s > st->iNoiseEnhancerThres) s = st->iNoiseEnhancerThres;
        } else
        {
            s = Mpy_32_16(valGainCode, valGainCodeLow, 27536);
            if (s < st->iNoiseEnhancerThres) s = st->iNoiseEnhancerThres;
        }
        st->iNoiseEnhancerThres = s;

        valCodeGain = Mpy_32_16(valGainCode, valGainCodeLow, (Ipp16s)(IPP_MAX_16S - valFac));
        Unpack_32s(s, &valGainCode, &valGainCodeLow);
        valCodeGain += Mpy_32_16(valGainCode, valGainCodeLow, valFac);

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

        pSrcCoeff[0] = 1;
        pSrcCoeff[1] = tmp;
        ippsHighPassFilter_Direct_AMRWB_16s(pSrcCoeff, pFixedCodevec, pFixedCodevec2, SUBFRAME_SIZE, 0);

        /* build excitation */

        valGainCode = Cnvrt_NR_32s16s(valCodeGain << valQNew);
        ippsInterpolateC_NR_16s(pFixedCodevec2, valGainCode, 7,
            pExcvec2, valPitchGain, 2, pExcvec2,SUBFRAME_SIZE);

        if ((irate == IPP_SPCHBR_6600)||(irate == IPP_SPCHBR_8850)||(irate == IPP_SPCHBR_DTX))
        {
            if (valPitchSharp > 16384)
            {
                ippsAdd_16s_I(pExcvec2, pExctmp, SUBFRAME_SIZE);
                ownagc2(pExcvec2, pExctmp, SUBFRAME_SIZE);
                ippsCopy_16s(pExctmp, pExcvec2, SUBFRAME_SIZE);
            }
        }
        if ((irate == IPP_SPCHBR_6600)||(irate == IPP_SPCHBR_DTX))
        {
            j = (Ipp16s)(valSubFrame >> 6);
            ippsInterpolateC_NR_G729_16s_Sfs(pIsftmp, (Ipp16s)(IPP_MAX_16S - InterpolFracTbl[j]),
                pIsfvec,InterpolFracTbl[j], pHfIsfvec, LP_ORDER, 15);
        } else
            ippsZero_16s(st->asiSynthHighFilt, LP_ORDER_16K - LP_ORDER);

        if (irate == IPP_SPCHBR_23850)
        {
            valCorrGain = *(pPrms)++;
            ownSynthFun(pLPC, pExcvec2, valQNew, &dst[valSubFrame * 5 / 4], valCorrGain, pHfIsfvec,
                irate, valDTXState, st, bfi);
        } else
            ownSynthFun(pLPC, pExcvec2, valQNew, &dst[valSubFrame * 5 / 4], 0, pHfIsfvec,
                irate, valDTXState, st, bfi);
        pLPC += (LP_ORDER + 1);                   /* interpolated LPC parameters for next subframe */
    }

    ippsCopy_16s(&pExcOld[FRAME_SIZE], st->asiExcOld, PITCH_LAG_MAX + INTERPOL_LEN);

    ownScaleSignal_AMRWB_16s_ISfs(pExcvec, FRAME_SIZE, (Ipp16s)(-valQNew));
    ippsDecDTXBuffer_AMRWB_16s(pExcvec, pIsfvec, &st->dtxDecState.siHistPtr,
        st->dtxDecState.asiIsfHistory, st->dtxDecState.siLogEnerHist);

    st->dtxDecState.siGlobalState = valDTXState;

    st->siBfiPrev = bfi;

    return APIAMRWB_StsNoErr;
}

/* Synthesis of signal at 16kHz with HF extension */
static void ownSynthesis(Ipp16s *pLPCvec, Ipp16s *pExcvec, Ipp16s valQNew,
     Ipp16u *pSynSignal, Ipp16s pPrmvec, Ipp16s *pHfIsfvec,
     IppSpchBitRate mode, Ipp16s valDTXState, AMRWBDecoder_Obj * st, Ipp16s bfi)
{
    Ipp16s i, valFac, tmp, exp;
    Ipp16s ener, exp_ener;
    Ipp32s s;

    IPP_ALIGNED_ARRAY(16, Ipp32s, pSynthHi, LP_ORDER + SUBFRAME_SIZE);
    IPP_ALIGNED_ARRAY(16, Ipp16s, pSynthvec, SUBFRAME_SIZE);
    IPP_ALIGNED_ARRAY(16, Ipp16s, pHFvec, SUBFRAME_SIZE_16k);
    IPP_ALIGNED_ARRAY(16, Ipp16s, pLPCtmp, LP_ORDER_16K + 1);
    IPP_ALIGNED_ARRAY(16, Ipp16s, pHFLCPvec, LP_ORDER_16K + 1);
    Ipp16s valHFCorrGain;
    Ipp16s valHFGainIndex;
    Ipp16s gain1, gain2;
    Ipp16s weight1, weight2;
    Ipp16s tmp_aq0;
    Ipp32s tmpSum, sfs;

    ippsCopy_16s((Ipp16s*)st->asiSynthesis, (Ipp16s*)pSynthHi, LP_ORDER*2);

    tmp_aq0 = pLPCvec[0];
    sfs = Exp_16s(tmp_aq0) - 2;
    pLPCvec[0] >>= (4 + valQNew);
    if (sfs)
        ownSynthesisFilter_AMRWB_16s32s_ISfs(pLPCvec, LP_ORDER, pExcvec, pSynthHi + LP_ORDER, SUBFRAME_SIZE, sfs + 3);
    else
        ippsSynthesisFilter_AMRWB_16s32s_I(pLPCvec, LP_ORDER, pExcvec, pSynthHi + LP_ORDER, SUBFRAME_SIZE);
    pLPCvec[0] = tmp_aq0;

    ippsCopy_16s((Ipp16s*)(&pSynthHi[SUBFRAME_SIZE]), (Ipp16s*)st->asiSynthesis, LP_ORDER*2);
    ippsDeemphasize_AMRWB_32s16s(PREEMPH_FACTOR>>1, pSynthHi + LP_ORDER, pSynthvec, SUBFRAME_SIZE, &(st->siDeemph));
    ippsHighPassFilter_AMRWB_16s_ISfs(pSynthvec, SUBFRAME_SIZE, st->pSHPFiltStateSgnlOut, 14);
    ownOversampling_AMRWB_16s(pSynthvec, SUBFRAME_SIZE, pSynSignal, st->asiOversampFilt);

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

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

    ippsDotProd_16s32s_Sfs( pExcvec, pExcvec,SUBFRAME_SIZE, &tmpSum, -1);
    tmpSum = Add_32s(tmpSum, 1);

    exp_ener = (Ipp16s)(30 - Norm_32s_I(&tmpSum));
    ener = (Ipp16s)(tmpSum >> 16);

    exp_ener = (Ipp16s)(exp_ener - (valQNew + valQNew));

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