gain_util.c

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

                                            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(Ipp16s *a_PastQntEnergy, Ipp16s *a_PastQntEnergy_M122,
                                       IppSpchBitRate rate, Ipp16s index, Ipp16s *code, Ipp16s *decGainCode)
{
    Ipp32s i;
    Ipp16s predGainCB, exp, frac;
    const Ipp16s *p;
    Ipp16s qntEnergyErr_M122, qntEnergyErr;
    Ipp16s exp_inn_en;
    Ipp16s frac_inn_en;
    Ipp32s 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 = (Ipp16s)(ownPow2_GSMAMR (exp, frac));
        predGainCB = Cnvrt_32s16s(predGainCB << 4);
        *decGainCode = (Ipp16s)(Cnvrt_32s16s((predGainCB * *p++) >> 15) << 1);
    } else {
        predGainCB = (Ipp16s)(ownPow2_GSMAMR (14, frac));
        TmpVal = 2 * *p++ * predGainCB;
        if (exp > 9) TmpVal <<= (exp - 9);
        else         TmpVal >>= (9 - exp);
        *decGainCode = (Ipp16s)(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(Ipp16s *a_PastQntEnergy, Ipp16s *a_PastQntEnergy_M122,
                                   IppSpchBitRate rate, Ipp16s index, Ipp16s *code,
                                   Ipp16s evenSubfr, Ipp16s * pitchGainVar, Ipp16s * codeGainVar)
{
    Ipp32s i;
    const Ipp16s *p;
    Ipp16s frac, predGainCB, exp;
    Ipp16s qntEnergyErr, qntEnergyErr_M122;
    Ipp16s g_code;
    Ipp32s 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 = (Ipp16s)(index + (Ipp16s)((1 - evenSubfr) << 1));
            p = &table_gain_MR475[index];

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

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

            TmpVal = Mpy_32_16(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 = (Ipp16s)(ownPow2_GSMAMR(14, frac));

    TmpVal = 2 * g_code * predGainCB;
    if(exp > 10) TmpVal = ShiftL_32s(TmpVal, (Ipp16u)(exp - 10));
    else         TmpVal >>= (10 - exp);
    *codeGainVar = (Ipp16s)(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(Ipp16s *a_GainBuffer, Ipp16s vPastGainCode, Ipp16s *a_PastQntEnergy,
                                   Ipp16s *a_PastQntEnergy_M122, Ipp16s state, Ipp16s *decGainCode)
{
    static const Ipp16s cdown[7] = {32767, 32112, 32112, 32112, 32112, 32112, 22937};
    Ipp32s i;
    Ipp16s tmp;
    Ipp16s qntEnergyErr_M122;
    Ipp16s qntEnergyErr;

    tmp = ownGetMedianElements_GSMAMR(a_GainBuffer,5);
    if(tmp > vPastGainCode) tmp = vPastGainCode;
    tmp = (Ipp16s)((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(Ipp16s *a_GainBuffer, Ipp16s *vPastGainCode, Ipp16s *vPrevGainCode,
                                         Ipp16s badFrame, Ipp16s vPrevBadFr, Ipp16s *decGainCode)
{
    Ipp16s 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(Ipp16s *a_LSFBuffer, Ipp16s vPastGainZero,
                                Ipp16s state, Ipp16s *pGainPitch)
{
    static const Ipp16s pdown[7] = {32767, 32112, 32112, 26214, 9830, 6553, 6553};
    Ipp16s tmp;

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

/*
**************************************************************************
*  Function    : ownConcealGainPitchUpdate_GSMAMR
**************************************************************************
*/
void ownConcealGainPitchUpdate_GSMAMR(Ipp16s *a_LSFBuffer, Ipp16s *vPastGainZero, Ipp16s *vPrevGainCode,
                                      Ipp16s badFrame, Ipp16s vPrevBadFr, Ipp16s *pGainPitch)
{
    Ipp16s 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;
}