771 lines
39 KiB
Markdown
771 lines
39 KiB
Markdown
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
|
|
<link href="./markdown.css" rel="stylesheet"></link>
|
|
<style>
|
|
img:hover{
|
|
color: #424242;
|
|
-webkit-transition: all .3s ease-in;
|
|
-moz-transition: all .3s ease-in;
|
|
-ms-transition: all .3s ease-in;
|
|
-o-transition: all .3s ease-in;
|
|
transition: all .3s ease-in;
|
|
opacity: 1;
|
|
transform: scale(1.5);
|
|
-ms-transform: scale(1.5); /* IE 9 */
|
|
-webkit-transform: scale(1.5); /* Safari and Chrome */
|
|
}
|
|
</style>
|
|
|
|
|
|
# Pure Data
|
|
|
|
|
|
|
|
## Introduction
|
|
|
|
### Pure Data ?
|
|
|
|
*Pure Data est utilisé dans tous les champs de la création (musique, arts visuels, danse, théâtre, robotique, etc.) pour des performances visuelles et sonores ou la création d'installations interactives, participatives et génératives. Il possède des capacités particulières dans les domaines de la musique acoustique et de la musique audio-numérique : il sert à modéliser des instruments électroniques comme les synthétiseurs. Il permet la gestion d'échantillonneurs (samplers) et d'effets, la composition musicale, ou encore, la création de séquenceur MIDI, etc. Il peut également gérer des applications vidéo et 3D.*
|
|
|
|
*Avec Pure Data, il est possible également d'interfacer un programme avec le monde physique en utilisant des capteurs (caméras, détecteurs de présence, etc.) pour commander des robots, interagir avec des sites internet, ou encore effectuer une visualisation de données. En art appliqué, il est utilisé en design d'interaction, en architecture et pour créer des jeux.*
|
|
|
|
Source : [Manuel de PureData en français](https://fr.flossmanuals.net/puredata/introduction/)
|
|
|
|
### Obtenir PureData
|
|
|
|
[Télécharger Pure Data 0.49-0 pour Windows](./resources/pd-0.49-0.windows-installer.exe)
|
|
|
|
Les autres versions sont disponibles sur [le site web officiel](http://puredata.info/downloads/pure-data). La version à utiliser pour ce cours est PureData Vanilla, que l'on pourra compléter avec des plug-ins si besoin.
|
|
|
|
#### Versions
|
|
|
|
There are a few different versions of puredata available in the wild.
|
|
Below is a small list but I would *highly* advise to start with puredata vanilla.
|
|
The extended version is *very* dated now and I would not advise to use that one.
|
|
|
|
* puredata vanilla (the **main** version)
|
|
* puredata extended (up until a few years ago the go-to version for most people)
|
|
* Pd-L2Ork (same engine as vanilla but with different GUI)
|
|
|
|
#### libpd : pour intégrer PureData dans d'autres applications
|
|
|
|
PureData peut être intégré à d'autres application comme moteur audio. Cette technique est très utilisée par les développeurs d'applications et game designers.
|
|
Cela requière des compétences de programmations qui vont au-delà de cette courte formation, mais il est important de noter que PureData est utilisé, et utilisable en dehors du pur *sound design*.
|
|
|
|
Liens utiles :
|
|
|
|
* [libpd github](https://github.com/libpd)
|
|
* [libpd in unity3D](https://github.com/Magicolo/uPD)
|
|
* [camomille - VST creating with libpd](https://github.com/pierreguillot/Camomile)
|
|
|
|
## Interface
|
|
|
|
À l'ouverture, Pure Data n'affiche que la fenêtre principale, avec une barre de menu et un espace blanc en-dessous. Cette espace blanc sera la **console**, qui va afficher des infos utiles, des erreurs, ...
|
|
|
|
|
|
|
|
La fenêtre de programme audio, appelée fenêtre de **patch**, s'affiche lorsque l'on va dans le menu "Fichier" -> "Nouveau". C'est dans cette fenêtre que l'on va créer les boîtes, et les connections entre ces boîtes, pour créer graphiquement un programme audio.
|
|
|
|
|
|
|
|
### À faire :
|
|
|
|
* Créer un patch vide, ajouter une boîte Message (depuis le menu "Ajouter") et écrire à l'intérieur le texte : "hello world"
|
|
* Enregistrer le patch
|
|
* Fermer PureData, réouvrir le patch et vérifier que le message est toujours là.
|
|
|
|
---
|
|
|
|
|
|
## Chapitre 1 : Hello World
|
|
|
|
PureData propose cinq types de boîtes de base pour la programmation graphique - toutes disponibles depuis le menu "Ajouter".
|
|
Les deux types dont nous avons besoin pour cet exemple sont :
|
|
|
|
* Les boîtes **Objet**
|
|
* Les boîtes **Message**
|
|
|
|
Pour faire fonctionner ce "hello world", il faut connecter la sortie (*outlet* en anglais) de la boîte message "hello world" vers l'entrée (*inlet* en anglais) de la boîte objet "print".
|
|
|
|
|
|
|
|
Ce principe est valable pour toutes les boîtes : on relie la sortie d'une boîte à l'entrée d'une autre. S'il y a une incompatibilité de connection, PureData refusera de faire la connection - et un message d'erreur devrait s'afficher dans la console.
|
|
|
|
Les entrées des boîtes sont toujours en haut, les sorties sont en bas. En général, on écrit donc des patches Pure Data de haut en bas, avec les informations qui sont transmises des boîtes du haut vers les boîtes du bas.
|
|
|
|
Pour expliquer comment fonctionnent les objets, PureData fournit de l'aide en faisant un **clic droit**, puis en cliquant sur **Aide**.
|
|
La fenêtre d'aide qui va s'ouvrir est elle-même un patch PureData : il est donc possible de le tester (en cliquant sur les boutons, en modifiant les valeurs) et de copier les boîtes pour les mettres dans ses propres patches.
|
|
|
|
|
|
|
|
PureData a deux **modes** de fonctionnement :
|
|
|
|
* Le mode d'**édition** (pour éditer les boîtes et les connections)
|
|
* Le mode **normal**, ou mode de **jeu** (pour interagir avec les boîtes)
|
|
|
|
Pour passer d'un mode à l'autre, il faut utiliser le raccourci **Ctrl+E**.
|
|
Toutefois, il est possible de jouer avec une boîte alors qu'on est en mode d'édition, est maintenant la touche **Ctrl** appuyée (par exemple : **Ctrl+Clic** sur une boîte, un slider, ...).
|
|
|
|
### À faire
|
|
|
|
* Dupliquer le patch hello world
|
|
* Créer une deuxième boîte de message, avec un texte différent
|
|
* Créer un second objet "print"
|
|
* Passer du mode **édition** au mode **normal**, et cliquer sur les messages pour afficher du texte dans la console.
|
|
|
|
### Challenge
|
|
|
|
* Changer le préfixe "print" qui s'affiche dans la console, pour différentes boîtes "print"
|
|
|
|
### Ressources :
|
|
|
|
* **patches**
|
|
* [hello world patch](./resources/00_hello_world.pd)
|
|
|
|
---
|
|
|
|
\newpage
|
|
|
|
|
|
|
|
## Chapitre 2 : calculatrice simple
|
|
|
|
Pour faire des calculs arithmétiques (additions, soustractions, ... et des fonctions ) PureData contient des boîtes d'objets pour les opérations +, -, etc... Pour donner des valeurs à ces boîtes-objet, on peut utiliser des boîtes de message, mais aussi des boîtes de **nombres** (depuis le menu Ajouter).
|
|
|
|
* L'intérêt est que l'on peut cliquer sur ces nombres (en mode normal, pas en mode d'édition) pour modifier facilement le nombre l'intérieur.
|
|
* Le problème des nombres est qu'il ne sont pas sauvegardés lorsque l'on ferme le patch (alors que les messages, eux, sont bien sauvegardés)
|
|
|
|
|
|
|
|
|
|
|
|
### À faire :
|
|
|
|
* Re-créer le patch ci-dessus dans PureData, et l'essayer
|
|
* Pourquoi est-ce que ça ne fonctionne pas toujours ?
|
|
|
|
### Ressources :
|
|
|
|
* **patches**
|
|
* [calculator patch](./resources/01_calculators.pd)
|
|
* **Page-mémo**
|
|
* [Aide-mémoire pour les objets PureData [à imprimer]](https://puredata.info/docs/tutorials/pd-refcard)
|
|
* **online information**
|
|
* [hot and cold inlets (EN)](https://puredata.info/docs/manuals/pd/x2.htm#s3.3)
|
|
* [Entrées chaudes/froides, flux de données (FR)](https://fr.flossmanuals.net/puredata/le-flot-de-donnees/)
|
|
* **Référence PureData**
|
|
* [Opérations arithmétiques dans PureData Vanilla et Extended (EN)](http://booki.flossmanuals.net/pure-data/list-of-objects/math)
|
|
|
|
---
|
|
|
|
\newpage
|
|
|
|
|
|
|
|
## Chapitre 3: Bangs et Triggers
|
|
|
|
Dans Pure Data, les entrées et sorties (*inlets* et *outlets*) des boîtes n'ont pas toutes exactement le même comportement. Concernant les entrées, il existe des **entrées chaudes et froides** (*hot/cold*). Pour chaque boîte, on a :
|
|
|
|
* à gauche 1 seule entrée chaude
|
|
* toutes les entrées restantes à droite sont des entrées froides
|
|
|
|
Pour gérer ceci, il est très utile d'utiliser les deux objets suivants :
|
|
|
|
* bangs
|
|
* triggers
|
|
|
|
Le "Bang" (disponible de puis le menu "Ajouter") est une fonctionnalité essentielle de Pure Data. Un Bang permet à la fois de déclencher (*trigger* en anglais) des boîtes reliées à sa sortie, et de donner un retour visuel sur les actions des boîtes reliées à son entrée.
|
|
Les "Triggers" prennent une donnée (nombre, bang, list, message, ...) en entrée, et envoient les sorties **les unes après les autres, de droite à gauche**.
|
|
En ajoutant des objets trigger dans nos patches, on peut définir précisément **l'ordre des opérations**.
|
|
|
|
|
|
|
|
### À faire
|
|
|
|
* Créer ce patch et l'essayer
|
|
* Modifier les connexions pour bien voir les sorties dans l'ordre de droite à gauche
|
|
|
|
### Ressources
|
|
|
|
* **patches**
|
|
* [triggers and bangs patch](./resources/02_bangs_and_triggers.pd)
|
|
|
|
---
|
|
|
|
\newpage
|
|
|
|
|
|
|
|
## Chapitre 4: Timers and toggles
|
|
|
|
En tant qu'environnement temps-réel pour la musique, Pure Data offre l'objet **metro** (métronome) pour créer des évènements réguliers dans le temps.
|
|
Pour allumer le métronome, ou l'éteindre, le plus simple est de connecter une boîte Interrupteur à son entrée.
|
|
|
|
On se rapproche de la création d'un séquenceur / boîte à rythme !
|
|
|
|
|
|
|
|
Cet objet metro peut prendre un temps sur **l'entrée froide**, ou bien (ne pas utiliser les deux méthodes) en lui envoyant un argument (via un message "tempo 500 msec" par exemple);
|
|
Ci-dessous, voici un grille de quelques exemple de conversion de *BPM* (tempo) en longueur de notes (noire/*quarter*, croche/*8ths*, etc.)
|
|
|
|
|
|
|
|
### À faire
|
|
|
|
* Re-créer ce patch et l'essayer
|
|
* Écrire un compteur qui s'incrémente (augmente sa valeur de 1) à chaque bang du métronome
|
|
|
|
### Challenge
|
|
* Écrire un patch de conversion automatique de tempo (en BPM, Beats Per Minutes) pour créer un métronome de noires (*quater-note*)
|
|
* Écrire un patch de conversion de tempo vers un métronome *suffle* (typique du jazz). Indice : on pourra utiliser l'objet **select**
|
|
|
|
### Ressources
|
|
|
|
* **patches**
|
|
* [timers and toggles patch](./resources/03_timers_and_toggles.pd)
|
|
|
|
---
|
|
|
|
\newpage
|
|
|
|
## Chapitre 5 : Premier synthé !
|
|
|
|
### Configuration de l'interface audio
|
|
|
|
Depuis le menu **media**, sélectionner les Paramètres Audio. Les paramètres vont dépendre de la carte son de l'ordinateur, et du système d'exploitation.
|
|
Une bonne valeur est en général 512 ou 1024 échantillons (*samples*).
|
|
|
|
Lorsqu'un patch audio sera prêt, il ne faudra pas oublier de cocher la case DSP (*digital signal processing*) pour lancer le moteur de calcul audio de Pure Data.
|
|
|
|
Attention : PureData permet de créer n'importe quel son, et il n'y a donc pas de limitation du volume en sortie. Il faut d'abord ne jamais mettre le casque trop fort, et on mettra systématiquement un limiteur en sortie (vu juste après).
|
|
|
|
<p style="text-align:center;color:red;">Attention : Ne jamais mettre les écouteurs trop fort, et toujours mettre un limiteur (objet "clip") à 0.5 avant le bloc de sortie audio. Vos tympans sont très précieux, prenez-en soin !</p>
|
|
|
|
|
|
|
|
### Resources:
|
|
|
|
* **online information**
|
|
* [configuring puredata](http://write.flossmanuals.net/pure-data/configuring/)
|
|
|
|
---
|
|
|
|
### Connexions de données, connexions de signaux
|
|
|
|
Jusqu'à maintenant, nous n'avons utilisé que des connexions de **données** entre les boîtes. Pour créer du son, nous allons maintenant créer des connexions de **signaux audio** entre des blocs de traitement du signal. Ces blocs sont facilement reconnaissables car ils commencent par un **tilde : \~**.
|
|
|
|
|
|
|
|
Des objets de contrôle très répandus en audio sont les **sliders** (voir ci-dessous). Il peuvent être configurés en faisant un **clic droit** sur eux.
|
|
|
|
Pour utiliser des sliders comme contrôle de volume audio, il est très important de modifier leur intervalle de valeurs (leur *range*). En effet, il renvoient par défaut des valeurs entre 0 et 127, alors que les signaux audio dans Pure Data sont des flux de **nombres à virgule entre -1,0 et +1,0**.
|
|
|
|
Pour ne pas avoir de saturation, et pour ne pas avoir de volumes audio trop importants (attention à vos oreilles !) on va régler le slider principal de volume sur la plage de valeurs de 0,0 à 0,1.
|
|
Cela correspond à gains de moins l'infini à -20 dB (décibels).
|
|
|
|
Le bloc **dac\~** est un *Digital to Analog Converter*, Convertisseur Numérique-Analogique (CNA). Il indique à l'ordinateur de convertir les échantillons (il y en a en général 44100 ou 48000 par seconde) en un signal audio bien continu qui va vers le casque.
|
|
|
|
|
|
|
|
### À faire
|
|
|
|
* Re-créer les deux patches ci-dessus, et les tester
|
|
* Chercher la différence entre les connexions de données, et les connexions de signal audio
|
|
|
|
### Ressources
|
|
|
|
* **patches**
|
|
* [a 440Hz synth patch, with limiter](./resources/04_a_simple_synth-limiter.pd)
|
|
* [a simple synth patch (! without limiter)](./resources/04_a_simple_synth.pd)
|
|
* **online information**
|
|
* [waveshaping](http://www.pd-tutorial.com/english/ch03s05.html)
|
|
|
|
---
|
|
|
|
\newpage
|
|
|
|
|
|
|
|
## Chapitre 6 : Un peu de théorie musicale... et MIDI
|
|
|
|
Le MIDI permet de représenter des notes (Do, Ré, Mi, .. ou bien *C, D, E*, ...) avec des nombres sur 7 bits, entre 0 et 127. C'est une vieille norme - datant des années 1980 - qui est toujours très utilisée aujourd'hui.
|
|
|
|
|
|
|
|
En musique occidentale, le **système tonal** propose une manière de décomposer de mélodies en **gammes (majeures, mineures, ...)** basées sur 1 note principale : **la tonique**.
|
|
|
|
Même si maîtriser toutes les subtilités des gammes et des modes requière une très bonne connaissance du solfège, on va quand même pouvoir utiliser ces gammes de manière simple pour créer des séquences de notes dans Pure Data.
|
|
|
|
Les gammes sont composés de **degrés**, qui sont un ensemble de notes qui constituent la gamme - en plus de la note tonique.
|
|
|
|
Par exemple, une des gammes les plus utilisées est la **gamme majeure**. À partir d'une note tonique définie, la gamme majeure est composée des 6 **degrés** suivants :
|
|
|
|
|
|
| Degré | Nom | Écart degré précédent | Écart total en échelle MIDI |
|
|
|---|---|---|---|
|
|
| 1st | Tonique | - | 0 |
|
|
| 2nd | Sus-tonique | +1 | +2 |
|
|
| 3rd | Médiante | +1 | +4 |
|
|
| 4th | Sous-dominante | +1/2 | +5 |
|
|
| 5th | Dominante | +1 | +7 |
|
|
| 6th | Sus-dominante | +1 | +9 |
|
|
| 7th | Sensible | +1 | +11 |
|
|
| 8th | Tonique (à l'octave) | +1/2 | +12 |
|
|
|
|
Ci-dessous, voici un synthé qui peut jouer la gamme de Do (C) majeur, à partir du Do 4 (C4), qui se situe plutôt dans les fréquences médium-aigües.
|
|
|
|
|
|
|
|
### À faire
|
|
* Re-créer et tester ce patch (en ajoutant bien un limiteur "clip" avant la sortie)
|
|
* Modifier la gamme, pour jouer une gamme de Mi mineur (pour la gamme mineure : voir ressources ci-dessous)
|
|
|
|
### Ressources
|
|
|
|
* **patches**
|
|
* [a musical synth](./resources/05_a_musical_synth.pd)
|
|
* **online information**
|
|
* [what is midi?](https://en.wikipedia.org/wiki/MIDI)
|
|
* [musical scales](https://en.wikipedia.org/wiki/Major_scale)
|
|
* [Gamme mineure](https://fr.wikipedia.org/wiki/Liste_des_gammes_et_modes#Gamme_mineure)
|
|
|
|
---
|
|
|
|
\newpage
|
|
|
|
|
|
|
|
## Chapitre 7 : contrôle du synthé avec un clavier d'ordinateur
|
|
|
|
Pour récupérer le numéro de la touche du clavier qui vient d'être appuyée, Pure Data fourni l'objet **key**.
|
|
On peut alors router la sortie de la boîte "key" vers des notes de synthétiseur, à l'aide de l'objet **route**.
|
|
|
|
|
|
|
|
Le routage des touches du clavier doit permettre de se rapprocher de l'agencement des touches d'un piano. Un exemple de routage (celui utilisé dans Ableton Live par exemple) pour 1 octave est présenté ci-dessous.
|
|
|
|
|
|
|
|
### À faire
|
|
* Re-créer ce patch, et le configurer correctement pour qu'il fonctionne bien avec votre clavier. La table des caractères ASCII est disponible ci-dessous dans les ressources.
|
|
|
|
### Challenge
|
|
* Ré-écrire l'objet "route" avec des blocs **==** et **sel** (avant de regarder la solution)
|
|
|
|
### Ressources
|
|
|
|
* **patches**
|
|
* [a musical synth](./resources/05_controlling_the_musical_synth.pd)
|
|
* **online information**
|
|
* [Code ASCII (lettre latines + caractères spéciaux)](https://fr.wikipedia.org/wiki/American_Standard_Code_for_Information_Interchange#/media/Fichier:ASCII-Table-wide.svg)
|
|
* [controlling the synth](http://write.flossmanuals.net/pure-data/controlling-the-synth/)
|
|
* **Blocs "==" et "sel"**
|
|
* [patch de solution du challenge](06-keyboard-equal-sel.pd)
|
|
|
|
|
|
A more common way to control music programs is by using MIDI devices.
|
|
You can setup midi from the **media** menu and selecting **midi settings**.
|
|
Puredata provides a simple patch to test and see the midi messages coming into the computer.
|
|
It can be shown by clicking on the **media** menu and selecting **test audio and midi**.
|
|
|
|
|
|
|
|
|
|
---
|
|
|
|
\newpage
|
|
|
|
|
|
|
|
## Chapter 8: Controlling with a gamepad
|
|
|
|
The **hid** object gives us access to gamepads and joysticks.
|
|
Depending on the OS the object needs to be installed via the help menu **find
|
|
externals** option.
|
|
|
|
|
|
|
|
### TODO:
|
|
|
|
* create this patch yourself and try it out
|
|
* try to add more controls to the synth
|
|
|
|
### Resources:
|
|
|
|
* **patches**
|
|
* [gamepad synth patch](./resources/07_gamepad_with_the_musical_synth.pd)
|
|
* [gamepad synth with filter patch](./resources/08_gamepad_and_filter.pd)
|
|
|
|
---
|
|
|
|
\newpage
|
|
|
|
|
|
|
|
## Chapitre 9 : Filtres
|
|
|
|
Dans les domaines d'étude des signaux, on commence en général par s'intéresser à leur forme d'onde, dans ce qu'on appelle le **domaine temporel** (dans lequel les choses évoluent au cours du temps). Par exemple :
|
|
|
|
* l'onde osc\~ sinusoïdale fait un sorte de vague
|
|
* l'onde phasor\~ est en dents de scie
|
|
* l'onde carrée ressemble à des créneaux de châteaux-forts
|
|
|
|
En pratique, on s'intéresse aussi beaucoup à la **représentation fréquentielle** des signaux. Dans le **domaine fréquentiel**, on ne voit plus le signal évoluer dans le temps, mais on le décompose en un très grand nombre de petits signaux sinusoïdaux de fréquences différentes. Les fréquences faibles (entre 20Hz et quelques 100Hz) sont les fréquences que notre cerveau perçoit comme graves (ou basses), et les fréquences hautes (entre 2kHz et 20kHz) sont les fréquences que notre cerveau perçoit comme aigües.
|
|
|
|
Cette représentation se fait par la **Transformation de Fourier**, dont les bases mathématiques dépassent largement le cadre de cette formation. Connaître son nom est cependant très utile pour comprendre certaines documentations.
|
|
|
|
On dispose aujourd'hui de nombreux outils dans Pure Data pour manipuler les signaux dans le **domaine fréquentiel**, et non **pas dans le domaine temporel**. Ces outils sont appelés des **filtres**, et on a par exemple ces 3 filtres de base :
|
|
|
|
* la boîte **lop\~**: *LOw-Pass filter*, qui laisse passer les fréquences basses en-dessous d'une fréquence de coupure, et qui coupe les fréquences plus hautes que la fréquence de coupure
|
|
* la boîte **hip\~**: *HIgh-Pass filter*, qui laisse passer les fréquences hautes au-dessus de la fréquence de coupure, et qui coupe les fréquences plus basses que la fréquence de coupure
|
|
* la boîte **bp\~**: *Band-Pass filter*, qui laisse passer une bande de fréquences dans les fréquences médium, et coupe à la fois les fréquences hautes et les fréquences basses
|
|
|
|
|
|
|
|
### À faire
|
|
* Re-créer (ou télécharger...) le patch ci-dessus et le tester en changeant les signaux en entrée du filtre. Essayer de bien comprendre les visualisation des signaux.
|
|
* Remplacer le filtre passe-bas par un filtre passe-haut
|
|
|
|
### Challenge
|
|
* Remplacer le filtre passe-bas par l'objet **bob\~**, qui est une modélisation de filtre analogique "Bob Moog". C'est un classique, qui sonne mieux ! Mais il demande plus de temps de processeur à l'ordinateur...
|
|
|
|
### Ressources
|
|
* [Patch d'exemple sur les filtres](./resources/09-filters.pd)
|
|
* [Patch d'exemple avec filtres, oscillateurs légèrements désaccordés et enveloppe ADSR](./resources/09-filters-detuned-enveloppes.pd)
|
|
* [Filtres dans Pure Data (EN)](http://write.flossmanuals.net/pure-data/filters/)
|
|
|
|
|
|
---
|
|
|
|
|
|
## Chapitre 10 : Drum machine
|
|
|
|
On peut charger et jouer des fichiers sons à l'aide de l'objet **readsf\~**. Pour cela il faut déclencher l'envoi d'un **message "open Chemin/Vers/Mon_Fichier.wav"** dans l'objet readsf\~. Le chargement du fichier est alors complètement géré par Pure Data.
|
|
|
|
Pour fabriquer une boîte à rythme, il faut rajouter à l'objet readsf\~ une fonctionnalité de **séquenceur**, qui déclenche des notes au bon moment. Pour fabriquer un séquenceur facilement, on va combiner un métronome **metro** avec un compteur qui boucle - voir l'objet **mod** pour l'opération de modulo - puis un objet **select** qui redirige chaque valeur de décompte.
|
|
|
|
Ci-dessous, vous trouverez des patches d'une boîte à rythme très simple, et d'une seconde boîte à rythme configurable.
|
|
|
|
|
|
|
|
### À faire
|
|
|
|
* Re-créer ces deux patches, et les essayer
|
|
|
|
### Challenge
|
|
* Rendre cette boîte à rythme polyphonique ! (Pour jouer plusieurs sons en même temps)
|
|
|
|
### Ressources
|
|
|
|
* **patches**
|
|
* [simple drum machine](./resources/08_gamepad_and_filter.pd)
|
|
* [advanced drum machine](./resources/09_advanced_drum_machine.pd)
|
|
* **samples**
|
|
* [drum samples zip file](./resources/808_drum_kit.zip)
|
|
|
|
---
|
|
|
|
\newpage
|
|
|
|
|
|
## Chapitre 11 : Sub-patches et Abstractions
|
|
|
|
Pour expliquer les sub-patches et les abstractions, on va partir d'un cas concret. Lorsque l'on veut jouer avec le clavier d'ordinateur, on doit toujours commencer un patch par les mêmes boîtes ci-dessous :
|
|
|
|
|
|
|
|
Or, on va vouloir deux choses en pratique :
|
|
|
|
* que ces boîtes prennent moins de place à l'écran (qu'on puisse toutes les ranger dans une super-boîte, ce qu'on appelle un **subpatch**)
|
|
* que l'on puisse réutiliser proprement - et de manière robuste - cette fonction "Key To Frequency" dans n'importe quel patch (on utilisera alors plutôt les **abstractions**)
|
|
|
|
### Sub-patch
|
|
|
|
Un sub-patch est un simple conteneur (une super-boîte) dans laquelle on va aller ranger et cacher d'autres boîtes. Pour créer un sub-patch vide, il faut créer une boîte "**pd NomDeMonSubpatch**".
|
|
|
|
|
|
|
|
Ensuite, on va déplacer toutes les boîtes qui doivent être rangées dans ce sub-patch. Le problème est alors que pour modifier l'octave, on doit ouvrir et modifier le sub-patch. Pour résoudre ce problème, on va créer un **inlet**, c'est-à-dire une entrée de données pour le sub-patch.
|
|
|
|
|
|
|
|
### Abstraction
|
|
|
|
Les sub-patches permettent de donner de l'ordre et de la structure à de gros patches (comme dans le chapitre qui suit : Pure Data Orchestra). Ils sont très efficaces et très utiles dans un premier temps.
|
|
|
|
Le problème principal survient lorsqu'on les utilise dans plusieurs patches différents. Pour notre exemple, il faut copier-coller ce sub-patch dans chaque nouveau patch qui doit utiliser le clavier d'ordinateur comme clavier MIDI. C'est un problème car si on fait une mise à jour du sub-patch à un endroit, par exemple si l'on a détecté puis corrigé un bug, **les copies du sub-patch ne seront pas modifiées car elles sont indépendantes**.
|
|
|
|
Pour résoudre ce problème, on va créer un patch Pure Data indépendant pour notre ensemble de boîtes "Keyboard To Frequency". Pour être accessible pour tous les autres patches, le plus simple est de le mettre dans le dossier des "externals", qui contient en fait toutes les bibliothèques externes. Ce dossier dépend du système d'exploitation, mais est en général situé dans "Mes Documents" -> "Pd" -> "externals".
|
|
|
|
Dès qu'un patch est stocké dans ce dossier, il devient automatiquement une abstraction ! Pour l'utiliser dans un autre patch, il suffit alors de créer une boîte-objet et d'y inscrire le nom correspondant (voir exemple ci-dessous).
|
|
|
|
|
|
|
|
### À faire
|
|
* Question : depuis le patch principal, comment fait-on pour différencier un subpatch d'une abstraction ?
|
|
* Créer des sub-patches et des abstractions très simples - par exemple : qui font des additions - pour bien comprendre la différence entre abstraction et sub-patch
|
|
* Créer votre propre abstraction KeyboardToMidiNote ou KeyboardToFrequency
|
|
|
|
|
|
### Remarque importante
|
|
Lorsque l'on insère une abstraction dans un patch, on crée ce que l'on appelle une **instance** de cette abstraction. En programmation orientée-objet classique, on parle d'**instance de classe**, avec les classes (les objets) qui sont définies par du code informatique (C#, C++, Python, etc.) plutôt que par des liaisons entre des boîtes comme dans Pure Data.
|
|
|
|
### Ressources
|
|
* Patches
|
|
* [Patch avec sub-patch inclus](./resources/11-subpatch-keyboard.pd)
|
|
* [Patch qui utilise une abstraction](./resources/11-abstraction-base.pd)
|
|
* [Patch-abstraction, à placer dans le dossier "externals"](./resources/KeyboardToFrequency.pd)
|
|
* En ligne
|
|
* [Sub-patches (EN)](http://write.flossmanuals.net/pure-data/subpatches/)
|
|
* [Abstractions (EN)](http://write.flossmanuals.net/pure-data/abstractions/)
|
|
|
|
---
|
|
\newpage
|
|
|
|
|
|
|
|
## Chapitre 12 : Pure Data Orchestra
|
|
|
|
La boîte à rythme de l'exemple précédent peut être utilisée pour créer un patch qui joue à la fois de la musique séquencée (aléatoire), et des boucles des synthés précédents.
|
|
|
|
Pour gérer les transitions entre notes, un nouvel objet appelé **vline\~** est introduit dans le patch ci-dessous. Il permet d'obtenir des courbes de transition douces pour le volume des notes, ou d'autres paramètres comme les fréquence de coupure des filtres. En synthèse audio, ces courbes de transition sont appelées des **enveloppes**. Ces enveloppes comportent le plus souvent 4 paramètres : *Attack, Decay, Sustain, Release* ; on parle alors d'**enveloppes ADSR**.
|
|
|
|
|
|
|
|
### À faire
|
|
|
|
* Un patch personnalisé ! En vous inspirant des exemples précédents... Et surtout de vos idées
|
|
* Essayer d'utiliser des abstractions (plutôt que des subpatches) pour éviter d'avoir 1 seul énorme patch
|
|
|
|
### Ressources
|
|
|
|
* **patches**
|
|
* [music by numbers](./resources/10_putting_it_all_together.pd)
|
|
* **online information**
|
|
* [envelopes](http://write.flossmanuals.net/pure-data/envelope-generator/)
|
|
|
|
---
|
|
|
|
\newpage
|
|
|
|
|
|
## Chapitre 13 : effets audio avancés - délai
|
|
|
|
Parmi les effets audio, les plus basiques (présents dans l'exemple précédent Pure Data Orchestra) sont les filtres. Ils filtrent - c'est-à-dire suppriment - certains fréquences du signal, comme les fréquences hautes, les fréquences basses, les médiums, etc.
|
|
|
|
Dans une autre catégorie, beaucoup d'effets sont basés sur le principe des **lignes de délai**. Une ligne de délai peut être vue comme un morceau d'une bande magnétique sur lequel on va aller écrire et lire du son (pour ceux à qui cet exemple parle...). Concrètement, dans l'ordinateur, la ligne de délai est un morceau de mémoire RAM dans lequel on va aller écrire et lire.
|
|
|
|
Par rapport aux simples connexions de signaux de données, sur lesquelles le son numérique ne reste que sur une durée infiniment courte, l'intérêt d'une ligne de délai est que le son est encore accessible pendant un certain temps. On peut donc aller écrire (avec **delwrite\~**) le son qu'on souhaite, puis lire (avec **delread\~**) le son avec un retard que l'on peut choisir.
|
|
|
|
|
|
|
|
### À faire
|
|
* Créer un délai simple pour un de vos synthétiseurs
|
|
|
|
### Challenge
|
|
* Transformer ce délai en un effet "écho". Pour cela, il faut ajouter un *feedback*, c'est-à-dire que la ligne de délai doit additionner à elle-même le signal d'entrée avec délai. On obtient ainsi un "écho" qui dure assez longtemps (plusieurs réflections du son, de plus en plus faibles)
|
|
* Rajouter un filtre sur les réflections de l'écho, pour faire un *space echo*
|
|
|
|
### Ressources
|
|
* En ligne
|
|
* [Delay sur wikipedia (avec extraits audio)](https://fr.wikipedia.org/wiki/Delay_(effet))
|
|
* Patches
|
|
* [Patch du délai simple](./resources/11_delay.pd)
|
|
* [Patch du délai écho](./resources/11_delay-feedback.pd)
|
|
|
|
|
|
---
|
|
|
|
|
|
## Chapitre 14 : effets audio avancés - flanger
|
|
|
|
Un autre effet est le flanger. Le principe est assez proche du délai : on va ajouter au signal sonore une copie de lui-même, mais avec cette fois un retard très court. L'effet obtenu est assez facilement reconnaissable (essayer le patch ci-dessous).
|
|
|
|
|
|
|
|
### À faire
|
|
* Re-créer et tester le patch ci-dessus
|
|
* Créer un flanger simple pour un de vos synthétiseurs, en utilisant **delread4\~** plutôt que delread\~.
|
|
|
|
### Challenge
|
|
* Introduire une légère modulation (variation au cours du temps) sur le délai du flanger
|
|
|
|
### Ressources
|
|
* En ligne
|
|
* [Flanger sur wikipedia (avec extraits audio)](https://fr.wikipedia.org/wiki/Flanger)
|
|
* Patch
|
|
* [Patch du flanger](./resources/12_flanger.pd)
|
|
|
|
|
|
---
|
|
|
|
\newpage
|
|
|
|
## Chapitre 15 : package manager, external libraries
|
|
|
|
Jusqu'à présent, tous vos patches Pure Data ont été créés à partir des blocs de base fournis avec Pure Data "Vanilla". Ces blocs de traitement de données et de signaux sont très efficaces et il est très important que vous sachiez les utiliser pour créer vos propres expériences sonores.
|
|
|
|
Cependant, de nombreuses personnes ont construit des blocs intéressants et complexes, et les ont mis à disposition de la communauté via le "package manager" intégré à Pure Data Vanilla. Il est accessible via le menu **help** -> **find externals** (ou **Aide** -> **Installer des objets supplémentaires**). Les plus utiles - et les plus utilisés - sont entre autres :
|
|
|
|
* mrpeach (for everything network and OSC related)
|
|
* cyclone (nombreux petits outils très utiles)
|
|
* comport (interfaçage Arduino ou autres périphériques sur port série)
|
|
* hid (*Human Interface Devices* : souris, joysticks, ...)
|
|
* list-abs (abstractions pour la manipulation de listes)
|
|
|
|
|
|
|
|
Vous pouvez voir tous les *externals* installés via le menu **Aide** -> **Navigateur d'aide** (**help**-> **browser**). La plupart des bibliothèques proposent une aide claire avec des exemples d'utilisation.
|
|
|
|
|
|
|
|
Pour aller rapidement plus loin dans la synthèse sonore, **Automatonism** fournit un très bon ensemble de blocs de synthétiseurs et de filtres. Avec cette bibliothèque, il devient possible de construire rapidement des **synthétiseurs modulaires** pour obtenir des textures sonores très difficiles à obtenir avec les synthés classiques du commerce.
|
|
|
|
Toutefois, pour utiliser correctement Automatonism (ou n'importe quelle autre bibliothèque de ce genre), il reste indispensable de maîtriser la programmation Pure Data.
|
|
|
|
|
|
|
|
### Ressources
|
|
* [Automatonism](https://www.automatonism.com/the-software)
|
|
|
|
---
|
|
|
|
|
|
|
|
## Chapitre 16 : OSC et musique contrôlée par la météo
|
|
|
|
L'OSC (*Open Sound Control*) est un protocole fréquemment utilisé en musique numérique pour la communication de données de contrôle : notes à jouer, tempo, etc. Les **messages OSC** peuvent être transmis via des paquets UDP/IP (ou plus rarement TCP/IP) entre des machines connectées sur un même réseau.
|
|
|
|
On ne va pas trop s'étendre sur ce standard, mais il faut quand même connaître la structure de base des messages. Ils sont constitués de deux éléments principaux :
|
|
|
|
* une **adresse au format URL**, par exemple "/main_oscillator/adsr"
|
|
* une **liste d'arguments**, par exemple "30.0 51.7 400 120" (2 nombres à virgule puis 2 nombres entiers)
|
|
|
|
Vous n'avez pas besoin d'aller trop loin dans la connaissance du standard. En effet, nous vons avons préparé un patch qui envoie des requêtes puis reçoit les infos depuis un serveur OSC branché directement dans la salle de formation, sur un Raspberry Pi. Ce serveur récupère des infos en ligne, comme les coordonnées géographiques et la météo de certaines villes, le cours du bitcoin, la charge CPU et RAM du serveur, ... Et les met à disposition via OSC. L'adresse IP vous sera donnée au moment où le serveur sera branché et correctement démarré dans la salle de formation.
|
|
|
|
|
|
|
|
Attention : lorsque le *receiver* OSC (qui réceptionne les données du RPi serveur) est présent dans un patch, il se connecte automatiquement sur le port pour lequel il est configuré - ici, cela doit être le port 8081.
|
|
Or, pour une machine donnée, 1 seul programme peut se mettre en écoute d'un port ; il ne faut donc avoir qu'un seul patch Pure Data ouvert à la fois pour que la boîte "mrpeach/receiver" fonctionne à coup sûr.
|
|
|
|
|
|
|
|
### Ressources
|
|
* En ligne
|
|
* [OSC et bibliothèque MrPeach](https://fr.flossmanuals.net/puredata/osc/)
|
|
* Patch
|
|
* [Patch de connexion, requêtes et réception OSC](./resources/16_exemple-meteo.pd)
|
|
|
|
|
|
- - -
|
|
|
|
\newpage
|
|
|
|
|
|
## Chapitre 17 : Automatonism
|
|
|
|
Le projet Automatonism se décrit comme "un synthétiseur modulaire qui fonctionne dans l'environnement Pure Data". Cela signifie qu'il utilise le blocs de traitement de signaux et de données de Pure Data, mais qu'il fonctionne aussi en partie avec ses propres fonctionnalités. Par exemple pour ajouter des boîtes, Automatonism a ses propres menus.
|
|
|
|
Tout d'abord, récupérer Automatonism depuis [le site officiel](https://www.automatonism.com/the-software). Il consiste en une suite de patches et d'outils graphiques pour créer efficacement des séquenceurs, des sons complexes, des filtres, des mixers, ... Le dossier télécharger contient 1 fichier main.pd, et 3 sous-dossiers :
|
|
|
|
|
|
|
|
### À faire :
|
|
* Déplacer le dossier dans votre répertoire de documents Pure Data
|
|
* Dupliquer le dossier complet, puis ouvrir le fichier main.pd du nouveau dossier
|
|
|
|
Pour jouer des notes avec Automatonism, il faut comprendre que ce logiciel se base sur des **signaux** pour les déclenchements de notes. En effet, l'idée de base des **synthétiseurs modulaires** est que l'on doit pouvoir brancher directement n'importe quelle sortie de module audio dans l'entrée d'un autre module audio.
|
|
|
|
Concrètement, pour déclencher une seule note (comme un coup de grosse caisse), il faut alors créer des **enveloppes** très courtes. Cela va être fait par l'objet **vline\~** que l'on a déjà vu ensemble, pour créer une enveloppe-impulsion de durée 1 milliseconde.
|
|
|
|
|
|
|
|
|
|
## À faire
|
|
* Lire le *MANUAL* Automatonism, en particulier le chapitre *signal flow*
|
|
|
|
- - -
|
|
|
|
\newpage
|
|
|
|
|
|
|
|
# Video
|
|
|
|
## Creating a GEM window and drawing a pretty cube
|
|
|
|
GEM should come installed with puredata vanilla.
|
|
If not, you can find it via the find externals menu.
|
|
The best way to get familiar with GEM is to play around with the example files.
|
|
You can find them in the **browser**.
|
|
|
|
The most basic way to get GEM going is to:
|
|
|
|
* **declare -lib Gem** enables the library of use
|
|
* the **gemwin** object controls a window
|
|
* the **create, 1** message will display the empty window
|
|
|
|
|
|
|
|
Now to display a simple shape in this window we need to add a **gemhead** object.
|
|
This will compute everything attached to it at every frame.
|
|
|
|
|
|
|
|
This cube can be controlled with **messages** to the cube itself *and* by putting **objects** between the gemhead and itself.
|
|
The same cube but with rotation, color control (including transparency) and XYZ control can be seen below.
|
|
A light source is also added to introduce shade on the cube.
|
|
|
|
|
|
|
|
To project something onto the cube we add a **pix_film** object.
|
|
This object needs to flow into a **pix_texture** object in order to be drawn.
|
|
The object loads .mp4 files and can play them back, in loop if desired.
|
|
|
|
|
|
|
|
### Resources:
|
|
|
|
* **patches**
|
|
* [the assets](./resources/assets.zip)
|
|
* [the dancing cat](./resources/11_gem_intro.pd)
|
|
* **online information**
|
|
* [GEM intro](http://write.flossmanuals.net/pure-data/basics/)
|
|
* [Ye olde GEM manual](https://puredata.info/downloads/gem/documentation/manual/manual)
|
|
|
|
## Particles
|
|
|
|
Besides displaying pictures and videos, GEM can animate particles.
|
|
The way to draw them is very similar to the dancing cat.
|
|
For each element we want to show and control separately we need different **gemhead**.
|
|
Download the test files below and have a play with it, it will explain itself a lot better like that.
|
|
Don't forget to download the assets as well, otherwise the video won't load.
|
|
You can find the link below (it's the same file as the previous example).
|
|
|
|
|
|
|
|
### Resources:
|
|
|
|
* **patches**
|
|
* [the assets](./resources/assets.zip)
|
|
* [a dancing cat with particles](./resources/11_gem_cat_with_particles.pd)
|
|
* **online information**
|
|
* [GEM particles](https://puredata.info/downloads/gem/documentation/tutorial/particles)
|
|
|
|
# Learning more about Pure data
|
|
|
|
That's it for me but if you want to learn more about puredata you should have a look at the links below.
|
|
It's a list of tutorials and interesting work created with puredata.
|
|
|
|
* **documentation and tutorials**
|
|
* [FLOSS manual](http://write.flossmanuals.net/pure-data/introduction2/)
|
|
* [Rafael Hernadez youtube channel](https://www.youtube.com/playlist?list=PL12DC9A161D8DC5DC)
|
|
* [puredata tutorials list](https://puredata.info/docs/tutorials/)
|
|
* [Programming Electronic Music in Pd](http://www.pd-tutorial.com/english/index.html)
|
|
* **videos of sound made with pure data and some GEM stuff**
|
|
* [puredata drone](https://www.youtube.com/watch?v=V1E52x15RYU)
|
|
* [puredata sequencer 2015](https://www.youtube.com/watch?v=9Nz0bxwoqQE)
|
|
* [72-EDO algorithmic IDM in Pure Data](https://www.youtube.com/watch?v=d4t5B6nPQGg)
|
|
* [New Euclidean Rhythms Module in Pure Data Demo](https://www.youtube.com/watch?v=szFtVT5j69A)
|
|
* [Pure Data - Particle-based Music Visualisation](https://www.youtube.com/watch?v=U1k44Tr0pu4)
|
|
* [webe.omnibox / PureData Visual with GEM (Test_02)](https://www.youtube.com/watch?v=zs1lsw1q_gU)
|