demo.cpp

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

            }
            fTmp = dbl(sClipLevel);
//            fTmp = dbl(pDb->sClipLevel+pDb->Cfg.sClipThr);
            __iLast = plt(__iLast, fTmp, DARKGRAY);
        }
// error  energy
        {
            static int __iLast;
            fTmp = dbl(pDb->VadErr.sEn);
//		    __iLast = plt(__iLast, fTmp, CYAN);
        }
        {
            static int __iLast;
            fTmp = dbl(pSc->sErr1En);
		    __iLast = plt(__iLast, fTmp, CYAN);
        }
        {
            static int __iLast;
            fTmp = dbl(pSc->sErr2En);
            if (pSc->uAdaptMode & 0x000c)
		    __iLast = plt(__iLast, fTmp, GREEN);
        }
// error  noise energy
        {
            static int __iLast;
            fTmp = dbl(pDb->VadErr.sEnNoise);
            if (_Frame & 1)
		        __iLast = plt(__iLast, fTmp, CYAN);
        }
// rx noise energy
        {
            static int __iLast;
            fTmp = dbl(pDb->sRxNoiseLevel);
            if ((_Frame & 3) == 3)
		        __iLast = plt(__iLast, fTmp, CYAN);
        }
// Energy Corr
        {
            static int __iLast;
            fTmp = dbl(lec_en2log(pDb->Adf2.slAcc));
            if (_Frame & 1)
		        __iLast = plt(__iLast, fTmp, MAGENTA);
        }
    }

///////////////// PLOT HIGH ///////////////////////

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

    	bar(st_x+1, YGH, st_x+10, YGH+YVH);

	    set_color(DARKGRAY);
	    for (k = 0; k < 6; k++)
	    {
            __aLine[k] = plt_h(__aLine[k], -10*k, DARKGRAY);
	    }

        if (iStateChange)
        {
            cline(x, YGH+YVH, x, YGH, DARKGRAY);
        }
// Err VAD Crit
        {
            static int __iLast;
            fTmp = -45-dbl(-pDb->VadErr.sCrit)*0.5;
  	        __iLast = plt_h(__iLast, fTmp, CYAN);
        }
// DT Crit
        {
            static int __iLast;
            fTmp = -45+pDb->sDtCriteria*1.0;
  	        __iLast = plt_h(__iLast, fTmp, RED);
        }
// ErrOverrideCnt
        {
            static int __iLast;
            fTmp = dbl(-pDb->sErrOverrideCnt);
  	        __iLast = plt_h(__iLast, fTmp, LIGHTRED);
        }
// CONV LACK
        {
            static int __iLast;
            S16 sConvLack = 
                lec_en2log(LEC_SLACC_MAX) - // this is const
                lec_en2log(pDb->Adf2.slAcc);
            fTmp = dbl(-sConvLack);
            if (_Frame & 1)
      	        __iLast = plt_h(__iLast, fTmp, LIGHTMAGENTA);
        }
// CORR
        {
            static int __iLast;
            fTmp = 20*log10(pSc->sStepCorr/4096.+EPS);
	        __iLast = plt_h(__iLast, fTmp, LIGHTGRAY);
        }
// MSE-real
        {
            static int __iLast;
            fTmp = fMSE1;
	        __iLast = plt_h(__iLast, fTmp, WHITE);
        }
// MSE2-real
        {
            static int __iLast;
            fTmp = fMSE2;
	        __iLast = plt_h(__iLast, fTmp, LIGHTCYAN);
        }
// MSE-est-Db
        {
            static int __iLast;
            fTmp = dbl(pDb->Adf2.sMSE);
//            if (_Frame & 1)
    	        __iLast = plt_h(__iLast, fTmp, YELLOW);
        }
// MSE-est-Sc
        {
            static int __iLast;
            fTmp = dbl(pSc->sMSE);
            __iLast = plt_h(__iLast, fTmp, BROWN);
        }
// ERL-est-SC
        {
            static int __iLast;
            fTmp = dbl(-pSc->sERL);
            __iLast = plt_h(__iLast, fTmp, GREEN);
        }
// ERL-est-Db
        {
            static int __iLast;
            fTmp = dbl(-pDb->Adf2.sERL);
//            if (_Frame & 1)
                __iLast = plt_h(__iLast, fTmp, LIGHTGREEN);
        }
    }

// ------------------ COEFFS ----------------------

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

    	bar(st_x+1, YCC-YCM, st_x+10, YCC+YCM);

	    set_color(DARKGRAY);

	    for (k = -4; k < 5; k++)
	    {
            __aLine[k+4] = plt_c(__aLine[k+4], k/4.0, DARKGRAY);
	    }

        plt_c(0, 0, LIGHTGRAY);

        if (iStateChange)
        {
            cline(x, YCC+YCM, x, YCC-YCM, DARKGRAY);
        }

// CORR
        {
            extern double aFs[6];
            extern double aF[6];
            extern double dJ;

            static int __aiLast[8];

            for (k = 0; k < 8; k++)
            {
                double f = pSc->asF[k]/32767.;
                if (k == 7) f = pSc->sJ0Tx/32767.;
                if (k == 6) f = pSc->sJ0/32767.;
		        __aiLast[k] = plt_c(__aiLast[k], f, __aiColor[k]);

            }
        }
    }
// -------------------- DATA --------------------------

    /* row 0 --------------------------------------------- */
    {
        int iOut = 0;
        static long __lCnt;
        static double __dSpeed = 0; 
        static unsigned long __ulTime = 0;

        if (__lCnt == 199)
        {
            unsigned long ulTime = timeGetTime();
            __dSpeed = (5.0*__lCnt)/(ulTime - __ulTime);
            __ulTime = ulTime;
            __lCnt = 0;
        }
        else
        {
            __lCnt++;
        }

        if (_Control.iGmode & 0x20)
        {
            if (__lCnt == 0)
                iOut = 1;
        }
        else
        {
            iOut = 1;
        }

        if (iOut)
        {
            bar(XT0, YT0, XTM, YT0+YTD);
            val_out(XT0, YT0, GREEN,      "Frame  %ld", _Frame);
            val_out(XT1, YT0, GREEN,      "Time,s %8.3f", _Frame*0.005);
            val_out(XT2, YT0, GREEN,      "Speed %8.2f", __dSpeed);
            val_out(XT3, YT0, GREEN,      "Erle %8.2f", -dbl(-pSc->sErle));
            val_out(XT4, YT0, GREEN,      "ErleAv %8.2f", -dbl(-pDb->Adf1.sErleAveraged));
            val_out(XT5, YT0, GREEN,      "Erl %8.2f", -dbl(-pSc->sErl));
            val_out(XT7, YT0, GREEN,      "MSE1 %8.2f", fMSE1);
            val_out(XT8, YT0, GREEN,      "MSE2 %8.2f", fMSE2);
        }
    }

    if ((_Control.iGmode & 0x20) == 0)
    {
        /* row 1 --------------------------------------------- */
        bar(XT0, YT1, XTM, YT1+YTD);
        {
            val_out(XT0, YT1, LIGHTGREEN, "GState %d", _Gen.iState);
            val_out(XT1, YT1, LIGHTBLUE,  "TxEn %6.2f", dbl(pSc->sTxEn));
            val_out(XT2, YT1, RED,        "RxIn %6.2f", dbl(pSc->sRxEn));
            val_out(XT3, YT1, LIGHTCYAN,  "Err %6.2f",  dbl(pDb->VadErr.sEn));
            val_out(XT4, YT1, LIGHTRED,   "RxOut %6.2f", 
                    dbl(lec_en2log(lec_pkt_energy(_asRxOut))));
            val_out(XT5, YT1, LIGHTGRAY,  "ErrCr %6.2f",  -dbl(-pDb->VadErr.sCrit));
            val_out(XT6, YT1, CYAN,       "ErrSt %d",  pDb->VadErr.sState);
        }
        /* row 2 --------------------------------------------- */
        bar(XT0, YT2, XTM, YT2+YTD);
        {
            val_out(XT0, YT2, LIGHTGRAY,  "IsDt %d", pDb->uIsDT);
            val_out(XT1, YT2, LIGHTGRAY,  "DtCrit %d", pDb->sDtCriteria);
            val_out(XT2, YT2, LIGHTGRAY,  "AdMode %d", pSc->uAdaptMode);
            val_out(XT3, YT2, LIGHTGRAY,  "IsAd %s", 
                (pSc->uFlags & LEC_FLAG_ADAPT) ? "On" : "Off");
            val_out(XT4, YT2, LIGHTGRAY,  "SS %d", pSc->sStepSize);
            val_out(XT5, YT2, LIGHTGRAY,  "Corr %d", pSc->sStepCorr);
            val_out(XT6, YT2, LIGHTGRAY,  "Clip %d", pSc->sClipThreshold);
            val_out(XT7, YT2, LIGHTGRAY,  "En %lx", pSc->slEn);
            val_out(XT8, YT2, LIGHTGRAY,  "ErOv %7.2f", dbl(-pDb->sErrOverrideCnt));
        }
        /* row 3 --------------------------------------------- */
        bar(XT0, YT3, XTM, YT3+YTD);
        {
            val_out(XT0, YT3, BROWN,      "MSE1 %7.2f", dbl(pDb->Adf1.sMSE));
            val_out(XT1, YT3, LIGHTGREEN, "ERL1 %7.2f", -dbl(-pDb->Adf1.sERL));
            val_out(XT3, YT3, YELLOW,     "ErleAv %7.2f", -dbl(-pDb->Adf1.sErleAveraged));
            val_out(XT4, YT3, WHITE,      "Shift %d", pDb->Adf1.sShift);
            val_out(XT5, YT3, RED,        "Conv %d", pDb->Adf1.uConverged);
            val_out(XT6, YT3, MAGENTA,    "Lack %7.2f", 
                -dbl(-lec_en2log(LEC_SLACC_MAX) + lec_en2log(pDb->Adf1.slAcc)));
            val_out(XT7, YT3, LIGHTGREEN, "ADB %7.2f", dbl(lec_en2log(pDb->Adf1.slAcc)));
            val_out(XT8, YT3, RED,        "Err %7.2f", dbl(pSc->sErr1En));
        }

        /* row 4 --------------------------------------------- */
        bar(XT0, YT4, XTM, YT4+YTD);
        {
#if 0
            {
                S16 a[ILEC_FR_SZ];
                for (k = 0; k < ILEC_FR_SZ; k++) a[k] = int(LEV0/10);
                S32 sl = lec_pkt_energy(a);
                S16 s = lec_en2log(sl,-1024);
            val_out(XT1, YT4, LIGHTRED ,  "En %7.2f", dbl(s));
            }
#endif
            val_out(XT0, YT4, BROWN,      "MSE2 %7.2f", dbl(pDb->Adf2.sMSE));
            val_out(XT1, YT4, LIGHTGREEN, "ERL2 %7.2f", -dbl(-pDb->Adf2.sERL));
            val_out(XT3, YT4, YELLOW,     "ErleAv %7.2f", -dbl(-pDb->Adf2.sErleAveraged));
            val_out(XT4, YT4, WHITE,      "Shift %d", pDb->Adf2.sShift);
            val_out(XT5, YT4, RED,        "Conv %d", pDb->Adf2.uConverged);
            val_out(XT6, YT4, MAGENTA,    "Lack %7.2f", 
                -dbl(-lec_en2log(LEC_SLACC_MAX) + lec_en2log(pDb->Adf2.slAcc)));
            val_out(XT7, YT4, LIGHTGREEN, "ADB %7.2f", dbl(lec_en2log(pDb->Adf2.slAcc)));
            val_out(XT8, YT4, RED,        "Err %7.2f", dbl(pSc->sErr2En));

        }
        /* row 5 --------------------------------------------- */
        bar(XT0, YT5, XTM, YT5+YTD);
        {
            val_out(XT0, YT5, LIGHTRED ,  "Err %7.2f", dbl(pDb->sErrAvrEn));
            val_out(XT1, YT5, BROWN,   "XX %7.2f", dbl(pDb->sRxNoiseLevel));
            val_out(XT2, YT5, WHITE,   "J0T %7.2f", pSc->sJ0Tx/32767.);
            val_out(XT3, YT5, RED,     "r0 %d", pSc->asRk[0]);
            val_out(XT4, YT5, BROWN,   "r1 %d", pSc->asRk[1]);
            val_out(XT5, YT5, GREEN,   "r2 %d", pSc->asRk[2]);
            val_out(XT6, YT5, CYAN,    "r3 %d", pSc->asRk[3]);
            val_out(XT7, YT5, BLUE,    "r4 %d", pSc->asRk[4]);
            val_out(XT8, YT5, MAGENTA, "r5 %d", pSc->asRk[5]);
        }
        /* row 6 --------------------------------------------- */
        bar(XT0, YT6, XTM, YT6+YTD);
        {
            extern double aFs[6];
            extern double dJ;
            val_out(XT0, YT6, LIGHTRED,  "iR0 %d",  pSc->sInvR0);

            static double dJ_min = 1.;
            if (pSc->sJ0/32767. < dJ_min) dJ_min = pSc->sJ0/32767.;
            val_out(XT1, YT6, LIGHTRED,  "Jmin %8.4f",  dJ_min);

            val_out(XT2, YT6, LIGHTRED,     "J0  %7.2f", pSc->sJ0/32767.);
            val_out(XT3, YT6, RED,     "F0 %7.2f", pSc->asF[0]/32767.);
            val_out(XT4, YT6, BROWN,   "F1 %7.2f", pSc->asF[1]/32767.);
            val_out(XT5, YT6, GREEN,   "F2 %7.2f", pSc->asF[2]/32767.);
            val_out(XT6, YT6, CYAN,    "F3 %7.2f", pSc->asF[3]/32767.);
            val_out(XT7, YT6, BLUE,    "F4 %7.2f", pSc->asF[4]/32767.);
            val_out(XT8, YT6, MAGENTA, "F5 %7.2f", pSc->asF[5]/32767.);
        }
    }
}

/*--------------------- public  functions ---------------------------------*/
int iGmode;

/*-------------------------------------------------------------------------*/
void                    demo_init
/*-------------------------------------------------------------------------*/
(
int Err
)
{
    _init_generator();

    sp_bpf_init(&_SpBpfDb);

    LEC_MIKET_init_db(
        &_LecDb, 
        &ILEC_MIKET_DefaultCfg, 
        _asHst
        );
    _LEC_Status.size = sizeof(_LEC_Status);
#if 0
    for (int k = 0; k < LEC_FLT_SZ; k++)
    {
        _asAdf[k+ILEC_FR_SZ] = S16(_afEcho[k]*32767.0);
    }
#endif
    LEC_MIKET_control(&_LecDb, 
                    0
                    | ILEC_CMD_DETECT_HIRCV
//                    | ILEC_CMD_NLP_OFF
//                    | ILEC_CMD_NOADAPT 
                    ,&_LEC_Status);

    
    graphic_init(Err);
    iGmode = _Control.iGmode;
}

/*-------------------------------------------------------------------------*/
void                        demo_run
/*-------------------------------------------------------------------------*/
(
)
{
    S16 k;

    _Frame++;

//    if(_Frame == 790) DEMO_StepMode = TRUE;
//    if(_Frame == (50000/5+10))  DEMO_StepMode = TRUE;
//    if(_Frame == 5870) DEMO_StepMode = TRUE;

    if (_Frame < _GR_FR) _Control.iGmode = 0xffff;
    else _Control.iGmode = iGmode;

	_fill_input();

    if (_Control.iReplaceRx)
    {
        for (k = 0; k < ILEC_FR_SZ; k++) _asRx[k] = 0;
		_add_reflections();
    }
	else if (_Control.iAddReflections)
    {
		_add_reflections();
    }

    sp_bpf(&_SpBpfDb, &_SpBpfSc, _asRx);

    for( k = 0; k < ILEC_FR_SZ; k++)
	{
		_asRxIn[k] = _asRx[k];
	}

    lec_pkts_cpy(_asRxInHst, _asRxInHst+ILEC_FR_SZ, LEC_HST_SZ/ILEC_FR_SZ-1);
    lec_pkts_cpy(_asRxInHst+(LEC_HST_SZ-ILEC_FR_SZ), _asRx, 1);

	LEC_MIKET_process(&_LecDb, &_LecSc, &_asTx[0], &_asRx[0], FALSE);

    for( k = 0; k < ILEC_FR_SZ; k++)
	{
		_asRxOut[k] = _asRx[k];
	}
    lec_pkts_cpy(_asRxOutHst, _asRxOutHst+ILEC_FR_SZ, LEC_HST_SZ/ILEC_FR_SZ-1);
    lec_pkts_cpy(_asRxOutHst+(LEC_HST_SZ-ILEC_FR_SZ), _asRx, 1);

//    for(k=0; k < ILEC_FR_SZ; k++) dump_val(_aRx[k],0);

	if (_Control.pPcmFile) _dump_out();
	if (_Control.pNlpWavFile) _dump_wav();
	if (_Control.pAdfFile) _dump_filters();
	if (_Control.pTmpFile) _dump_vars();
	plot_results();
#if 0
    if (_Frame == 9900)
    {
        for (k = ILEC_FR_SZ*3; k < LEC_FLT2_SZ; k++)
        {
            _LecDb.psFlt1[k] = 0;
            _LecDb.psFlt2[k] = 0;
        }
    }
#endif
}

/*-------------------------------------------------------------------------*/
void                    demo_exit
/*-------------------------------------------------------------------------*/
(
)
{
	// close all files
	if (_Control.pInTxFile)  fclose(_Control.pInTxFile);
	if (_Control.pInTrxFile)  fclose(_Control.pInTrxFile);
	if (_Control.pAdfFile) fclose(_Control.pAdfFile);
	if (_Control.pPcmFile) fclose(_Control.pPcmFile);
	if (_Control.pTmpFile) fclose(_Control.pTmpFile);

	if (_Control.pNlpWavFile) 
    {
        rewind(_Control.pNlpWavFile);
        fwrite(&_WavHdr, 1, sizeof(_WavHdr), _Control.pNlpWavFile);
        fclose(_Control.pNlpWavFile);

        rewind(_Control.pCnlWavFile);
        fwrite(&_WavHdr, 1, sizeof(_WavHdr), _Control.pCnlWavFile);
        fclose(_Control.pCnlWavFile);

        rewind(_Control.pRxWavFile);
        fwrite(&_WavHdr, 1, sizeof(_WavHdr), _Control.pRxWavFile);
        fclose(_Control.pRxWavFile);

        rewind(_Control.pTxWavFile);
        fwrite(&_WavHdr, 1, sizeof(_WavHdr), _Control.pTxWavFile);
        fclose(_Control.pTxWavFile);

    }
}

/*-------------------------------------------------------------------------*/
int                     demo_get_cfg
/*-------------------------------------------------------------------------*/
(
)
{
    int Err = 0;
	FILE *pCfgFile = fopen("sim.cfg", "r");
    int Line;

	if ( pCfgFile == NULL )
	{
        Err = 99;
		_err(Err, 0, "opening config file SIM.CFG ");
	}
	else
	{
		for ( Line = 1;; Line++)
		{
			int i;
			char *p = fgets(_aBuff, 80, pCfgFile);
			if ( p == NULL )	// EOF
			{
				break;
			} /* end-of-if */
			for ( i = 0; i < 80; i++ )
			{
				if ( iscntrl(_aBuff[i]))
				{
					_aBuff[i] = 0;
					break;
				} /* end-of-if */
			}  /* end-of-for */

			if (strlen(_aBuff))
			{
				Err = get_cfg_line(_aBuff);
				if(Err)
				{
                    _err(Err, Line, " processing sim.cfg file at ");
                    val_out(330, 20, WHITE,      "%s", _aBuff);

					break;
				}
			}
		}  /* end-of-for */
		fclose(pCfgFile);
	}
    return Err;
}