main.c

来自「The line echo canceller (LEC) is designe」· C语言 代码 · 共 766 行 · 第 1/2 页

C
766 行
字号
12
#elif (DBG_IT == 16)
	for (k = 0; k < 100; k++)
	{
		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++)
	{
		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 == 20)
	for (k = 0; k < 100; k++)
	{
		fill_rand(asHstC, LEC_HST_SZ, 8000);
		fill_rand(LecDbC.asAdf1, LEC_FLT2_SZ, 1000);
//		memset(asFlt1C, 0, LEC_FLT2_SZ);
		fill_rand(asRxC, ILEC_FR_SZ, 4000);
//		memset(asRxC, 0, ILEC_FR_SZ);
		memcpy(asHstA, asHstC, LEC_HST_SZ);
		memcpy(LecDbA.asAdf1, LecDbC.asAdf1, LEC_FLT2_SZ);
		memcpy(asRxA, asRxC, ILEC_FR_SZ);
		LecDbC.Adf1.sShift = 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(LecDbC.asAdf1, LEC_FLT2_SZ, 1000);
		memcpy(asHstA, asHstC, LEC_HST_SZ);
		memcpy(LecDbA.asAdf1, LecDbC.asAdf1, LEC_FLT2_SZ);
		sC = (rand() - RAND_MAX/2)/8;
		sA = sC;
		sC = lec_cancelC(asHstC+LEC_HST_SZ-1, LecDbC.asAdf1, sC);
		sA = lec_cancel (asHstA+LEC_HST_SZ-1, LecDbA.asAdf1, sA);
		if (sC-sA) sErr++;
	}
#elif (DBG_IT == 22)
	for (k = 0; k < 100; k++)
	{
		fill_rand(asHstC, LEC_HST_SZ, 8000);
		fill_rand(LecDbC.asAdf1, LEC_FLT2_SZ, 1000);
		memcpy(asHstA, asHstC, LEC_HST_SZ);
		memcpy(LecDbA.asAdf1, LecDbC.asAdf1, LEC_FLT2_SZ);
		sC = (rand() - RAND_MAX/2)/8;
		sA = sC;
		sC = lec_cancel_shiftedC(asHstC+LEC_HST_SZ-1, LecDbC.asAdf1, sC, 2);
		sA = lec_cancel_shifted (asHstA+LEC_HST_SZ-1, LecDbA.asAdf1, 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(LecDbC.asAdf1, LEC_FLT2_SZ, 1000);
		memcpy(asHstA, asHstC, LEC_HST_SZ);
		memcpy(LecDbA.asAdf1, LecDbC.asAdf1, LEC_FLT2_SZ);
		slC = lec_get_xzC(asHstC+ILEC_FR_SZ*5-1, LecDbC.asAdf1+ILEC_FR_SZ*5-1);
		slA = lec_get_xz (asHstC+ILEC_FR_SZ*5-1, LecDbA.asAdf1+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(LecDbC.asAdf2, LEC_FLT2_SZ, max);
		memcpy(LecDbA.asAdf2, LecDbC.asAdf2, LEC_FLT2_SZ);
		lec_shift_adf2C(&LecDbC, &LecScC);
		lec_shift_adf2 (&LecDbA, &LecScA);
		sErr += compare_db();
		sErr += compare_sc();
	}
#elif (DBG_IT == 251)
	for (k = 0; k < 100; k++)
	{
		S16 max = rand();
		fill_rand(LecDbC.asAdf2, LEC_FLT2_SZ, max);
		memcpy(LecDbA.asAdf2, LecDbC.asAdf2, LEC_FLT2_SZ);
		lec_rshift_adfC(LecDbC.asAdf2, 2);
		lec_rshift_adf (LecDbA.asAdf2, 2);
		sErr += compare_db();
		sErr += compare_sc();
	}
#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(LecDbC.asAdf2, 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(LecDbA.asAdf2, LecDbC.asAdf2, LEC_FLT2_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_highC(&LecDbC, &LecScC, sBase, sStep);
		lec_adapt_fast_high (&LecDbA, &LecScA, sBase, sStep);
		sErr += compare_db();
		sErr += compare_sc();
	}
#elif (DBG_IT == 28)
	for (k = 0; k < 100; k++)
	{
		S16 sBase;
		S16 sStep;
		fill_rand(asHstC, LEC_HST_SZ, 800);
		fill_rand(LecDbC.asAdf2, LEC_FLT2_SZ, 2000);
		fill_rand(LecScC.asErr2, ILEC_FR_SZ, 200);
		fill_rand(LecDbC.psTxF, LEC_HST_SZ, 300);
		memcpy(asHstA, asHstC, LEC_HST_SZ);
		memcpy(LecDbA.asAdf2, LecDbC.asAdf2, LEC_FLT2_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_db();
		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(LecDbC.asAdf2, 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(LecDbA.asAdf2, LecDbC.asAdf2, 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_db();
		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(LecDbC.asAdf2, 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(LecDbA.asAdf2, LecDbC.asAdf2, 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_db();
		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_fast2C(&LecDbC, &LecScC, base);
		sA = lec_step_size_corr_fast2 (&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
                    | ILEC_CMD_DETECT_HIRCV;
		LecCfg.sClipThr = 60;
		LecCfg.sErlMin = 30;
		LecCfg.sToneDetectThr = Q15(0.05);
		LecCfg.sToneReleaseThr = Q15(0.12);
		LecCfg.sRcvMax = 7770;

		LEC_MIKET_init_db(&LecDbA, &LecCfg, asHstA);

		for (k = 0; k < 2000; k++)
		{
			fill_rand(asTx, ILEC_FR_SZ, 5000);
			LEC_MIKET_process(&LecDbA, &LecScA, asTx, asRxA, 0);
			LEC_MIKET_get_stts(&LecDbA, &SttsA);
		}
	}
#elif (DBG_IT == 36)
	for (k = 0; k < 100; k++)
	{
		dummy();	
	}
#elif (DBG_IT == 37)
	{
		FILE *pfTx = fopen("c2.dat","r");
		FILE *pfRx = fopen("c3.dat","r");
		FILE *pfCnl = fopen("cnl.dat","w");
//		ILEC_Status Sts;
		ILEC_tCfg LecCfg;

		LecCfg.uControl = 0
                    | ILEC_CMD_DETECT_HIRCV;
		LecCfg.sClipThr = 60;
		LecCfg.sErlMin = 10;
		LecCfg.sToneDetectThr = Q15(0.05);
		LecCfg.sToneReleaseThr = Q15(0.12);
		LecCfg.sRcvMax = 7770;

		LEC_MIKET_init_db(&LecDbA, &LecCfg, asHstA);
		sp_bpf_init(&BpfDbA);

		for (k = 0; k< 200*10; k++)
		{
			S16 n;
			for (n=0; n < ILEC_FR_SZ; n++)fscanf(pfTx, "%d", &asTx[n]);
			for (n=0; n < ILEC_FR_SZ; n++)fscanf(pfRx, "%d", &asRxA[n]);
			sp_bpf(&BpfDbA, &BpfScA, asRxA);
			LEC_MIKET_process(&LecDbA, &LecScA, asTx, asRxA, 0);
			for (n=0; n < ILEC_FR_SZ; n++)fprintf(pfCnl, "%d\n", asRxA[n]);
		}
		fclose(pfTx);
		fclose(pfRx);
		fclose(pfCnl);
	}
#elif (DBG_IT == 38)
#elif (DBG_IT == 39)
#endif
	{
		for(;;)
		{
//			extern S16 lec_en2log(S32 slEn, S16 sCorr);
			slCntr++;
			lec_en2log(slCntr);
		}
	}

}
12

main.c - 源码说明

本页面展示了「The line echo canceller (LEC) is designed to provide the maximum attainable transparent voice qualit」中的 main.c 源码文件，采用 C语言 编程语言编写，共 766 行代码。您可以在线阅读完整代码内容，也可以返回资源详情页下载完整源码包进行本地学习和开发。

虫虫开发者社区收录了大量与回声消除相关的技术资源，包括源代码、技术文档、电路图等，是电子工程师和嵌入式开发者的专业学习平台。

⌨️ 快捷键说明

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