demo.cpp

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

    val_out(XT2, YT0, WHITE, "adf file: %p", _Control.pAdfFile);
    val_out(XT2, YT1, WHITE, "tmp file: %p", _Control.pTmpFile);
    val_out(XT2, YT2, WHITE, "wav file: %p", _Control.pNlpWavFile);
    val_out(XT2, YT3, WHITE, "tx  file: %p", _Control.pInTxFile);
    val_out(XT2, YT4, WHITE, "trx file: %p", _Control.pInTrxFile);
    val_out(XT2, YT5, WHITE, "rsp file: %p", _Control.pRespFile);
    val_out(XT2, YT6, LIGHTBLUE, "add file: %p", _Control.pAddRxTrxFile);
    val_out(XT2, YT7, LIGHTBLUE, "AddRxCorr %f", _Control.fAddRxCorr);


    val_out(XT4, YT0, LIGHTCYAN, "RxLevel %6.2f", _Gen.fRxLevel);
    val_out(XT4, YT1, LIGHTCYAN, "RxNoise %6.2f", _Gen.fRxNoise);
    val_out(XT4, YT2, LIGHTCYAN, "TxLevel %6.2f", _Gen.fTxLevel);
    val_out(XT4, YT3, LIGHTCYAN, "TxNoise %6.2f", _Gen.fTxNoise);
    val_out(XT4, YT4, LIGHTGREEN, "WordLen %f", _Gen.fWordLen);
    val_out(XT4, YT5, LIGHTGREEN, "PauseLen %f", _Gen.fPauseLen);
    val_out(XT4, YT6, LIGHTGREEN, "Words %ld", _Gen.liSentenceLen);
    val_out(XT4, YT7, LIGHTGREEN, "DT %% %f", _Gen.fDoubleTalk);
//    val_out(XT4, YT9, LIGHTGREEN, "Begin %d", _Gen.iState);

}

/* ------------------------------------------------------------------- */
void                    plot_jk
/* ------------------------------------------------------------------- */
(
S16 *pJ,
S16 *pK,
S16 x,
S16 y,
S16 amp,
S16 color
)
{
    bar(x, y-amp-1, x+5*6+40, y+amp+1);
	set_color(color);
    line(x, y+amp,x+5*6, y+amp);
    for (int k = 0; k < 6; k++)
	{
		int t = (int)(2.*amp*(pJ[k]/32767.));
        line(k*5+x, y+amp, k*5+x, y+amp-t);
	}

    line(x+40, y,x+70, y);
    for (k = 0; k < 6; k++)
	{
		int t = (int)(amp*(pK[k]/32767.));
        line(k*5+40+x, y, k*5+40+x, y-t);
	}
}

/* ------------------------------------------------------------------- */
void                        plot_band_en
/* ------------------------------------------------------------------- */
(
int x0, 
int y0, 
int ymax,
int ymin,
int x, 
int *pOld, 
S16 *psNew,
char *pcTitle, 
const int *piColor
)
{
    int k;
    int band;

    bar(x0+x+1,            y0-int(ymax*DYEN),x0+x+10,y0-int(ymin*DYEN));
    bar(x0-GAEC_BANDS*2-20,y0-int(ymax*DYEN),x0-20,  y0-int(ymin*DYEN));

    set_color(LIGHTGRAY);
    for (k = ymax/10; k >= ymin/10; k--)
    {
        line (x0+x,              y0-int(k*DYEN*10), 
              x0+x+1,            y0-int(k*DYEN*10));
        line (x0-20,             y0-int(k*DYEN*10), 
              x0-GAEC_BANDS*2-20,y0-int(k*DYEN*10));

        val_out(x0-20,           y0-int(k*DYEN*10)-9, DARKGRAY,"%3d", k*10);
        set_color(DARKGRAY);
    }

    if (pcTitle != NULL)
    {
        val_out(x0-20,           y0-12, RED,"%s", pcTitle);
    }

    for (band = 0; band < GAEC_BANDS+1;band++)
    {
         k = (int)(psNew[band]*DYEN/170.1);
         if (k > int(ymax*DYEN)) k = int(ymax*DYEN);
         if (k < int(ymin*DYEN)) k = int(ymin*DYEN);
         cline(x0+x,            y0-pOld[band],
               x0+x+1,          y0-k,
               piColor[band]);
         cline(x0-(GAEC_BANDS-band)*2-20,y0-int(ymin*DYEN),
               x0-(GAEC_BANDS-band)*2-20,y0-k,
               piColor[band]);
         pOld[band] = k;

    }

}

/* ------------------------------------------------------------------- */
void                        plot_adf_energy
/* ------------------------------------------------------------------- */
(
const int *piColor
)
{
    int k;
    int band;
    bar(XADFE, YADFE, XADFE+GAEC_ADF_SZ-GAEC_BLKS, int(YADFE+80*DYAD));

    set_color(DARKGRAY);
    for (k = 0; k < 9; k++)
    {
        int y = int(YADFE+DYAD*k*10);
        line(XADFE, y, XADFE+GAEC_ADF_SZ-GAEC_BLKS, y);
        val_out(XADFE-20, y-9, DARKGRAY,"%3d", 10-k*10);

    }
    for (band = 0; band < GAEC_BANDS+1; band++)
    {
        set_color(piColor[band]);
        for (k = 0; k < GAEC_ADF_SZ-GAEC_BLKS-1; k++)
        {
            int x1 = int(DYAD*(_aasAdfEn[band][k]/170.1-10));
            int x2 = int(DYAD*(_aasAdfEn[band][k+1]/170.1-10));
            if (x1 < int(-DYAD*80))
                x1 = int(-DYAD*80);
            if (x2 < int(-DYAD*80))
                x2 = int(-DYAD*80);

            line(XADFE+k, YADFE-x1, XADFE+k+1, YADFE-x2);
        }
    }
}
/* ------------------------------------------------------------------- */
int                     plt
/* ------------------------------------------------------------------- */
(
int y, 
double ynew, 
int color
)
{
    if (ynew < YDBMIN) ynew = YDBMIN;
    if (ynew > YDBMAX) ynew = YDBMAX;
    ynew = ((ynew-YDBMAX)* YV)/(YDBMIN-YDBMAX);
//	if (ynew > YV) ynew = YV;
//	if (ynew < 0) ynew = 0;
//	if (y > YV) y = YV;
//	if (y < 0) y = 0;
	cline(st_x-1, YG+y, st_x, YG+int(ynew) , color);
	return int(ynew);
}
/* ------------------------------------------------------------------- */
int                     plt_h
/* ------------------------------------------------------------------- */
(
int y, 
double ynew, 
int color
)
{
    if (ynew < YDHMIN) ynew = YDHMIN;
    if (ynew > YDHMAX) ynew = YDHMAX;
    ynew = ((ynew-YDHMAX)* YVH)/(YDHMIN-YDHMAX);
//	if (ynew > YV) ynew = YV;
//	if (ynew < 0) ynew = 0;
//	if (y > YV) y = YV;
//	if (y < 0) y = 0;
	cline(st_x-1, YGH+y, st_x, YGH+int(ynew) , color);
	return int(ynew);
}

/* ------------------------------------------------------------------- */
int                     plt_c
/* ------------------------------------------------------------------- */
(
int y, 
double ynew, 
int color
)
{
    int iy;

    if (ynew < -1) ynew = -1;
    if (ynew >  1) ynew =  1;

    iy = int(-ynew * YCM);
	cline(st_x-1, YCC+y, st_x, YCC+iy , color);

	return iy;
}

#if 0
/* ------------------------------------------------------------------- */
int                     plt_low
/* ------------------------------------------------------------------- */
(
int y, 
double ynew, 
int color
)
{
	if (ynew > YVL) ynew = YVL;
	if (ynew < 0) ynew = 0;
	if (y > YVL) y = YVL;
	if (y < 0) y = 0;
	cline(st_x-1, YGL+y, st_x, YGL+int(ynew) , color);
	return int(ynew);
}
#endif

/* ------------------------------------------------------------------- */
void                    trc
/* ------------------------------------------------------------------- */
(
int y, 
int color
)
{
	cline(st_x-1, YG-5-y*4, st_x, YG-5-y*4, color);
	cline(st_x-1, YG-6-y*4, st_x, YG-6-y*4, color);
}
/* ------------------------------------------------------------------- */
void                    trc1
/* ------------------------------------------------------------------- */
(
int y, 
int color
)
{
	cline(st_x-1, YG-5-y*4, st_x, YG-5-y*4, color);
}
/* ------------------------------------------------------------------- */
void                    trc12
/* ------------------------------------------------------------------- */
(
int y, 
int color
)
{
	cline(st_x-1, YG-6-y*4, st_x, YG-6-y*4, color);
}
/* ------------------------------------------------------------------- */
void                    trc2
/* ------------------------------------------------------------------- */
(
int y, 
int color
)
{
	cline(st_x, YG-6-y*4, st_x, YG-8-y*4, color);
}


/* ------------------------------------------------------------------- */
double                  dbl
/* ------------------------------------------------------------------- */
(
S16 in
)
{
    double en = in/double(GAEC_DB(1));
    if (en < YDBMIN) en = YDBMIN;
    if (en > YDBMAX) en = YDBMAX;
    return en;
}

/*-------------------------------------------------------------------------*/
void                    plot_results
/*-------------------------------------------------------------------------*/
(
)
{
    GAEC_tDb *pDb = &_GaecDb;
    GAEC_tSc *pSc = &_GaecSc;
    GAEC_tScRcv *pScRcv = &_GaecScRcv;

    const static int __aiColor[11] = { 
        LIGHTBLUE, LIGHTMAGENTA, 
        RED, LIGHTRED, 
        BROWN, YELLOW, 
        GREEN, LIGHTGREEN, 
        CYAN, LIGHTCYAN,
        BLUE
    }; 

    int     x;
	int     k;
    int     band;
//    double  fDiff1;
//    double  fDiff2;
//    double  fMSE1;
//    double  fMSE2;
//    int     ErrMax;
    double  fTmp;
    static double __asMSE[GAEC_BANDS+1];

    static int sOldState = 0;
    int iStateChange = FALSE;
    if (sOldState)
    {
        if (pDb->sVadErrCrit < 0.0) 
        {
            sOldState = 0;
            iStateChange = TRUE;
        }
    }
    else
    {
        if (pDb->sVadErrCrit > 15.0) 
        {
            sOldState = 1;
            iStateChange = TRUE;
        }
    }
#if 0
    {
        double __aAbs[GAEC_BANDS*2];
        double __aDlt[GAEC_BANDS*2];
        double Dlt = 0;
        double Abs = 0;
        for (int band = 0; band < GAEC_BANDS*2; band++)
        {
            __aAbs[band] = 0;
            __aDlt[band] = 0;
            for (int idx = 0; idx < GAEC_ADF_SZ; idx++)
            {
                int i;
                if (band < GAEC_BANDS)
                    i = GAEC_ADF_SZ*2*band+idx*2+0;
                else
                    i = GAEC_ADF_SZ*2*(band-GAEC_BANDS)+idx*2+1;
                double x = pDb->psAdf[i]/32767. - _aasAdf[band][idx];
                __aDlt[band] += x * x;
                x = _aasAdf[band][idx];
                __aAbs[band] += x * x;
            }
            Dlt += __aDlt[band];
            Abs += __aAbs[band];
        }
        
        fTmp = 10*log10(Dlt / (Abs + 0.00001));
        fMSE1 = fTmp;
        __asMSE[0] = 10*log10(__aAbs[0]/(__aDlt[0]+0.0001));
        __asMSE[GAEC_BANDS] = 10*log10(__aAbs[GAEC_BANDS]/(__aDlt[GAEC_BANDS]+0.00001));
        for (band= 1; band < GAEC_BANDS; band++)
        {
            Dlt = __aDlt[band] + __aDlt[band+GAEC_BANDS];
            Abs = __aAbs[band] + __aAbs[band+GAEC_BANDS];
            __asMSE[band] = 10*log10(Abs/(Dlt+0.0000001));
        }
    }
#endif
// ------------------- SIGNALS ------------------

    if ((_Control.iGmode & 0x1) == 0)
	{
        plot_out(
            _asRinHst,  
            _HST_SZ, 
		    XSIG, 
            YSIG + 0*(YSIGWIN+1), 
            YSIGWIN, 
            "Rin",
            LIGHTBLUE);
        plot_out(
            _asRoutHst,  
            _ROUT_SZ, 
		    XSIG, 
            YSIG + 2*(YSIGWIN+1), 
            YSIGWIN, 
            "Rout",
            RED);
        plot_out(
            _asSinHst,  
            _HST_SZ, 
		    XSIG, 
            YSIG + 4*(YSIGWIN+1), 
            YSIGWIN, 
            "Sin",
            RED);

        plot_out(
            _asCnlHst, 
            _SOUT_SZ, 
		    XSIG, 
            YSIG + 6*(YSIGWIN+1), 
            YSIGWIN, 
            "Cnl", 
            LIGHTCYAN);
        plot_out(
            _asSoutHst, 
            _SOUT_SZ, 
		    XSIG, 
            YSIG + 8*(YSIGWIN+1), 
            YSIGWIN, 
            "Sout", 
            LIGHTRED);

        plot_out(
            _GaecScEpc.asEpcRcv,
            GAEC_EPC_MAXD,
            XSIG + _SOUT_SZ+3,
            YSIG + 6*(YSIGWIN+1),
            YSIGWIN,
            NULL,
            LIGHTBLUE);
        plot_out(
            _GaecScEpc.asEpcSnd,
            GAEC_EPC_MAXD,
            XSIG + _SOUT_SZ+3,
            YSIG + 8*(YSIGWIN+1),
            YSIGWIN,
            NULL,
            LIGHTCYAN);
#if 0
        plot_out(
            pDb->asEpcRcvIn,
            GAEC_EPC_SZ,
            XSIG + _SOUT_SZ-150,
            YSIG + 2*(YSIGWIN+1),
            YSIGWIN,
            NULL,
            LIGHTBLUE);
#endif
    }
    // plot ADF
    if ((_Control.iGmode & 0x2) == 0)
	{
        static S16 __asAdf[GAEC_ADF_SZ*2];
		static S16 __aasAdfSav[GAEC_BANDS*2][GAEC_ADF_SZ*2];

        S16 sMax = 0;
        for (k = 0; k < GAEC_BANDS*2*GAEC_ADF_SZ; k++)
        {
            if (sMax < abs(pDb->psAdf[k]))
                sMax = abs(pDb->psAdf[k]);
        }
        val_out(XADF, 0, WHITE, "%05d", sMax);

        for (int band = 0; band < GAEC_BANDS; band++)
        {
            for (k = 0; k < GAEC_ADF_SZ; k++)
            {
                __asAdf[k] = pDb->psAdf[band*GAEC_ADF_SZ*2+k*2+0];
                __asAdf[k+GAEC_ADF_SZ] = pDb->psAdfM[band*GAEC_ADF_SZ*2+k*2+0];
            }
        	plot_band_adf(
                __asAdf, 
				__aasAdfSav[band*2+0],
	            XADF, 
                YADF + band*YDLT, 
                YWIN, 
                __aiColor[band]);

            for (k = 0; k < GAEC_ADF_SZ; k++)
            {
                __asAdf[k] = pDb->psAdf[band*GAEC_ADF_SZ*2+k*2+1];
                __asAdf[k+GAEC_ADF_SZ] = pDb->psAdfM[band*GAEC_ADF_SZ*2+k*2+1];
            }
            plot_band_adf(
                __asAdf, 
				__aasAdfSav[band*2+1],
	            XADF + GAEC_ADF_SZ + 3, 
                YADF + band*YDLT, 
                YWIN, 
                __aiColor[band]);

			val_out(
				XADF+GAEC_ADF_SZ-90, 
				YADF + band*YDLT-YWIN, 
				__aiColor[band], 
				"%2d", 
				pDb->asShft[band]);

        }
#if 1
        {
#define __DBAND         (1)
            static S16 __asAdfOld[GAEC_ADF_SZ*2];
            S16 __asAdfDif[GAEC_ADF_SZ*2];
            for (k = 0; k < GAEC_ADF_SZ*2; k++)
            {
                __asAdfDif[k] = pDb->psAdf[k+__DBAND*GAEC_ADF_SZ*2] - __asAdfOld[k]; 
                __asAdfOld[k] = pDb->psAdf[k+__DBAND*GAEC_ADF_SZ*2]; 
            }
            plot_out(
                __asAdfDif, 
                GAEC_ADF_SZ*2,
                XADF,
                YADF+10*YDLT,
                YWIN,
                "dif",
                __aiColor[__DBAND]);
        }
#endif
    }
//  AdfM
    if ((_Control.iGmode & 0x4) == 0)
    {
        static S16 __asAdf[GAEC_ADF_SZ];
        S16 sMax = 0;

        for (k = 0; k < GAEC_ADF_SZ*4; k++)
        {
            if (sMax < abs(pDb->psAdfM[k]))
                sMax = abs(pDb->psAdfM[k]);
        }
        val_out(XADF-2*GAEC_ADF_SZ-10, 0, WHITE, "%05d", sMax);
        for (band = 0; band < 2; band++)
        {
            for (k = 0; k < GAEC_ADF_SZ; k++)
                __asAdf[k] = pDb->psAdfM[band*GAEC_ADF_SZ*2+k*2+0];
        	plot_band(
                __asAdf, 
                GAEC_ADF_SZ,
	            XADF-2*GAEC_ADF_SZ-6, 
                YADF + band*YDLT, 
                YWIN, 
                sMax,
                __aiColor[band+1]);

            for (k = 0; k < GAEC_ADF_SZ; k++)
                __asAdf[k] = pDb->psAdfM[band*GAEC_ADF_SZ*2+k*2+1];
            plot_band(
                __asAdf, 
                GAEC_ADF_SZ,
	            XADF - GAEC_ADF_SZ - 3, 
                YADF + band*YDLT, 
                YWIN, 
                sMax,
                __aiColor[band+1]);

        }
    }
    // plot Hst
    if ((_Control.iGmode & 0x8) == 0)
	{
        S16 sMax = 0;
        for (k = 0;