Problème overlap-add kissfft

Version imprimable

Salut,
Alors voilà, j'essaye d'écrire un plugin VST (traitement audio en temps-réel) qui ferait du filtrage par FFT, et je n'y arrive pas trop...

J'ai essayé d'implémenter la méthode overlap-add, en remplissant donc l'autre moitié du buffer avec des 0 et en faisant la transformée de fourier de tout ça.

Voilà mon code :
(Tous les buffers outdata, indata ont une taille 1024). Pour l'instant je recopie sur les deux canaux de sortie le canal gauche d'entrée, la stéréo viendra quand ça ça marchera...

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
 
for (int s = 0; s < nFrames; ++s, ++in1, ++in2, ++out1, ++out2)
  {
 
	  if(current_buf == 0)
	  {
		  *out1 = outdata1[pos_in_data]  + outdata2[pos_in_data + 512];
		  *out2 = outdata1[pos_in_data]  + outdata2[pos_in_data + 512];
		  indata1[pos_in_data] = *in1;
		  if(++pos_in_data > 512)
		  {
			   memset(indata1 + 512, 0, sizeof(kiss_fft_scalar) * 512);
 
			   kiss_fftr(fftcfg, indata1, sdata);
			   kiss_fftri(ifftcfg, sdata, outdata1);
			   for(int i = 0; i < 1024; ++i)
				   outdata1[i] = outdata1[i] / 1024.;
			   pos_in_data = 0;
			   current_buf = 1;
		  }
	  }
	  else
	  {
 
		  *out1 = outdata2[pos_in_data] + outdata1[pos_in_data + 512];
		  *out2 = outdata2[pos_in_data] + outdata1[pos_in_data + 512];
		  indata2[pos_in_data] = *in1;
 
		  if(++pos_in_data > 512)
		  {
			   memset(indata2 + 512, 0, sizeof(kiss_fft_scalar) * 512);
 
			   kiss_fftr(fftcfg, indata2, sdata);
			   kiss_fftri(ifftcfg, sdata, outdata2);
			   for(int i = 0; i < 1024; ++i)
				   outdata2[i] = outdata2[i] / 1024.;
			   pos_in_data = 0;
			   current_buf = 0;
		  }
	  }
 
  }

Voilà, merci de votre aide !

21/06/2013, 09h44
ternel
Bonjour,
Tu te rends compte qu'ici, notre spécialité, c'est le C++, pas le son.

Si tu as un problème lié au langage, on va pouvoir t'aider, mais si c'est un problème "métier", mieux vaut regarder si une autre section du forum n'irai pas mieux.

Qui plus est, je ne vois aucun aspect C++, mais du code dans le style du C. Tu ne te serai pas trompé de langage?

Enfin, pour t'aider, il nous faut une (ou plusieurs) questions plus précises que "je n'y arrive pas trop". Et plus interrogatives, aussi :mouarf:

Quand a ton code:
- Ca sent la variable globale
- les noms sont assez mal choisis
- il y a trop de constantes magiques
- Ca manque un peu de protection de données (encapsulation, classes?)
21/06/2013, 10h44
boozook

Salut,
Je dois t'avouer que j'ai pas mal hésité avant de poster dans cette section, mais le framework VST (et à vrai dire la grande majorité des frameworks audio) est en C++, donc je me suis dit que les développeurs vst auraient plus tendance à être dans cette section. Mais c'est vrai que le code que j'ai paste aurait aussi bien marché dans un programme C.

De plus j'ai cherché une section relative aux DSPs mais je ne l'ai pas trouvée... J'ai peut-être mal regardé, tu pourrais me l'indiquer si elle existe ? Je changerai mon topic de place. Merci!

Sinon :
. Ca sent la variable globale => je t'assure, il n'y en a pas. fftcfg et ifftcfg sont des attributs de la classe ou se trouve cette fonction, et toutes les autres variables sont locales (je n'ai pas copié leur initialisation).

. les noms sont assez mal choisis => lesquels ? inx et outx sont assez standards, et pour les autres c'est un peu du brouillon, ceci dit je veux bien des conseils pour m'améliorer.

. il y a trop de constantes magiques => qu'appelles-tu une constante magique ?

. Ca manque un peu de protection de données (encapsulation, classes?) => ben disons qu'il faut un maximum de performance donc bof je pense...

Merci bien !

Edit: ah oui, un peu plus de précision sur mon problème : bah c'est simple, il y a de la distorsion aïgue, forte et très moche dans le son après traitement.
21/06/2013, 11h05
ternel
les constantes magiques sont les nombres différentes de 0, 1 et -1, et encore.
512 et 1024, dans ton cas.
Il faut créer des constantes explicites, de facon à pouvoir les changer sans impacter le code.
Code:

1 2 3 namespace { const int buffer_size = 1024; }
Pour les noms de fonctions ifftcfg, ca ressemble quand même beaucoup à ssittypwd, autrement dit, à un nom comprimé, inintelligible pour un relecteur
Le max de perf ne veut pas dire ignorer les classes, qui sont facilement inlinables par les compilateurs.

Bon, j'ai corrigé mon problème tout seul, c'était juste un <= au lieu d'un < :cry:

Merci de tes remarques, voici un code un peu plus propre (et qui ne fait pas de distorsion) pour ceux qui passeront un jour par là.

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
 
// pos_in_data et current_buf sont initialisés à 0 dans le constructeur
void IPlugEffect::ProcessDoubleReplacing(double** inputs, double** outputs, int nFrames)
{
  double* in1 = inputs[0];
  double* in2 = inputs[1];
  double* out1 = outputs[0];
  double* out2 = outputs[1];
 
  for (int s = 0; s < nFrames; ++s, ++in1, ++in2, ++out1, ++out2)
  {
		*out1 = outdata[current_buf][pos_in_data] + outdata[1 - current_buf][pos_in_data + halfFFT_size];
		*out2 = outdata[current_buf][pos_in_data] + outdata[1 - current_buf][pos_in_data + halfFFT_size];
		indata[current_buf][pos_in_data] = *in1;
		if(++pos_in_data >= halfFFT_size)
		{
			memset(indata[current_buf] + halfFFT_size, 0, sizeof(kiss_fft_scalar) * halfFFT_size);
 
			kiss_fftr(fftcfg, indata[current_buf], sdata);
                        // Faire le traitement spectral ici
			kiss_fftri(ifftcfg, sdata, outdata[current_buf]);
			for(int i = 0; i < FFT_size; ++i)
				outdata[current_buf][i] = outdata[current_buf][i] / (double)FFT_size;
			pos_in_data = 0;
			current_buf = 1 - current_buf;
		}
  }
}