CRÉATION DYNAMIQUE DE PLUGICIELS AVEC LE LANGAGE JS DE
REAPER ET LA LIBRAIRIE COOKDSP
Olivier Bélanger
iACT (institut Arts Cultures et Technologies)
Université de Montréal, Faculté de Musique
R ÉSUMÉLes compositeurs de musique électroacoustique sont régulièrement confrontés aux problématiques reliées à l’exploration du traitement de signal et au développement de modules d’effets originaux à l’intérieur d’une station audionumérique. Les plugiciels existant ne répondant pas toujours exactement aux besoins des compositeurs, il devraitêtre possible pour ceux-ci de créer leurs propres outils demanipulations sonores sans avoir à quitter le séquenceur pourtravailler avec des logiciels externes. Les solutions présentées dans cet article visent principalement les créateurs sonores possédant déjà des notions de base en traitement designal, sans pour autant être des programmeurs chevronnés.
Après un tour d’horizon des alternatives disponibles, une revue détaillée du langage de script audio JS (Jesusonic), intégré au logiciel Reaper, sera présentée. Ensuite, nous introduirons la librairie CookDSP, développée par l’auteur pourle langage JS, qui est une collection de fonctions offrant accès à plusieurs algorithmes essentiels en traitement de signal. CookDSP constitue une extension du langage JS permettant de simplifier et d’accélérer le développement desplugiciels. Finalement, des exemples de plugiciels JSFX,
créés avec la librairie CookDSP, seront présentés.
1. INTRODUCTION
Le flux de production du créateur sonore utilisant l’ordinateur comme instrument principal peut prendre plusieurs
formes. Quantité d’outils de traitements audionumériques etde mise en place de la musique existent et le choix des uns
ou des autres dans le travail de création dépend principalement des besoins de l’œuvre, ainsi que des habitudes etcompétences du créateur. La nature de l’œuvre (composition
pour support fixe, musique mixte interprétée en concert, musique d’application, etc.) favorise déjà certains environnements de travail plutôt que d’autres. Ainsi, une pièce destinée à être jouée en concert, utilisant des traitements en temps
réel, sera généralement composée dans un environnement
offrant les outils nécessaires à la création et au contrôle en
direct de chaînes de traitements audio originales. Ces environnements, pour la plupart des langages de programmation(MaxMSP, Puredata, SuperCollider, Chuck, pyo), impliquedéjà, de la part du créateur, une connaissance de base de laprogrammation musicale et du traitement de signal. À l’intérieur de ces environnements, le compositeur peut créer deschaînes de traitements originales en toute liberté. Mais qu’enest-il des compositeurs utilisant principalement le séquenceur comme outil de mise en forme de la musique ? Le traitement du son à l’intérieur du séquenceur est limité aux plugiciels (gratuits ou payants) disponibles ainsi qu’aux contrôles
que leurs concepteurs ont bien voulu rendre accessibles. Cetétat de fait force généralement le compositeur soit à modifier son idée originale pour se plier aux contraintes desoutils disponibles, soit à quitter momentanément la station
audionumérique pour travailler ses sources sonores avec desoutils dédiés au traitement de signal qui répondent mieuxà ses besoins. Ces allers-retours entre les différents environnements ralentissent le travail et compliquent les manipulations sur les sources lorsque celles-ci doivent présenter une forte corrélation au mixage final. En effet, travailler
une source sonore à l’aide d’un logiciel externe équivaut
à travailler à l’aveuglette puisque l’on n’entend pas l’effet
des manipulations sur l’ensemble des signaux en interaction.
C’est pourquoi les compositeurs apprécient généralement
les outils qui s’intègrent aisément à l’environnement de travail principal, c’est-à-dire le séquenceur. Quelles sont donc
les possibilités qui s’offrent aux compositeurs désirant travailler dans un environnement unique, mais qui, sans nécessairement être des programmeurs expérimentés, possèdent
suffisamment de connaissances en mathématique du traitement de signal pour être en mesure de créer leurs propres
outils de traitement du son ? Dans cet article, les problématiques reliées au traitement de signal à l’intérieur même dela station audionumérique seront discutées. Ensuite, après
un tour d’horizon des alternatives les plus communes, lelangage JS 1 , intégré au logiciel Reaper, et la librairie CookDSP seront détaillés. Finalement, des exemples de plugiciels utilisant les outils précédemment décrits seront présentés.

1 . Acronyme pour Jesusonic, à ne pas confondre avec le JavaScript.

2. PROBLÉMATIQUE
Les rôles principaux du séquenceur consistent à effectuer
la mise en forme temporelle de la musique, c’est-à-dire placer avec précision les événements sonores dans le temps,
ainsi qu’à faire la gestion de la polyphonie, c’est-à-dire lemixage des différentes sources en interaction. Plusieurs plugiciels existent sur le marché pour effectuer les opérations
propres au mastering 2 (gestion de la dynamique, filtrage,
spatialisation, etc.) mais lorsque l’on parle de traitement duson dans le but de créer de nouvelles sources sonores, l’éventail des possibilités de traitement est beaucoup trop vaste
pour être entièrement couvert par les plugiciels existants.
C’est principalement dans ce contexte que le compositeur abesoin d’un espace, à l’intérieur même du séquenceur, danslequel il peut définir la nature des modifications à apporter
au signal audio. De cette façon, il est possible d’effectuer
toutes les opérations nécessaires au processus de création
à l’intérieur d’un environnement unique. Il existe, bien sûr,une quantité importante de plugiciels effectuant des traitements originaux sur le signal audio. Ces outils, souvent très
intéressants, ont le désavantage d’être, par nature, très hermétiques. Un plugiciel (vst, audioUnit, ladspa, etc.) compilé en format binaire est une boîte noire offerte à l’utilisateur avec très peu de possibilité de personnalisation. Lescontrôles accessibles via l’interface sont ceux que les concepteurs ont jugés pertinents mais il arrive que le compositeurpense autrement. Si un plugiciel ne produit pas tout à faitle résultat sonore souhaité par le créateur, ce dernier doit-il
bifurquer de son plan original pour faire au mieux avec lesoutils disponibles ou doit-il quitter le séquenceur et ouvrir
un autre logiciel pour y travailler ses sources sonores ? Dans
un monde idéal, le compositeur devrait avoir la possibilitéde modifier ses plugiciels afin qu’ils répondent le plus exactement possible à ses besoins. Ceci pose toutefois un autreproblème. Écrire un plugiciel nécessite un bagage informatique que ne possède généralement pas les compositeurs demusique. Mises à part les notions de traitement de signal indispensables à la conception du plugiciel, il est impératif demaîtriser le langage de programmation orienté-objet C++,avec lequel la plupart des plugiciels sont écrits, et d’installer un environnement de développement de logiciels, afinde compiler le code source en format binaire. Chaque système d’exploitation possède ses propres particularités et leplugiciel doit être compilé indépendamment pour chacun.
Tout ceci concerne l’ingénierie informatique, un domaine
d’expertise en soi, et nous éloigne grandement du processus de création sonore. La section suivante présente un certain nombres d’alternatives permettant au compositeur de se
créer un environnement de travail rapide, efficace et versatile, sans pour autant devenir expert en informatique. Ces
solutions offrent des plates-formes de travail très différentes
2 . Ensemble de traitements audio finalisant un morceau de musique, envue de son exploitation ou de sa diffusion.

les unes des autres, chacune possédant ses forces et ses faiblesses. Nous élaborerons sur les raisons qui ont motivé lechoix du langage JS de Reaper pour le présent projet.

3. ALTERNATIVES
Les quatre plates-formes suivantes offrent la possibilité
au compositeur d’explorer le traitement de signal et de développer ses propres processus audio, tout en conservant une
relation plus ou moins étroite avec la station audionumérique.

3.1. MaxForLive
MaxForLive est une version du logiciel MaxMSP, un environnement de programmation par patch, intégré à la station audionumérique Live. Il permet d’insérer, et de modifier
en temps réel, des modules développés avec MaxMSP dansla chaîne de production sonore de Live [6]. Très populaireauprès des communautés électroacoustique et électronique,ce couple de logiciels est couramment utilisé pour la composition ou les performances en temps réel. Ces logiciels nesont malheureusement ni gratuits ni multi-plates-formes (ils
ne fonctionnent pas sous linux).

3.2. Faust
Faust (acronyme pour Functional Audio Stream) est un
langage fonctionnel permettant de définir des chaînes de traitement de signal pouvant ensuite être compilés pour différents environnements (plugiciel ladspa, lv2 ou vst, objet
Puredata, Csound, SuperCollider, etc.). Faust est gratuit etsupporte les plates-formes les plus populaires (OSX, Windows, linux, iOS, Android, Raspian). Une interface web estégalement disponible afin de développer la chaîne de traitement de signal. Une fois le code Faust écrit, l’interface
fournit automatiquement le code source en C++ pour l’environnement demandé, un diagramme de la chaîne de traitement et une documentation en format pdf. L’interface permet aussi de télécharger un exécutable pré-compilé du traitement développé. Cette option est un énorme avantage surl’écriture directe de plugiciel puisque la compilation pourun environnement donné nécessite généralement une grandepart de configuration et des connaissances informatiques quene devrait pas avoir à assumer un compositeur de musique.
Un autre avantage de Faust est la parallélisation des processus audio à l’intérieur du code [4], permettant de tirer profit
des architectures multi-cœurs (de plus en plus répandues) etd’obtenir du code très efficace en temps de calcul. Faust est
un environnement d’exploration du traitement de signal trèsversatile et efficace pour les compositeurs, par contre, il fautquitter le séquenceur pour développer le plugiciel...

3.3. Blue Cat’s plug’n script
La compagnie Blue Cat, qui offre plusieurs instruments
et effets de grande qualité, a lancé en 2014 un nouveau plugiciel nommé Plug’n Script [5]. Il permet de développer
des algorithmes de traitement de signal audio, ou des instruments MIDI, à même l’interface du plugiciel, sans quitter leséquenceur. Il utilise le langage hautement optimisé AngelScript, d’une syntaxe similaire au C++ et au Java. Le code
est compilé « à la volée », ce qui permet de développer sansmême arrêter la lecture de la séquence. Cet environnement
permet le prototypage rapide d’effets audionumériques dans
un langage similaire à celui d’un plugiciel autonome. Il est
donc très simple de se servir du code AngelScript commebase à la programmation d’un plugiciel indépendant (vst ou
audioUnit par exemple). Cependant, cette alternative nécessite des connaissances en programmation plus approfondies
qu’une simple maîtrise du traitement de signal puisque leAngelScript n’est pas un langage particulièrement simple àmanier. Plug’n Script supporte une grande quantité de formats de plugiciels mais ne fonctionne que sous OSX et Windows. Qui plus est, ce produit n’est pas gratuit.
3.4. Les plugiciels JSFX de Reaper
Le logiciel Reaper, développé par la compagnie Cockos,
propose un environnement de développement de plugiciels
complètement intégré à la station audionumérique [7]. Les
plugiciels sont écrits à même l’interface avec le langage descript audio JS, compilé « à la volée » par Reaper. Le langage permet de développer des effets audio, des algorithmes
MIDI ainsi que des interfaces graphiques à l’aide d’un moteur de dessin vectoriel optimisé. Ce système ne nécessite
aucune configuration particulière, la compilation étant priseen charge par le logiciel, et très peu de connaissances enprogrammation, ce qui en fait un environnement idéal pourle compositeur désirant explorer les techniques de traitement de signal. Reaper fonctionne sur les principales platesformes (OSX, Windows et linux) et est disponible en téléchargement gratuit sur le site de Cockos. La compagnie fait
confiance à la bonne foi des utilisateurs pour acheter une
licence, à un prix tout-à-fait raisonnable, si le logiciel est
utilisé dans un contexte professionnel. La section suivanteélabore sur les particularités du langage de script audio JS
de Reaper. Ensuite sera présenté la librairie CookDSP, qui
ajoute une couche de fonctionnalités au langage JS, facilitant ainsi la création d’effets audionumériques originaux.

compilé « à la volée » lorsque sauvegardé, contenant les directives nécessaires à l’exécution du processus sonore désiré. Les effets et instruments JSFX distribués avec le logiciel peuvent être consultés, modifiés ou utilisés comme pointde départ pour la création de traitements originaux. Nous introduirons dans cette section les fonctionnalités de base dulangage, la structure d’un fichier JSFX ainsi que les règles
de syntaxe essentielles à l’écriture d’effets audio ou d’instrument MIDI.
4.1. Structure d’un fichier JSFX
Un fichier JSFX est un simple fichier texte, sans extension, contenant un certain nombre de lignes de description,
suivi par une ou plusieurs sections de code. Les descriptions
servent principalement à gérer le contenu de l’interface graphique tandis que les sections de code spécifient les actions
à poser (modification des échantillons sonores) en fonction
du processus développé et des manipulations effectuées parl’utilisateur.
4.1.1. Les descriptions
Une description est une commande, sous la forme d’un
mot-clé, suivi du symbole deux-points ( : ), puis des arguments spécifiques à la commande. Les deux descriptions essentielles sont desc, qui permet de donner un titre au plugiciel, ainsi que sliderX (où X est remplacé par le numéro dupotentiomètre), utilisé pour créer des contrôles graphiquesde paramètres. Selon les paramètres donnés à la description sliderX, Reaper affichera soit un potentiomètre, soit unmenu déroulant. Les descriptions permettent aussi d’établir
des canaux de communication audio entre différents plugiciels ou de spécifier des fichiers audio nécessaires au bon
fonctionnement du code. Le lecteur est invité à consulter ladocumentation du langage [2] pour de plus amples détails.
Le code suivant, bien que n’effectuant aucun traitement
sur le signal audio, construira l’interface graphique illustréeà la figure 1.
d e s c : Un P l u g i c i e l q u i ne f a i t r i e n
s l i d e r 1 : 0 < 0 , 1 0 , 1 > Compteur d ’ e n t i e r s
s l i d e r 2 :0.5 <0 ,1 > Panoramisations l i d e r 3 : 0 < 0 , 1 , 1 { Off , On}> Commutateur On / O f f
s l i d e r 4 : 0 < 0 , 4 , 1 { Rect , T r i a n g l e , C l o c h e }> E n v e l o p p e

4. LE LANGAGE DE SCRIPT AUDIO JS
JS est un langage de script audio propre à la station audionumérique Reaper. Il permet la création rapide de plugiciels par le biais d’une structure épurée ainsi que d’une
intégration directe et efficace à l’architecture du logiciel. Un
plugiciel JSFX consiste tout simplement en un fichier texte,

Figure 1. Interface graphique simple.

Le langage JS possède aussi plusieurs fonctions permettant d’effectuer du dessin vectoriel, dont le rafraîchissementa lieu à l’intérieur d’un processus parallèle au processus audio, offrant ainsi la possibilité de construire des interfaces
graphiques plus évoluées.
4.1.2. Les sections de code
Les sections de code représentent des actions à poser,
c’est-à-dire des manipulations à effectuer sur les signaux,
en différents moments du processus. Par exemple, certaines
opérations doivent être effectuées à l’initialisation du plugiciel, tandis que d’autres doivent être appliquées à chacun
des échantillons, ou encore seulement quand un potentiomètre change de valeurs, etc. Une section est déclarée àl’aide d’une ligne unique, contenant le nom de la section,
précédée du symbole arobas ( @ ). Toutes les lignes suivantes appartiennent à cette section, jusqu’à la déclarationde la section suivante (ou jusqu’à la fin du fichier). Voici laliste des sections de code disponibles et leur contexte d’utilisation :• @init : Les commandes contenues dans cette section seront exécutées au chargement du plugiciel ainsi qu’aulancement de la lecture de la séquence.
• @slider : Les commandes contenues de cette section neseront exécutées que lors de la manipulation d’un élément graphique.
• @block : Cette section est exécutée une seule fois par
bloc d’échantillons, tout juste avant le calcul des échantillons eux-mêmes.
• @sample : Le code de cette section est exécutée à chaquepériode d’échantillonnage, on y a donc accès à chacun
des échantillons de façon indépendante.
• @serialize : Cette section est exécutée pour la sauvegarde ou la recharge d’un préréglage.
• @gfx : Section de code dédiée au dessin vectoriel. On y
retrouve les commandes pour les affichages complexes(oscilloscope, spectrogramme, filtre paramétrique, etc.).
L’exemple suivant illustre l’organisation des opérations
d’un plugiciel en sections de code. C’est un plugiciel qui
met en place un contrôle du volume en décibels ainsi qu’une
gestion de la balance des canaux gauche et droit. La section @init spécifie la valeur initiale des variables utilisées
par le processus. La section @slider met à jour les variables
en fonction des manipulations de potentiomètres effectuéesà l’écran. Le code contenu dans la section @sample est
exécuté à chaque période d’échantillonnage, ce qui permetd’appliquer les valeurs d’amplitude aux échantillons successifs du signal audio.

/∗ A m p l i f i c a t i o n e t Balance ∗/d e s c : Gain e t B a l a n c e
s l i d e r 1 :0 < −60 ,18 > Gain ( dB )s l i d e r 2 :0 < −100 ,100 > B a l a n c e@i n i t/ ∗ Code d ’ i n i t i a l i s a t i o n ∗ /g a i n = amL = amR = 1 . 0 ;@s l i d e r/ ∗ Code d e s
g a i n = 10 ^slider2 < 0slider2 > 0

manipulations graphiques ∗/( slider1 / 20);
? amL = 1 : amL = 1 − s l i d e r 2 ∗ 0 . 0 1 ;? amR = 1 : amR = s l i d e r 2 ∗ −0.01;@sample/ ∗ Code a f f e c t a n t c h a c u n d e s e c h a n t i l l o n s ∗ /s p l 0 = s p l 0 ∗ g a i n ∗ amL ;s p l 1 = s p l 1 ∗ g a i n ∗ amR ;4.2. Les éléments de langage
Le corps d’un plugiciel JSFX est écrit avec le langage
EEL2 (Extensible Embeddable Language) [3], dont la syntaxe est comparable à celle du C. Ce langage a été conçu expressément pour faciliter l’écriture en temps réel de scripts
offrant une puissance de calcul comparable au langages compilés. Il est autonome et nécessite peu de dépendances, ce
qui en fait un langage très facile à intégrer à différents environnements, tel que Reaper.
4.2.1. Syntaxe
Tout langage de programmation, aussi simple soit-il, implique un certain nombre de règles de syntaxe. Voici un petit
condensé des notions essentielles concernant le langage JS :• Les variables n’ont pas besoin d’être déclarées et ellessont « globales » par défaut (c’est-à-dire qu’elles sontaccessibles dans toutes les sections de code). Toute valeur numérique est définie avec une double précision (64bit).
• Un commentaire peut être spécifié à l’aide de la double
barre oblique ( // ) ou entre les symboles « /* » et « */ ».
• Le symbole point-virgule ( ; ) sert à séparer les déclarations (opérations mathématiques, assignation à une variable, etc.).
• Les parenthèses peuvent servir à clarifier l’ordre despriorités dans une expression mathématique ou à regrouper plusieurs opérations en un seul appel.
• Une mémoire virtuelle (environ 8 millions de mots) uniqueau plugiciel est accessible à l’aide des crochets ( [ et ] ).
• Il n’y a pas de mot-clé tel que if ou else dans le langage
JS, les expressions conditionnelles utilisent la syntaxe :condition ? code si vrai : code si faux

4.2.2. Variables réservées

d e s c : Dent de s c i e

Un certain nombre de variables réservés sont définies dansle langage afin d’assurer la communication entre le logiciel
et le plugiciel. En voici un bref aperçu :@i n i t/ ∗ I n i t i a l i s e une d e n t de s c i e . ∗ /f u n c t i o n saw ( f r e q )(t h i s . inc = freq ∗ 2 / srate ;t h i s . phs = 0 ;);• slider1, slider2, ..., slider64, noms réservés des 64 potentiomètres possibles. Dans les sections de code, on récupère la valeur d’un potentiomètre via son nom de variable.
• spl0, spl1, ..., spl63, noms réservés des 64 canaux audio
possibles. En stéréo, le signal de gauche est accessible
via la variable spl0 tandis que le signal de droite est accessible via la variable spl1.

/∗ Calcule l e s e c h a n t i l l o n s . ∗/f u n c t i o n saw_do ( )(v a l = t h i s . phs ;t h i s . p h s += t h i s . i n c ;t h i s . p h s >= 1 ? t h i s . p h s −= 2 ;
val ;
);

• srate, variable donnant accès à la fréquence d’échantillonnage courante de Reaper. Cette variable peut êtreutilisée chaque fois qu’un calcul doit tenir en compte lafréquence d’échantillonnage.

/ ∗ C r e a t i o n de d e u x d e n t s de s c i e . ∗ /r 0 . saw ( 1 7 2 ) ;r 1 . saw ( 8 6 ) ;• play_state, variable indiquant l’état courant de la lecture(en mode lecture, arrêt, enregistrement, etc.).

@sample/ ∗ Une d e n t de s c i e p a r c a n a l . ∗ /s p l 0 = r 0 . saw_do ( ) ;s p l 1 = r 1 . saw_do ( ) ;• play_position, variable donnant la position courante, en
secondes, du pointeur de lecture dans la session.
• tempo, variable indiquant le tempo, en « bpm », du projet courant.
4.2.3. Programmation orienté-objet
Parmi toutes les fonctionnalités du langage JS, celle quia permis le développement de la librairie CookDSP est sa
capacité à gérer du code orienté-objet. Quoique très simple
dans son implémentation, elle permet la persistance des variables internes d’une fonction d’un appel à l’autre, ce qui
est amplement suffisant pour développer des processus audio indépendants et les contrôler au cours du temps. Seulement deux éléments de syntaxe sont nécessaires pour mettreen place une structure de type objet. Premièrement, à l’intérieur des fonctions, le nom des variables propres à l’objet
doivent porter le préfixe this. Ensuite, on crée un objet en
faisant précéder l’appel de fonction d’un nom de variable(ex. : var.appel()). Le nom de variable choisi devient la référence de l’objet créée. Par la suite, chaque appel de fonction
qui sera précédé du nom de variable utilisera les variables
implicites (et « persistantes ») de l’objet référencé.
L’exemple suivant illustre l’orientation objet du langage
JS. Les fonctions saw et saw_do servent respectivement à
initialiser et à calculer les échantillons d’une onde en dent descie. Deux objets indépendants, oscillant à des fréquences
différentes, sont ensuite créés et manipulés à l’aide de ces
fonctions. Les deux signaux sont illustrés sur l’oscilloscopede la figure 2.

Figure 2. Deux dents de scie de fréquences différentes.

5. LA LIBRAIRIE COOKDSP
CookDSP est une boîte à outils de haut niveau, spécialement dédié au langage JS, facilitant l’élaboration de traitements audionumériques. Concrètement, tout ce que fournit
le langage JS est un environnement de développement ainsi
que des primitives indispensables au traitement de signal(opérateurs mathématiques, structures d’appels en boucle,
instructions conditionnelles, etc.). Tout processus de contrôle
ou de traitement audio doit être entièrement construit à partirde ces primitives. Cela peut s’avérer intimidant pour le compositeur ne possédant que des bases en traitement de signal.
La librairie CookDSP fournit une collections de fonctions
et d’objets prenant en charge certaines particularités propres
à la programmation audio, notamment des algorithmes deconversion, un système de gestion de la mémoire, des algorithmes d’interpolation et des générateurs de formes d’onde.
La librairie offre aussi plusieurs outils de traitement (filtres,
délais, distorsions, réverbérations) et d’analyses (suivi d’enveloppe, suivi de hauteur, centre de gravité spectrale, etc.)prêts à être utilisés. On y retrouve également tout le nécessaire pour créer des effets dans le domaine spectral, à l’aide
de la transformée de Fourier et du vocodeur de phase. La
documentation complète peut être consulté sur le site web
de la librairie [1]. Pour avoir accès à la collection de fonctions, il faut d’abord importer CookDSP à l’aide de la ligne
suivante :import c o o k d s p . j s f x −i n c

Les sections suivantes proposent un tour d’horizon détaillé des fonctionnalités offertes par la librairie CookDSP.

entre autre, par les algorithmes d’interpolation à l’écriture età la lecture des lignes de délai). Tous les objets de la librairie faisant usage de la mémoire utilisent la fonction memalloc afin d’assurer une compatibilité avec le reste du code.
L’exemple précédant pourrait donc s’écrire comme suit :@i n i ts i z e = 2048;
mem1 = memalloc ( s i z e ) ;mem2 = memalloc ( s r a t e ) ; / / une s e c o n d e de memoire
k = 0;
loop ( size ,mem1 [ k ] = −0.5 ∗ c o s ( 2 ∗ $ p i ∗ k / s i z e ) + 0 . 5 ;k += 1 ;);5.1. Gestion de l’espace-mémoire
Chaque plugiciel JSFX se voit automatiquement attribué
un espace-mémoire privé d’environ 8 millions de mots (trois
minutes de son monophonique pour une fréquence d’échantillonnage de 44100 Hz). Cet espace peut être utilisé en différents contextes. Par exemple, pour enregistrer du signal
audio en vue d’une utilisation ultérieure, pour initialiser lamémoire d’une ligne de délai, pour mettre en banque desenveloppes et des formes d’onde ou pour conserver des valeurs temporaires dans un algorithme d’analyse. Pour que leplugiciel fonctionne correctement, il est primordial que lesdifférentes utilisations de l’espace-mémoire n’interfère pas
entre-elles. La mémoire allouée doit donc être séparée en
blocs de différentes tailles selon les besoins du processus.
Le code suivant initialise deux blocs de mémoire, le premier commençant à l’index 0 et le second à l’index 1024.
Le premier bloc peut donc utiliser au plus 1024 échantillons(0 → 1023) avant de chevaucher le second. Une enveloppe
hanning est mise en mémoire dans le bloc. La taille du second bloc n’est actuellement limité que par la taille totale del’espace-mémoire.
@i n i t
mem1 = 0 ;mem2 = 1 0 2 4 ;k = 0;
loop (1024 ,mem1 [ k ] = −0.5 ∗ c o s ( 2 ∗ $ p i ∗ k / 1 0 2 4 ) + 0 . 5 ;k += 1 ;);Dans un contexte comme celui-ci, si l’on veut augmenter la taille de l’enveloppe à 2048 échantillons, il faudra
aussi augmenter l’index de départ de tous les blocs suivants
afin d’éviter les chevauchements. Si le programme contientdes dizaines de blocs-mémoire, jongler avec la taille desespaces-mémoire augmentera considérablement les risquesd’erreur. La librairie CookDSP propose une gestion automatique de l’espace mémoire avec la fonction memalloc. Cette
fonction alloue un bloc d’une taille spécifiée en argument etgarde en mémoire l’index de départ suivant pour une allocation ultérieure. Chaque allocation de mémoire sera séparée de la suivante par huit espaces vides, qui seront utilisés,De cette façon, on peut modifier à volonté la valeur de lavariable size, toutes les allocations de mémoire s’ajusteront
automatiquement.
En plus de la fonction memalloc, la librairie offre deux
objets forts pratiques en ce qui concerne la gestion de la mémoire. Le premier est l’objet buffer, qui contient plusieurs
algorithmes de génération d’enveloppes et de formes d’ondeainsi que différentes méthodes de lecture. Le second est delay, qui permet de créer aisément des effets à base de lignesde délai récursives. En utilisant ces objets, la section d’initialisation de notre exemple se résumerait à ceci :@i n i t
buf . buffer ( 2 0 4 8 ) ;b u f . buffer_window ( 1 ) ; / / e n v e l o p p e h a n n i n g
d e l . d e l a y ( s r a t e ) ; / / une s e c o n d e de memoire

5.2. Les outils de conversion
La librairie offre plusieurs fonctions permettant de convertir une valeur d’une échelle à une autre. La conversion d’une
note midi en fréquence s’effectue avec la fonction mtof, l’inverse (Hz → midi) avec ftom. Les fonctions dbtoa et atodb
convertissent des valeurs d’amplitude entre l’échelle des décibels (logarithmique) et l’échelle linéaire. La fonction scale
offre le contrôle sur les ambitus d’entrée et de sortie de laconversion ainsi que sur le type de courbe utilisée (linéaire,exponentielle ou logarithmique). L’exemple suivant effectue
deux conversions. Dans un premier temps, la valeur en décibels d’un potentiomètre est récupérée et convertie en amplitude linéaire. Ensuite, la valeur d’un second potentiomètre,normalisée entre 0 et 1, est convertie en fréquence à l’aide
d’une courbe exponentielle.
import c o o k d s p . j s f x −i n c
s l i d e r 1 :0 < −60 ,18 > Gain ( dB )s l i d e r 2 : 0 . 1 < 0 , 1 > F r e q Norm@s l i d e r
g a i n = dbtoa ( s l i d e r 1 ) ;hz = s c a l e ( s l i d e r 2 , 0 , 1 , 2 0 , 2 0 0 0 0 , 4 ) ;5.3. Les objets de traitement
La librairie CookDSP fournit une vaste gamme de traitements audio, sous la forme de pseudo-classes, pouvant êtreassemblés afin de construire des chaînes d’effets complexes.
Les traitements offerts couvrent le filtrage, les outils de gestion de la dynamique, les effets basés sur les délais, la granulation et les effets dans le domaine spectral. Des outilsde génération aléatoire et d’analyse du signal audio accompagnent les objets de traitements et offrent la possibilité deconstruire de multiples trajectoires de contrôle de paramètre.
Tous les objets de la librairie utilisent la structure décrite
ci-dessous.
1) Une fonction portant le nom de l’objet sert à initialiser leprocessus (une distorsion dans cet exemple).
@i n i t
dis . disto (0.7 , 5000);

2) Diverses fonctions objet_xxx servent à modifier le comportement de l’objet.
@s l i d e r
dis . disto_set_drive ( slider1 );dis . disto_set_cutoff ( slider2 );3) Une méthode objet_do exécute le processus audio surl’échantillon donné en argument. Cette fonction est généralement appelée à chaque période d’échantillonnage, c’està-dire dans la section @sample.
@sample/ / A j u s t e m e n t de l ’ a m p l i t u d e
amp = s c a l e ( s l i d e r 1 , 0 , 1 , 0 . 7 , 0 . 4 , 2 ) ;/ / Applique la d i s t o r s i o n
s p l 0 = d i s L . d i s t o _ d o ( s p l 0 ) ∗ amp ;Voici le code complet pour une distorsion stéréophonique :desc : Simple D i s t o r t i o nimport c o o k d s p . j s f x −i n c
s l i d e r 1 :0.7 <0 ,1 > Drives l i d e r 2 :5000 <500 ,10000 > Lowpass C u t o f f@i n i t
disL . disto ( slider1 , s l i d e r 2 ) ;disR . d i s t o ( slider1 , s l i d e r 2 ) ;6. EXEMPLES
Cette section présente deux exemples complets de plugiciel JSFX construits à l’aide de la librairie CookDSP.
6.1. Un plugiciel d’Auto-Wah
Le premier exemple de plugiciel, illustré à la figure 3,
met en place un effet d’Auto-Wah, où la fréquence centraled’un filtre passe-bande varie en fonction de l’amplitude dusignal source.
/ ∗ ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
Auto−Wah : Un f i l t r e p a s s e −bande d o n t l a f r e q u e n c e
c e n t r a l e v a r i e en f o n c t i o n d ’ un s u i v i d ’ a m p l i t u d es u r l e s i g n a l s o u r c e . ( c ) b e l a n g e o − 2014∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ∗ /d e s c : Auto−Wah
import c o o k d s p . j s f x −i n c
s l i d e r 1 :5 <1 ,10 >Q d e s F i l t r e s
s l i d e r 2 :5000 <500 ,8000 > F r e q u e n c e Maximales l i d e r 3 :20 <1 ,100 > R e a c t i v i t e du S u i v i@i n i t/ ∗ I n i t i a l i s a t i o n du s u i v e u r d ’ e n v e l o p p e . ∗ /fol . follow (10);/ ∗ I n i t i a l i s a t i o n d e s f i l t r e s p a s s e −bande . ∗ /bpL . bp ( 1 0 0 0 , s l i d e r 1 ) ;bpR . bp ( 1 0 0 0 , s l i d e r 1 ) ;@s l i d e r/ ∗ A j u s t e m e n t de l a f r e q u e n c e d e s f i l t r e s . ∗ /bpL . b p _ s e t _ q ( s l i d e r 1 ) ;bpR . b p _ s e t _ q ( s l i d e r 1 ) ;/ ∗ A j u s t e m e n t de l a f r e q u e n c e du s u i v e u r . ∗ /fol . follow_set_freq ( slider3 );@sample/∗ Suivi d ’ enveloppe . ∗/input = ( spl0 + spl1 ) ∗ 0.707;
amp = f o l . f o l l o w _ d o ( i n p u t ) ;/ ∗ C o n v e r s i o n a m p l i t u d e −> f r e q u e n c e ∗ /f r e q = s c a l e ( amp , 0 , 1 , 5 0 , s l i d e r 2 , 2 ) ;/∗ Modifie la frequence c e n t r a l e des f i l t r e s . ∗/bpL . b p _ s e t _ f r e q ( f r e q ) ;bpR . b p _ s e t _ f r e q ( f r e q ) ;/ ∗ F i l t r a g e du s i g n a l d ’ e n t r e e . ∗ /s p l 0 = bpL . bp_do ( s p l 0 ) ;s p l 1 = bpR . bp_do ( s p l 1 ) ;@s l i d e r
disL . disto_set_drive ( s l i d e r 1 ) ;disR . d i s t o _ s e t _ d r i v e ( s l i d e r 1 ) ;disL . d i s t o _ s e t _ c u t o f f ( s l i d e r 2 ) ;disR . d i s t o _ s e t _ c u t o f f ( s l i d e r 2 ) ;@sampleamp = s c a l e ( s l i d e r 1 , 0 , 1 , 0 . 7 , 0 . 4 , 2 ) ;s p l 0 = d i s L . d i s t o _ d o ( s p l 0 ) ∗ amp ;s p l 1 = d i s R . d i s t o _ d o ( s p l 1 ) ∗ amp ;Figure 3. Interface graphique du plugiciel d’Auto-Wah.

6.2. Un plugiciel de délai récursif
Le second exemple de plugiciel, illustré à la figure 4, met
en place un effet de délai récursif, où un signal stéréo est
délayé puis réinjecté en entrée de la ligne de délai.
/ ∗ ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
D e l a i S t e r e o + F e e d b a c k : Un s i g n a l s t e r e o e s t
d e l a y e p u i s r e i n j e c t e en e n t r e e d e s l i g n e s ded e l a i . ( c ) b e l a n g e o − 2014∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ∗ /desc : Delai S t e r e o + Feedbacks l i d e r 1 :250 <1 ,1000 > D e l a y Time ( ms )s l i d e r 2 :0 < −1 ,1 > F e e d b a c kimport c o o k d s p . j s f x −i n c@i n i t/ / Deux l i g n e s de d e l a i de une s e c o n d e
d0 . d e l a y ( s r a t e ) ;d1 . d e l a y ( s r a t e ) ;@s l i d e r/ / C o n v e r s i o n du t e m p s de d e l a i en e c h a n t i l l o n ssamps = s l i d e r 1 ∗ 0 . 0 0 1 ∗ s r a t e ;@sample/ / Lecture avec i n t e r p o l a t i o n cubiquev a l 0 = d0 . d e l a y _ r e a d 3 ( samps ) ;v a l 1 = d1 . d e l a y _ r e a d 3 ( samps ) ;/ / E c r i t u r e d a n s l e s l i g n e s de d e l a i
d0 . d e l a y _ w r i t e ( s p l 0 + v a l 0 ∗ s l i d e r 2 ) ;d1 . d e l a y _ w r i t e ( s p l 1 + v a l 1 ∗ s l i d e r 2 ) ;/ / Mixage d e s s i g n a u x o r i g i n a u x e t d e l a y e s
spl0 = ( spl0 + val0 ) ∗ 0.5;
spl1 = ( spl1 + val1 ) ∗ 0.5;

plate-forme alternative a été motivé par la simplicité du langage lui-même ainsi que par l’épuration de l’environnementde développement (aucune installation ni compilation de librairies ne sont requises). La simplicité du langage et la priseen charge automatique de la compilation du plugiciel en fontun environnement idéal pour initier les non-programmeurs
au traitement de signal. Les compositeurs peuvent créer leurs
propres banques d’effets audionumériques et les transporter
facilement d’une plate-forme à l’autre puisque ceux-ci résident dans de simples fichiers texte. La librairie CookDSP
représente un pas de plus vers la liberté d’exploration en
fournissant aux créateurs une collection de fonctions automatisant certains aspects propres au traitement de signal(gestion de la mémoire, algorithmes d’interpolation, calcul
des coefficients des filtres, etc.). À l’Université de Montréal,en classe de théorie électroacoustique, cette plate-forme a
été utilisée avec succès pour illustrer et explorer les diverses
techniques de traitement du son.
Beaucoup de travail a été accomplie afin d’optimiser au
maximum les fonctionnalités déjà présentes dans la librairie
CookDSP. Parmi les projets de développements futurs, enplus de continuer à agrémenter la librairie de nouveaux processus de traitement, une attention particulière sera accordéeà la création d’instruments MIDI. Le langage JS prend déjà
en charge les messages MIDI en entrée et en sortie mais très
peu d’outils existent en ce qui concerne la gestion de la polyphonie. La polyphonie MIDI, ainsi que les éléments de basepour la création de sons de synthèse originaux (enveloppes,
lecture de forme d’onde, anti-alias, etc.) seront au cœur desfuturs développements de la librairie.

8. REFERENCES

Figure 4. Interface graphique du plugiciel de délai récursif.

7. CONCLUSIONS
Dans cet article, nous avons exploré le langage de script
audio JS, intégré à la station audionumérique Reaper, ainsi
que la librairie CookDSP, une collection de fonctions facilitant l’exploration du traitement de signal et la création deplugiciels JSFX. Ces outils s’avèrent particulièrement utiles
pour le compositeur désirant développer ses propres modules d’effets sonores sans quitter le logiciel de mise en
forme de la musique. La décision de créer une librairie deprocessus sonores pour le langage JS plutôt que pour une[1] Bélanger, Olivier, « Documentation de la librairie
CookDSP », http://ajaxsoundstudio.com/cookdspdoc/,
2014.
[2] Cockos Incorporated, « Documentation du langage descript audio JS », http://www.reaper.fm/sdk/js/js.php,(2005-2014).
[3] Olofson, David, « The Extensible Embeddable Language », http://eelang.org/, (2002-2014).
[4] Orlarey, Y., Fober, D., Letz, S., « Parallelization of Audio Applications with Faust », 6th Sound and Music
Computing Conference , Porto, Portugal, 2009.
[5] Press Release, « Make your own FX and VIs withBlue Cat’s Plug’n Script », Sound On Sound, septembre,
2014.
[6] Rothwell, Nick, « Max for Live, Real-time Programming Toolkit For Ableton Live », Sound On Sound, february, 2010.
[7] Watson, Barry, « Jesusonic Plug-Ins, Reaper Tips andTechniques », Sound On Sound, february, 2013.