demo.cpp

The line echo canceller (LEC) is designed to provide the maximum attainable transparent voice qualit

	{
		_asEchoS16[k] = S16(_afEcho[k]*32767.0);
	}

	plot_out(_asEchoS16, ECHO_SZ, XADF, YADF, YADFA, "  ECHO", RED);

    val_out(XT0, YT0, WHITE,    "ERR %d", Err);
    val_out(XT0, YT1, WHITE,    "gr_mode %d", _Control.iGmode);
    val_out(XT0, YT2, LIGHTRED, "RxCorr  %f", _Control.fRxCorr);
    val_out(XT0, YT3, LIGHTRED, "TxCorr  %f", _Control.fTxCorr);
    val_out(XT0, YT4, LIGHTRED, "RxDelay %d", _Control.iRxDelay);
    val_out(XT0, YT4, LIGHTRED, "TxDelay %d", _Control.iTxDelay);

    val_out(XT2, YT1, WHITE, "adf file: %p", _Control.pAdfFile);
    val_out(XT2, YT2, WHITE, "tmp file: %p", _Control.pTmpFile);
    val_out(XT2, YT3, WHITE, "pcm file: %p", _Control.pPcmFile);
    val_out(XT2, YT3, WHITE, "wav file: %p", _Control.pNlpWavFile);
    val_out(XT2, YT4, WHITE, "tx  file: %p", _Control.pInTxFile);
    val_out(XT2, YT5, WHITE, "trx file: %p", _Control.pInTrxFile);
    val_out(XT2, YT6, WHITE, "rsp file: %p", _Control.pRespFile);


    val_out(XT4, YT1, LIGHTCYAN, "RxLevel %6.2f", _Gen.fRxLevel);
    val_out(XT4, YT2, LIGHTCYAN, "RxNoise %6.2f", _Gen.fRxNoise);
    val_out(XT4, YT3, LIGHTCYAN, "TxLevel %6.2f", _Gen.fTxLevel);
    val_out(XT4, YT4, LIGHTCYAN, "TxNoise %6.2f", _Gen.fTxNoise);

    val_out(XT6, YT1, LIGHTGREEN, "WordLen %f", _Gen.fWordLen);
    val_out(XT6, YT2, LIGHTGREEN, "PauseLen %f", _Gen.fPauseLen);
    val_out(XT6, YT3, LIGHTGREEN, "Words %ld", _Gen.liSentenceLen);
    val_out(XT6, YT4, LIGHTGREEN, "DT %% %f", _Gen.fDoubleTalk);
    val_out(XT6, YT5, 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);
	}
}

/* ------------------------------------------------------------------- */
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-5-y*4, color);
}
/* ------------------------------------------------------------------- */
void                    trc1
/* ------------------------------------------------------------------- */
(
int y, 
int color
)
{
	cline(st_x-1, YG-5-y*4, st_x, YG-5-y*4, color);
}


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

/*-------------------------------------------------------------------------*/
void                    plot_results
/*-------------------------------------------------------------------------*/
(
)
{
    LEC_tDb *pDb = &_LecDb;
    LEC_tSc *pSc = &_LecSc;

    const static int __aiColor[8] = 
            { RED, BROWN, GREEN, CYAN, BLUE, MAGENTA, LIGHTRED, LIGHTGRAY};
	int k;
    double fDiff1;
    double fDiff2;
    double fMSE1;
    double fMSE2;
    int ErrMax;
    double fTmp;
    double fDiv1 = double(1<<pDb->Adf1.sShift);
    double fDiv2 = double(1<<pDb->Adf2.sShift);
    int x;
    
    static int sOldState = 0;
    int iStateChange = FALSE;
    
    if (pDb->VadErr.sState != sOldState)
    {
        sOldState = pDb->VadErr.sState;
        iStateChange = TRUE;
    }
    iStateChange = (pSc->uFltCpyMode == 2);

// ------------------- SIGNALS ------------------

    if ((_Control.iGmode & 0x1) == 0)
	{
        extern S16 _asJkW[], _asKkW[];
        extern S16 _asJkS[], _asKkS[];

    	S16 TxFmax = plot_out(
            pDb->psTxF, 
            LEC_HST_SZ,
	        XT, 
            YADF + 0*(YADFA+8), 
            YTA, 
            "TxF", 
            LIGHTCYAN);
        plot_jk(
            _asJkS, _asKkS,
            XT+LEC_HST_SZ+10, 
            YADF + 0*(YADFA+8),
            YTA,
            WHITE);

        S16 TxMax = plot_out(
            pDb->psHst,  
            LEC_HST_SZ,
		    XT, 
            YADF + 2*(YADFA+8), 
            YTA, 
            "Hst", 
            LIGHTBLUE);

        plot_jk(
            _asJkW, _asKkW,
            XT+LEC_HST_SZ+10, 
            YADF + 2*(YADFA+8),
            YTA,
            LIGHTBLUE);

        S16 RxInMax = plot_out(
            _asRxInHst,  
            LEC_HST_SZ, 
		    XT, 
            YADF + 4*(YADFA+8), 
            YTA, 
            "RxIN",
            RED);

        S16 RxOutMax = plot_out(
            _asRxOutHst, 
            LEC_HST_SZ, 
		    XT, 
            YADF + 6*(YADFA+8), 
            YTA, 
            "RxOut", 
            LIGHTRED);
	    
        ErrMax = plot_out(
            pSc->asErr1, 
            ILEC_FR_SZ, 
		    XT + ILEC_FR_SZ * 6+10 , 
            YADF + 6*(YADFA+8), 
            YTA, 
            "Err1",
            CYAN);
	    
        S16 NormErrMax = plot_out(
            pSc->asNormErr, 
            ILEC_FR_SZ, 
		    XT + ILEC_FR_SZ * 6+10, 
            YADF + 4*(YADFA+8), 
            YTA, 
            "Ner",   
            LIGHTCYAN);
	}

// ----------------- ADF ------------------

    if ((_Control.iGmode & 0x2) == 0)
    {
       	plot_out(
            pDb->asAdf1, 
            ADF2_SZ, 
		    XADF, 
            YADF, 
            YADFA, 
            "ADF", 
            WHITE);

    	plot_out(
            pDb->asAdf2, 
            ADF2_SZ, 
		    XADF, 
            YADF + YADFA*2+16, 
            YADFA, 
            "Flt2", 
            LIGHTRED);

        fDiff1 = 0;
        fDiff2 = 0;

	    for (k = 0; k < ADF_SZ; k++)
	    {
		    _asAdf1Diff[k] = int(pDb->asAdf1[k+ILEC_FR_SZ]/fDiv1) - int(_asEchoS16[k]);
            fDiff1 += (_asAdf1Diff[k]/32767.0) * (_asAdf1Diff[k]/32767.0);

		    _asAdf2Diff[k] = int(pDb->asAdf2[k+ILEC_FR_SZ]/fDiv2) - int(_asEchoS16[k]);
            fDiff2 += (_asAdf2Diff[k]/32767.0) * (_asAdf2Diff[k]/32767.0);
	    }
        fMSE1 = 10*log10(fDiff1/(_fReflection+EPS)+EPS);
        fMSE2 = 10*log10(fDiff2/(_fReflection+EPS)+EPS);

	    plot_out(
            _asAdf2Diff, 
            ADF_SZ, 
		    XADF+ILEC_FR_SZ, 
            YADF + YADFA*4+32, 
            YADFA, 
            "Diff2", 
            LIGHTMAGENTA);
    
        for (k = 0; k < ADF_SZ; k++)
        {
            _asAdf2Diff[k] = int(pDb->asAdf2[k]/fDiv2) - _asAdfOld[k];
            _asAdfOld[k]  = int(pDb->asAdf2[k]/fDiv2);
        }

    	plot_out(
            _asAdf2Diff, 
            ADF_SZ, 
		    XADF+ILEC_FR_SZ, 
            YADF + YADFA*6+48, 
            YADFA, 
            "Upd2", 
            LIGHTCYAN);
    }

    x = X0 + (_Frame % FR_MAX)*DX;
    st_x = x;

// ---------------- STATE TRACE ------------------

    if ((_Control.iGmode & 0x4) == 0)
    {
        int color;
// CLEAN CURR LINE
    	bar(st_x+1, YG, st_x+10, YG-80);

        if (_Control.pInTrxFile == 0)
        {
		    switch(_Gen.iState){
			    case 0:	color = BLACK; break;
			    case 1:	color = BLUE; break;
			    case 2:	color = LIGHTRED; break;
			    case 3:	color = YELLOW; break;
			    default: color = BLACK; break;
		    }
		    trc(1, color);
        }
		switch(pDb->VadErr.sState){
			case 0:	color = BLACK; break;
			case 1:	color = RED; break;
			case 2:	color = LIGHTRED; break;
			case 3:	color = BROWN; break;
			default: color = BLACK; break;
		}
		trc(2, color);

        color = (pSc->uFlags & LEC_FLAG_HIRCV)? RED: BLACK;
	    trc(4, color);


        trc1(5, DARKGRAY);

        color = (pSc->uFlags & LEC_FLAG_ERL_OK) ? LIGHTBLUE: LIGHTRED;
		trc(6, color);

        color = (pDb->uIsDT) ? YELLOW : BLACK;
		trc(7, color);

        switch(pDb->uTone)
        {
        case 0: color = BLACK;break;
        case 1: color = LIGHTRED;break;
        case 2: color = RED;break;
        }
		trc(8, color);

        color = (pSc->uFlags & LEC_FLAG_SINGULAR) ? LIGHTGRAY: BLACK;
		trc(9, color);

        trc1(11, DARKGRAY);

        color = (ErrMax > pSc->sClipThreshold) ? WHITE : BLACK;
		trc(12, color);

		switch (pSc->uNlpMode){
			case 1:	color = RED; break; // pass
			case 2:	color = LIGHTMAGENTA;  break; // clip
			case 3:	color = WHITE;   break; // clear
			default: color = BLACK; break;
		}
		trc(13, color);

        trc1(14, DARKGRAY);

		switch(pSc->uAdaptMode){
    		case 4+2: color = CYAN; break;     /* high, slow */
	    	case 4+1: color = LIGHTCYAN; break;      /* high, fast */
		    case 8+2: color = BLUE; break; /* low, slow */
		    case 8+1: color = LIGHTBLUE; break; /* low, fast */
		    default: color = BLACK; break;
	    }
		trc(15, color);

        switch(pSc->uFltCpyMode){
    		case 1: color = GREEN; break;  
	    	case 2: color = LIGHTRED; break;
//		    case 3: color = BLUE; break; 
		    default: color = BLACK; break;
	    }
		trc(16, color);

        color = (pSc->uFlags & LEC_FLAG_ERROVERIDE) ? GREEN : BLACK;
		trc(17, color);

//        trc1(15, DARKGRAY);


    }

// ------------ ENERGIES -----------------------

    if ((_Control.iGmode & 0x8) == 0)
    {
        static int __aLine[9];

    	bar(st_x+1, YG, st_x+10, YG+YV);

	    set_color(DARKGRAY);
	    for (k = 0; k < 9; k++)
	    {
            __aLine[k] = plt(__aLine[k], -10*k, DARKGRAY);
//		    int y=YG+k*(YV/8)+DBMAX;
//		    line(st_x-1, y, st_x, y);
	    }

        if (iStateChange)
        {
            cline(x, YG+YV, x, YG, DARKGRAY);
        }

// erle averaged
        {
            static int __iLast;
            fTmp = dbl(-pDb->Adf1.sErleAveraged);
            if (_Frame&1)
		        __iLast = plt(__iLast, fTmp, YELLOW);
        }
// erle
        {
            static int __iLast;
            fTmp = dbl(-pSc->sErle);
		    __iLast = plt(__iLast, fTmp, BROWN);
        }
// erl
        {
            static int __iLast;
            fTmp = dbl(-pSc->sErl);
		    __iLast = plt(__iLast, fTmp, GREEN);
        }
// tx energy
        {
            static int __iLast;
            fTmp = dbl(pSc->sTxEn);
		    __iLast = plt(__iLast, fTmp, LIGHTBLUE);
        }
// rx in  energy
        {
            static int __iLast;
            fTmp = dbl(pSc->sRxEn);
		    __iLast = plt(__iLast, fTmp, RED);
        }
// rx out  energy
        {
            static int __iLast;
            long lsEn = lec_pkt_energy(_asRxOut);
            int sEn = lec_en2log(lsEn);
            fTmp = dbl(sEn);
		    __iLast = plt(__iLast, fTmp, LIGHTRED);
        }
// error  expected energy (clipping level)
        {
            static int __iLast;
//            fTmp = dbl(pSc->sExpectedErrorEn);
            S16 sClipLevel = pDb->sClipLevel;
            S16 sDlt = sClipLevel - pDb->VadErr.sEnNoise;
            if (sDlt < LEC_DB(6))
            {
                sClipLevel -= sDlt/2 - LEC_DB(3);
            }
            if (sDlt < LEC_DB(-6))
            {
                sClipLevel -= sDlt/2 + LEC_DB(3);