WebSVN – dashGPS – Blame – /trunk/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/TransformFunctions/cfft.c

Rev	Author	Line No.	Line
2	mjames	1	#include "ref.h"
		2	#include "arm_const_structs.h"
		3
		4	void ref_cfft_f32(
		5	const arm_cfft_instance_f32 * S,
		6	float32_t * p1,
		7	uint8_t ifftFlag,
		8	uint8_t bitReverseFlag)
		9	{
		10	int n, mmax, m, j, istep, i;
		11	float32_t wtemp, wr, wpr, wpi, wi, theta;
		12	float32_t tempr, tempi;
		13	float32_t * data = p1;
		14	uint32_t N = S->fftLen;
		15	int32_t dir = (ifftFlag) ? -1 : 1;
		16
		17	// decrement pointer since the original version used fortran style indexing.
		18	data--;
		19
		20	n = N << 1;
		21	j = 1;
		22	for (i = 1; i < n; i += 2) {
		23	if (j > i) {
		24	tempr = data[j]; data[j] = data[i]; data[i] = tempr;
		25	tempr = data[j+1]; data[j+1] = data[i+1]; data[i+1] = tempr;
		26	}
		27	m = n >> 1;
		28	while (m >= 2 && j > m) {
		29	j -= m;
		30	m >>= 1;
		31	}
		32	j += m;
		33	}
		34	mmax = 2;
		35	while (n > mmax) {
		36	istep = 2*mmax;
		37	theta = -6.283185307179586f/(dir*mmax);
		38	wtemp = sinf(0.5f*theta);
		39	wpr = -2.0fwtempwtemp;
		40	wpi = sinf(theta);
		41	wr = 1.0f;
		42	wi = 0.0f;
		43	for (m = 1; m < mmax; m += 2) {
		44	for (i = m; i <= n; i += istep) {
		45	j =i + mmax;
		46	tempr = wrdata[j] - widata[j+1];
		47	tempi = wrdata[j+1] + widata[j];
		48	data[j] = data[i] - tempr;
		49	data[j+1] = data[i+1] - tempi;
		50	data[i] += tempr;
		51	data[i+1] += tempi;
		52	}
		53	wr = (wtemp = wr)wpr - wiwpi + wr;
		54	wi = wiwpr + wtempwpi + wi;
		55	}
		56	mmax = istep;
		57	}
		58
		59	// Inverse transform is scaled by 1/N
		60	if (ifftFlag)
		61	{
		62	data++;
		63	for(i = 0; i<2*N; i++)
		64	{
		65	data[i] /= N;
		66	}
		67	}
		68	}
		69
		70	void ref_cfft_q31(
		71	const arm_cfft_instance_q31 * S,
		72	q31_t * p1,
		73	uint8_t ifftFlag,
		74	uint8_t bitReverseFlag)
		75	{
		76	uint32_t i;
		77	float32_t fSrc = (float32_t)p1;
		78
		79	for(i=0;i<S->fftLen*2;i++)
		80	{
		81	//read the q31 data, cast to float, scale down for float
		82	fSrc[i] = (float32_t)p1[i] / 2147483648.0f;
		83	}
		84
		85	switch(S->fftLen)
		86	{
		87	case 16:
		88	ref_cfft_f32(&arm_cfft_sR_f32_len16, fSrc, ifftFlag, bitReverseFlag);
		89	break;
		90
		91	case 32:
		92	ref_cfft_f32(&arm_cfft_sR_f32_len32, fSrc, ifftFlag, bitReverseFlag);
		93	break;
		94
		95	case 64:
		96	ref_cfft_f32(&arm_cfft_sR_f32_len64, fSrc, ifftFlag, bitReverseFlag);
		97	break;
		98
		99	case 128:
		100	ref_cfft_f32(&arm_cfft_sR_f32_len128, fSrc, ifftFlag, bitReverseFlag);
		101	break;
		102
		103	case 256:
		104	ref_cfft_f32(&arm_cfft_sR_f32_len256, fSrc, ifftFlag, bitReverseFlag);
		105	break;
		106
		107	case 512:
		108	ref_cfft_f32(&arm_cfft_sR_f32_len512, fSrc, ifftFlag, bitReverseFlag);
		109	break;
		110
		111	case 1024:
		112	ref_cfft_f32(&arm_cfft_sR_f32_len1024, fSrc, ifftFlag, bitReverseFlag);
		113	break;
		114
		115	case 2048:
		116	ref_cfft_f32(&arm_cfft_sR_f32_len2048, fSrc, ifftFlag, bitReverseFlag);
		117	break;
		118
		119	case 4096:
		120	ref_cfft_f32(&arm_cfft_sR_f32_len4096, fSrc, ifftFlag, bitReverseFlag);
		121	break;
		122	}
		123
		124	if (ifftFlag)
		125	{
		126	for(i=0;i<S->fftLen*2;i++)
		127	{
		128	//read the float data, scale up for q31, cast to q31
		129	p1[i] = (q31_t)( fSrc[i] * 2147483648.0f );
		130	}
		131	}
		132	else
		133	{
		134	for(i=0;i<S->fftLen*2;i++)
		135	{
		136	//read the float data, scale up for q31, cast to q31
		137	p1[i] = (q31_t)( fSrc[i] * 2147483648.0f / (float32_t)S->fftLen);
		138	}
		139	}
		140	}
		141
		142	void ref_cfft_q15(
		143	const arm_cfft_instance_q15 * S,
		144	q15_t * pSrc,
		145	uint8_t ifftFlag,
		146	uint8_t bitReverseFlag)
		147	{
		148	uint32_t i;
		149	float32_t fSrc = (float32_t)pSrc;
		150
		151	for(i=0;i<S->fftLen*2;i++)
		152	{
		153	//read the q15 data, cast to float, scale down for float, place in temporary buffer
		154	scratchArray[i] = (float32_t)pSrc[i] / 32768.0f;
		155	}
		156
		157	for(i=0;i<S->fftLen*2;i++)
		158	{
		159	//copy from temp buffer to final buffer
		160	fSrc[i] = scratchArray[i];
		161	}
		162
		163	switch(S->fftLen)
		164	{
		165	case 16:
		166	ref_cfft_f32(&arm_cfft_sR_f32_len16, fSrc, ifftFlag, bitReverseFlag);
		167	break;
		168
		169	case 32:
		170	ref_cfft_f32(&arm_cfft_sR_f32_len32, fSrc, ifftFlag, bitReverseFlag);
		171	break;
		172
		173	case 64:
		174	ref_cfft_f32(&arm_cfft_sR_f32_len64, fSrc, ifftFlag, bitReverseFlag);
		175	break;
		176
		177	case 128:
		178	ref_cfft_f32(&arm_cfft_sR_f32_len128, fSrc, ifftFlag, bitReverseFlag);
		179	break;
		180
		181	case 256:
		182	ref_cfft_f32(&arm_cfft_sR_f32_len256, fSrc, ifftFlag, bitReverseFlag);
		183	break;
		184
		185	case 512:
		186	ref_cfft_f32(&arm_cfft_sR_f32_len512, fSrc, ifftFlag, bitReverseFlag);
		187	break;
		188
		189	case 1024:
		190	ref_cfft_f32(&arm_cfft_sR_f32_len1024, fSrc, ifftFlag, bitReverseFlag);
		191	break;
		192
		193	case 2048:
		194	ref_cfft_f32(&arm_cfft_sR_f32_len2048, fSrc, ifftFlag, bitReverseFlag);
		195	break;
		196
		197	case 4096:
		198	ref_cfft_f32(&arm_cfft_sR_f32_len4096, fSrc, ifftFlag, bitReverseFlag);
		199	break;
		200	}
		201
		202	if (ifftFlag)
		203	{
		204	for(i=0;i<S->fftLen*2;i++)
		205	{
		206	//read the float data, scale up for q15, cast to q15
		207	pSrc[i] = (q15_t)( fSrc[i] * 32768.0f );
		208	}
		209	}
		210	else
		211	{
		212	for(i=0;i<S->fftLen*2;i++)
		213	{
		214	//read the float data, scale up for q15, cast to q15
		215	pSrc[i] = (q15_t)( fSrc[i] * 32768.0f / (float32_t)S->fftLen);
		216	}
		217	}
		218	}
		219
		220	void ref_cfft_radix2_f32(
		221	const arm_cfft_radix2_instance_f32 * S,
		222	float32_t * pSrc)
		223	{
		224	switch(S->fftLen)
		225	{
		226	case 16:
		227	ref_cfft_f32(&arm_cfft_sR_f32_len16, pSrc, S->ifftFlag, S->bitReverseFlag);
		228	break;
		229
		230	case 32:
		231	ref_cfft_f32(&arm_cfft_sR_f32_len32, pSrc, S->ifftFlag, S->bitReverseFlag);
		232	break;
		233
		234	case 64:
		235	ref_cfft_f32(&arm_cfft_sR_f32_len64, pSrc, S->ifftFlag, S->bitReverseFlag);
		236	break;
		237
		238	case 128:
		239	ref_cfft_f32(&arm_cfft_sR_f32_len128, pSrc, S->ifftFlag, S->bitReverseFlag);
		240	break;
		241
		242	case 256:
		243	ref_cfft_f32(&arm_cfft_sR_f32_len256, pSrc, S->ifftFlag, S->bitReverseFlag);
		244	break;
		245
		246	case 512:
		247	ref_cfft_f32(&arm_cfft_sR_f32_len512, pSrc, S->ifftFlag, S->bitReverseFlag);
		248	break;
		249
		250	case 1024:
		251	ref_cfft_f32(&arm_cfft_sR_f32_len1024, pSrc, S->ifftFlag, S->bitReverseFlag);
		252	break;
		253
		254	case 2048:
		255	ref_cfft_f32(&arm_cfft_sR_f32_len2048, pSrc, S->ifftFlag, S->bitReverseFlag);
		256	break;
		257
		258	case 4096:
		259	ref_cfft_f32(&arm_cfft_sR_f32_len4096, pSrc, S->ifftFlag, S->bitReverseFlag);
		260	break;
		261	}
		262	}
		263
		264	void ref_cfft_radix2_q31(
		265	const arm_cfft_radix2_instance_q31 * S,
		266	q31_t * pSrc)
		267	{
		268	uint32_t i;
		269	float32_t fSrc = (float32_t)pSrc;
		270
		271	for(i=0;i<S->fftLen*2;i++)
		272	{
		273	//read the q31 data, cast to float, scale down for float
		274	fSrc[i] = (float32_t)pSrc[i] / 2147483648.0f;
		275	}
		276
		277	switch(S->fftLen)
		278	{
		279	case 16:
		280	ref_cfft_f32(&arm_cfft_sR_f32_len16, fSrc, S->ifftFlag, S->bitReverseFlag);
		281	break;
		282
		283	case 32:
		284	ref_cfft_f32(&arm_cfft_sR_f32_len32, fSrc, S->ifftFlag, S->bitReverseFlag);
		285	break;
		286
		287	case 64:
		288	ref_cfft_f32(&arm_cfft_sR_f32_len64, fSrc, S->ifftFlag, S->bitReverseFlag);
		289	break;
		290
		291	case 128:
		292	ref_cfft_f32(&arm_cfft_sR_f32_len128, fSrc, S->ifftFlag, S->bitReverseFlag);
		293	break;
		294
		295	case 256:
		296	ref_cfft_f32(&arm_cfft_sR_f32_len256, fSrc, S->ifftFlag, S->bitReverseFlag);
		297	break;
		298
		299	case 512:
		300	ref_cfft_f32(&arm_cfft_sR_f32_len512, fSrc, S->ifftFlag, S->bitReverseFlag);
		301	break;
		302
		303	case 1024:
		304	ref_cfft_f32(&arm_cfft_sR_f32_len1024, fSrc, S->ifftFlag, S->bitReverseFlag);
		305	break;
		306
		307	case 2048:
		308	ref_cfft_f32(&arm_cfft_sR_f32_len2048, fSrc, S->ifftFlag, S->bitReverseFlag);
		309	break;
		310
		311	case 4096:
		312	ref_cfft_f32(&arm_cfft_sR_f32_len4096, fSrc, S->ifftFlag, S->bitReverseFlag);
		313	break;
		314	}
		315
		316	if (S->ifftFlag)
		317	{
		318	for(i=0;i<S->fftLen*2;i++)
		319	{
		320	//read the float data, scale up for q31, cast to q31
		321	pSrc[i] = (q31_t)( fSrc[i] * 2147483648.0f );
		322	}
		323	}
		324	else
		325	{
		326	for(i=0;i<S->fftLen*2;i++)
		327	{
		328	//read the float data, scale up for q31, cast to q31
		329	pSrc[i] = (q31_t)( fSrc[i] * 2147483648.0f / (float32_t)S->fftLen);
		330	}
		331	}
		332	}
		333
		334	void ref_cfft_radix2_q15(
		335	const arm_cfft_radix2_instance_q15 * S,
		336	q15_t * pSrc)
		337	{
		338	uint32_t i;
		339	float32_t fSrc = (float32_t)pSrc;
		340
		341	for(i=0;i<S->fftLen*2;i++)
		342	{
		343	//read the q15 data, cast to float, scale down for float, place in temporary buffer
		344	scratchArray[i] = (float32_t)pSrc[i] / 32768.0f;
		345	}
		346
		347	for(i=0;i<S->fftLen*2;i++)
		348	{
		349	//copy from temp buffer to final buffer
		350	fSrc[i] = scratchArray[i];
		351	}
		352
		353	switch(S->fftLen)
		354	{
		355	case 16:
		356	ref_cfft_f32(&arm_cfft_sR_f32_len16, fSrc, S->ifftFlag, S->bitReverseFlag);
		357	break;
		358
		359	case 32:
		360	ref_cfft_f32(&arm_cfft_sR_f32_len32, fSrc, S->ifftFlag, S->bitReverseFlag);
		361	break;
		362
		363	case 64:
		364	ref_cfft_f32(&arm_cfft_sR_f32_len64, fSrc, S->ifftFlag, S->bitReverseFlag);
		365	break;
		366
		367	case 128:
		368	ref_cfft_f32(&arm_cfft_sR_f32_len128, fSrc, S->ifftFlag, S->bitReverseFlag);
		369	break;
		370
		371	case 256:
		372	ref_cfft_f32(&arm_cfft_sR_f32_len256, fSrc, S->ifftFlag, S->bitReverseFlag);
		373	break;
		374
		375	case 512:
		376	ref_cfft_f32(&arm_cfft_sR_f32_len512, fSrc, S->ifftFlag, S->bitReverseFlag);
		377	break;
		378
		379	case 1024:
		380	ref_cfft_f32(&arm_cfft_sR_f32_len1024, fSrc, S->ifftFlag, S->bitReverseFlag);
		381	break;
		382
		383	case 2048:
		384	ref_cfft_f32(&arm_cfft_sR_f32_len2048, fSrc, S->ifftFlag, S->bitReverseFlag);
		385	break;
		386
		387	case 4096:
		388	ref_cfft_f32(&arm_cfft_sR_f32_len4096, fSrc, S->ifftFlag, S->bitReverseFlag);
		389	break;
		390	}
		391
		392	if (S->ifftFlag)
		393	{
		394	for(i=0;i<S->fftLen*2;i++)
		395	{
		396	//read the float data, scale up for q15, cast to q15
		397	pSrc[i] = (q15_t)( fSrc[i] * 32768.0f );
		398	}
		399	}
		400	else
		401	{
		402	for(i=0;i<S->fftLen*2;i++)
		403	{
		404	//read the float data, scale up for q15, cast to q15
		405	pSrc[i] = (q15_t)( fSrc[i] * 32768.0f / (float32_t)S->fftLen);
		406	}
		407	}
		408	}
		409
		410	void ref_cfft_radix4_f32(
		411	const arm_cfft_radix4_instance_f32 * S,
		412	float32_t * pSrc)
		413	{
		414	switch(S->fftLen)
		415	{
		416	case 16:
		417	ref_cfft_f32(&arm_cfft_sR_f32_len16, pSrc, S->ifftFlag, S->bitReverseFlag);
		418	break;
		419
		420	case 32:
		421	ref_cfft_f32(&arm_cfft_sR_f32_len32, pSrc, S->ifftFlag, S->bitReverseFlag);
		422	break;
		423
		424	case 64:
		425	ref_cfft_f32(&arm_cfft_sR_f32_len64, pSrc, S->ifftFlag, S->bitReverseFlag);
		426	break;
		427
		428	case 128:
		429	ref_cfft_f32(&arm_cfft_sR_f32_len128, pSrc, S->ifftFlag, S->bitReverseFlag);
		430	break;
		431
		432	case 256:
		433	ref_cfft_f32(&arm_cfft_sR_f32_len256, pSrc, S->ifftFlag, S->bitReverseFlag);
		434	break;
		435
		436	case 512:
		437	ref_cfft_f32(&arm_cfft_sR_f32_len512, pSrc, S->ifftFlag, S->bitReverseFlag);
		438	break;
		439
		440	case 1024:
		441	ref_cfft_f32(&arm_cfft_sR_f32_len1024, pSrc, S->ifftFlag, S->bitReverseFlag);
		442	break;
		443
		444	case 2048:
		445	ref_cfft_f32(&arm_cfft_sR_f32_len2048, pSrc, S->ifftFlag, S->bitReverseFlag);
		446	break;
		447
		448	case 4096:
		449	ref_cfft_f32(&arm_cfft_sR_f32_len4096, pSrc, S->ifftFlag, S->bitReverseFlag);
		450	break;
		451	}
		452	}
		453
		454	void ref_cfft_radix4_q31(
		455	const arm_cfft_radix4_instance_q31 * S,
		456	q31_t * pSrc)
		457	{
		458	uint32_t i;
		459	float32_t fSrc = (float32_t)pSrc;
		460
		461	for(i=0;i<S->fftLen*2;i++)
		462	{
		463	//read the q31 data, cast to float, scale down for float
		464	fSrc[i] = (float32_t)pSrc[i] / 2147483648.0f;
		465	}
		466
		467	switch(S->fftLen)
		468	{
		469	case 16:
		470	ref_cfft_f32(&arm_cfft_sR_f32_len16, fSrc, S->ifftFlag, S->bitReverseFlag);
		471	break;
		472
		473	case 32:
		474	ref_cfft_f32(&arm_cfft_sR_f32_len32, fSrc, S->ifftFlag, S->bitReverseFlag);
		475	break;
		476
		477	case 64:
		478	ref_cfft_f32(&arm_cfft_sR_f32_len64, fSrc, S->ifftFlag, S->bitReverseFlag);
		479	break;
		480
		481	case 128:
		482	ref_cfft_f32(&arm_cfft_sR_f32_len128, fSrc, S->ifftFlag, S->bitReverseFlag);
		483	break;
		484
		485	case 256:
		486	ref_cfft_f32(&arm_cfft_sR_f32_len256, fSrc, S->ifftFlag, S->bitReverseFlag);
		487	break;
		488
		489	case 512:
		490	ref_cfft_f32(&arm_cfft_sR_f32_len512, fSrc, S->ifftFlag, S->bitReverseFlag);
		491	break;
		492
		493	case 1024:
		494	ref_cfft_f32(&arm_cfft_sR_f32_len1024, fSrc, S->ifftFlag, S->bitReverseFlag);
		495	break;
		496
		497	case 2048:
		498	ref_cfft_f32(&arm_cfft_sR_f32_len2048, fSrc, S->ifftFlag, S->bitReverseFlag);
		499	break;
		500
		501	case 4096:
		502	ref_cfft_f32(&arm_cfft_sR_f32_len4096, fSrc, S->ifftFlag, S->bitReverseFlag);
		503	break;
		504	}
		505
		506	if (S->ifftFlag)
		507	{
		508	for(i=0;i<S->fftLen*2;i++)
		509	{
		510	//read the float data, scale up for q31, cast to q31
		511	pSrc[i] = (q31_t)( fSrc[i] * 2147483648.0f );
		512	}
		513	}
		514	else
		515	{
		516	for(i=0;i<S->fftLen*2;i++)
		517	{
		518	//read the float data, scale up for q31, cast to q31
		519	pSrc[i] = (q31_t)( fSrc[i] * 2147483648.0f / (float32_t)S->fftLen);
		520	}
		521	}
		522	}
		523
		524	void ref_cfft_radix4_q15(
		525	const arm_cfft_radix4_instance_q15 * S,
		526	q15_t * pSrc)
		527	{
		528	uint32_t i;
		529	float32_t fSrc = (float32_t)pSrc;
		530
		531	for(i=0;i<S->fftLen*2;i++)
		532	{
		533	//read the q15 data, cast to float, scale down for float, place in temporary buffer
		534	scratchArray[i] = (float32_t)pSrc[i] / 32768.0f;
		535	}
		536
		537	for(i=0;i<S->fftLen*2;i++)
		538	{
		539	//copy from temp buffer to final buffer
		540	fSrc[i] = scratchArray[i];
		541	}
		542
		543	switch(S->fftLen)
		544	{
		545	case 16:
		546	ref_cfft_f32(&arm_cfft_sR_f32_len16, fSrc, S->ifftFlag, S->bitReverseFlag);
		547	break;
		548
		549	case 32:
		550	ref_cfft_f32(&arm_cfft_sR_f32_len32, fSrc, S->ifftFlag, S->bitReverseFlag);
		551	break;
		552
		553	case 64:
		554	ref_cfft_f32(&arm_cfft_sR_f32_len64, fSrc, S->ifftFlag, S->bitReverseFlag);
		555	break;
		556
		557	case 128:
		558	ref_cfft_f32(&arm_cfft_sR_f32_len128, fSrc, S->ifftFlag, S->bitReverseFlag);
		559	break;
		560
		561	case 256:
		562	ref_cfft_f32(&arm_cfft_sR_f32_len256, fSrc, S->ifftFlag, S->bitReverseFlag);
		563	break;
		564
		565	case 512:
		566	ref_cfft_f32(&arm_cfft_sR_f32_len512, fSrc, S->ifftFlag, S->bitReverseFlag);
		567	break;
		568
		569	case 1024:
		570	ref_cfft_f32(&arm_cfft_sR_f32_len1024, fSrc, S->ifftFlag, S->bitReverseFlag);
		571	break;
		572
		573	case 2048:
		574	ref_cfft_f32(&arm_cfft_sR_f32_len2048, fSrc, S->ifftFlag, S->bitReverseFlag);
		575	break;
		576
		577	case 4096:
		578	ref_cfft_f32(&arm_cfft_sR_f32_len4096, fSrc, S->ifftFlag, S->bitReverseFlag);
		579	break;
		580	}
		581
		582	if (S->ifftFlag)
		583	{
		584	for(i=0;i<S->fftLen*2;i++)
		585	{
		586	//read the float data, scale up for q15, cast to q15
		587	pSrc[i] = (q15_t)( fSrc[i] * 32768.0f );
		588	}
		589	}
		590	else
		591	{
		592	for(i=0;i<S->fftLen*2;i++)
		593	{
		594	//read the float data, scale up for q15, cast to q15
		595	pSrc[i] = (q15_t)( fSrc[i] * 32768.0f / (float32_t)S->fftLen);
		596	}
		597	}
		598	}

Subversion Repositories dashGPS

(root)/trunk/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/TransformFunctions/cfft.c – Rev 2