jens/mips
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

- use build in data types

Browse Source 
git-svn-id: http://moon:8086/svn/mips@35 a8ebac50-d88d-4704-bea3-6648445a41b3
This commit is contained in:
jens
2015-05-28 19:19:01 +00:00
parent 3263f9d79c
commit a655e1c5d9
54 changed files with 1551 additions and 1583 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/fft.c
+32 -32
View File
@@ -3,7 +3,7 @@
/* Fast-Fourier-Transformation
/* Author: Jens Ahrensfeld
/* Datum : 24.06.1999
/* letzte Änderung: 09.06.2000
/* letzte �nderung: 09.06.2000
/***************************************************************************/
#include <stdio.h>
#include <stdlib.h>
@@ -18,7 +18,7 @@
/* Konstruktor FFT-Objekt */
/* */
/***************************************************************************/
void FFTinit(fft_t *pFFT, UINT32 N)
void FFTinit(fft_t *pFFT, uint32_t N)
{
pFFT->m_numPoints = 0;
pFFT->m_numStages = 0;
@@ -32,8 +32,8 @@ void FFTinit(fft_t *pFFT, UINT32 N)
exit(1);
}
pFFT->m_numStages = (UINT32) (1e-06 + log((fft_float_t)N)/log(2.0));
pFFT->m_numPoints = (UINT32 )N;
pFFT->m_numStages = (uint32_t) (1e-06 + log((fft_float_t)N)/log(2.0));
pFFT->m_numPoints = (uint32_t )N;
pFFT->pTwfRe = (fft_float_t*)malloc(pFFT->m_numPoints * sizeof(fft_float_t) /2);
pFFT->pTwfIm = (fft_float_t*)malloc(pFFT->m_numPoints * sizeof(fft_float_t) /2);
@@ -76,11 +76,11 @@ void FFTfree(fft_t *pFFT)
/***************************************************************************/
void fft_inplace(fft_t *pFFT, fft_float_t *in_re, fft_float_t *in_im)
{
register UINT32 stageCnt, k, kk, twf, numNodesPerStage, nodeCnt, opsPerNode, opCnt, i, i2, j;
register uint32_t stageCnt, k, kk, twf, numNodesPerStage, nodeCnt, opsPerNode, opCnt, i, i2, j;
fft_float_t tempr, tempi, s, c;
#ifdef FFTMsg
UINT32 numMul, numAdd;
uint32_t numMul, numAdd;
printf ("\nStart %d-Point FFT.\n\n",pFFT->m_numPoints);
#endif
@@ -162,7 +162,7 @@ printf ("Total number of complex multiplications = %u\n",numMul);
/***************************************************************************/
void ifft_inplace(fft_t *pFFT, fft_float_t *in_re, fft_float_t *in_im)
{
register UINT32 stageCnt, k, kk, twf, numNodesPerStage, nodeCnt, opsPerNode, opCnt, i, i2, j;
register uint32_t stageCnt, k, kk, twf, numNodesPerStage, nodeCnt, opsPerNode, opCnt, i, i2, j;
fft_float_t tempr, tempi, s, c;
#ifdef FFTMsg
@@ -235,11 +235,11 @@ printf ("\n%d-Point IFFT is completed.\n",pFFT->m_numPoints);
/***************************************************************************/
void ffts_inplace(fft_t *pFFT, fft_float_t *in_re, fft_float_t *in_im)
{
register UINT32 stageCnt, k, kk, twf, numNodesPerStage, nodeCnt, opsPerNode, opCnt, i, i2, j;
register uint32_t stageCnt, k, kk, twf, numNodesPerStage, nodeCnt, opsPerNode, opCnt, i, i2, j;
fft_float_t tempr, tempi, s, c;
#ifdef FFTMsg
UINT32 numMul, numAdd;
uint32_t numMul, numAdd;
printf ("\nStart %d-Point FFT.\n\n",pFFT->m_numPoints);
#endif
@@ -319,9 +319,9 @@ printf ("Total number of complex multiplications = %u\n",numMul);
/* TWIDDLE-FAKTOR-TABLE */
/* Erstellt Twiddle-Faktor-Tabelle von WN^0 bis WN^N/2 */
/***************************************************************************/
void FFTCalcTwiddleTable (fft_float_t *pRealData, fft_float_t *pImagData, UINT32 numPoints)
void FFTCalcTwiddleTable (fft_float_t *pRealData, fft_float_t *pImagData, uint32_t numPoints)
{
UINT32 i, size;
uint32_t i, size;
fft_float_t arg1;
size = numPoints/2;
@@ -344,9 +344,9 @@ fft_float_t arg1;
/* MODULUS */
/* Berechnet den Betrag einer komplexen Zahl */
/***************************************************************************/
void Modulus(fft_float_t *pRealData, fft_float_t *pImagData, UINT32 N)
void Modulus(fft_float_t *pRealData, fft_float_t *pImagData, uint32_t N)
{
UINT32 i;
uint32_t i;
fft_float_t temp;
for (i = 0; i < N; i++) {
@@ -359,9 +359,9 @@ fft_float_t temp;
/* Hanning */
/* Legt das Hanningfenster auf die Abtastwerte im Zeitbereich der Groesse N */
/***************************************************************************/
void Hanning(fft_float_t *pRealData, fft_float_t *pImagData, UINT32 N, UINT32 maximum)
void Hanning(fft_float_t *pRealData, fft_float_t *pImagData, uint32_t N, uint32_t maximum)
{
UINT32 n;
uint32_t n;
fft_float_t arg;
for (n=0; n < N; n++)
@@ -374,9 +374,9 @@ void Hanning(fft_float_t *pRealData, fft_float_t *pImagData, UINT32 N, UINT32 ma
/***************************************************************************/
/* HANNING_K */
/* Gibt einen Faktor k in Abhängigkeit von n bezogen auf N zurück. */
/* Gibt einen Faktor k in Abh�ngigkeit von n bezogen auf N zur�ck. */
/***************************************************************************/
fft_float_t hanning_k(UINT32 n, UINT32 N)
fft_float_t hanning_k(uint32_t n, uint32_t N)
{
fft_float_t arg;
arg = (fft_float_t)(2 * PI / (fft_float_t)N);
@@ -386,9 +386,9 @@ return ((1-(fft_float_t)cos(arg*(fft_float_t)n))/2);
/***************************************************************************/
/* GAUSS_K */
/* Gibt einen Faktor k in Abhängigkeit von n bezogen auf N zurück. */
/* Gibt einen Faktor k in Abh�ngigkeit von n bezogen auf N zur�ck. */
/***************************************************************************/
fft_float_t gauss_k(UINT32 n, UINT32 m, UINT32 s)
fft_float_t gauss_k(uint32_t n, uint32_t m, uint32_t s)
{
fft_float_t arg;
arg = (fft_float_t)((n-m)*(n-m)/(2*s*s));
@@ -400,9 +400,9 @@ return (fft_float_t)(exp(-arg));
/* Normalize) */
/* */
/***************************************************************************/
void Scale(fft_float_t *pRealData, fft_float_t *pImagData, fft_float_t scaleFactor, UINT32 N)
void Scale(fft_float_t *pRealData, fft_float_t *pImagData, fft_float_t scaleFactor, uint32_t N)
{
UINT32 k;
uint32_t k;
// Scaling Data
for (k=0; k < N; k++)
@@ -416,17 +416,17 @@ void Scale(fft_float_t *pRealData, fft_float_t *pImagData, fft_float_t scaleFact
/* BiPower()
/* checks if N is power of 2
/***************************************************************************/
UINT32 IsPowerOfTwo(UINT32 N)
uint32_t IsPowerOfTwo(uint32_t N)
{
UINT32 i, iterations;
iterations = sizeof(UINT32)*8;
uint32_t i, iterations;
iterations = sizeof(uint32_t)*8;
if (N == 0)
return FFT_ERROR;
for (i=0; i <iterations; i++)
{
if (N == (UINT32)(2 << i))
if (N == (uint32_t)(2 << i))
return 0;
}
@@ -437,7 +437,7 @@ UINT32 IsPowerOfTwo(UINT32 N)
/* FFT2Dinit()
/*
/***************************************************************************/
void FFT2Dinit(fft2_t *pFFT, UINT32 Nx, UINT32 Ny)
void FFT2Dinit(fft2_t *pFFT, uint32_t Nx, uint32_t Ny)
{
pFFT->pXfft = NULL;
pFFT->pYfft = NULL;
@@ -486,7 +486,7 @@ void FFT2Dfree(fft2_t *pFFT)
void fft2d_inplace(fft2_t *pFFT, fft_float_t **ppReal, fft_float_t **ppImag)
{
fft_float_t *pTempr, *pTempi;
UINT32 i, row;
uint32_t i, row;
pTempr = (fft_float_t*)malloc(pFFT->m_Ny*sizeof(fft_float_t));
@@ -524,7 +524,7 @@ void fft2d_inplace(fft2_t *pFFT, fft_float_t **ppReal, fft_float_t **ppImag)
void ifft2d_inplace(fft2_t *pFFT, fft_float_t **ppReal, fft_float_t **ppImag)
{
fft_float_t *pTempr, *pTempi;
UINT32 i, row;
uint32_t i, row;
pTempr = (fft_float_t*)malloc(pFFT->m_Ny*sizeof(fft_float_t));
@@ -559,11 +559,11 @@ void ifft2d_inplace(fft2_t *pFFT, fft_float_t **ppReal, fft_float_t **ppImag)
/* DFT()
/* DISKRETE FOURIER-TRANSFORMATION S(f) -> s(t) */
/***************************************************************************/
void DFT(fft_float_t *pDataR, fft_float_t *pDataI, UINT32 N)
void DFT(fft_float_t *pDataR, fft_float_t *pDataI, uint32_t N)
{
fft_float_t *a, *b;
fft_float_t phi, c, s;
UINT32 i, j;
uint32_t i, j;
a = (fft_float_t*)malloc(N * sizeof(fft_float_t));
b = (fft_float_t*)malloc(N * sizeof(fft_float_t));
@@ -595,11 +595,11 @@ void DFT(fft_float_t *pDataR, fft_float_t *pDataI, UINT32 N)
/* IDFT()
/* INVERSE DISKRETE FOURIER-TRANSFORMATION S(f) -> s(t) */
/***************************************************************************/
void IDFT(fft_float_t *pDataR, fft_float_t *pDataI, UINT32 N)
void IDFT(fft_float_t *pDataR, fft_float_t *pDataI, uint32_t N)
{
fft_float_t *a, *b;
fft_float_t phi, c, s;
UINT32 i, j;
uint32_t i, j;
a = (fft_float_t*)malloc(N * sizeof(fft_float_t));
b = (fft_float_t*)malloc(N * sizeof(fft_float_t));