main.c

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

	{
		fill_rand(asRxC, ILEC_FR_SZ, 8000);
		sC = lec_pkt_excessC(asRxC, 4000);
		sA = lec_pkt_excess (asRxC, 4000);
		sErr += abs(sC - sA);
	}
#elif (DBG_IT == 17)
	for (k = 0; k < 100; k++)
	{
		fill_rand(asHstC, ILEC_FR_SZ*2, 32000);
		lec_make_noiseC(asRxC, asHstC, 200);
		lec_make_noise (asRxA, asHstC, 200);
		sErr += compare(asRxC, asRxA, ILEC_FR_SZ);
	}
#elif (DBG_IT == 18)
	for (k = 0; k < 100; k++)
	{
		fill_rand(asHstC, ILEC_FR_SZ*2, 32000);
//		memset(asRxC, 0, ILEC_FR_SZ);
		fill_rand(asRxC, ILEC_FR_SZ, 5000);
		memcpy(asRxA, asRxC, ILEC_FR_SZ);
		asHstC[0] = 264;
		lec_central_clippingC(asRxC, asHstC, 200);
		lec_central_clipping (asRxA, asHstC, 200);
		sErr += compare(asRxC, asRxA, ILEC_FR_SZ);
	}
#elif (DBG_IT == 19)
	for (k = 0; k < 100; k++)
	{
		extern S16 _aasLpFilter[][6];
		
		fill_rand(LecScC.asErr1, ILEC_FR_SZ, 8000);
		fill_rand(LecDbC.asLpSav, 5, 8000);
		memcpy(LecScA.asErr1, LecScC.asErr1, ILEC_FR_SZ);
		memcpy(LecDbA.asLpSav, LecDbC.asLpSav, 5);
		lec_lp_residual_errorC(&LecDbC, &LecScC, &_aasLpFilter[3][0]);
		lec_lp_residual_error (&LecDbA, &LecScA, &_aasLpFilter[3][0]);
		sErr += compare_sc();
		sErr += compare_db();
	}
#elif (DBG_IT == 20)
	for (k = 0; k < 100; k++)
	{
		fill_rand(asHstC, LEC_HST_SZ, 8000);
		fill_rand(asFltC, LEC_FLT2_SZ, 1000);
//		memset(asFltC, 0, LEC_FLT2_SZ);
		fill_rand(asRxC, ILEC_FR_SZ, 4000);
//		memset(asRxC, 0, ILEC_FR_SZ);
		memcpy(asHstA, asHstC, LEC_HST_SZ);
		memcpy(asFltA, asFltC, LEC_FLT2_SZ);
		memcpy(asRxA, asRxC, ILEC_FR_SZ);
		LecDbC.Adf1.sShift = 1;
		LecDbA.Adf1.sShift = 1;
		LecDbC.Adf1.sNegShift = -1;
		LecDbA.Adf1.sNegShift = -1;
		lec_cancel_pktC(&LecDbC, &LecScC);
		lec_cancel_pkt (&LecDbA, &LecScA);
		sErr += compare_sc();
	}
#elif (DBG_IT == 21)
	for (k = 0; k < 100; k++)
	{
		fill_rand(asHstC, LEC_HST_SZ, 8000);
		fill_rand(asFltC, LEC_FLT2_SZ, 1000);
		memcpy(asHstA, asHstC, LEC_HST_SZ);
		memcpy(asFltA, asFltC, LEC_FLT2_SZ);
		sC = (rand() - RAND_MAX/2)/8;
		sA = sC;
		sC = lec_cancelC(asHstC+LEC_HST_SZ-1, asFltC, sC);
		sA = lec_cancel (asHstA+LEC_HST_SZ-1, asFltA, sA);
		if (sC-sA) sErr++;
	}
#elif (DBG_IT == 22)
	for (k = 0; k < 100; k++)
	{
		fill_rand(asHstC, LEC_HST_SZ, 8000);
		fill_rand(asFltC, LEC_FLT2_SZ, 1000);
		memcpy(asHstA, asHstC, LEC_HST_SZ);
		memcpy(asFltA, asFltC, LEC_FLT2_SZ);
		sC = (rand() - RAND_MAX/2)/8;
//		sC = 0;
		sA = sC;
		sC = lec_cancel_shiftedC(asHstC+LEC_HST_SZ-1, asFltC, sC, 2);
		sA = lec_cancel_shifted (asHstA+LEC_HST_SZ-1, asFltA, sA, 2);
		if (sC-sA) sErr++;
	}
#elif (DBG_IT == 23)
	for (k = 0; k < 100; k++)
	{
		extern S32 lec_get_xzC(S16 *, S16 *);
		extern S32 lec_get_xz (S16 *, S16 *);
		fill_rand(asHstC, LEC_HST_SZ, 8000);
		fill_rand(asFltC, LEC_FLT2_SZ, 1000);
		memcpy(asHstA, asHstC, LEC_HST_SZ);
		memcpy(asFltA, asFltC, LEC_FLT2_SZ);
		slC = lec_get_xzC(asHstC+ILEC_FR_SZ*5-1, asFltC+ILEC_FR_SZ*5-1);
		slA = lec_get_xz (asHstC+ILEC_FR_SZ*5-1, asFltC+ILEC_FR_SZ*5-1);
		if (slC-slA) sErr++;
	}
#elif (DBG_IT == 24)
	for (k = 0; k < 100; k++)
	{
		extern S32 lec_get_xz (S16 *, S16 *);
		extern S32 lec_update_xzC(S32, S16 *, S16 *);
		extern S32 lec_update_xz (S32, S16 *, S16 *);
		fill_rand(asHstC, LEC_HST_SZ, 8000);
		fill_rand(asHstA, LEC_HST_SZ, 1000);
		slC = lec_get_xz (asHstC+ILEC_FR_SZ*5-1, asHstA+ILEC_FR_SZ*5-1);
		slA = slC;
		slC = lec_update_xzC(slC, asHstC+ILEC_FR_SZ*5, asHstA+ILEC_FR_SZ*5);
		slA = lec_update_xz (slA, asHstC+ILEC_FR_SZ*5, asHstA+ILEC_FR_SZ*5);
		if (slC-slA) sErr++;
	}
#elif (DBG_IT == 25)
	for (k = 0; k < 100; k++)
	{
		S16 max = rand()/3;
		fill_rand(asFltC+LEC_FLT2_SZ, LEC_FLT2_SZ, max);
		memcpy(asFltA+LEC_FLT2_SZ, asFltC+LEC_FLT2_SZ, LEC_FLT2_SZ);
		lec_shift_adf2C(&LecDbC, &LecScC);
		lec_shift_adf2 (&LecDbA, &LecScA);
		sErr += compare(asFltC+LEC_FLT2_SZ, asFltA+LEC_FLT2_SZ, LEC_FLT2_SZ);
		sErr += compare_db();
	}
#elif (DBG_IT == 26)
	for (k = 0; k < 100; k++)
	{
		slC = rand();
		slC += ((S32)rand())<<15;
		slC = labs(slC);
//		slC >>= 10;
//		slC >>= 10;
		slA = slC;
		sC = lec_step_sizeC(slC, asRxC);		
		sA = lec_step_size (slA, asRxA);
		if (sC-sA) sErr++;
		if (asRxC[0] - asRxA[0]) sErr++;
	}
#elif (DBG_IT == 27)
	for (k = 0; k < 100; k++)
	{
		S16 sBase;
		S16 sStep;
		fill_rand(asHstC, LEC_HST_SZ, 8000);
		fill_rand(asFltC+LEC_FLT2_SZ, LEC_FLT2_SZ, 1000);
		fill_rand(LecScC.asErr2, ILEC_FR_SZ, 2000);
		fill_rand(LecScC.asTxF, LEC_HST_SZ, 3000);
		memcpy(asHstA, asHstC, LEC_HST_SZ);
		memcpy(asFltA+LEC_FLT2_SZ, asFltC+LEC_FLT2_SZ, LEC_FLT2_SZ);
		memcpy(LecScA.asErr2, LecScC.asErr2, ILEC_FR_SZ);
		memcpy(LecScA.asTxF, LecScC.asTxF, LEC_HST_SZ);
		sBase = rand() % ILEC_FR_SZ;
		sStep = rand() % 2000;
		lec_adapt_fast_highC(&LecDbC, &LecScC, sBase, sStep);
		lec_adapt_fast_high (&LecDbA, &LecScA, sBase, sStep);
		sErr += compare(asFltC+LEC_FLT2_SZ, asFltA+LEC_FLT2_SZ, LEC_FLT2_SZ);
		sErr += compare_sc();
	}
#elif (DBG_IT == 28)
	{
		fill_rand(asFltC+LEC_FLT2_SZ, LEC_FLT2_SZ, 2000);
		memcpy(asFltA+LEC_FLT2_SZ, asFltC+LEC_FLT2_SZ, LEC_FLT2_SZ);
	}
	for (k = 0; k < 100; k++)
	{
		S16 sBase;
		S16 sStep;
		fill_rand(asHstC, LEC_HST_SZ, 800);
//		memset(asFltC+LEC_FLT2_SZ, 0, LEC_FLT2_SZ);
		fill_rand(LecScC.asErr2, ILEC_FR_SZ, 200);
		fill_rand(LecDbC.psTxF, LEC_HST_SZ, 300);
		memcpy(asHstA, asHstC, LEC_HST_SZ);
		memcpy(LecScA.asErr2, LecScC.asErr2, ILEC_FR_SZ);
		memcpy(LecDbA.psTxF, LecDbC.psTxF, LEC_HST_SZ);
		sBase = rand() % ILEC_FR_SZ;
		sStep = rand() % 2000;
		lec_adapt_fast_lowC(&LecDbC, &LecScC, sBase, sStep);
		lec_adapt_fast_low (&LecDbA, &LecScA, sBase, sStep);
		sErr += compare(asFltC+LEC_FLT2_SZ, asFltA+LEC_FLT2_SZ, LEC_FLT2_SZ);
		sErr += compare_sc();
	}
#elif (DBG_IT == 29)
	for (k = 0; k < 100; k++)
	{
		extern S32 lec_get_xz_slowC(S16 *, S16 *);
		extern S32 lec_get_xz_slow (S16 *, S16 *);
		fill_rand(asHstC, LEC_HST_SZ, 8000);
		fill_rand(asHstA, LEC_HST_SZ, 1000);
		slC = lec_get_xz_slowC(asHstC, asHstA);
		slA = lec_get_xz_slow (asHstC, asHstA);
		if (slC-slA) sErr++;
	}
#elif (DBG_IT == 30)
	for (k = 0; k < 100; k++)
	{
		S16 sBase;
		S16 sStep;
		fill_rand(asHstC, LEC_HST_SZ, 8000);
		fill_rand(asFltC+LEC_FLT2_SZ, LEC_FLT2_SZ, 1000);
		fill_rand(LecScC.asErr2, ILEC_FR_SZ, 2000);
		fill_rand(LecDbC.psTxF, LEC_HST_SZ, 3000);
		memcpy(asHstA, asHstC, LEC_HST_SZ);
		memcpy(asFltA+LEC_FLT2_SZ, asFltC+LEC_FLT2_SZ, LEC_FLT2_SZ);
		memcpy(LecScA.asErr2, LecScC.asErr2, ILEC_FR_SZ);
		memcpy(LecDbA.psTxF, LecDbC.psTxF, LEC_HST_SZ);
		sBase = (rand() % (ILEC_FR_SZ/LEC_SECTION_SZ))*LEC_SECTION_SZ;
		sStep = rand() % 2000;
		lec_adapt_slow_highC(&LecDbC, &LecScC, sBase, sStep);
		lec_adapt_slow_high (&LecDbA, &LecScA, sBase, sStep);
		sErr += compare(asFltC+LEC_FLT2_SZ, asFltA+LEC_FLT2_SZ, LEC_FLT2_SZ);
		sErr += compare_sc();
	}
#elif (DBG_IT == 31)
	for (k = 0; k < 100; k++)
	{
		S16 sBase;
		S16 sStep;
		fill_rand(asHstC, LEC_HST_SZ, 800);
		fill_rand(asFltC+LEC_FLT2_SZ, LEC_FLT2_SZ, 1000);
		fill_rand(LecScC.asErr2, ILEC_FR_SZ, 200);
		fill_rand(LecDbC.psTxF, LEC_HST_SZ, 300);
		memcpy(asHstA, asHstC, LEC_HST_SZ);
		memcpy(asFltA+LEC_FLT2_SZ, asFltC+LEC_FLT2_SZ, LEC_FLT2_SZ);
		memcpy(LecScA.asErr2, LecScC.asErr2, ILEC_FR_SZ);
		memcpy(LecDbA.psTxF, LecDbC.psTxF, LEC_HST_SZ);
		sBase = (rand() % (ILEC_FR_SZ/LEC_SECTION_SZ))*LEC_SECTION_SZ;
		sStep = rand() % 2000;
		lec_adapt_slow_lowC(&LecDbC, &LecScC, sBase, sStep);
		lec_adapt_slow_low (&LecDbA, &LecScA, sBase, sStep);
		sErr += compare(asFltC+LEC_FLT2_SZ, asFltA+LEC_FLT2_SZ, LEC_FLT2_SZ);
		sErr += compare_sc();
	}
#elif (DBG_IT == 32)
	for (k = 0; k < 100; k++)
	{
		fill_rand(LecScC.asErr2, ILEC_FR_SZ, 8000);
		LecScC.asErr2[0] = 0x1000;
		memcpy(LecScA.asErr2, LecScC.asErr2, ILEC_FR_SZ);
		LecDbC.Adf2.sShift = 2;
		LecDbC.Adf2.sNegShift = -2;
		LecDbA.Adf2.sShift = 2;
		LecDbA.Adf2.sNegShift = -2;
		lec_shift_err2C(&LecDbC, &LecScC);
		lec_shift_err2 (&LecDbA, &LecScA);
		sErr += compare_sc();
	}
#elif (DBG_IT == 33)
	for (k = 0; k < 100; k++)
	{
		S16 base;
		fill_rand(LecScC.asErr2, ILEC_FR_SZ, 3000);
		LecScC.asErr2[0] = 0x1000;
		memcpy(LecScA.asErr2, LecScC.asErr2, ILEC_FR_SZ);
		LecDbC.Adf2.sShift = 2;
		LecDbC.Adf2.sNegShift = -2;
		LecDbA.Adf2.sShift = 2;
		LecDbA.Adf2.sNegShift = -2;
		LecDbC.sErrAvrEn = LEC_DB(-40) - rand()/100;
		LecDbA.sErrAvrEn = LecDbC.sErrAvrEn;
		LecScC.sExpectedErrorEn = LEC_DB(-40) - rand()/100;
		LecScA.sExpectedErrorEn = LecScC.sExpectedErrorEn;
		LecDbC.VadErr.sEnNoise = LEC_DB(-40) - rand()/100;
		LecDbA.VadErr.sEnNoise = LecDbC.VadErr.sEnNoise;
		base = (rand() % 10)*4;
		sC = lec_step_size_corr_slowC(&LecDbC, &LecScC, base);
		sA = lec_step_size_corr_slow (&LecDbA, &LecScA, base);
		sErr += compare_sc();
		sErr += compare_db();
		if (sC != sA) sErr++;
		if (sErr > 0)
		{
			slCntr++;
//			sErr = 0;
		}
	}
#elif (DBG_IT == 34)
	for (k = 0; k < 100; k++)
	{
		S16 base;
		fill_rand(LecScC.asErr2, ILEC_FR_SZ, 3000);
		LecScC.asErr2[0] = 0x1000;
		memcpy(LecScA.asErr2, LecScC.asErr2, ILEC_FR_SZ);
		LecDbC.Adf2.sShift = 1;
		LecDbC.Adf2.sNegShift = -LecDbC.Adf2.sShift;
		LecDbA.Adf2.sShift = LecDbC.Adf2.sShift;
		LecDbA.Adf2.sNegShift = LecDbC.Adf2.sNegShift;
		LecDbC.sErrAvrEn = LEC_DB(-50) - rand()/100;
		LecDbA.sErrAvrEn = LecDbC.sErrAvrEn;
		LecScC.sExpectedErrorEn = LEC_DB(-50) - rand()/100;
		LecScA.sExpectedErrorEn = LecScC.sExpectedErrorEn;
		LecDbC.VadErr.sEnNoise = LEC_DB(-50) - rand()/100;
		LecDbA.VadErr.sEnNoise = LecDbC.VadErr.sEnNoise;
		base = (rand() % 40);
		sC = lec_step_size_corr_fastC(&LecDbC, &LecScC, base);
		sA = lec_step_size_corr_fast (&LecDbA, &LecScA, base);
		sErr += compare_sc();
		sErr += compare_db();
		if (sC != sA) sErr++;
		if (sErr > 0)
		{
			slCntr++;
//			sErr = 0;
		}
	}
#elif (DBG_IT == 35)
	{
//		ILEC_Status Sts;
		ILEC_tCfg LecCfg;

		LecCfg.uControl = 
					  ILEC_CMD_LOOPBACK_MASK
					| ILEC_CMD_HIPASS_MASK 
                    | ILEC_CMD_DETECT_HITX_MASK;
		LecCfg.sClipThr = LEC_DB(6);
		LecCfg.sErlMin = LEC_DB(3);
		LecCfg.sToneDetectThr = Q15(0.05);
		LecCfg.sToneReleaseThr = Q15(0.12);
		LecCfg.sTxMax = 7770;

		LEC_MIKET_init_db(&LecDbA, &LecCfg, &SttsA, asHstA, asFltA);

		for (k = 0; k < 100; k++)
		{
			fill_rand(asTx, ILEC_FR_SZ, 5000);
			LEC_MIKET_process(&LecDbA, &LecScA, asTx, asRxA, 0);
		}
	}
#elif (DBG_IT == 36)
	for (k = 0; k < 100; k++)
	{
		dummy();	
	}
#elif (DBG_IT == 37)
	for (k = 0; k < 100; k++)
	{
		lec_dummya1();	
	}
#elif (DBG_IT == 38)
	{
//		S16 i;
		fill_rand(asFltC+LEC_FLT2_SZ, LEC_FLT2_SZ, 1000);
//		for(i=0;i<LEC_FLT2_SZ;i++)asFltC[LEC_FLT2_SZ+i] = i+1;
		memcpy(asFltA+LEC_FLT2_SZ, asFltC+LEC_FLT2_SZ, LEC_FLT2_SZ);
		LecDbC.sErrAvrEn = LecDbA.sErrAvrEn = LEC_DB(-10);
		LecScC.sExpectedErrorEn = LecScA.sExpectedErrorEn = LEC_DB(-10);
		LecDbC.Adf2.slAcc = LecDbA.Adf2.slAcc = 100000L;
	}
	for (k = 0; k < 100; k++)
	{
		fill_rand(asHstC, LEC_HST_SZ, 8000);
		fill_rand(asRxC, ILEC_FR_SZ, 2000);
		fill_rand(asHstC+LEC_HST_SZ, LEC_HST_SZ, 4000);
		
		memcpy(asHstA, asHstC, LEC_HST_SZ*2);
		memcpy(asRxA, asRxC, ILEC_FR_SZ);
		lec_adapt_fastC(&LecDbC, &LecScC);
		lec_adapt_fast (&LecDbA, &LecScA);
		sErr += compare(asFltC+LEC_FLT2_SZ, asFltA+LEC_FLT2_SZ, LEC_FLT2_SZ);
		sErr += compare_sc();
		sErr += compare_db();
	}
#elif (DBG_IT == 39)
	for (k = 0; k < 100; k++)
	{
		S16 i;
		fill_rand(asHstC, LEC_HST_SZ, 800);
//		fill_rand(asFltC+LEC_FLT2_SZ, LEC_FLT2_SZ, 1000);
		for(i=0;i<LEC_FLT2_SZ;i++)asFltC[LEC_FLT2_SZ+i] = i+1;
		fill_rand(asRxC, ILEC_FR_SZ, 2000);
		memcpy(LecScC.asTxF, asHstC, LEC_HST_SZ);
		
		memcpy(asHstA, asHstC, LEC_HST_SZ);
		memcpy(asFltA+LEC_FLT2_SZ, asFltC+LEC_FLT2_SZ, LEC_FLT2_SZ);
		memcpy(asRxA, asRxC, ILEC_FR_SZ);
		memcpy(LecScA.asTxF, LecScC.asTxF, LEC_HST_SZ);
		LecDbC.sErrAvrEn = LecDbA.sErrAvrEn = LEC_DB(-30);
		LecScC.sExpectedErrorEn = LecScA.sExpectedErrorEn = LEC_DB(-30);
		LecDbC.Adf2.slAcc = LecDbA.Adf2.slAcc = 100000L;
		lec_adapt_slow (&LecDbA, &LecScA);
	}
#elif (DBG_IT == 40)
#elif (DBG_IT == 41)
#elif (DBG_IT == 42)
#elif (DBG_IT == 43)
#endif
	{
		for(;;)
		{
			extern S16 lec_en2log(S32 slEn, S16 sCorr);
			slCntr++;
			lec_en2log(slCntr, 0);
		}
	}

}