Une introduction aux sons en Pharo

Tout d'abord il faut récupérer et installer la dernière version 3.0 de Pharo à l'adresse: http://www.pharo.org/. Le plus simple restant d'exécuter le script de téléchargement qui suit dans un shell.

Si curl n'est pas disponible:

D'autres scripts de téléchargement sont disponibles à l'adresse http://get.pharo.org. L'interface graphique se lance avec la commande ./pharo-ui Pharo.image.

Vous devez ensuite charger le paquet PharoSound en utilisant :

- soit le Configuration Browser (comme le montre la figure 1) qui se trouve dans le menu Tools (entrer « Sound » dans la zone de texte pour sélectionner le paquet et presser sur le bouton Install Stable Version).

- soit Gofer, le gestionnaire de paquets:

1. Vérifications

Avant de nous familiariser avec les différentes méthodes proposées, nous allons nous assurer que notre environnement puisse jouer un son convenablement. Pour cela il suffit d'ouvrir un workspace (depuis le menu Tools) et d'évaluer la ligne de code suivante en sélectionnant l'expression puis en utilisant l'item Do it du menu :

Nous vous expliquerons par la suite ce dont il s'agit. Notez que dans un workspace pour exécuter une ligne il suffit d'y positionner le curseur de la souris et de presser<alt> + <d> (cela équivaut à sélectionner la ligne et utiliser le menu). Pour sélectionner un bloc d'instructions rapidement, placez la souris au tout début ou à la fin du bloc et cliquez, cela a pour effet de tout sélectionner.

Si vous obtenez du son, vous pouvez passer au paragraphe suivant, sinon voici quelques pistes pour obtenir du son :

- Activation du son dans Pharo : vérifiez que le son est activé dans votre image Pharo. Pour cela, ouvrez le Settings Browser depuis le menu Tools. Tapez ensuite « sound » dans la barre et cliquez sur les boutons radio pour obtenir une configuration proche de celle présentée en figure 2.

- Le volume sonore de votre système est trop bas ou en mode muet.

- Pulseaudio est activé (sur pratiquement toutes les distributions actuelles). Par défaut l'archive Linux n'embarque pas de plugin pulseaudio, seule l'utilisation du plugin Alsa est possible. Nous allons donc désactiver le serveur sonore de manière temporaire. Il ne doit pas être relancé automatiquement lorsque nous l'arrêterons :

- Créer le fichier /home/[user]/.pulse/client.conf s'il n'existe pas ;

- Ajouter le paramètre autospawn=no;

- Supprimer les processus en cours avec la commande pulseaudio -k avec votre compte utilisateur. Pour le relancer dès que vous le souhaitez, lancez la commande pulseaudio -D.

Nous pouvons maintenant relancer Pharo.

Il peut également arriver que le processus sonore ne fonctionne plus. Vous pouvez utiliser les commandes suivantes pour le réinitialiser :

Une petite astuce avant d'aller plus loin concernant le rendu sonore : par défaut, de la réverbération est ajoutée au son joué. Dans certaines conditions, cela peut amener une certaine douceur dans le rendu, mais dans notre cas de découverte cela peut aussi fausser ce que nous entendons. Pour désactiver le rendu avec réverbération, lancer la commande :

Ou, si vous préférez la relancer, vous pouvez le faire avec la commande:

2. Les Bases de la synthèse FM par l'exemple

Maintenant que nous nous sommes assurés que le son était fonctionnel, nous allons découvrir comment celui-ci est généré. Prenons le code de la méthode qui définit l'instrument organ1 :

Étudions cette méthode. Tout d'abord, elle crée une nouvelle instance de la classe FMSound avec sound := self new. Elle définit ensuite un ensemble de points afin de créer une enveloppe de volume. Pour chaque point la première donnée exprime une durée en milliseconde, la seconde (après le @) un volume sous forme d'un réel compris entre 0 et 1 (1 étant égal à 100% du volume).

Nous remarquons qu'une enveloppe se caractérise d'après un ensemble de points et d'une boucle. La méthode associée est points:loopStart:loopEnd:. Une boucle peut aussi bien utiliser l'ensemble des points définis ou 1 seul.

Par exemple ici on ajoute au son une enveloppe avec une boucle allant des indices 2 à 4 (l'indice 1 correspondant à la première valeur du tableau). La séquence suivante est jouée pour des valeurs oscillant entre 0.8 et 1. Le volume du son semble vibrer :

Si nous avions voulu maintenir le volume à un certain niveau, nous aurions écrit l'enveloppe comme ceci :

Le son se termine avec la valeur 250@0.0 et une boucle maintenant le volume à 0 pendant toute sa durée.

Finalement, la méthode retourne le son avec comme paramètre la note exprimée en Hz (voir le tableau des fréquences en figure 3), la durée en seconde et un volume global de la note. Ce volume sera ensuite modulé grâce à l'enveloppe qui est définie.

3. Comment faire pour jouer notre propre son ?

Nous allons vous montrer comment nous allons créer notre propre son. Commençons par jouer un LA de la manière suivante:

Le son est joué à une fréquence de 440 Hz pendant 1 seconde avec un volume maximum.

La classe FMSound permet la génération de sons sinusoïdaux. Ça donne un son assez doux et régulier. La figure 4 montre à quoi ressemble la courbe.

Fig. 4 : Courbe sinusoïdale classique

Une chose à savoir est, qu'au lieu de définir une note par sa fréquence nous pouvons l'écrire dans sa notation anglaise. Le tableau de la figure 5 va nous indiquer les correspondances pour plus de facilité. Par exemple, le LA est représenté dans la notation anglaise par un « a ». Pour obtenir le LA de la quatrième octave nous demandons a4.

Le LA de tout à l'heure peut s'écrire maintenant sous cette forme :

Le SOL# par exemple s'écrit :

3. Jouer plusieurs sons en séquence

Jouer un son c'est bien, mais en jouer deux c'est mieux. Pour cela nous avons à notre disposition une classe nommée SequentialSound. Comme son nom l'indique, nous allons pouvoir jouer les sons de manière séquentielle :

Si nous écoutons les sons générés, nous pouvons percevoir un petit clap entre chaque transition de notes. Afin d'éviter cela, nous allons appliquer une enveloppe de volume sur chacune des notes. Ceci est fait comme suit :

La note jouée est à son maximum au début puis repasse progressivement à 0 au bout de 500ms. L'enveloppe étant définie sur une durée égale à la durée de la note, la transition se fait plus naturellement et sonne mieux à l'oreille.

Voyons ce que donne notre code précédent avec une enveloppe de volume :

La séquence est maintenant bien plus agréable à écouter !

4. Jouer plusieurs sons simultanément

Jouer des sons en séquence c'est bien, mais pas encore suffisant pour donner une âme à notre production. Pour cela nous allons utiliser la classe MixedSound. Elle va littéralement mixer plusieurs sons en même temps :

Modifions un peu les valeurs de l'attaque à l'aide de la méthode setPitch:duration:loudness: pour obtenir des notes différentes et nous familiariser avec les méthodes. Les enveloppes de volume modifient la courbe du son au cours du temps et peuvent être utilisées pour obtenir des effets particuliers.

Par exemple si nous voulions rajouter un effet d'écho à notre son, il faudrait modifier les points de l'enveloppe de volume par :

La déclaration des enveloppes devrait être modifiée par :

Dans notre exemple, nous avons également utilisé le message pan: qui va positionner le son en stéréo. Une valeur de 0 pour gauche et de 1 pour droite (une valeur de 0.5 place le son au milieu).

Nous allons réutiliser l'exemple plus haut et lui rajouter de la stéréo :

Dans ce nouvel exemple, nous avons introduit une nouvelle classe de son RestSound pour créer un silence. Elle ne possède qu'un seul message duration: exprimé en secondes et générant un son plus ou moins long.

La méthode SequentialSound possède toutefois une limitation. Regardons l'exemple suivant pour voir ce qu'il se passe :

Normalement nous devrions entendre quatre sons joués à la suite, or il n'y en a que trois. Visiblement nous ne pouvons pas réutiliser un son déjà déclaré. Cette méthode n'est pas adaptée pour ce que nous souhaitons faire. Pour cela il existe une autre classe qui va répondre à notre besoin: QueueSound.

Remplaçons la ligne seq := SequentialSound par seq := QueueSound et écoutons de nouveau notre exemple. Nous entendons bien nos quatre sons. Le tour est joué !

5. Les enveloppes

Nous avons introduit une première enveloppe qui agit sur le volume d'un son. Il y en a une autre qui change la note ou plutôt sa fréquence pendant qu'elle est jouée ; c'est ce qu'on appelle l'attaque de la note, le pitch en anglais.

De la même manière que pour le volume, nous allons définir un ensemble de points qui indiqueront le moment du changement de la fréquence du son. Plus la valeur est haute, plus la note sera haute. Si on indique un chiffre négatif, la note descendra en dessous de la note de départ. Nous définissons donc une enveloppe, mais cette fois-ci une enveloppe d'attaque en utilisant la classe PitchEnvelope :

La transition entre les différentes fréquences se fait en douceur et sans cassures. Nous allons rajouter à cela une enveloppe de volume pour produire un son plus intéressant :

Le volume est dans notre exemple très variable, l'ensemble des points a été défini manuellement. Imaginons maintenant que nous voulions le réduire progressivement jusqu'à 0. Nous aurions à définir un certain nombre de points afin de produire une courbe décroissante. C'est faisable, fastidieux et surtout la courbe ne produirait pas l'effet souhaité.

Au lieu de la définir point par point, nous allons utiliser une méthode appelée exponentialDecay: de la classe VolumeEnvelope pour le volume ou la classe PitchEnvelope pour le pitch. La courbe sera de type exponentielle partant du volume le plus élevé pour arriver en douceur à 0. La définition du volume devient alors ceci :

La valeur doit être impérativement plus grande que 0 et plus petite que 1. Pour connaître l'ensemble des points générés il suffit de faire un clic droit sur la ligne de code suivante et de sélectionner Print it dans le menu contextuel :

Nous obtenons le résultat suivant

Plus la valeur est grande, plus le nombre de valeurs sera important.

Nous pouvons visualiser à quoi ressemble notre enveloppe en ouvrant le morph EnvelopeEditorMorph comme ceci :

Sélectionnez l'ensemble de la ligne et faites un clic droit puis Do it. Une fenêtre apparaît comme celle présentée en figure 6. Comme le montre la figure 7, vous pouvez l'agrandir en la sélectionnant avec <shift> + clic droit puis en déplaçant l'ancre en bas à droite de la fenêtre.

Le morph expose les courbes de l'instrument et nous permet de les modifier en déplaçant les points le composant. Vous pouvez passer d'une courbe à l'autre soit en la sélectionnant directement dans la fenêtre, soit en la choisissant dans le menu editing en bas à gauche du morph.

En abscisse, nous avons le temps en millisecondes. L'ordonnée se modifie en fonction de la courbe choisie. Nous avons également trois délimitations représentées par les axes verticaux de couleur orange. Les deux plus à gauche sont utilisées pour la boucle lorsque la note est tenue, ce sont les paramètres loopStart:loopEnd:. La plus à droite, c'est lorsque la note est relâchée. Nous pouvons également les déplacer en fonction de nos besoins en utilisant les triangles orange au-dessus de la courbe des abscisses. À noter qu'il n'est pas possible d'avoir sur le morph une boucle d'une durée inférieure à 50ms, comme il n'est pas possible d'avoir une valeur de début de boucle différente de la valeur de fin. Ce qui paraît logique si nous souhaitons obtenir une boucle harmonieuse.

Pour rajouter un point sur une partie de la courbe, il suffit de cliquer sur les petits triangles verts pour faire apparaître le point correspondant. Ce point peut être ensuite déplacé pour être positionné à la valeur souhaitée.

Je vous invite à tester toutes ces possibilités et à écouter le résultat obtenu grâce au clavier de piano disponible.

Les enveloppes viennent compléter nos connaissances sur la génération du son. Nous savons donc jouer un son, plusieurs sons les uns après les autres ou encore plusieurs joués en même temps. Nous avons entre nos mains pratiquement tous les outils pour écrire notre première mélodie... que disons-nous, notre première super-production !

6. Jouer une mélodie

À quoi peut bien ressembler de la musique produite dans Pharo ? Évaluons la ligne de code suivante dans un workspace et écoutons :

La musique est constituée d'une séquence de notes. Nous savons maintenant comment écrire une telle séquence, mais pour une mélodie entière ce n'est pas adapté. Il est nécessaire de faire autrement.

Nous allons décrire l'ensemble des notes dans un tableau. Le format est le suivant :

La note peut être écrite sous sa forme littérale ou d'après sa fréquence en hertz. La durée s'exprime en millisecondes. Le volume, quant à lui, est une valeur entre 0 et 1000. Au-delà de 1000 le son peut être amené à saturer, mais cela peut se révéler utile dans certains cas pour donner un effet.

Voici un exemple de déclaration d'une séquence :

Nous allons écrire notre premier morceau avec un air qui devrait rappeler de bons souvenirs à tous ceux qui aiment le début de l'ère des jeux vidéos. Nous allons définir la mélodie d'introduction du jeu pacman.

7. Définissons un nouvel élément

Commençons par définir un nouvel instrument. Afin de ne pas compliquer notre exercice, nous allons utiliser la classe FMSound dans laquelle nous allons définir quelques nouvelles méthodes. Notez que pour être plus propres et modulaires, nous devrions définir nos propres paquets et classes.

Pour définir une méthode, nous allons utiliser un navigateur de classe. Pour cela :

- ouvrez le SystemBrowser depuis le menu Tools ;

- dans le panneau de gauche, faites un clic droit puis Find Class ;

- entrez dans la zone de saisie « FMSound » et sélectionnez-la.

Vous devez obtenir un navigateur comme celui de la figure 8.

Comme les méthodes que nous définissons sont des méthodes qui créent des instances de FMSound par opposition à des méthodes qui agissent sur des instances de la classe FMSound, nous allons les définir sur le côté classe de la classe FMSound. Pour cela :

- cliquez sur le bouton radio Class side ;

- à l'aide du menu de la troisième liste, en partant de la gauche (liste des protocoles de méthodes - il s'agit de simples classeurs de rangement), ajoutez un protocole (Add protocol) nommé par exemple « new instruments ».

- sélectionnez le nouveau protocole puis ajoutez la méthode fm1 suivante. Pour ajouter une méthode, tapez le corps de la méthode dans le panneau prévu à cet effet (en bas à gauche) puis utilisez l'entrée Accept du menu (clic droit) qui compile la méthode ou alors utilisez le raccourci<alt> + <s>.

Vous devez obtenir une situation similaire à celle présentée en figure 9.

Vérifiez que votre nouvel instrument fonctionne en exécutant FMSound fm1 play.

Nous allons définir un autre instrument en copiant celui-ci afin de vous permettre d'expérimenter.

Déclarons maintenant de la même manière la méthode pacman permettant de mixer l'ensemble des pistes qui vont être créées à l'aide des méthodes pacmanV10: et pacmanV20:.

Lorsque vous allez compiler la méthode, Pharo va vérifier que l'ensemble des méthodes appelées existent. Si elles n'existent pas, elles apparaissent en rouge dans le code. Une boîte de dialogue va vous demander de confirmer votre saisie. Il vous suffit de sélectionner le premier choix de la liste. Répétez cette opération autant de fois qu'il y aura de méthodes inconnues.

Les deux méthodes suivantes contiennent l'ensemble des notes à jouer avec le triplet note, durée et volume :

La méthode noteSequenceOn:from: va générer une séquence de notes (par exemple SequentialSound) à partir d'un tableau de notes pour un instrument donné. Elle va utiliser comme vu précédemment le triplet note, durée, volume.

Si votre mélodie utilise des notes à fréquence basse, le volume de celle-ci sera difficilement audible. Vous pouvez alors, pour y remédier, augmenter le volume des notes. Ici nous sommes passés à un volume de 500, contrairement à la précédente mélodie où nous étions restés à 150.

Voilà, il ne reste plus qu'à exécuter la mélodie: FMSound pacman play.

Si vous souhaitez modifier les mélodies, n'oubliez pas de décompiler à chaque fois comme vu précédemment.

8. Jouer un sample

La sonorisation d'une production ne passe pas essentiellement par de la synthèse sonore, parfois il est nécessaire de faire appel à des sons digitalisés reproduisant des bruitages, des voix ou des musiques entières. Nous allons vous montrer comment jouer un sample à partir d'un fichier ou directement depuis la mémoire.

Tout d'abord nous allons télécharger les sons pour notre exemple. Pour cela, exécutez dans une console la commande suivante ou alors téléchargez directement l'archive sur votre ordinateur :

Décompressez-la ensuite dans le répertoire de votre choix. Le sous-répertoire sounds contient l'ensemble des sons digitalisés de l'article dont nous aurons besoin.

Il vous faudra adapter les répertoires de dépôt en fonction de votre environnement. Essayons dans un premier temps de jouer un son à partir d'un fichier au format wav :

Le son est joué en tâche de fond sans bloquer le reste de notre environnement. Nous pouvons par exemple utiliser cette méthode pour sonoriser une action ponctuelle ou une alerte.

Si notre but était de concevoir un jeu, le chargement du son directement depuis le disque à des moments clés risquerait de ralentir les animations voire de le rendre injouable. Afin d'éviter ces petits désagréments, les sons seront chargés en mémoire et joués lorsque ce sera nécessaire pour gagner en temps de réponse.

Pharo met à notre disposition une banque de sons que nous pouvons alimenter suivant nos besoins. Pour rajouter un son à cette librairie, nous utiliserons le message addLibrarySoundNamed:samples:samplingRate:. Dans un workspace, copiez le code suivant et évaluez-le pour rajouter le sample dans la librairie :

Maintenant nous pouvons jouer le sample à la fréquence et à la durée souhaitée :

Nous entendons uniquement les premiers samples du fichier et à une fréquence très basse. Si nous augmentons samplingrate et duration nous pourrons entendre de plus en plus de samples jusqu'à ce que l'ensemble des données soit joué.

9. Un dernier petit effort

Nous allons clore cet article sur une dernière méthode permettant de jouer plusieurs sons digitalisés en séquence. Dans un premier temps nous allons charger en mémoire les différents samples qui seront utilisés.

Maintenant que tous nos sons sont chargés, nous allons les jouer en séquence grâce à la classe QueueSound vue précédemment. Ils sont joués les uns après les autres à la fréquence souhaitée.

Conclusion

Nous vous avons montré une petite partie des possibilités que Pharo offre pour la création et manipulation des sons. Nous espérons vous avoir donné envie d'expérimenter !