main.c

TI公司DSP/tms320c55x/tms320c54x系列的声学回声消除代码

	{
		void gaec_nr_nrgC(GAEC_tDb *pDb,GAEC_tSc *pSc);
		int band;

		for (k = 0; k < 404; k++)
		{
			for (band = 0; band < GAEC_BANDS+1; band++)
			{
				GaecScC.asErrEn[band] = 
				GaecScA.asErrEn[band] = 
					GAEC_DB(-70) + (S16)((rand() *(170*70L))>>15);
				GaecDbC.asVadErrNse[band] =
				GaecDbA.asVadErrNse[band] =
					GAEC_DB(-70) + (S16)((rand() *(170*40L))>>15);
				GaecDbC.aslNrPrior[band] = 
				GaecDbA.aslNrPrior[band] = 
					labs(rand() * (S32) rand()) >> 25;
			}
				
			gaec_nr_nrgC(&GaecDbC, &GaecScC);
			gaec_nr_nrg (&GaecDbA, &GaecScA);
			sErr += compare_sc();
			sErr += compare_db();
			if (sErr)
			{
				sTrap = gaec_utl_en2log(sErr);
//				sErr = 0;
			}
		}
	}
#elif (DBG_IT == 405)
	{
		void gaec_nr_nrgC(GAEC_tDb *pDb,GAEC_tSc *pSc);
		void gaec_nr_coefC(GAEC_tDb *pDb,GAEC_tSc *pSc);
		int band;

		for (k = 0; k < 405; k++)
		{
			for (band = 0; band < GAEC_BANDS+1; band++)
			{
				GaecScC.asErrEn[band] = 
				GaecScA.asErrEn[band] = 
					GAEC_DB(-70) + (S16)((rand() *(170*70L))>>15);
				GaecDbC.asVadErrNse[band] =
				GaecDbA.asVadErrNse[band] =
					GAEC_DB(-70) + (S16)((rand() *(170*40L))>>15);
				GaecDbC.aslNrPrior[band] = 
				GaecDbA.aslNrPrior[band] = 
					labs(rand() * (S32) rand()) >> 15;
			}
				
			gaec_nr_nrgC(&GaecDbC, &GaecScC);
			gaec_nr_nrg (&GaecDbA, &GaecScA);
			gaec_nr_coefC(&GaecDbC, &GaecScC);
			gaec_nr_coef (&GaecDbA, &GaecScA);
			sErr += compare_sc();
			sErr += compare_db();
			if (sErr)
			{
				sTrap = gaec_utl_en2log(sErr);
//				sErr = 0;
			}
		}
	}
#elif (DBG_IT == 406)
	{
		void gaec_nr_updC(GAEC_tDb *pDb,GAEC_tSc *pSc);
		int band;

		for (k = 0; k < 4060; k++)
		{
			for (band = 0; band < GAEC_BANDS+1; band++)
			{
				GaecDbC.asNrCoef[band] = 
				GaecDbA.asNrCoef[band] = 
					rand() & 4095;
				GaecScC.u.aNr[band].sCoef =
				GaecScA.u.aNr[band].sCoef =
					rand() & 4095;
				GaecScC.u.aNr[band].sSig =
				GaecScA.u.aNr[band].sSig =
					(S16)((rand() * 2567L)>>15);
			}
				
			gaec_nr_updC(&GaecDbC, &GaecScC);
			gaec_nr_upd (&GaecDbA, &GaecScA);
			sErr += compare_sc();
			sErr += compare_db();
			if (sErr)
			{
				sTrap = gaec_utl_en2log(sErr);
//				sErr = 0;
			}
		}
	}
#elif (DBG_IT == 407)
	{
		void gaec_nr_attC(GAEC_tDb *pDb,GAEC_tSc *pSc);
		int band;

		for (k = 0; k < 407; k++)
		{
			S16 amp = rand() & 0x1fff;
			for (band = 0; band < GAEC_BANDS+1; band++)
			{
				GaecDbC.asNrCoef[band] = 
				GaecDbA.asNrCoef[band] = 
					rand() & 0x0fff;
			}
			fill_rand(&GaecScC.aasErr0[0][0], GAEC_ERR_SZ*GAEC_BANDS*2, amp);
			memcpy(&GaecScA.aasErr0[0][0],&GaecScC.aasErr0[0][0],GAEC_ERR_SZ*GAEC_BANDS*2);
				
			gaec_nr_attC(&GaecDbC, &GaecScC);
			gaec_nr_att (&GaecDbA, &GaecScA);
			sErr += compare_sc();
			sErr += compare_db();
			if (sErr)
			{
				sTrap = gaec_utl_en2log(sErr);
//				sErr = 0;
			}
		}
	}
#elif (DBG_IT == 501)
//			fill_rand (GaecDbC.asRbufSav, GAEC_RBUF_SSZ, 8000);
//			fill_rand (GaecDbC.asSbufSav, GAEC_SBUF_SSZ, 8000);
//			fill_rand (&GaecDbC.aasErrSav[0][0], GAEC_ERR_SSZ*2*GAEC_BANDS, 8000);
//			fill_rand (GaecDbC.psRcv, GAEC_RCV_SZ*2*GAEC_BANDS, 8000);
//			memcpy (GaecDbA.asRbufSav, GaecDbC.asRbufSav, GAEC_RBUF_SZ);
//			memcpy (GaecDbA.asSbufSav, GaecDbC.asSbufSav, GAEC_SBUF_SZ);
//			memcpy (&GaecDbA.aasErrSav[0][0], &GaecDbC.aasErrSav[0][0], GAEC_ERR_SSZ*2*GAEC_BANDS);
//			memcpy (GaecDbA.psRcv, GaecDbC.psRcv, GAEC_RCV_SZ*2*GAEC_BANDS);
	{
		void gaec_update_rbufC(GAEC_tDb *pDb, S16 *psRcv);
		
		for (k = 0; k < 501; k++)
		{
			fill_rand (asRxC, GAEC_FR_SZ, 8000);
			gaec_update_rbufC(&GaecDbC, asRxC);
			gaec_update_rbuf (&GaecDbA, asRxC);
			sErr += compare_sc();
			sErr += compare_db();
			if (sErr)
			{
				sTrap = gaec_utl_en2log(sErr);
//				sErr = 0;
			}
		}
	}
#elif (DBG_IT == 502)
	{
		void gaec_shift_rcvC(GAEC_tDb *pDb);
		
		for (k = 0; k < 502; k++)
		{
			fill_rand (GaecDbC.psRcv, GAEC_RCV_SZ*2*GAEC_BANDS, 8000);
			memcpy (GaecDbA.psRcv, GaecDbC.psRcv, GAEC_RCV_SZ*2*GAEC_BANDS);
			gaec_shift_rcvC(&GaecDbC);
			gaec_shift_rcv (&GaecDbA);
			sErr += compare_sc();
			sErr += compare_db();
			sErr += compare(asHstC, asHstA, GAEC_RCV_SZ*GAEC_BANDS*2);
			if (sErr)
			{
				sTrap = gaec_utl_en2log(sErr);
//				sErr = 0;
			}
		}
	}
#elif (DBG_IT == 503)
	{
		void gaec_update_err_savC(GAEC_tDb *pDb, GAEC_tSc *pSc);
		
		fill_rand (&GaecDbC.aasErrSav[0][0], GAEC_ERR_SZ*2*GAEC_BANDS, 0);
		memcpy (&GaecDbA.aasErrSav[0][0], 
				&GaecDbC.aasErrSav[0][0], 
				GAEC_ERR_SZ*2*GAEC_BANDS);
		for (k = 0; k < 503; k++)
		{
			fill_rand (&GaecScC.aasErr[0][0], GAEC_BLKS*2*GAEC_BANDS, 8000);

			memcpy (&GaecScA.aasErr[0][0], 
					&GaecScC.aasErr[0][0], 
					GAEC_BLKS*2*GAEC_BANDS);
			
			gaec_update_err_savC(&GaecDbC, &GaecScC);
			gaec_update_err_sav (&GaecDbA, &GaecScA);
			sErr += compare_sc();
			sErr += compare_db();
			if (sErr)
			{
				sTrap = gaec_utl_en2log(sErr);
//				sErr = 0;
			}
		}
	}
#elif (DBG_IT == 504)
	{
		void gaec_copy_adfC(S16 *psTo, S16 *psFrom, S16 band);
		
		for (k = 0; k < 504; k++)
		{
			S16 band = rand() % (GAEC_BANDS+1);
			fill_rand (asAdfC, GAEC_ADF_SZ*2*GAEC_BANDS, 8000);
			fill_rand (asAdfMC, GAEC_ADF_SZ*2*GAEC_BANDS, 8000);

			memcpy (asAdfA, asAdfC,GAEC_ADF_SZ*2*GAEC_BANDS);
			memcpy (asAdfMA, asAdfMC,GAEC_ADF_SZ*2*GAEC_BANDS);
			
			gaec_copy_adfC(GaecDbC.psAdf, GaecDbC.psAdfM, band);
			gaec_copy_adf (GaecDbA.psAdf, GaecDbA.psAdfM, band);
			sErr += compare_sc();
			sErr += compare_db();
			sErr += compare(asAdfC, asAdfA, GAEC_ADF_SZ*GAEC_BANDS*2);
			sErr += compare(asAdfMC, asAdfMA, GAEC_ADF_SZ*GAEC_BANDS*2);
			if (sErr)
			{
				sTrap = gaec_utl_en2log(sErr);
//				sErr = 0;
			}
		}
	}
#elif (DBG_IT == 505)
	{
		void gaec_copy_errC(GAEC_tSc *pSc, S16 band);
		
		for (k = 0; k < 505; k++)
		{
			S16 band = rand() % (GAEC_BANDS+1);
			fill_rand (&GaecScC.aasErr[0][0], GAEC_BLKS*2*GAEC_BANDS, 800);
			fill_rand (&GaecScC.aasErrM[0][0], GAEC_BLKS*2*GAEC_BANDS, 8000);

			memcpy (
				&GaecScA.aasErrM[0][0], 
				&GaecScC.aasErrM[0][0],
				GAEC_BLKS*2*GAEC_BANDS);
			memcpy (
				&GaecScA.aasErr[0][0], 
				&GaecScC.aasErr[0][0],
				GAEC_BLKS*2*GAEC_BANDS);
				
//			band = 10;
			gaec_copy_errC(&GaecScC, band);
			gaec_copy_err (&GaecScA, band);
			sErr += compare_sc();
			sErr += compare_db();
			if (sErr)
			{
				sTrap = gaec_utl_en2log(sErr);
//				sErr = 0;
			}
		}
	}
#elif (DBG_IT == 506)
	{
		void gaec_in_corrC(S16 *, S16 *psIO);
		
		GaecDbC.sSinSav = 
		GaecDbA.sSinSav = 
			rand();
			
		for (k = 0; k < 506; k++)
		{
			fill_rand (asRxC, GAEC_FR_SZ, 800);
			memcpy (asRxA, asRxC, GAEC_FR_SZ);
			
			gaec_in_corrC(&GaecDbC.sSinSav, asRxC);
			gaec_in_corr (&GaecDbA.sSinSav, asRxA);
			sErr += compare_sc();
			sErr += compare_db();
			sErr += compare(asRxC, asRxA, GAEC_FR_SZ);
			if (sErr)
			{
				sTrap = gaec_utl_en2log(sErr);
//				sErr = 0;
			}
		}
	}
#elif (DBG_IT == 507)
	{
		void gaec_out_corrC(S32 *, S16 *psIO);
		
		GaecDbC.slSoutSav = 
		GaecDbA.slSoutSav = 
			((S32)rand()) << 10;
			
		for (k = 0; k < 507; k++)
		{
			fill_rand (asRxC, GAEC_FR_SZ, 800);
			memcpy (asRxA, asRxC, GAEC_FR_SZ);
			
			gaec_out_corrC(&GaecDbC.slSoutSav, asRxC);
			gaec_out_corr (&GaecDbA.slSoutSav, asRxA);
			sErr += compare_sc();
			sErr += compare_db();
			sErr += compare(asRxC, asRxA, GAEC_FR_SZ);
			if (sErr)
			{
				sTrap = gaec_utl_en2log(sErr);
//				sErr = 0;
			}
		}
	}
#elif (DBG_IT == 508)
	for (k = 0; k < 508; k++)
	{
		extern void gaec_utl_avrgC  (S16 *psSav, S16 sNew, S16 sCoeff);
	
		S16 asTmp[3];
		S16 C;
		S16 A;
		fill_rand(asTmp, 3, 8000);
		C = A = asTmp[0];
		gaec_utl_avrgC(&C, asTmp[1], asTmp[2]);
		gaec_utl_avrg (&A, asTmp[1], asTmp[2]);
		if (C != A) sErr ++;
		if (sErr)
		{
			sTrap = gaec_utl_en2log(sErr);
//				sErr = 0;
		}
	}
#elif (DBG_IT == 509)
	{
		for (k = 0; k < 509; k++)
		{
			extern S16 gaec_utl_pkt_energyC(S16*);
			fill_rand(asRxC, GAEC_FR_SZ, 8000);
			sC = gaec_utl_pkt_energyC(asRxC);
			sA = gaec_utl_pkt_energy (asRxC);
			if (sA != sC) sErr++;
		}
	}
#elif (DBG_IT == 510)
	{
		for (k = 0; k < 510; k++)
		{
			extern S32 gaec_utl_pkt_normC(S16*);
			fill_rand(asRxC, GAEC_FR_SZ, 8000);
			slC = gaec_utl_pkt_normC(asRxC);
			slA = gaec_utl_pkt_norm (asRxC);
			if (slA != slC) sErr++;
		}
	}
#elif (DBG_IT == 511)
	{
		for (k = 0; k < 511; k++)
		{
			extern S16 gaec_utl_pen2logC(S32 slEn);
			fill_rand((S16 *)&slC, 2, 8000);
			slC = labs(slC);
//			slC = (40*4096L*4096L/4);
			slA = slC;
			sC = gaec_utl_pen2logC(slC);
			sA = gaec_utl_pen2log (slC);
			if(sC-sA) sErr++;
		}
	}
#elif (DBG_IT == 512)
	{
		for (k = 0; k < 512; k++)
		{
			extern S16 gaec_utl_en2logC(S32 slEn);
			fill_rand((S16 *)&slC, 2, 8000);
			slC = labs(slC);
//			slC = (40*4096L*4096L/4);
			slA = slC;
			sC = gaec_utl_en2logC(slC);
			sA = gaec_utl_en2log (slC);
			if(sC-sA) sErr++;
		}
	}
#elif (DBG_IT == 513)
	{
		S16 gaec_utl_expC(S16);
		for (k = -170*100; k < 170*18; k++)
//		for (k = 0; k < 100; k++)
		{
//			sC = (rand()-RAND_MAX/2);
			sC = k;
			if (sC > 170*18) sC = 170*18;
			if (sC < -170*100) sC = -170*100;
	//		sC = -512*3+100;
			sA = sC;
			sC = gaec_utl_expC(sC);
			sA = gaec_utl_exp (sA);
			sErr += abs(sC-sA);
		}
	}
#elif (DBG_IT == 514)
	{
		extern void gaec_loopbackC(GAEC_tDb *pDb,S16 *psSnd);
		
		for (k = 0; k < 514; k++)
		{
			fill_rand(GaecDbC.asRbuf, GAEC_RBUF_SZ, 8200);
//			memset(GaecDbC.asRbuf, 10000, GAEC_RBUF_SZ);
			memcpy(GaecDbA.asRbuf, GaecDbC.asRbuf, GAEC_RBUF_SZ);
			
			gaec_loopbackC(&GaecDbC, asRxC);
			gaec_loopback (&GaecDbA, asRxA);
			sErr += compare_sc();
			sErr += compare_db();
			sErr += compare(asRxC, asRxA, GAEC_FR_SZ);
			if (sErr)
			{
				sTrap = gaec_utl_en2log(sErr);
//				sErr = 0;
			}
		}
	}
#elif (DBG_IT == 515)
	{
		sC = _smpyr(10000, 10923);
		sA = _smpy(10000, 10923);//21845);
	}
#elif (DBG_IT == 516)
	{
		extern void gaec_max_coefC(GAEC_tDb *pDb, GAEC_tSc *pSc);
		
		for (k = 0; k < 516; k++)
		{
			S16 amp = rand() % 32767;
			fill_rand(GaecDbC.psAdf, GAEC_ADF_SZ*GAEC_BANDS*2, amp);
			memcpy(GaecDbA.psAdf, GaecDbC.psAdf, GAEC_ADF_SZ*GAEC_BANDS*2);
			
			gaec_max_coefC(&GaecDbC, &GaecScC);
			gaec_max_coef (&GaecDbA, &GaecScA);
			sErr += compare_sc();
			sErr += compare_db();
			if (sErr)
			{
				sTrap = gaec_utl_en2log(sErr);
//				sErr = 0;
			}
		}
	}
#elif (DBG_IT == 517)
	{
		extern void gaec_scale_bandC(S16 *psAdf,S16 *psAdfM,S16  sBand,S16  sShft);
		
		for (k = 0; k < 517; k++)
		{
			S16 band = rand() %(GAEC_BANDS+1);
			S16 shft = rand() & 1;
			
			S16 amp = rand() % 32767;
			fill_rand(GaecDbC.psAdf, GAEC_ADF_SZ*GAEC_BANDS*2, amp);
			memcpy(GaecDbA.psAdf, GaecDbC.psAdf, GAEC_ADF_SZ*GAEC_BANDS*2);
			fill_rand(GaecDbC.psAdfM, GAEC_ADF_SZ*GAEC_BANDS*2, amp);
			memcpy(GaecDbA.psAdfM, GaecDbC.psAdfM, GAEC_ADF_SZ*GAEC_BANDS*2);
			
			shft <<= 1;
			shft -= 1;
			
			gaec_scale_bandC(GaecDbC.psAdf, GaecDbC.psAdfM, band, shft);
			gaec_scale_band (GaecDbA.psAdf, GaecDbA.psAdfM, band, shft);
			sErr += compare_sc();
			sErr += compare_db();
			sErr += compare(GaecDbA.psAdf,  GaecDbC.psAdf,  GAEC_ADF_SZ*GAEC_BANDS*2);
			sEr