Se connecter
Se connecter
Mot de passe oublié ?
ou
Créer un compte
ou
Se connecter avec Facebook
Notifications
< Retour vers Bidouille & Développement Informatique
Agrandir
Bidouille & Développement Informatique
Les Mains dans le Cambouis
Bidouille & Développement Informatique
Actu 1 1
Articles
Médias 33 33
Tutoriels
Forums 326 326

Sujet Programmation de débruitage et transformation de voix en temps réel

  • 6 réponses
  • 2 participants
  • 1 263 vues
  • 2 followers
Sujet de la discussion Programmation de débruitage et transformation de voix en temps réel
Salut a tous!

je voulais juste vous demander ce que vous pouviez me conseiller pour développer des plugins audio qui traiteraient de débruitage et de transformation de voix) en temps réel.



Hors sujet : Note pour les physiciens:
il s'agit d'une méthode de soustraction spectrale suivie d'un traitement visant a enlever le bruit musical par méthode Ephraïm et Malah et de normalisation du conduit vocal (VTLN )





Je suis a priori parti pour les développer avec les standards VST et C++ mais ayant beaucoup de liberté sur les méthodes je me demandais si d autres méthodes pourraient etre plus performantes/efficaces/simples par exemple DirectX ou programmation en Matlab


Pouvez vous aussi me conseiller des tutoriels pour VST en supposant que je parte dans cette méthode? (la partie théorique de traitement du signal et de la voix est tres bien comprise, mais j ai des petites lacunes en programmation)


Je vous en remercie
2
Deja, au niveau dsp, VST, directX, CoreAudio (et AudioUnit), etc... ca change rien. C'est dans ce qu'il y a autour que tu as des variations, entre autre comment gerer les parametres et leur timing, etc...

Toutes les API temps reels, niveau calcul, se resument a une fonction (process en VST) qui te donne N samples en entree, et s'attend a en recevoir N en sorties, sachant que le N varie en general entre chaque appel. C'est donc ce probleme que tu fois attaquer, le reste etant annexe.

En general, toi, tu as un algo qui necessite M samples, M etant fixe, il faut donc que tu adaptes un flux a debut variable (entree sorties de l'hote) a un flux constant. La structure de base pour ca, c'est le ring buffer.

Tu peux d'abord te creer un hote virtuel, qui va initialiser ton plug in, puis appeler regulierement la fonction process de ton plug in. Si t'es debutant en prog, je te conseille de faire ca dans un langage haut niveau au debut (matlab, python, ce que tu veux). Avoir ton hote et ton plug in rend le debuggage beaucoup plus simple.

Si tu veux, j'ai un exemple minimal de ce procede en python que je peux te filer.
3
Je te remercie pour ta réponse. Malheureusement je me rends compte que le sujet a l'air beaucoup plus complexe que ce a quoi je m'attendais.

Si tu as un petit exemple qui me permettrait de me lancer, que je pourrais décortiquer et adapter à mes besoins ce serait avec un grand plaisir.

Je pense donc que je vais plutot attaquer en Matlab pour la facilité ( je commence a bien le manier ) et bien lire le didacticiel du pack developpeur de VST.

Maintenant je pense que si je désire utiliser c++, il doit exister des bibliotheques propres au traitement du signal, qui me permettraient de me rapprocher des fonctions de transformée de Fourier de Matlab. je vais essayer de trouver cela.

Merci pour ta réponse
4
Attention, il y a plusieurs problemes qui sont vraiment independants dont tu parles, la, et aucun n'est vraiment lie a VST vs DirectX.

Citation :
Maintenant je pense que si je désire utiliser c++, il doit exister des bibliotheques propres au traitement du signal, qui me permettraient de me rapprocher des fonctions de transformée de Fourier de Matlab. je vais essayer de trouver cela.



Si ton plug in est open source, il y a des tonnes de librairies que tu peux utiliser pour la fft, le traitement du signal (LPC, etc...). Tout ca depend de ce que tu veux faire et du type de plugin (au niveau license) que tu veux utilier.

Typiquement, pour la fft, il y a fftw, qui est d'ailleurs la librairie utilisee par matlab au moins jusqu'a 6.5 (7, je suis pas sur):

http://www.fftw.org/

Mais si tu fais pas un truc open source, tu devras payer pour une license si tu veux distribuer ton plugin.

Maintenant, pour le reste: une fois que ton algo est au point sous matlab, le porter sous VST implique differentes etapes:

- porter l'algo en soi en C.
- le rendre temps reel
- l'interfacer avec VST.

1 et 2 sont plus compliques que 3, tant que tu ne t'occupes que de l'algorithmie (eg tu ne t'interesses ni a l'interface, ni a l'automation des parametres, etc..). La 2, c'est pas plus complique de le faire pour ton algo que pour un algo qui fait un simple gain par blocs de taille fixe.

La partie 1, il y a pas de techniques particulieres. Pour le 2, il s'agit avant tout dans ton cas de faire l'adaptation flux variable du cote VST vers flux constant cote algo. Je sais pas quel est ton algo, mais disons qu'il 's'agisse d'un simple vocoder de phase, avec des fenetres de 512 echantillons. Ton algo en C (de la partie 1) va donc avoir une function compute qui prend 512 samples, et en ressort 512. Mais en temps reel, c'est pas aussi simple, car l'hote va appeler ton plug in avec un nombre variable d'echantillons:

- 1er appel: process avec 50 echantillons
- 2e appel: process avec 100
- 3 appel: process avec 256
- 4e -10e appel: process avec 2000 echantillons.

Toi, de ton cote, tu dois convertir ca en blocs de 512 echantillons, car c'est le seul truc que ton algo peut gerer. La structure de donnees pour faire cette conversion, c'est le ring buffer:

https://en.wikipedia.org/wiki/Ring_buffer

Mon exemple en python (python est suffisament simple a lire pour que le principe soit clair meme sans connaitre le langage, je pense, c'est quasiment du pseudo code) est la:
http://www.ar.media.kyoto-u.ac.jp/members/david/archives/pyringbuffer/ring.zip

Y a 2 fichiers:
- 1 qui implemente le ring buffer en python (en utilisant des listes)
- 1, fakeengine.py, qui implemente 3 classes: une Engine, une Plugin et une BlockAlgo.

La classe BlockAlgo est triviale: elle applique un gain constant a son entree, mais agit par blocs de taille fixe (tu peux fixer la taille a l'initialisation).

La class Engine est triviale aussi: en gros, tu lui passe une instance de Plugin, et elle initialise le plugin, puis la fonction membre run appelle un certain nombre de fois la fonction de calcul du plugin avec un nombre variable d'echantillons a chaque fois (les valeurs sont tirees au hasard pour tester)

La Classe Plugin est la ou tout se passe: elle utilise une instance de BlockAlgo pour faire les calculs, et adapte la taille variable de buffers que lui donne Engine, a la taille fixe de l'instance de BlockAlgo. En gros, c'est la fonction process qui fait le truc un peu complique:

- d'abord, remplir le ring buffer avec les echantillons files par l'hote (nframes echantillons).
- ensuite, regarder si le ring buffer a assez de donnees pour traiter au moins un bloc (appeles full blocs, dans le code), et calculer le nombre d'echantillons qui "depassent" (si tu as 1040 enchantillons dans le ring buffer, et que tu as des blocs de taille 512, tu as 2 blocs entiers, et 16 echantillons restants).
- pour chaque bloc entier, tu prends les echantillons du ring buffer, puis tu appelles BlockAlgo (qui fait le calcul dsp sur taille fixe).
- tu ecris le resultat de BlockAlgo dans un autre ring buffer, celui de sortie (tu as un ring buffer en entree, et un en sortie).
- enfin, tu lis nframes echantillons du ring buffer de sortie, et tu les files a l'hote.

Note que ce processus suppose que l'hote te file un nombre d'echantillons en entree et demande le mem nombe en sorties (c'est peut etre pas toujours vrai, ca l'est en tout cas en VST), et suppose que ton algo lui aussi sort le membre nombre. C'est aussi totalement non optimise, dans le sens ou j'essaye pas d'eviter des copies dans les ring buffer s'il y en a pas besoin; ca compliquerait pas mal l'exemple, que j'ai voulu simple lorsque je l'ai programme pour comprendre comment ca marche.

Par contre, l'initialisation est prise en compte dans mon exemple, ainsi que la latence induite par le plug in qui est file a l'hote, ce qui est necessaire pour les dernieres variations VST qui font du "latency delay compensation".
5
Et bien, je te remercie pour cette explication plus que claire!
Je ne pensais pas rencontrer quelqu'un d'aussi calé dans le domaine et qui m'aiderait autant.

Je vous tient au courant de l'avancement si d'autres personnes sont intéressées par le sujet!
6

Citation :
Je ne pensais pas rencontrer quelqu'un d'aussi calé dans le domaine et qui m'aiderait autant.



Bof, tu trouveras des personnes bien plus calees sur les forums specialistes (kvr, music-dsp, LAD: la, il y a de vrais developeurs, qui font autre chose que bidouiller dans leur coin comme moi :) ).
7
Pourrais tu m envoyer en privé ton adresse mail, si bien sur tu serais d'accord d'appronfondir le sujet, ainsi que des forums que tu me conseillerais afin de trouver des gens qualifies dans le domaine?


Je t'en remercie