main.c

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

#include "leci.h"
#include <stdlib.h>

#define DBG_IT	(35)

S16 asTx[ILEC_FR_SZ];
S16 asRxC[ILEC_FR_SZ];
S16 asRxA[ILEC_FR_SZ];
S16 aS[ILEC_FR_SZ*2];
S16 aC[ILEC_FR_SZ*2];

LEC_MIKET_tStts	SttsC;
LEC_MIKET_tStts	SttsA;

#pragma DATA_ALIGN(asHstC, 2);
#pragma DATA_ALIGN(asHstA, 2);
#pragma DATA_SECTION(asHstC, ".lecb");
#pragma DATA_SECTION(asHstA, ".lecb");
S16 asHstC[LEC_HST_SZ*2];
S16 asHstA[LEC_HST_SZ*2];

#pragma DATA_ALIGN(asFltC, 2);
#pragma DATA_ALIGN(asFltA, 2);
#pragma DATA_SECTION(asFltC, ".leca");
#pragma DATA_SECTION(asFltA, ".leca");
S16 asFltC[LEC_FLT2_SZ*2];
S16 asFltA[LEC_FLT2_SZ*2];

LEC_tDb LecDbA, LecDbC;
LEC_tSc LecScA, LecScC;

volatile S16 sErr = 0;
volatile S32 slA, slC;
volatile S16 sA, sC;
volatile S32 slCntr = 0;
volatile S16 k;

S16 asErrPosDb[8];
S16 asErrPosSc[32];
S16 asErrPos[32];

/*-------------------------------------------------------------------------*/
void 						fill_rand
/*-------------------------------------------------------------------------*/
(
S16 *pTo,
S16 sSz,
S16 sLevel
)
{
	S16 s;
	for (s = 0; s < sSz; s++)
	{
		S16 x = rand() - (RAND_MAX/2);
		x  = (S16)((x * (S32)sLevel)>>14); /* /RAND_MAX = 32767 */
		pTo[s] = x;
	}
}

/*-------------------------------------------------------------------------*/
void 						fill_cnt
/*-------------------------------------------------------------------------*/
(
S16 *pTo,
S16 sSz,
S16 sStart
)
{
	S16 s;
	S16 x = sStart;
	for (s = 0; s < sSz; s++)
	{
		pTo[s] = x;
		x += 0x100;
	}
}

/*-------------------------------------------------------------------------*/
S16 						compare
/*-------------------------------------------------------------------------*/
(
S16 *psIn,
S16 *psInC,
S16 sSz
)
{
	S16 s;     
	S16 err = 0;
	
	for (s = 0; s < 32; s++)asErrPos[s] = 0;
	for (s = 0; s < sSz; s++)
	{
		if(psIn[s] != psInC[s]) {
			err++;
			if (err < 32)
			{
				asErrPos[err] = s;
			}
		}
	}      
	asErrPos[0] = err;
	return err;
}
/*-------------------------------------------------------------------------*/
S16 						compare_db
/*-------------------------------------------------------------------------*/
(
)
{
	S16 *psC = (S16 *)&LecDbC;
	S16 *psA = (S16 *)&LecDbA;
	S16 s;     
	S16 err = 0;

	for (s = 0; s < 8; s++)asErrPosDb[s] = 0;
	
	for (s = 5*2; s < sizeof(LecDbC); s++)
	{
		if(psA[s] != psC[s])
		{
			err++;
			if (err < 8)
			{
				asErrPosDb[err] = s;
			}
		}
		asErrPosDb[0] = err;
	}
	return err;
}
/*-------------------------------------------------------------------------*/
S16 						compare_sc
/*-------------------------------------------------------------------------*/
(
)
{
	S16 *psC = (S16 *)&LecScC;
	S16 *psA = (S16 *)&LecScA;
	S16 s;     
	S16 err = 0;
	
	for (s = 0; s < 32; s++)asErrPosSc[s] = 0;
	/* last is ptr, which is different */
	/* all structures are long-word aligned */
	for (s = 2*2; s < sizeof(LecScC); s++)
	{
		if(psA[s] != psC[s])
		{
			err++;
			if (err < 32)
			{
				asErrPosSc[err] = s;
			}
		}
		asErrPosSc[0] = err;
	}
	return err;
}


void main ()
{
	memset(&LecDbA, 0, sizeof(LecDbA));	
	memset(&LecDbC, 0, sizeof(LecDbC));	
	memset(&LecScA, 0, sizeof(LecScA));	
	memset(&LecScC, 0, sizeof(LecScC));	
	LecScA.psRx = asRxA;
	LecScC.psRx = asRxC;
	LecScA.psTx = asTx;
	LecScC.psTx = asTx;
	LecDbA.psHst = asHstA;
	LecDbC.psHst = asHstC;
	LecDbA.psTxF = asHstA + LEC_HST_SZ;
	LecDbC.psTxF = asHstC + LEC_HST_SZ;
	LecDbA.psFlt1 = asFltA;
	LecDbA.psFlt2 = asFltA+LEC_FLT2_SZ;
	LecDbC.psFlt1 = asFltC;
	LecDbC.psFlt2 = asFltC+LEC_FLT2_SZ;
	sErr = 0;
	
#if (DBG_IT == 0)	
#elif (DBG_IT == 1)
	for (k = 0; k < 100; k++)
	{
		fill_rand(LecDbC.asBandPassSav, LEC_BP_SSZ, 3333);
		fill_rand(asRxC, ILEC_FR_SZ, 4444);
//		fill_cnt(LecDbC.asBandPassSav, LEC_BP_SSZ, 0x12);
//		fill_cnt(asRxC, ILEC_FR_SZ, 0x34);
		memcpy(LecDbA.asBandPassSav, LecDbC.asBandPassSav, LEC_BP_SSZ);
		memcpy(asRxA, asRxC, ILEC_FR_SZ);
		lec_band_pass_rxC(&LecDbC, &LecScC);
		lec_band_pass_rx (&LecDbA, &LecScA);
		sErr += compare_db();
		sErr += compare_sc();
		sErr += compare(asRxC, asRxA, ILEC_FR_SZ);
	}
#elif (DBG_IT == 2)
	LecScC.asRk[0] = 32767;
	LecScC.asRk[1] = 25000;
	LecScC.asRk[2] = 20000;
	LecScC.asRk[3] = 10000;
	LecScC.asRk[4] = 5000;
	LecScC.asRk[5] = 3000; 
	memcpy(LecScA.asRk, LecScC.asRk, 6);
	LecScC.sJ0 = lec_durbinC(&LecDbC, &LecScC);
	LecScA.sJ0 = lec_durbin (&LecDbA, &LecScA);
	for (k = 0; k < 6; k++) LecScC.aslG[k] = LecScC.aslG[k]<<1;
	sErr += compare_sc();

#elif (DBG_IT == 3)
	for (k = 0; k < 100; k++)
	{
		S16 i;
		LecScC.asRk[0] = 32767;
		fill_rand(&LecScC.asRk[1], 5, 32000);
		memcpy(LecScA.asRk, LecScC.asRk, 6);
		LecScC.sJ0 = lec_durbinC(&LecDbC, &LecScC);
		LecScA.sJ0 = lec_durbin (&LecDbA, &LecScA);
		for (i = 0; i < 6; i++) LecScC.aslG[i] = LecScC.aslG[i]<<1;
		sErr += compare_sc();
	}
#elif (DBG_IT == 4)
	{
		LecScC.aslRk[0] = 2900000;
		LecScC.aslRk[1] = 2500000;
		LecScC.aslRk[2] = 2000000;
		LecScC.aslRk[3] = 1000000;
		LecScC.aslRk[4] = 500000;
		LecScC.aslRk[5] = 300000; 
		memcpy(LecScA.aslRk, LecScC.aslRk, 2*6);
		lec_normalise_rkC(&LecDbC, &LecScC, -4, (1<<4));
		lec_normalise_rk (&LecDbA, &LecScA, -4, (1<<4));
		sErr += compare_sc();
	}

#elif (DBG_IT == 50)
	for (k = 0; k < 100; k++)
	{
		fill_rand(asTx, ILEC_FR_SZ, 8000);
//		memset(asTx, 1000, ILEC_FR_SZ);
		fill_rand(asHstC, LEC_HST_SZ, 8000);
//		memset(asHstC, 1000, LEC_HST_SZ);
		memcpy(asHstA, asHstC, LEC_HST_SZ);
		lec_tx_momentsC(&LecDbC, &LecScC);
		lec_tx_moments (&LecDbA, &LecScA);
		sErr += compare_sc();
		sErr += compare_db();
	}
#elif (DBG_IT == 5)
	{
		S16 i;
		for (i = 0; i < 6; i++)
		{
			S32 ac0 = rand();
			ac0 <<= 16;
			ac0 += rand();
			if (ac0 < 0) ac0 = -ac0;
			LecDbC.aslRk[i] = ac0;
			LecDbA.aslRk[i] = ac0;
		}
	}
	for (k = 0; k < 100; k++)
	{
		fill_rand(asTx, ILEC_FR_SZ, 8000);
		fill_rand(asHstC, LEC_HST_SZ, 8000);
		memcpy(asHstA, asHstC, LEC_HST_SZ);
		lec_tx_moments (&LecDbC, &LecScC);
		lec_tx_moments (&LecDbA, &LecScA);
		lec_gs_momentsC(&LecDbC, &LecScC);
		lec_gs_moments (&LecDbA, &LecScA);
		sErr += compare_sc();
		sErr += compare_db();
	}
#elif (DBG_IT == 6)
	for (k = 0; k < 100; k++)
	{
		fill_rand(asHstC, LEC_HST_SZ, 8000);
		memcpy(asHstA, asHstC, LEC_HST_SZ);
		LecScC.asF[0] =  32767;
		LecScC.asF[1] = -30000;
		LecScC.asF[2] =  20000;
		LecScC.asF[3] = -15000;
		LecScC.asF[4] =  10000;
		LecScC.asF[5] = -5000;
		memcpy(LecScA.asF, LecScC.asF, 6);
		lec_gs_filterC(&LecDbC, &LecScC);
		lec_gs_filter (&LecDbA, &LecScA);
		sErr += compare_sc();
	}
#elif (DBG_IT == 7)
	{
		S16 i;
		for (i = 0; i < 6; i++)
		{
			S32 ac0 = rand();
			ac0 <<= 16;
			ac0 += rand();
			if (ac0 < 0) ac0 = -ac0;
			ac0 >>= 2;
			LecDbC.aslRkSav[i] = ac0;
			LecDbA.aslRkSav[i] = ac0;
		}
	}
	for (k = 0; k < 100; k++)
	{
		fill_rand(asTx, ILEC_FR_SZ, 8000);
		fill_rand(asHstC, LEC_HST_SZ, 8000);
		memcpy(asHstA, asHstC, LEC_HST_SZ);
		lec_tx_moments (&LecDbC, &LecScC);
		lec_tx_moments (&LecDbA, &LecScA);
		lec_ts_momentsC(&LecDbC, &LecScC);
		lec_ts_moments (&LecDbA, &LecScA);
		sErr += compare_sc();
		sErr += compare_db();
	}
#elif (DBG_IT == 8)
	for (k = 0; k < 100; k++)
	{
		S16 asTmp[3];
		S16 C;
		S16 A;
		fill_rand(asTmp, 3, 8000);
		C = A = asTmp[0];
		lec_avrgC(&C, asTmp[1], asTmp[2]);
		lec_avrg (&A, asTmp[1], asTmp[2]);
		sErr += abs(C-A);
	}
#elif (DBG_IT == 9)
	{
		for(k = 0; k < ILEC_FR_SZ*3; k++) asHstA[k] = k;
		lec_pkts_cpy(asHstC, asHstA, 2);
	}
#elif (DBG_IT == 10)
	for (k = 0; k < 100; k++)
	{
		S16 C, A;
		C = asRxC[ILEC_FR_SZ-1];
		A = asRxC[ILEC_FR_SZ-1];
		lec_pkt_randC(asRxC, &C);
		lec_pkt_rand (asRxA, &A);
		sErr += compare(asRxC, asRxA, ILEC_FR_SZ);
	}
#elif (DBG_IT == 11)
	for (k = 0; k < 100; k++)
	{
		extern S32 lec_pkt_energy(S16*);
		extern S32 lec_pkt_energyC(S16*);
//		S32 slC, slA;
		fill_rand(asRxC, ILEC_FR_SZ, 8000);
		slC = lec_pkt_energyC(asRxC);
		slA = lec_pkt_energy (asRxC);
		if (slA != slC) sErr++;
	}
#elif (DBG_IT == 12)
	for (k = 0; k < 100; k++)
	{
		extern S16 lec_en2log(S32 slEn, S16 sCorr);
		extern S16 lec_en2logC(S32 slEn, S16 sCorr);
		fill_rand((S16 *)&slC, 2, 8000);
		slC = labs(slC);
//		slC = 0x2000000L;
		slA = slC;
		sC = lec_en2logC(slC, 512);
		sA = lec_en2log (slC, 512);
		if(sC-sA) sErr++;
	}
#elif (DBG_IT == 13)
	for (k = 0; k < 100; k++)
	{
		sC = (rand()-RAND_MAX/2);
		if (sC > 170*18) sC = 170*18;
		if (sC < -170*100) sC = -170*100;
//		sC = -512*3+100;
		sA = sC;
		sC = lec_expC(sC);
		sA = lec_exp (sA);
		sErr += abs(sC-sA);
	}
#elif (DBG_IT == 14)
	for (k = 0; k < 100; k++)
	{
		fill_rand(asRxC, ILEC_FR_SZ, 8000);
		sC = lec_pkt_zcC(asRxC);
		sA = lec_pkt_zc (asRxC);
		sErr += abs(sC - sA);
	}
#elif (DBG_IT == 15)
	for (k = 0; k < 100; k++)
	{
		fill_rand(asRxC, ILEC_FR_SZ, 8000);
		sC = lec_pkt_peakC(asRxC);
		sA = lec_pkt_peak (asRxC);
		sErr += abs(sC - sA);
	}
#elif (DBG_IT == 16)
	for (k = 0; k < 100; k++)