fast fourier transform

Version imprimable

17/06/2006, 20h50
debutantcpp

fast fourier transform

Salut a tous,voia mon pb.
Je veux recuperer le son du micro et savoir qu'elles frequences sont emise.
je m'aide d'un source qui me donne:

fft_float(1024,0,Temp1,Temp2,RO,IO);

RO et IO sont des tableaux de 1024 float de sortie.
Jusque la ca va mais ensuite je ne sais pas quoi en faire.
Il faut un calcule pour savoir l'amplitude de chaques frequences.
J'essais donc celuis ci:

for (i=0;i<1024;i++){
Amp[i]=(float)(sqrt(pow(RO[i],2)+pow(IO[i],2)));
Freq[i]=(float)((44100*(i+1))*2);
Freq[i]/=Buffer.dwBufferLength;
}

Mais quand j'essais avec le micro eteint(donc silence) j'ai quand meme des grosses valeur dans l'amplitude,c'est normal ?.

Si quelqu'un peut m'aider ,merci.
17/06/2006, 22h24
debutantcpp

reponse

Merci mais je sais deja aquerir le son depuis un micro.
Le probleme vient du tableau de sortie.
Apres la transformer de fourier que dois je faire?.
17/06/2006, 23h29
Matthieu Brucher

Prendre la valeur absolue, comme tu le fais...
Affiche une fois un graphe de tes valeurs. C'est ta version de la FFT ? Est-ce qu'elle est mise à l'échelle ? - application du 1/T lors de la transformation directe ou inverse ? -
Enfin, pour qui veut faire du vrai traitement audio, on utilise des hôtes ASIO, pas du DirectX...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
void fft_float ( unsigned NumSamples,
                 int    InverseTransform,
                 float  *RealIn,
                 float  *ImagIn,
                 float  *RealOut,
                 float  *ImagOut )
{
unsigned NumBits;    /* Number of bits needed to store indices */
unsigned i, j, k, n;
unsigned BlockSize, BlockEnd;
 
float angle_numerator = 2.0F * 3.141592F;
float delta_angle;
float alpha, beta;  /* used in recurrence relation */
float delta_ar;
float tr, ti;     /* temp real, temp imaginary */
float ar, ai;     /* angle vector real, angle vector imaginary */
 
	if (InverseTransform)
		angle_numerator = -angle_numerator;
	NumBits = NumberOfBitsNeeded ( NumSamples );
 
	for ( i=0; i < NumSamples; i++ )
	{
		j = ReverseBits ( i, NumBits );
		RealOut[j] = RealIn[i];
		ImagOut[j] = ImagIn ? ImagIn[i] : 0.0F;
	}
 
	BlockEnd = 1;
	for ( BlockSize = 2; BlockSize <= NumSamples; BlockSize <<= 1 )
	{
		delta_angle = angle_numerator / (float)BlockSize;
		alpha = (float)sin(0.5 * delta_angle);
		alpha = 2.0F * alpha * alpha;
		beta = (float)sin (delta_angle);
 
		for ( i=0; i < NumSamples; i += BlockSize )
		{
			ar = 1.0;   /* cos(0) */
			ai = 0.0;   /* sin(0) */
			 for ( j=i, n=0; n < BlockEnd; j++, n++ )
			 {
					k = j + BlockEnd;
					tr = ar*RealOut[k] - ai*ImagOut[k];
					ti = ar*ImagOut[k] + ai*RealOut[k];
 
					RealOut[k] = RealOut[j] - tr;
					ImagOut[k] = ImagOut[j] - ti;
 
					RealOut[j] += tr;
					ImagOut[j] += ti;
 
					delta_ar = alpha*ar + beta*ai;
					ai -= (alpha*ai - beta*ar);
					ar -= delta_ar;
			 }
		}
 
		BlockEnd = BlockSize;
	}
 
	if ( InverseTransform )
	{
		float denom = (float)NumSamples;
		for ( i=0; i < NumSamples; i++ )
		{
			 RealOut[i] /= denom;
			 ImagOut[i] /= denom;
		}
	}
}

Voila mon code fft.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
HWAVEIN	hwi;	//Nouvelle allocation pour le Handle
WAVEHDR  wh;
static WAVEFORMATEX wfx;
 
#define TAILLE_BUFFER     44100
static short Buffer[TAILLE_BUFFER / 2], BufferTmp[TAILLE_BUFFER / 2] = {0};
 
float Real[22050]; //tableau d'entree
float Imag[22050];//tableau imaginaire
float IOut[22050];//
float ROut[22050];//tableaux de sortie
float Amp[22050]; 
float Freq[22050];
 
 
Donc je capture le son au micro dans Buffer.
Buffer[1] = 384 ,Buffer[2]=140,Buffer[50]=139 etc..
 
Ensuite je les passent en float dans Real:
	  for (i=0;i<22050;i++){
Real[i] =(float)Buffer[i];
	  }
 
Ensuite je pratique la fft:
fft_float(22050,0,Real,Imag,ROut,IOut);
 
Ensuite je cherche l'amplitude pour chaque frequence:
 
for (i=0;i<22050;i++){
Amp[i]=(float)(sqrt(pow(ROut[i],2)+pow(IOut[i],2)));
Freq[i]=(float)((44100*(i+1))*2);
Freq[i]/=wh.dwBufferLength;
}
 
Cela me donne :
Freq[1]=4   Amp[1]=3.98441e+006
Freq[2]=6   Amp[2]=241
Freq[3]=8   Amp[3]=3.98441e+006
Freq[4]=10   Amp[4]=241

etc
Je ne comprend pas ces resultats.
Merci.

19/06/2006, 10h50
Matthieu Brucher

:tagcode:
Et alors ? Je ne vais pas regarder ton code pour savoir quans tu fais la mise à l'échelle, c'est à toi de le savoir si tu l'as codée.

edit : je regarde, et en 2sec je trouve le code de mise à l'échelle. Tu lis parfois ce que tu écris ?
19/06/2006, 13h30
poukill

Non, ce n'est pas normal...
Si ton micro est éteint, le spectre devrait quasiment être bul (aux bruits d'acquisition prêt)!
POur le fft, y'a des choses déjà faites ;)

http://www.fftw.org/
19/06/2006, 13h44
debutantcpp

Non sans lib svp.
Moi aussi je crois que j'ai foiré quelque part mais ou...
19/06/2006, 13h55
Matthieu Brucher

:tagcode: - dernière demande...

Juste pour dire, vu ton code, ça ne m'étonne pas, la réponse de la FFT. Elle peut être bonne. Tu as au moins testé avec un sinus ?
19/06/2006, 19h26
Gnux

Citation:

Envoyé par Miles

:tagcode: - dernière demande...

Juste pour dire, vu ton code, ça ne m'étonne pas, la réponse de la FFT. Elle peut être bonne. Tu as au moins testé avec un sinus ?

Balises rajoutées :roll:
20/06/2006, 20h39
debutantcpp
Ca y est j'ai rectifié le code.
Maintenent apres la fft j'ai mon tableau : ROut[1024].
Micro eteint il vaut 0 environ, puis quand je l'allume j'ai des valeurs (20,35,41,...).
Ca me semble correte jusque la.
Maintenent comment attribuer ces valeurs aux frequences.
Code:

1 2 3 4 5 for (i=0;i<1024,i++){ Freq[i]=(44100/1024)*i; Amp[i]=ROut[i]; }
exmple pour i=1 :
Freq[1](44100/1024)*1=43,06640625 hz
Amp[1]=45

la frequence 43.06hz a une amplitude de 45 db,
Vous croyez que c'est bon?.
Merci
20/06/2006, 20h42
Matthieu Brucher

Fais gaffe, tu as un facteur d'échelle dans le tas, n'oublie pas !
Si tu veux savoir combien de dB, ça fait, prends un signal dont tu connais exactement la puissance et fais la FFT dessus, pour savoir quelle est la puissance effective.
21/06/2006, 08h40
poukill

C'est en effet la meilleure méthode : un bon cosinus (de durée longue gare aux effets de bords) dont tu connais l'amplitude et hop c'est gagné !
Il suffit de mesurer l'amplitude du pic obtenue...

Vérifie au passage la fréquence (dépend de ta fréquence d'échantillonage ) car bon nombre de FTT affiche en fréquence réduite (-0.5 0.5)....

A+