WebSVN – dashGPS – Blame – /branches/dashGPS-bmp/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/TransformFunctions/rfft.c

Rev	Author	Line No.	Line
2	mjames	1	#include "ref.h"
		2	#include "arm_const_structs.h"
		3
		4	void ref_rfft_f32(
		5	arm_rfft_instance_f32 * S,
		6	float32_t * pSrc,
		7	float32_t * pDst)
		8	{
		9	uint32_t i;
		10
		11	if (S->ifftFlagR)
		12	{
		13	for(i=0;i<S->fftLenReal*2;i++)
		14	{
		15	pDst[i] = pSrc[i];
		16	}
		17	}
		18	else
		19	{
		20	for(i=0;i<S->fftLenReal;i++)
		21	{
		22	pDst[2*i+0] = pSrc[i];
		23	pDst[2*i+1] = 0.0f;
		24	}
		25	}
		26
		27	switch(S->fftLenReal)
		28	{
		29	case 128:
		30	ref_cfft_f32(&arm_cfft_sR_f32_len128, pDst, S->ifftFlagR, S->bitReverseFlagR);
		31	break;
		32
		33	case 512:
		34	ref_cfft_f32(&arm_cfft_sR_f32_len512, pDst, S->ifftFlagR, S->bitReverseFlagR);
		35	break;
		36
		37	case 2048:
		38	ref_cfft_f32(&arm_cfft_sR_f32_len2048, pDst, S->ifftFlagR, S->bitReverseFlagR);
		39	break;
		40
		41	case 8192:
		42	ref_cfft_f32(&ref_cfft_sR_f32_len8192, pDst, S->ifftFlagR, S->bitReverseFlagR);
		43	break;
		44	}
		45
		46	if (S->ifftFlagR)
		47	{
		48	//throw away the imaginary part which should be all zeros
		49	for(i=0;i<S->fftLenReal;i++)
		50	{
		51	pDst[i] = pDst[2*i];
		52	}
		53	}
		54	}
		55
		56	void ref_rfft_fast_f32(
		57	arm_rfft_fast_instance_f32 * S,
		58	float32_t * p, float32_t * pOut,
		59	uint8_t ifftFlag)
		60	{
		61	uint32_t i,j;
		62
		63	if (ifftFlag)
		64	{
		65	for(i=0;i<S->fftLenRFFT;i++)
		66	{
		67	pOut[i] = p[i];
		68	}
		69	//unpack first sample's complex part into middle sample's real part
		70	pOut[S->fftLenRFFT] = pOut[1];
		71	pOut[S->fftLenRFFT+1] = 0;
		72	pOut[1] = 0;
		73	j=4;
		74	for(i = S->fftLenRFFT / 2 + 1;i < S->fftLenRFFT;i++)
		75	{
		76	pOut[2i+0] = p[2i+0 - j];
		77	pOut[2i+1] = -p[2i+1 - j];
		78	j+=4;
		79	}
		80	}
		81	else
		82	{
		83	for(i=0;i<S->fftLenRFFT;i++)
		84	{
		85	pOut[2*i+0] = p[i];
		86	pOut[2*i+1] = 0.0f;
		87	}
		88	}
		89
		90	switch(S->fftLenRFFT)
		91	{
		92	case 32:
		93	ref_cfft_f32(&arm_cfft_sR_f32_len32, pOut, ifftFlag, 1);
		94	break;
		95
		96	case 64:
		97	ref_cfft_f32(&arm_cfft_sR_f32_len64, pOut, ifftFlag, 1);
		98	break;
		99
		100	case 128:
		101	ref_cfft_f32(&arm_cfft_sR_f32_len128, pOut, ifftFlag, 1);
		102	break;
		103
		104	case 256:
		105	ref_cfft_f32(&arm_cfft_sR_f32_len256, pOut, ifftFlag, 1);
		106	break;
		107
		108	case 512:
		109	ref_cfft_f32(&arm_cfft_sR_f32_len512, pOut, ifftFlag, 1);
		110	break;
		111
		112	case 1024:
		113	ref_cfft_f32(&arm_cfft_sR_f32_len1024, pOut, ifftFlag, 1);
		114	break;
		115
		116	case 2048:
		117	ref_cfft_f32(&arm_cfft_sR_f32_len2048, pOut, ifftFlag, 1);
		118	break;
		119
		120	case 4096:
		121	ref_cfft_f32(&arm_cfft_sR_f32_len4096, pOut, ifftFlag, 1);
		122	break;
		123	}
		124
		125	if (ifftFlag)
		126	{
		127	//throw away the imaginary part which should be all zeros
		128	for(i=0;i<S->fftLenRFFT;i++)
		129	{
		130	pOut[i] = pOut[2*i];
		131	}
		132	}
		133	else
		134	{
		135	//pack last sample's real part into first sample's complex part
		136	pOut[1] = pOut[S->fftLenRFFT];
		137	}
		138	}
		139
		140	void ref_rfft_q31(
		141	const arm_rfft_instance_q31 * S,
		142	q31_t * pSrc,
		143	q31_t * pDst)
		144	{
		145	uint32_t i;
		146	float32_t fDst = (float32_t)pDst;
		147
		148	if (S->ifftFlagR)
		149	{
		150	for(i=0;i<S->fftLenReal*2;i++)
		151	{
		152	fDst[i] = (float32_t)pSrc[i] / 2147483648.0f;
		153	}
		154	}
		155	else
		156	{
		157	for(i=0;i<S->fftLenReal;i++)
		158	{
		159	fDst[2*i+0] = (float32_t)pSrc[i] / 2147483648.0f;
		160	fDst[2*i+1] = 0.0f;
		161	}
		162	}
		163
		164	switch(S->fftLenReal)
		165	{
		166	case 32:
		167	ref_cfft_f32(&arm_cfft_sR_f32_len32, fDst, S->ifftFlagR, S->bitReverseFlagR);
		168	break;
		169
		170	case 64:
		171	ref_cfft_f32(&arm_cfft_sR_f32_len64, fDst, S->ifftFlagR, S->bitReverseFlagR);
		172	break;
		173
		174	case 128:
		175	ref_cfft_f32(&arm_cfft_sR_f32_len128, fDst, S->ifftFlagR, S->bitReverseFlagR);
		176	break;
		177
		178	case 256:
		179	ref_cfft_f32(&arm_cfft_sR_f32_len256, fDst, S->ifftFlagR, S->bitReverseFlagR);
		180	break;
		181
		182	case 512:
		183	ref_cfft_f32(&arm_cfft_sR_f32_len512, fDst, S->ifftFlagR, S->bitReverseFlagR);
		184	break;
		185
		186	case 1024:
		187	ref_cfft_f32(&arm_cfft_sR_f32_len1024, fDst, S->ifftFlagR, S->bitReverseFlagR);
		188	break;
		189
		190	case 2048:
		191	ref_cfft_f32(&arm_cfft_sR_f32_len2048, fDst, S->ifftFlagR, S->bitReverseFlagR);
		192	break;
		193
		194	case 4096:
		195	ref_cfft_f32(&arm_cfft_sR_f32_len4096, fDst, S->ifftFlagR, S->bitReverseFlagR);
		196	break;
		197
		198	case 8192:
		199	ref_cfft_f32(&ref_cfft_sR_f32_len8192, fDst, S->ifftFlagR, S->bitReverseFlagR);
		200	break;
		201	}
		202
		203	if (S->ifftFlagR)
		204	{
		205	//throw away the imaginary part which should be all zeros
		206	for(i=0;i<S->fftLenReal;i++)
		207	{
		208	//read the float data, scale up for q31, cast to q31
		209	pDst[i] = (q31_t)( fDst[2i] 2147483648.0f);
		210	}
		211	}
		212	else
		213	{
		214	for(i=0;i<S->fftLenReal;i++)
		215	{
		216	//read the float data, scale up for q31, cast to q31
		217	pDst[i] = (q31_t)( fDst[i] * 2147483648.0f / (float32_t)S->fftLenReal);
		218	}
		219	}
		220	}
		221
		222	void ref_rfft_q15(
		223	const arm_rfft_instance_q15 * S,
		224	q15_t * pSrc,
		225	q15_t * pDst)
		226	{
		227	uint32_t i;
		228	float32_t fDst = (float32_t)pDst;
		229
		230
		231	if (S->ifftFlagR)
		232	{
		233	for(i=0;i<S->fftLenReal*2;i++)
		234	{
		235	fDst[i] = (float32_t)pSrc[i] / 32768.0f;
		236	}
		237	}
		238	else
		239	{
		240	for(i=0;i<S->fftLenReal;i++)
		241	{
		242	//read the q15 data, cast to float, scale down for float
		243	fDst[2*i+0] = (float32_t)pSrc[i] / 32768.0f;
		244	fDst[2*i+1] = 0.0f;
		245	}
		246	}
		247
		248	switch(S->fftLenReal)
		249	{
		250	case 32:
		251	ref_cfft_f32(&arm_cfft_sR_f32_len32, fDst, S->ifftFlagR, S->bitReverseFlagR);
		252	break;
		253
		254	case 64:
		255	ref_cfft_f32(&arm_cfft_sR_f32_len64, fDst, S->ifftFlagR, S->bitReverseFlagR);
		256	break;
		257
		258	case 128:
		259	ref_cfft_f32(&arm_cfft_sR_f32_len128, fDst, S->ifftFlagR, S->bitReverseFlagR);
		260	break;
		261
		262	case 256:
		263	ref_cfft_f32(&arm_cfft_sR_f32_len256, fDst, S->ifftFlagR, S->bitReverseFlagR);
		264	break;
		265
		266	case 512:
		267	ref_cfft_f32(&arm_cfft_sR_f32_len512, fDst, S->ifftFlagR, S->bitReverseFlagR);
		268	break;
		269
		270	case 1024:
		271	ref_cfft_f32(&arm_cfft_sR_f32_len1024, fDst, S->ifftFlagR, S->bitReverseFlagR);
		272	break;
		273
		274	case 2048:
		275	ref_cfft_f32(&arm_cfft_sR_f32_len2048, fDst, S->ifftFlagR, S->bitReverseFlagR);
		276	break;
		277
		278	case 4096:
		279	ref_cfft_f32(&arm_cfft_sR_f32_len4096, fDst, S->ifftFlagR, S->bitReverseFlagR);
		280	break;
		281
		282	case 8192:
		283	ref_cfft_f32(&ref_cfft_sR_f32_len8192, fDst, S->ifftFlagR, S->bitReverseFlagR);
		284	break;
		285	}
		286
		287	if (S->ifftFlagR)
		288	{
		289	//throw away the imaginary part which should be all zeros
		290	for(i=0;i<S->fftLenReal;i++)
		291	{
		292	pDst[i] = (q15_t)( fDst[2i] 32768.0f);
		293	}
		294	}
		295	else
		296	{
		297	for(i=0;i<S->fftLenReal;i++)
		298	{
		299	pDst[i] = (q15_t)( fDst[i] * 32768.0f / (float32_t)S->fftLenReal);
		300	}
		301	}
		302	}

Subversion Repositories dashGPS

(root)/branches/dashGPS-bmp/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/TransformFunctions/rfft.c – Rev 2