gain_util.c

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

    return index;
}


/********************************************************************************
*  Function: ownGainQuant_GSMAMR:    Quantization of gains
*********************************************************************************/
int ownGainQuant_GSMAMR(sGainQuantSt *st, IppSpchBitRate rate, short *pLTPRes, short *pLTPExc,
                        short *code, short *pTargetVec, short *pTargetVec2, short *pAdaptCode,
                        short *pFltVector, short even_subframe, short gainPitchLimit, short *gainPitSF0,
                        short *gainCodeSF0, short *pitchGainVar, short *codeGainVar, short **ppAnalysisParam)
{
    int i;
    short expGainCodeCB;
    short fracGainCodeCB;
    short qntEnergyErr_M122;
    short qntEnergyErr;
    short fracCoeff[5];
    short expCoeff[5];
    short expEnergyCoeff, fracEnergyCoeff;
    short codGainExp, codGainFrac;

    if (rate == IPP_SPCHBR_4750) {
        if (even_subframe != 0) {

            st->pGainPtr = (*ppAnalysisParam)++;
            ippsCopy_16s(st->a_PastQntEnergy, st->a_PastUnQntEnergy, NUM_PRED_TAPS);
            ippsCopy_16s(st->a_PastQntEnergy_M122, st->a_PastUnQntEnergy_M122, NUM_PRED_TAPS);

            ownPredEnergyMA_GSMAMR(st->a_PastUnQntEnergy,st->a_PastUnQntEnergy_M122, rate, code,
                    &st->vExpPredCBGain, &st->vFracPredCBGain, &expEnergyCoeff, &fracEnergyCoeff);

            ownCalcFiltEnergy_GSMAMR(rate, pTargetVec, pTargetVec2, pAdaptCode, pFltVector, st->a_FracEnCoeff, st->a_ExpEnCoeff,
                                     &codGainFrac, &codGainExp);

            if ((codGainExp + 1) > 0)
                *codeGainVar = Cnvrt_32s16s(codGainFrac << (codGainExp + 1));
            else
                *codeGainVar = Cnvrt_32s16s(codGainFrac >> -(codGainExp + 1));

            ownCalcTargetEnergy_GSMAMR(pTargetVec, &st->vExpTargetEnergy, &st->vFracTargetEnergy);

            ownUpdateUnQntPred_M475(st->a_PastUnQntEnergy,st->a_PastUnQntEnergy_M122,
                                  st->vExpPredCBGain, st->vFracPredCBGain,
                                  codGainExp, codGainFrac);

        } else {

            ownPredEnergyMA_GSMAMR(st->a_PastUnQntEnergy,st->a_PastUnQntEnergy_M122, rate, code,
                    &expGainCodeCB, &fracGainCodeCB, &expEnergyCoeff, &fracEnergyCoeff);

            ownCalcFiltEnergy_GSMAMR(rate, pTargetVec, pTargetVec2, pAdaptCode, pFltVector,
                               fracCoeff, expCoeff, &codGainFrac, &codGainExp);

            ownCalcTargetEnergy_GSMAMR(pTargetVec, &expEnergyCoeff, &fracEnergyCoeff);

            *st->pGainPtr = ownGainQnt_M475(st->a_PastQntEnergy, st->a_PastQntEnergy_M122, st->vExpPredCBGain,
                                            st->vFracPredCBGain, st->a_ExpEnCoeff,  st->a_FracEnCoeff,
                                            st->vExpTargetEnergy, st->vFracTargetEnergy, code, expGainCodeCB,
                                            fracGainCodeCB, expCoeff, fracCoeff, expEnergyCoeff, fracEnergyCoeff,
                                            gainPitchLimit, gainPitSF0, gainCodeSF0, pitchGainVar, codeGainVar);
        }
    } else {

        ownPredEnergyMA_GSMAMR(st->a_PastQntEnergy,st->a_PastQntEnergy_M122, rate, code, &expGainCodeCB, &fracGainCodeCB,
                               &expEnergyCoeff, &fracEnergyCoeff);

        if (rate == IPP_SPCHBR_12200) {
            *codeGainVar = ownComputeCodebookGain_GSMAMR(pTargetVec2, pFltVector);
            *(*ppAnalysisParam)++ = ownQntGainCodebook_GSMAMR(rate, expGainCodeCB, fracGainCodeCB,
                                                              codeGainVar, &qntEnergyErr_M122, &qntEnergyErr);
        } else {

            ownCalcFiltEnergy_GSMAMR(rate, pTargetVec, pTargetVec2, pAdaptCode, pFltVector,
                                     fracCoeff, expCoeff, &codGainFrac, &codGainExp);

            if (rate == IPP_SPCHBR_7950) {
                ownGainQuant_M795_GSMAMR(&st->vOnSetQntGain,&st->vPrevAdaptOut,&st->vPrevGainCode,st->a_LTPHistoryGain, pLTPRes, pLTPExc, code,
                                         fracCoeff, expCoeff, expEnergyCoeff, fracEnergyCoeff, expGainCodeCB, fracGainCodeCB, SUBFR_SIZE_GSMAMR,
                                         codGainFrac, codGainExp, gainPitchLimit, pitchGainVar, codeGainVar,
                                         &qntEnergyErr_M122, &qntEnergyErr, ppAnalysisParam);
            } else {
                *(*ppAnalysisParam)++ = ownGainQntInward_GSMAMR(rate, expGainCodeCB, fracGainCodeCB,
                                                                fracCoeff, expCoeff, gainPitchLimit,
                                                                pitchGainVar, codeGainVar,
                                                                &qntEnergyErr_M122, &qntEnergyErr);
            }
        }

        for (i = 3; i > 0; i--) {
            st->a_PastQntEnergy[i] = st->a_PastQntEnergy[i - 1];
            st->a_PastQntEnergy_M122[i] = st->a_PastQntEnergy_M122[i - 1];
        }
        st->a_PastQntEnergy_M122[0] = qntEnergyErr_M122;
        st->a_PastQntEnergy[0] = qntEnergyErr;
    }

    return 0;
    /* End of ownGainQuant_GSMAMR() */
}
/*
**************************************************************************
*  Function    : ownDecodeFixedCodebookGain_GSMAMR
**************************************************************************
*/
void ownDecodeFixedCodebookGain_GSMAMR(short *a_PastQntEnergy, short *a_PastQntEnergy_M122,
                                       IppSpchBitRate rate, short index, short *code, short *decGainCode)
{
    int i;
    short predGainCB, exp, frac;
    const short *p;
    short qntEnergyErr_M122, qntEnergyErr;
    short exp_inn_en;
    short frac_inn_en;
    int TmpVal;

    ownPredEnergyMA_GSMAMR(a_PastQntEnergy,a_PastQntEnergy_M122, rate, code, &exp, &frac,
            &exp_inn_en, &frac_inn_en);

    p = &pTblQntGainCode[index*3];

    if (rate == IPP_SPCHBR_12200) {
        predGainCB = (short)(ownPow2_GSMAMR (exp, frac));
        predGainCB = Cnvrt_32s16s(predGainCB << 4);
        *decGainCode = Cnvrt_32s16s((predGainCB * *p++) >> 15) << 1;
    } else {
        predGainCB = (short)(ownPow2_GSMAMR (14, frac));
        TmpVal = 2 * *p++ * predGainCB;
        if (exp > 9) TmpVal <<= (exp - 9);
        else         TmpVal >>= (9 - exp);
        *decGainCode = (short)(TmpVal >> 16);
    }

    qntEnergyErr_M122 = *p++;
    qntEnergyErr = *p++;
    for (i = 3; i > 0; i--) {
        a_PastQntEnergy[i] = a_PastQntEnergy[i - 1];
        a_PastQntEnergy_M122[i] = a_PastQntEnergy_M122[i - 1];
    }
    a_PastQntEnergy_M122[0] = qntEnergyErr_M122;
    a_PastQntEnergy[0] = qntEnergyErr;

    return;
}
/*************************************************************************
 *   Function:  ownDecodeCodebookGains_GSMAMR()
 ************************************************************************/
void ownDecodeCodebookGains_GSMAMR(short *a_PastQntEnergy, short *a_PastQntEnergy_M122,
                                   IppSpchBitRate rate, short index, short *code,
                                   short evenSubfr, short * pitchGainVar, short * codeGainVar)
{
    int i;
    const short *p;
    short frac, predGainCB, exp;
    short qntEnergyErr, qntEnergyErr_M122;
    short g_code;
    int TmpVal;

    index <<= 2;

    if ((rate == IPP_SPCHBR_10200) || (rate == IPP_SPCHBR_7400) || (rate == IPP_SPCHBR_6700)) {
        p = &TableGainHighRates[index];
        *pitchGainVar = *p++;
        g_code = *p++;
        qntEnergyErr_M122 = *p++;
        qntEnergyErr = *p;

    } else {
        if (rate == IPP_SPCHBR_4750) {
            index += (1 - evenSubfr) << 1;
            p = &table_gain_MR475[index];

            *pitchGainVar = *p++;
            g_code = *p++;

            ownLog2_GSMAMR (g_code, &exp, &frac);
            exp -= 12;
            qntEnergyErr_M122 = (frac >> 5) + (exp << 10);

            TmpVal = Mul16s_32s(exp, frac, 24660);
            qntEnergyErr = Cnvrt_NR_32s16s(ShiftL_32s(TmpVal, 13));

        } else {
            p = &TableGainLowRates[index];
            *pitchGainVar = *p++;
            g_code = *p++;
            qntEnergyErr_M122 = *p++;
            qntEnergyErr = *p;
        }
    }

    ownPredEnergyMA_GSMAMR(a_PastQntEnergy,a_PastQntEnergy_M122, rate, code, &exp, &frac, NULL, NULL);
    predGainCB = (short)(ownPow2_GSMAMR(14, frac));

    TmpVal = 2 * g_code * predGainCB;
    if(exp > 10) TmpVal = ShiftL_32s(TmpVal, (unsigned short)(exp - 10));
    else         TmpVal >>= (10 - exp);
    *codeGainVar = (short)(TmpVal >> 16);

    for (i = 3; i > 0; i--) {
        a_PastQntEnergy[i] = a_PastQntEnergy[i - 1];
        a_PastQntEnergy_M122[i] = a_PastQntEnergy_M122[i - 1];
    }
    a_PastQntEnergy_M122[0] = qntEnergyErr_M122;
    a_PastQntEnergy[0] = qntEnergyErr;

    return;
    /* End of ownDecodeCodebookGains_GSMAMR() */
}
/*
**************************************************************************
*  Function    : ownConcealCodebookGain_GSMAMR
**************************************************************************
*/
void ownConcealCodebookGain_GSMAMR(short *a_GainBuffer, short vPastGainCode, short *a_PastQntEnergy,
                                   short *a_PastQntEnergy_M122, short state, short *decGainCode)
{
    static const short cdown[7] = {32767, 32112, 32112, 32112, 32112, 32112, 22937};
    int i;
    short tmp;
    short qntEnergyErr_M122;
    short qntEnergyErr;

    tmp = ownGetMedianElements_GSMAMR(a_GainBuffer,5);
    if(tmp > vPastGainCode) tmp = vPastGainCode;
    tmp = (short)((tmp * cdown[state]) >> 15);
    *decGainCode = tmp;

    ippsSum_16s_Sfs((const Ipp16s*)a_PastQntEnergy_M122, NUM_PRED_TAPS, &qntEnergyErr_M122, 2);
    if (qntEnergyErr_M122 < MIN_ENERGY_M122) qntEnergyErr_M122 = MIN_ENERGY_M122;

    ippsSum_16s_Sfs((const Ipp16s*)a_PastQntEnergy, NUM_PRED_TAPS, &qntEnergyErr, 2);
    if (qntEnergyErr < MIN_ENERGY) qntEnergyErr = MIN_ENERGY;

    for (i = 3; i > 0; i--) {
        a_PastQntEnergy[i] = a_PastQntEnergy[i - 1];
        a_PastQntEnergy_M122[i] = a_PastQntEnergy_M122[i - 1];
    }
    a_PastQntEnergy_M122[0] = qntEnergyErr_M122;
    a_PastQntEnergy[0] = qntEnergyErr;
}

/**************************************************************************
*  Function    : ownConcealCodebookGainUpdate_GSMAMR
***************************************************************************/
void ownConcealCodebookGainUpdate_GSMAMR(short *a_GainBuffer, short *vPastGainCode, short *vPrevGainCode,
                                         short badFrame, short vPrevBadFr, short *decGainCode)
{
    short i;

    if (badFrame == 0) {
        if (vPrevBadFr != 0) {
            if(*decGainCode > *vPrevGainCode) *decGainCode = *vPrevGainCode;
        }
        *vPrevGainCode = *decGainCode;
    }

    *vPastGainCode = *decGainCode;

    for(i = 1; i < 5; i++)
       a_GainBuffer[i - 1] = a_GainBuffer[i];

    a_GainBuffer[4] = *decGainCode;

    return;
    /* End of ownConcealCodebookGainUpdate_GSMAMR() */
}

/*
**************************************************************************
*  Function    : ownConcealGainPitch_GSMAMR
**************************************************************************
*/
void ownConcealGainPitch_GSMAMR(short *a_LSFBuffer, short vPastGainZero,
                                short state, short *pGainPitch)
{
    static const short pdown[7] = {32767, 32112, 32112, 26214, 9830, 6553, 6553};
    short tmp;

    tmp = ownGetMedianElements_GSMAMR(a_LSFBuffer, 5);
    if(tmp > vPastGainZero) tmp = vPastGainZero;
    *pGainPitch = (short)((tmp * pdown[state]) >> 15);
}

/*
**************************************************************************
*  Function    : ownConcealGainPitchUpdate_GSMAMR
**************************************************************************
*/
void ownConcealGainPitchUpdate_GSMAMR(short *a_LSFBuffer, short *vPastGainZero, short *vPrevGainCode,
                                      short badFrame, short vPrevBadFr, short *pGainPitch)
{
    short i;
    if(badFrame == 0) {
        if(vPrevBadFr != 0) {
           if(*pGainPitch > *vPrevGainCode) *pGainPitch = *vPrevGainCode;
        }
        *vPrevGainCode = *pGainPitch;
    }

    *vPastGainZero = *pGainPitch;
    if(*vPastGainZero > 16384) *vPastGainZero = 16384;

    for(i = 1; i < 5; i++)
       a_LSFBuffer[i - 1] = a_LSFBuffer[i];

    a_LSFBuffer[4] = *vPastGainZero;
}