首页 › 资源下载 › DSP编程 › The line echo cancel › 源码查看
main.c

来自「The line echo canceller (LEC) is designe」· C语言代码 · 共 766 行 · 第 1/2 页
766 行
#include "leci.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include "ilec.c"
#include "splec.h"
#include "spbpf.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_SECTION(asHstC, ".lecb")
#pragma DATA_SECTION(asHstA, ".lecb")
S16 asHstC[LEC_HST_SZ*2];
S16 asHstA[LEC_HST_SZ*2];

LEC_tDb LecDbA, LecDbC;
LEC_tSc LecScA, LecScC;

SPBPF_tDb BpfDbA, BpfDbC;
SPBPF_tSc BpfScA, BpfScC;

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 sErrPos;

// stubs 

SPLEC_tDb  SPLEC_aDb[1];
SPLEC_tHst SPLEC_aHst[1];
U16 SP_uInstCur;
U16 SP_uInstMax;
void *SP_pScratch;
SPIF_tLog *SP_pLog;
void SPIFcbLog(const SPIF_tLog *SP_pLog){}

/*-------------------------------------------------------------------------*/
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 < sSz; s++)
	{
		if(psIn[s] != psInC[s]) {
			err++;
			sErrPos = s;
		}
	}      
	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 = 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; 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;
	sErr = 0;
#if (DBG_IT == 0)
	{
		if (sizeof(SPLEC_tDb) != sizeof(LEC_tDb))
		{
			exit(1);
		}
		if (sizeof(SPLEC_tSc) != sizeof(LEC_tSc))
		{
			exit(1);
		}
		
	}
#elif (DBG_IT == 1)
	fill_rand(BpfDbC.asSav, SPBPF_SSZ, 3333);
	memcpy(BpfDbA.asSav, BpfDbC.asSav, SPBPF_SSZ);
	for (k = 0; k < 100; k++)
	{
		fill_rand(asRxC, ILEC_FR_SZ, 4444);
//		fill_cnt(LecDbC.asBandPassSav, LEC_BP_SSZ, 0x12);
//		fill_cnt(asRxC, ILEC_FR_SZ, 0x34);
		memcpy(asRxA, asRxC, ILEC_FR_SZ);
		sp_bpfC(&BpfDbC, &BpfScC, asRxC);
		sp_bpf (&BpfDbA, &BpfScA, asRxA);
		sErr += compare((S16*)&BpfDbC, (S16*)&BpfDbA, sizeof(BpfDbA));
		sErr += compare((S16*)&BpfScC, (S16*)&BpfScA, sizeof(BpfScA));
		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)
	LecScC.asRk[0] = 32767;
	for (k = 0; k < 100; k++)
	{
		S16 i;
		fill_rand(&LecScC.asRk[1], 5, 25000);
		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 == 51)
	for (k = 0; k < 100; k++)
	{
		fill_rand(asTx, ILEC_FR_SZ, 8000);
		fill_rand(LecDbC.psHst, LEC_HST_SZ, 8000);
		memcpy(LecDbA.psHst, LecDbC.psHst, LEC_HST_SZ);
		lec_tx_momentsC(&LecDbC, &LecScC);
		lec_tx_moments (&LecDbA, &LecScA);
		sErr += compare_sc();
		sErr += compare_db();
	}
#elif (DBG_IT == 5)
	for (k = 0; k < 100; k++)
	{
		fill_rand((S16*)LecDbC.aslRk, 12, 8000);
		fill_rand((S16*)LecScC.aslRk, 12, 8000);
		fill_rand((S16*)LecScC.aslRkTx, 12, 8000);
		memcpy(LecDbA.aslRk,LecDbC.aslRk,12);
		memcpy(LecScA.aslRk,LecScC.aslRk,12);
		memcpy(LecScA.aslRkTx,LecScC.aslRkTx,12);
		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*2, 8000);
		memcpy(asHstA, asHstC, LEC_HST_SZ*2);
		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();
		sErr += compare(asHstC, asHstA, LEC_HST_SZ*2);
	}
#elif (DBG_IT == 7)
	for (k = 0; k < 100; k++)
	{
		fill_rand((S16*)LecDbC.aslRkSav, 12, 8000);
		fill_rand((S16*)LecScC.aslRk, 12, 8000);
		fill_rand((S16*)LecScC.aslRkTx, 12, 8000);
		memcpy(LecDbA.aslRkSav,LecDbC.aslRkSav,12);
		memcpy(LecScA.aslRk,LecScC.aslRk,12);
		memcpy(LecScA.aslRkTx,LecScC.aslRkTx,12);
		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++)
	{
		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 == 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);
		sErr += compare((S16*)&slC,(S16*)&slA,2);
	}
#elif (DBG_IT == 12)
	for (k = 0; k < 100; k++)
	{
		extern S16 lec_en2log(S32 slEn);
		extern S16 lec_en2logC(S32 slEn);
		fill_rand((S16 *)&slC, 2, 8000);
		slC = labs(slC);
//		slC = 0x2000000L;
		slA = slC;
		sC = lec_en2logC(slC);
		sA = lec_en2log (slC);
		sErr += abs(sC-sA);
	}
#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);
	}
main.c - 源码说明

本页面展示了「The line echo canceller (LEC) is designed to provide the maximum attainable transparent voice qualit」中的 main.c 源码文件，采用 C语言编程语言编写，共 766 行代码。您可以在线阅读完整代码内容，也可以返回资源详情页下载完整源码包进行本地学习和开发。
虫虫下载站收录了大量与transparent相关的技术资源，包括源代码、技术文档、电路图等，是电子工程师和嵌入式开发者的专业学习平台。
⌨️ 快捷键说明

复制代码Ctrl + C
搜索代码Ctrl + F
全屏模式F11
增大字号Ctrl + =
减小字号Ctrl + -
显示快捷键?