gaectxs.c

TI公司DSP/tms320c55x/tms320c54x系列的声学回声消除代码

/*-------------------------------------------------------------------------*
 *                                                                         *
 *   THIS IS AN UNPUBLISHED WORK CONTAINING CONFIDENTIAL AND PROPRIETARY   *
 *   INFORMATION.  IF PUBLICATION OCCURS, THE FOLLOWING NOTICE APPLIES:    *
 *      "COPYRIGHT 2002 MIKET DSP SOLUTIONS, ALL RIGHTS RESERVED"          *
 *                                                                         *
 *-------------------------------------------------------------------------*/
#include <string.h>
#include "gaeci.h"

/*--------------------- local defs ----------------------------------------*/

/*--------------------- public vars ---------------------------------------*/
/*--------------------- local vars ----------------------------------------*/
/*--------------------- local functions -----------------------------------*/

/*-------------------------------------------------------------------------*/
#if !defined(_dsp)
void                        gaec_tx_analysis
#else
void                        gaec_tx_analysisC
#endif
/*-------------------------------------------------------------------------*/
(
GAEC_tDb *pDb,
GAEC_tSc *pSc,
S16 *psTx
)
{
    // asTmp use: GAEC_FBS_SZ/2
	int k, band, blk;
    S16 *psFrom = &(pDb->asTbuf[0]);
    S16 *psTo   = &(pDb->aasT[0][GAEC_ERR_SZ-GAEC_BLKS]);
    S32 ac0;

// shift old data in buffer
	for (k = 0; k < GAEC_TBUF_SZ-GAEC_FR_SZ; k++) 
    {
        pDb->asTbuf[k] = pDb->asTbuf[k + GAEC_FR_SZ];
    }
// add new data
	for (k = 0; k < GAEC_FR_SZ; k++) 
    {
        pDb->asTbuf[GAEC_TBUF_SZ-GAEC_FR_SZ+k] = psTx[k];
    }
// shift old data in 2D array
    for (band = 0; band < GAEC_BANDS*2; band++)
    {
        for (k = 0; k < GAEC_ERR_SZ-GAEC_BLKS; k++)
        {
            pDb->aasT[band][k] = pDb->aasT[band][k+GAEC_BLKS];
        }
    }
// analysis + decimaition
    for (blk = 0; blk < GAEC_BLKS; blk++)
    {
        // symmetric filters
        for (k = 0; k < GAEC_FBS_SZ/2; k++)
        {
            pSc->u.asTmp[k] = psFrom[k] + psFrom[GAEC_FBS_SZ-1-k];
        }
	    for (band = 0; band < GAEC_BANDS; band++)
	    {
            ac0 = 0;
		    for(k = 0; k < GAEC_FBS_SZ/2; k++)
		    {
			    ac0 += pSc->u.asTmp[k] * (S32)GAEC_aasFBS[band][k];
		    }
		    *psTo = _Srnd(ac0, 0);
            psTo   += GAEC_ERR_SZ;
        }
        // asymmetric filters
        for (k = 0; k < GAEC_FBS_SZ/2; k++)
        {
            pSc->u.asTmp[k] = psFrom[k] - psFrom[GAEC_FBS_SZ-1-k];
        }
	    for (band = GAEC_BANDS; band < 2*GAEC_BANDS; band++)
	    {
            ac0 = 0;
		    for(k = 0; k < GAEC_FBS_SZ/2; k++)
		    {
			    ac0 += pSc->u.asTmp[k] * (S32)GAEC_aasFBS[band][k];
		    }
		    *psTo = _Srnd(ac0, 0);
            psTo   += GAEC_ERR_SZ;
        }
        psTo -= GAEC_ERR_SZ*(2*GAEC_BANDS)-1;
        psFrom += GAEC_BLK_SZ;

    }
#if 0   
#endif    
}

/*-------------------------------------------------------------------------*/
#if !defined(_dsp)
void                        gaec_tx_vad
#else
void                        gaec_tx_vadC
#endif
/*-------------------------------------------------------------------------*/
(
GAEC_tDb *pDb,
GAEC_tSc *pSc
)
{
    int band;
    S16 sMaxEn = -32768;

    for (band = 0; band < (GAEC_BANDS+1); band++)
    {
        if (sMaxEn < pSc->asRinEn[band])
            sMaxEn = pSc->asRinEn[band];
    }
    for (band = 0; band < GAEC_BANDS+1; band++)
    {
        if (pSc->asRinEn[band] > GAEC_VAD_NSE_MIN)
        {
            S16 sDlt = pSc->asRinEn[band] - pDb->asVadRinNse[band];
            pDb->asVadRinCrit[band] += sDlt - GAEC_VAD_CRIT_THR;
            if (pDb->asVadRinCrit[band] < GAEC_CRIT_MIN)
                pDb->asVadRinCrit[band] = GAEC_CRIT_MIN;
            if (pDb->asVadRinCrit[band] > GAEC_CRIT_MAX)
                pDb->asVadRinCrit[band] = GAEC_CRIT_MAX;

            if (pDb->asVadRinCrit[band] < 0)
            {
                if (pDb->uAdfMode < 3)
                    pDb->asVadRinNse[band] += sDlt >> 3;
                else
                    pDb->asVadRinNse[band] += sDlt >> 5;

                if (pDb->asVadRinNse[band] > GAEC_VAD_NSE_MAX)
                    pDb->asVadRinNse[band] = GAEC_VAD_NSE_MAX;
                if (pDb->asVadRinNse[band] < GAEC_VAD_NSE_MIN)
                    pDb->asVadRinNse[band] = GAEC_VAD_NSE_MIN;
            }
            else
            {
                if ((pSc->asRinEn[band] < GAEC_VAD_NSE_MAX) &
                    (sMaxEn < GAEC_VAD_NSE_MAX))

                {
                    if (pDb->uAdfMode < 3)
                        pDb->asVadRinNse[band] += 10;
                    else
                        pDb->asVadRinNse[band] += 1;
                }
            }
        }
        else
        {
            pDb->asVadRinCrit[band] -= GAEC_VAD_CRIT_THR;
            if (pDb->asVadRinCrit[band] < GAEC_CRIT_MIN)
                pDb->asVadRinCrit[band] = GAEC_CRIT_MIN;

        }
    }
}
/*-------------------------------------------------------------------------*/
#if !defined(_dsp)
void                        gaec_tx_vad_fb
#else
void                        gaec_tx_vad_fbC
#endif
/*-------------------------------------------------------------------------*/
(
GAEC_tDb *pDb,
GAEC_tSc *pSc
)
{
    if (pSc->sRinEn > GAEC_VAD_NSE_MIN)
    {
        S16 sDlt = pSc->sRinEn - pDb->sVadRinNse;
        pDb->sVadRinCrit += sDlt - GAEC_VAD_CRIT_THR;
        if (pDb->sVadRinCrit < GAEC_CRIT_MIN)
            pDb->sVadRinCrit = GAEC_CRIT_MIN;
        if (pDb->sVadRinCrit > GAEC_CRIT_MAX)
            pDb->sVadRinCrit = GAEC_CRIT_MAX;

        if (pDb->sVadRinCrit < 0)
        {
            if (pDb->uAdfMode < 3)
                pDb->sVadRinNse += sDlt >> 3;
            else
                pDb->sVadRinNse += sDlt >> 5;

            if (pDb->sVadRinNse > GAEC_VAD_NSE_MAX)
                pDb->sVadRinNse = GAEC_VAD_NSE_MAX;
            if (pDb->sVadRinNse < GAEC_VAD_NSE_MIN)
                pDb->sVadRinNse = GAEC_VAD_NSE_MIN;
        }
        else
        {
            if (pSc->sRinEn < GAEC_VAD_NSE_MAX) 
            {
                if (pDb->uAdfMode < 3)
                    pDb->sVadRinNse += 10;
                else
                    pDb->sVadRinNse += 1;
            }
        }
    }
    else
    {
        pDb->sVadRinCrit -= GAEC_VAD_CRIT_THR;
        if (pDb->sVadRinCrit < GAEC_CRIT_MIN)
            pDb->sVadRinCrit = GAEC_CRIT_MIN;

    }
}
/*-------------------------------------------------------------------------*/
#if !defined(_dsp)
void                        gaec_tx_att
#else
void                        gaec_tx_attC
#endif
/*-------------------------------------------------------------------------*/
(
GAEC_tDb *pDb,
GAEC_tSc *pSc
)
{
    // asTmp use: GAEC_BANDS*2
    int band;
    // attenuate
    for (band = 0; band < GAEC_BANDS+1; band++)
    {
        pSc->u.asTmp[band] = gaec_utl_exp((S16)-pSc->asAttRin[band]);
    }
    for (band = 1; band < GAEC_BANDS; band ++)
    {
        pSc->u.asTmp[band + GAEC_BANDS] = pSc->u.asTmp[band];
    }
    for (band = 0; band < GAEC_BANDS*2; band++)
    {
        S16 sAtt = pSc->u.asTmp[band];
        S16 k;
        for (k = 0; k < GAEC_ERR_SZ; k ++)
        {
            S32 ac0 = pDb->aasT[band][k] * (S32) sAtt;
            pSc->aasErr0[band][k] = _Srnd(ac0, 3);
        }
    }
}
/*-------------------------------------------------------------------------*/
#if !defined(_dsp)
void                        gaec_tx_nse
#else
void                        gaec_tx_nseC
#endif
/*-------------------------------------------------------------------------*/
(
GAEC_tDb *pDb,
GAEC_tSc *pSc
)
{
    // asTmp use: GAEC_BANDS*2
    int band;

    // add noise
    for (band = 0; band < GAEC_BANDS+1; band++)
    {
    	S16 sNse;
    	
        // if DT, then increase noise level
        S16 sEn1 = pSc->u.asTmp[band] + pDb->Cfg.sWhiteThr;
        S16 sEn2 = pDb->asVadRinNse[band];
        // in the begining if the call, nse est is not reliable
        S16 sEn3 = pSc->u.asTmp[band] - GAEC_DB(6);
        if (sEn2 > sEn3) sEn2 = sEn3; // min of those
        
        // sNse is a max of two
        sNse = (sEn1 < sEn2) ? sEn2 : sEn1;
        
        pSc->u.asTmp[band] = gaec_utl_exp((S16)(sNse+ GAEC_DB(13)));
//        pSc->asTmp[band] = sNse+ GAEC_DB(13);
    }
    for (band = 1; band < GAEC_BANDS; band ++)
    {
        pSc->u.asTmp[band + GAEC_BANDS] = pSc->u.asTmp[band];
    }
    for (band = 0; band < GAEC_BANDS*2; band++)
    {
#if defined(_dsp)    
        gaec_nlp_add_noiseC
#else
        gaec_nlp_add_noise
#endif
            (&pDb->sNseSav, &pSc->aasErr0[band][0], pSc->u.asTmp[band]);
    }

#if 0        
#endif
}