Jabalion - Un Environnement Informatique Pour LʼImprovisation Electroacoustique

UNIVERSITÉ PARIS VIII VINCENNENS À SAINT DENIS

UFR ARTS, PHILOSOPHIE, ESTHÉTIQUE

"JABALION"

Un Environnement Informatique Pour LʼImprovisation Electroacoustique

SUPERCOLLIDER

MAXMSP

LUIS ALEJANDRO OLARTE

MÉMORE DE MASTER II Sous la direction

Mme. Anne SEDES

Année universitaire 2009 2010

TABLE DES MATIÈRES 1. Introduction......................................................................................................3 2."Jabalion" Implémentation sur SuperCollider 3............................................9 2.1. SuperCollider. ...............................................................................................9 2.2. Synthétiseurs et moteurs de Synthèse....................................................13 2.2.1. Entrées Analogiques..............................................................................13 2.2.2. Lecture de fichiers sons.........................................................................15 2.2.3. Synthèse................................................................................................16 2.2.3.1. Modulation de Fréquence ...................................................................16 2.2.3.2. Gendy ................................................................................................18 2.2.3.3. k-means .............................................................................................20 2.3. Traitements du Signal. ...............................................................................21 2.3.1 Modulations.............................................................................................22 2.3.2 Lignes à retard........................................................................................24 2.3.2.1 Réverbération ......................................................................................25 2.3.2.2 Retards Longs et Structures Rythmiques ............................................27 2.3.2.3 Modulation du temps de retard. ...........................................................30 2.3.3 Analyse de Fourier..................................................................................33 2.3.3.1 Conformal Map ....................................................................................36 2.3.3.2 Freezer.................................................................................................38 2.3.4. Granulation ............................................................................................40 2.4 Matrix et Audio Mappings. ..........................................................................45 2.5 GU Interface Graphique ..............................................................................54 2.5.1. Potentiomètres et indicateurs de niveau................................................58 2.5.2 Panoramique...........................................................................................62 2.5.3 Lecteur de Fichiers .................................................................................65 2.5.4 Lecteur de tables ....................................................................................67 2.5.5 Tableau MIDI ..........................................................................................69 2.5.6 Clavier de lʼordinateur .............................................................................70 2.6. Contrôle. ......................................................................................................71 2.6.1 Lʼinterface ordinateur ..............................................................................73 2.6.2 LʼInterface MIDI.......................................................................................75 2.6.3. Arduino, captation du geste ...................................................................77 2.6.4. Le son contrôleur. ..................................................................................81 2.6.5. Sauvegarde et enregistrement...............................................................85 3. "Transgressions" Implémentation sur MAXMSP 5 ....................................87 3.1. Présentation de la version MAXMSP 5.........................................................88 3.2. Comparaison avec Jabalion..........................................................................94 4. Annexes .........................................................................................................97 4.1."Border Border Expres" Olarte / Okach, Electronique et Danse ....................97 4.2."Coco duro" Olarte / Montes de Oca Torres, Guitare et électronique............97 4.3."Workshop Helsinki Meeting Point"/ Sibelius Academy Finlande. .................97 5. Conclusions. ..................................................................................................98 6. Bibliographie..................................................................................................99

LuisAlejandroOLARTEUniversitédeParisVIIIDépartementdeMusique2010

3

1. INTRODUCTION Dans ce travail je vais explorer, présenter et discuter un environnement logiciel construit sur SuperCollider 3 et MaxMSP 5, pour l'improvisation de la musique électroacoustique. Je vais aborder la problématique de l'instrument ou l'interface musicale pour piloter le logiciel : lʼinterface graphique, les contrôleurs MIDI, lʼanalyse du son, la lecture de courbes et de tables, les automatisations. Pourquoi un environnement informatique? En tant que musicien et expérimentateur jʼai toujours été à la quête des outils électroacoustiques, plus pour les performances publiques que pour la production en studio, ainsi jʼai été confronté aux synthétiseurs, analogiques et numériques. Jʼai perçu le double enjeu de ces outils : la production sonore et le geste contrôleur, car ces machines à sons semblent séparer le problème technique de la synthèse avec des oscillateurs, filtres, amplificateurs de celui de lʼinterprétation instrumentale présenté sous forme de claviers, potentiomètres, boutons, tableaux de connectiques (patchs). Jʼai donc avancé parallèlement dans ces deux directions en apprenant les théories et les techniques des traitements et synthèses sonores puis en expérimentant avec le concept dʼinterface. Comme Claude Risset le rappelle1, l'ordinateur n'est pas en lui même un instrument de musique, il est une grande machine à calculs avec une interface visuelle et un accès gestuel très limité : un clavier et une souris. Cependant, comme on peut le constater dans manifestations comme le live coding et les laptop orchestra, l'ordinateur cherche à faire repenser sa place dans l'organologie contemporaine. Jʼai abandonné progressivement lʼillusion dʼune conception dʼun instrument nouveau principalement à cause de lʼisolement dans un répertoire musical et gestuel inexistant. Jʼai donc décidé « dʼaugmenter » mon instrument : la guitare avec des capteurs, et de là jʼai voulu avoir aussi des actionnaires pour modifier le comportement acoustique de la surface vibrante, imposer dʼautres modes de vibration, exploiter les réalimentations acoustiques, enfin passer de lʼinterface de contrôle à lʼinterface contrôlée2. Ces idées mʼont poussé dans lʼétude des automates et de robots et notamment du disklavier, mais ma place comme musicien se voyait métamorphosée en quelque chose de plus proche de la sculpture sonore ou des arts plastiques. 1 Jean Claude RISET dans « Interfaces homme machines », Hermes Science, 1999 2 Voir les travaux et les expérimentes réalisés au Laboratoire d’Acoustique Musical par Charles BESNAINOU sur des plaques de Marimba et tables de résonance des violons


4

Toujours actif dans ma discipline dʼinstrumentiste, je suis revenu sur mon instrument et jʼai décidé dʼapprofondir le côté logiciel et environnement informatique. Pour ceci, je me suis proposé dʼapprendre un outil très réputé comme SuperCollider et dʼy bâtir lʼenvironnement dont je ressentais le besoin. Il me fallait une plate-forme de pilotage pour interconnecter les traitements sonores appliqués à des sources acoustiques, la gestion de fichiers sons, différentes techniques de synthèse avec des paradigmes de contrôle comme capteurs, interfaces MIDI, microphones, clavier, souris et caméra de lʼordinateur. Le tout étant dʼun accès simple pour être performant dans des circonstances musicales individuelles et collectives. Bien que plusieurs logiciels circulent dans le milieu dʼinformatique musicale comme Omax, IXIQuarks, NajoInterface parmi dʼautres commercialisés dans le monde de DJs comme Pacemaker, Kontact, Traktor et les produits de Native Instruments pour ne nommer que quelques uns, jʼai toujours été convaincu de lʼimportance du processus pédagogique dans la réalisation de son propre logiciel, donc jʼai écrit mon propre environnement Jabalion. Cet écrit peut ressembler à un manuel du logiciel, jʼen suis conscient mais je me sens obligé de rendre compte du processus dʼécriture, de conception, de construction et de mise en marche du logiciel. Dʼautant plus que les sources francophones académiques concernant SuperCollider sont encore très rares. Quelles sont les caractéristiques de cet outil informatique? Ecrire cet environnement permettant le couplage entre l'ordinateur, les sources acoustiques et les interfaces de contrôle, exige une planification où les perspectives et les attentes de fonctionnement sont prévues clairement depuis le départ. Une première question concerne l'interactivité. Deux chemins se présentent comme choix très différents. Je vais les illustrer avec le travail de deux musiciens, le premier : George Lewis tromboniste, improvisateur membre du AACM à Chicago (Association for the Advancement of Creative Musicians) qui a consacré une partie très importante de sa recherche au développement du logiciel « voyageur » fondé sur le paradigme de « machine listening » où l'ordinateur reçoit des informations sur le jeu du musicien et propose des réponses sonores incluant une certaine logique musicale. Ce qui m'intéresse dans sa démarche, cʼest le degré d'autonomie de l'ordinateur, car comme l'explique Lewis lui même :


5

« ... je n'aime pas jouer des concerts en trombone solo, je préfère jouer avec quelqu'un d'autre, je cherche à faire un logiciel pour comprendre quelles sont les choses qu'un improvisateur doit connaître pour réussir à improviser avec un autre musicien... » 3 Il cherche donc à avoir un outil qui possède en amont un ensemble de modèles de comportement pour produire une réponse musicale au jeu (la machine connaît ou reconnaît la musique!). En d'autres mots, une fois le logiciel démarré, il doit agir comme un deuxième musicien qui écoute, agit et propose. C'est aussi l'inquiétude de Gerard Assayag et son groupe de recherche autour du logiciel « Omax » sur lequel je reviendrai plus loin, qui combine la puissance d'analyse de Lisp avec le traitement de signal en Max. En face de cette « autonomie », nous avons le cas d'un logiciel où le contrôle de ses opérations est totalement déterminé par les commandes en temps réel du musicien. C'est le cas dans les « IXIQuarks » (une série de modules interconnectés par busses de contrôle et de signaux) où la machine répond pas à pas aux informations données par lʼinterprète. Cʼest à dire pas de commande ou de geste modificateur donc pas de réponse sonore. Bien que dans les deux cas on cherche à faire de la musique avec la machine, qui « attend » le déclenchement du musicien, le degré d'intelligence de la machine ou la capacité à prendre des décisions, ou encore à les apprendre, permet d'éclaircir et comprendre la différence profonde de ces deux perspectives. Dans la première, la machine est en quelque sorte maître-esclave dʼelle même, dans la deuxième la machine est « l'esclave » suivant les ordres du « maître » musicien interprète. Jouer avec l'ordinateur qui « agit » permet une indépendance dans le jeu, par exemple, je joue une note : les opérations faites sur cette note suivent des algorithmes écrits à l'avance, dont je pourrais prédire le résultat, mais si je joue spontanément une combinaison plus complexe de notes, je ne peux pas être complètement sûr de la proposition résultante mais je peux la connaître à peu près, donc un facteur surprise ou inconnu peut jouer un rôle déterminant. Dans l'ordinateur qui « obéit », le musicien joue une note puis commande au logiciel les traitements qui vont suivre à chaque événement. Ceci demande au musicien d'être concentré à la fois dans la partie instrumentale et dans les opérations logicielles. Lʼutilisation de ces logiciels nʼest pas aussi dichotomique quʼelle semble lʼêtre, et

3 Curtis. ROADS, « Improvisation with George Lewis » éditions. Composers and the Computers Los Altos, CA: William Kaufmann, 75-87. 1985.


6

des solutions intermédiaires sont possibles, grâce à des automatisations qui rendent les tâches, et la quantité d'informations plus légère. Par exemple : je joue ma note et je déclenche un ensemble de courbes qui vont contrôler les paramètres dʼun filtre jusqu'à ce que lʼon décide de l'arrêter. Ceci demande une longue tâche de calibrage mapping et de sauvegarde de configurations en presets. Dʼautre part il est évident que dans le logiciel de Lewis, il serait très compliqué, voir impossible, d'établir de nouvelles lois de comportement au cours du jeu. Une autre possibilité est de rendre le contrôle de la partie logicielle à un autre musicien, ceci permet de pouvoir se concentrer profondément dans le jeu et le langage, et d'être dans une situation plus proche de la musique de chambre. Je vais donc exclusivement traiter du cas de lʼordinateur contrôlé, dʼoù l'absence dans les programmes que je présente pour ce mémoire, d'algorithmes d'apprentissage ou du type oracle ou prédictions statistiques ou encore des prises autonomes de décisions. Je me suis concentré à faire un mapping ouvert de chaque paramètre de contrôle, pour pouvoir les piloter de différentes façons : avec un contrôleur MIDI, ou un ensemble des capteurs, ou des courbes estoquées dans des tables ou dessinées à la main, ou avec les données issues d'une analyse spectrale. Dʼautres caractéristiques bien quʼévidentes doivent être prises en compte, par exemple : une interface graphique simple et claire, un contrôle précis des dynamiques, de positions ou trajectoires spatiales, possibilité dʼenregistrer et automatiser pour jouer avec la forme et la mémoire, possibilités de développer, varier ou contraster les matériaux musicaux. Pourquoi « pour l'improvisation »? L'improvisation musicale est un sujet très intéressant et délicat à traiter, car il s'agit d'une discipline hautement subjective et dont la définition est dépendante de la pratique de chaque artiste. De plus, le contexte dans lequel il joue - par exemple lʼimprovisation très présente dans la musique de lʼInde - sʼéloigne dans les méthodes, les principes, lʼusage et même dans les buts de lʼimprovisation dite « libre » pratiquée dans plusieurs pays européens. Sujet mystique à caractère religieux pour certains, ou activité ludique et pédagogique pour d'autres, ou comme Georges Lewis aime bien le dire « une façon de vivre »4 ; en tant que musiciens nous avons tous été concernés en différentes circonstances et à des échelles différentes par cette discipline. Une dualité souvent évoquée est celle du couple « improvisation vs 4 Gerorges LEWIS, Colloque « Analyser l’improvisation » IRCAM, Paris Février 2010


7

composition ». On parle de composition instantanée ou de création spontanée, mais la frontière commence à apparaître quand on considère une improvisation comme une œuvre achevée en elle même ou comme un processus précompositionnel qu'il faut travailler, répéter et modeler par l'écriture. Du côté auditeur, cette opposition nʼest toujours pas évidente car certaines improvisations sonnent comme des compositions largement travaillées (synchronisation rythmique, formes nettes...) et à son tour une écriture très ouverte (les scores graphiques...) donne comme résultat des interprétations tellement différentes de la même pièce qu'on a le sentiment d'une musique qui sʼinvente à chaque fois donc improvisée. Le point de rencontre entre ces deux mondes (écriture, improvisation) est la recherche esthétique du concept dʼœuvre ouverte, (dʼindétermination ou de liberté formelle, interprétative) en parlant de lʼopposition dʼune poétique de la multiplicité du sens, contre une théorie des formes finies ou fermées. Umberto Eco souligne dʼailleurs à ce sujet: « Cette poétique de lʼunivoque et du nécessaire recouvre un monde ordonné, une hiérarchie des êtres et des lois quʼun même discours poétique peut éclairer à plusieurs niveaux mais que chacun doit entendre dans la seule perspective possible, qui est celle du logos créateur. Lʼordre de lʼœuvre dʼart se confond avec celui dʼune société impériale et théocratique ; les lois qui président à la lecture sont celles-là même dʼun gouvernement autoritaire qui guide lʼhomme dans chacun de ses actes en lui prescrivant les buts à atteindre et en lui offrant les moyens dʼy parvenir »5 Un des traits distinctifs de l'improvisation sera donc son éloignement de l'écriture, non pas radicalement - comme Barb Phillips qui a déclaré lors d'une « master class » au conservatoire de Paris, avoir décidé de ne plus jouer une partition depuis plus de 40 ans6- mais dans une progression à plusieurs degrés : c'est à dire que plus on perd de contrôle sur le papier en effaçant des paramètres, plus on est dans le monde de l'improvisation. Par exemple, si on n'écrit pas la dynamique, ou si on utilise des boîtes aléatoires avec des hauteurs mais pas des rythmes ou le contraire, ou si on ne précise pas les durées des sections ou l'ordre d'enchaînement, si on nʼécrit qu'une suite d'accords ou voire seulement quelques indications poétiques, ou voire des indications graphiques, l'interprétation devient un exercice de composition7. 5 Umberto ECO « L’œuvre ouverte » Editions du seuil 1965, traduit de l’italien par Chantal Roux de Bézieux. Titre original « Opera Aperta » 6 Conservatoire National Supérieur de Musique et Danse de Paris, classe d’improvisation Générative, Masterclass Barb Phillips, 2007 7 Pour une étude musicologique sur l'écriture contemporaine l'ouvrage de Dominique et Jean Yves Bosseur "Révolutions Musicales" chez Minerve 1999. Offre un large aperçu


8

Ce rapport à l'écriture peut aussi se présenter sous un autre aspect : la minimisation du temps de création et d'interprétation. Dans le contexte de musiques improvisées, le temps de création est celui de lʼinterprétation : cʼest à dire quʼils sont fusionnés, toutes les opérations musicales sont faites en temps réel. Nous avons d'autres contraintes différentes à celles imposées pour le travail en studio où en face du papier. Ce fameux « temps réel » basé dans la puissance de calcul des processeurs a donné lieu à tout un développement hardware et software pour résoudre les paradigmes de la musique mixte : captation, traitement, diffusion, et pose des défis à lʼesthétique musicale dans les concepts fondamentaux comme celui de structure et forme, dans le vocabulaire sonore avec lʼexploration et le maniement du matériau sonore et lʼidée « politique » de création collective8. L'improvisation est pour moi un outil de recherche à la fois esthétique et organologique mais aussi une discipline dʼécoute individuelle et collective, intérieure et musicale, raisons pour lesquelles je lui ai consacré ce travail. Le plan Après une brève introduction à la syntaxe de SuperCollider, je vais décrire et explorer l'architecture de Jabalion, parcourant certaines techniques de synthèse, et de traitement du signal, puis les outils pour organiser et acheminer les signaux audio et contrôle. Je vais aussi étudier l'interface graphique, une composante clé dans ce type de projets. En suite je vais comparer lʼexpérience de réalisation dʼun tel travail sur MAXMSP, les différences, les atouts et les difficultés dʼun langage du type objets graphiques, logique totalement différente dʼune programmation du type texte. Finalement jʼaccompagne ce travail avec une série dʼexemples tirés de ma pratique professionnelle.

8 Je me permets d’énoncer cette idée très personnelle car depuis mon expérience en tant qu’improvisateur et dans le milieu de la création j’ai pu constaté comme le poids culturel de notre société joue dans la définition et le sens de propriété dans les créations musicales. On n’écrit pas à plusieurs et les droits d’auteur nous poussent à une jalousie sur les œuvres, il faut respecter la signature (…) Je vois un danger dans l’idolâtrie de l’individu créateur tout puisant et infiniment intelligent. Il ne s’agît pas non plus d’une opposition radicale entre composition et improvisation, car il est clair que la libre improvisation connaît des limites : quand le nombre de musiciens arrive à la dizaine, l’écoute est plus difficile, l’anarchie sonore devient courante, les principes d’auto-organisation formels sont brouillés et le groupe finit souvent par se scinder. C’est une des raisons qui a permis de développer des théories comme le « SOUND PAINTING OR LIVE COMPOSITION » par Walter Thompson. Ou le directeur improvisateur, Agusti Fernandez à l’ESMUC de Barcelone, ou bien le projet « COBRA » où John Zorn dirige une improvisation d’un BigBand, en proposant des combinaisons et des états. Sur ce point je reconnais l’habileté des compositeurs pour gérer les grands formats et les grandes formes. Aussi, je ne voudrais pas non plus aller jusqu’à nier le plaisir de l’écriture et du projet compositionnel, simplement je remarque que le monde de l’improvisation nous aide à lever des mythes et regarder plus humblement l’acte créateur.


9

2."JABALION" IMPLEMENTATION SUR SUPERCOLLIDER 3 Dans les chapitres que suivent, je vais présenter le logiciel Jabalion écrit dans SuperCollider. Pour ceci, je commence en parlant de lʼenvironnement logiciel puis je passe à une description du code (le code en entier fait lʼéquivalent dʼune cinquantaine de pages), dont jʼen ai extrait et commenté les parties les plus importantes, par exemple les synthétiseurs, le contrôle et lʼinterface graphique. Bien que toute cette section peut paraître un peu austère et difficile à lire pour la syntaxe du code, jʼétais obligé dʼy passer, autrement la partie la plus intéressante et à laquelle jʼai dédié le plus dʼénergie, la programmation et lʼécriture informatique, passerait sous lʼombre. Donc pour mettre en valeur lʼobjet de ce mémoire, le travail de programmation, jʼai alterné la description des concepts techniques et le code écrit pour chaque concept. Jʼespère aussi que cette présentation de mon approche dans lʼécriture servira à ceux intéressés dans ce type de langage. Les sources en langue française sont très rares pour ce type de logiciel où lʼanglais lʼemporte comme langue principale tant dans les forums de discussion dʼutilisateurs que dans celui de développeurs, ainsi que pour les tutoriaux, livres et documents référentiels. Donc ce mémoire peut maintenant compter parmi ces sources.

2.1. SuperCollider

SuperCollider 3 est un puissant et flexible langage de programmation "orienté objets" pour synthèse et traitement du son et de l'image. Il a été développé par James McCartney, sa syntaxe et ses librairies des fonctions sont dérivées de SmallTalk et C++, il a été mis en circulation en 1996 sur sa version 2 puis en 2002 publié sous GNU (General Public License). La dernière version 3.3 datant d'avril 2009. SuperCollider 3 est en fait deux applications tournant en même temps : sclang et scsynth, le langage et le moteur de synthèse, les deux applications communiquant à travers un réseau via UDP ou TCP et un utilisant un sous-ensemble du protocole Open Sound Control (OSC) développé par le CNMAT. Cette architecture permet d'envoyer des messages au moteur de synthèse dans deux styles différents :

• Directement : en utilisant la méthode ".sendMsg" sur une instance de " Server " et en utilisant la syntaxe OSC.

• Indirectement : en utilisant la syntaxe propre au sclang que permet de suivre et manipuler les objets créés dans le serveur : "Server". Ainsi sclang traduit cette syntaxe haut niveau dans des messages OSC de bas niveau et des envois au serveur.


10

Par exemple, les deux types de syntaxe suivants sont équivalents : Créer une instance de "Server", le démarrer, créer un synthétiseur (celui définie par défaut) et l'assigner un identifiant dans l'arborescence de synthèse, puis l'arrêter. style OSC s = Server.default; s.boot; s.sendMsg(\s_new,\default,1001,1,1); s.sendMsg(\n_free,1001); style sclang s = Server.default; s.boot; x = Synth("default") ; x.free; En étant équivalents, le choix entre les deux peut obéir à des raisons de contexte ou de goût personnel. D'autres logiciels (MAXMSP PureData) capables d'utiliser le protocole OSC peuvent aussi envoyer des messages directement au scsynth. Pour faciliter la lecture de mes exemples et clarifier la syntaxe, voici quelques conventions dans la typographie. Le code sera écrit dans la police Monaco 10 window = GUI.window.new("JabaLion", Rect(6, 6, 260, 230)).front; Une "classe" commence toujours par une majuscule (ex : Server) La classe est une structure informatique particulière dans le langage objet. Elle décrit la structure interne des données, et elle définit les méthodes qui s'appliqueront aux objets de même famille (même classe) ou type. Elle propose des méthodes de création des objets dont la représentation sera donc celle donnée par la classe génératrice. Les objets sont dits alors instances de la classe. C'est pourquoi les attributs d'un objet sont aussi appelés variables d'instance et les messages opération d'instance ou encore méthodes d'instance. L'interface de la classe (l'ensemble des opérations visibles) forme les types des objets. Une variable locale est définie par le caractère « ~ » ~myvariable = 888; équivalent à : currentEnvironment.put(\myvariable, 888);


11

Les symboles sont précédés par le caractère « \ », ou entre guillemets simples « ' ' » et dans la syntaxe colorée ils deviennent verts. Un symbole est un nom unique garanti comme unique, ils peuvent être utilisés pour représenter des valeurs constantes, des entrées dans des dictionnaires, des noms de synthétiseurs... \granulator 'granulator' Un vecteur de caractères ou "string" est écrit entre guillemets doubles et est coloré dans la syntaxe en gris. "ceci est un vecteur de caractères".postln Les commentaires à l'intérieur du code sont précédés par « // » ou en commençant et en finissant par /* ... */ Ils seront colorés en rouge. // sc libeary file Automation,MP3,FileListView,Arduino; /* Document.current.bounds_(Rect(2, 141, 940, 640)); s.options.device = "Digidesign HW ( MBox )" s.boot; { SinOsc.ar(440, 0, 0.5) }.play; */ Les parenthèses « () » servent à définir des bloques de code exécutable ou pour passer des valeurs ou arguments à des fonctions (~values.matrixprocessing.integrateRow_(12)) Les vecteurs sont écrits à l'intérieur de crochets « [] », un vecteur est une collection d'objets de nature similaire ou différente. [["On",Color.white,Color.green],["Off",Color.white,Color.red]] Les fonctions sont écrites à l'intérieur d'accolades « {} » {~values.matrixoutputs.front_(true)}.value; Les arguments dans une fonction sont précédés par le mot-clé arg ou écrits à l'intérieur de barres verticales « || » ~values.ucontrol.setAction_(1,12,{arg ez; ~values.complexattack.setreal_(ez.value)}); ~values.ucontrol.setAction_(1,12,{|ez| ~values.complexattack.setreal_(ez.value)});


12

Les variables dans une fonction sont déclarées et précédées par le mot-clé var var server = Server.local,window,devices=ServerOptions.devices Dans une classe les chevrons <> servent à définir les méthodes "get " > ou "set" < AudioStereo { var adcwindow,<>play,levelsadcviews,<>ezvol; ...} AudioStereo.play; AudioStereo.play_(value); Arborescence de synthèse : ordre d'exécution L'ordre d'exécution est un des points critiques en SuperCollider, il ne se réfère pas à l'ordre d'exécution d'assertions dans le langage mais à l'ordre de nœuds de synthèse dans le serveur, c'est à dire l'ordre dans lequel leur sortie est calculée à chaque cycle de contrôle (blockSize) ainsi chaque synthé est placé dans un lieu unique et spécifique dans la chaîne d'exécution. Par exemple : NODE TREE Group 0 1 group 1001 default 1002 fm 2 group 1003 granulator Ceci veut dire que toutes les unités génératrices du synthé default placé dans le premier groupe avec l'identifiant (id) 1001 seront calculées avant celles du synthé fm ou id 1002 à chaque cycle. Ce fait est crucial dans le traitement du signal car si par exemple le granulator 1003 arrivait avant le groupe 2, on n'aurait pas le traitement car le synthé granulator resterait toujours à l'attente du son à traiter car la sortie du default et fm ne serait calculée qu'après. SuperCollider propose donc plusieurs messages et commandes pour organiser et placer les nœuds et les groupes des nœuds dans l'ordre désiré. Dans le groupe de discussion organisé par l'université de Birmingham, il y a aussi l'idée d'implémenter une méthode « order » pour le Serveur qui permettrait de faciliter la tâche en envoyant un vecteur du type "[id synth, new id]". Méthode qui existe déjà dans la librairie JIT (Just In Time Programming) et qui utilise et étend les possibilités des espaces proxies dans SuperCollider.


13

Dans mon implémentation, j'utilise InFeedback.ar qui permet de récupérer des signaux qui sont plus tard dans l'arbre de synthèse. Toutefois, l'ordre auquel les synthés sont créés dans le serveur est capital pour un fonctionnement correct du programme et il faut rester vigilant.

2.2. Synthétiseurs et moteurs de Synthèse

La classe Synth dans SuperCollider est la représentation dans le langage d'un nœud de synthèse dans le serveur. Un Synth représente une unité produisant du son. Les opérations que cette unité réalise sont définies avec la classe SynthDef où les UGens (unités génératrices) sont spécifiées et connectées et aussi les types d'entrés et sorties qu'aura le synthé. Un SynthDef est une sorte de modèle fixe sur lequel les Synth sont basés. Dans Jabalion j'utilise 17 synthés différents pour accomplir les tâches de production et traitement sonore. Ces dix-sept synthés sont divisés en deux groupes, les sources et les traitements, dans les sources il y aura : - deux entrées analogiques - cinq lecteurs d'archives - trois algorithmes de synthèse : modulation de fréquence, synthèse dynamique stochastique. Pour connaître ou spécifier l'endroit où le programme sauvegarde les synthés, exécuter : SynthDef.synthDefDir Voici le synthé #1 qui permet d'avoir deux entrées analogiques.

2.2.1. Entrées Analogiques

// ADC audio in SynthDef(\AudioIn, {|inBus=0,vol=1, out1=20,out2=21,out3=22,out4=23,out5=24,out6=25,out7=26,out8=27, out9=28,out10=29,out11=30,out12=31,out13=32,out14=33,out15=34, amp1=0,amp2=0,amp3=0,amp4=0,amp5=0,amp6=0,amp7=0,amp8=0,amp9=0,amp10=0,amp11=0,amp12=0,amp13=0,amp14=0,amp15=0| var sig,imp,delimp,env,mix,ch1,ch2,ch3,ch4,ch5,ch6,ch7,ch8,ch9,ch10, ch11,ch12,ch13,ch14,ch15;


14

imp = Impulse.kr(10); delimp = Delay1.kr(imp); env = Linen.kr(gate, 2, 1, 2, 2); sig = SoundIn.ar(inBus); sig = sig * vol * env; mix = [sig*amp1,sig*amp2,sig*amp3,sig*amp4,sig*amp5,sig*amp6,sig*amp7, sig*amp8,sig*amp9,sig*amp10,sig*amp11,sig*amp12,sig*amp13,sig*amp14,sig*amp15]; #ch1,ch2,ch3,ch4,ch5,ch6,ch7,ch8,ch9,ch10,ch11,ch12,ch13,ch14,ch15 = DistributedOut.ar([out1,out2,out3,out4,out5,out6,out7,out8,out9,out10, out11,out12,out13,out14,out15],mix); SendReply.kr(imp,'levels', [Amplitude.kr(sig),K2A.ar(Peak.ar(sig, delimp).lag(0, 3))]); }).writeDefFile(SynthDef.synthDefDir) Regardons quelques détails du code. Le nom du synthé est déclaré comme un symbole (\AudioIn), il suivent les arguments, numéro du bus audio d'entrée, les canaux de sorties, le niveau de chaque canal, puis le variable où je déclare par exemple sig qui n'est autre que le convertisseur audio numérique des entrées analogiques de la carte son. J'ai été amené à écrire une classe DistributedOut pour avoir un accès facile aux sorties de chaque synthé et ainsi avec l'aide d'une matrix diriger les signaux dans des buses pour établir un mapping et contrôler l'arborescence de synthèse. Ce à quoi sert cette classe est de recevoir un vecteur de canaux et d'amplitudes non conjoints et de les assigner à des buses audio, ces signaux seront acheminés vers les entrées de synthés traitement ou directement vers les sorties (8) de la carte son. Un autre point commun à tous mes synthés est l'affichage graphique du niveau de sortie. Pour ceci j'utilise la classe SendReply qu'envoie un message osc ('levels') de l'amplitude instantanée avec des pics (Amplitude, Peak) à un taux déterminé (ici tous le 100 ms) produit par l'oscillateur d'impulses, à l'interface graphique. La classe K2A convertit des signaux à taux contrôlé vers le taux audio. Les UGens (Unités génératrices) sont les bloques basiques pour la construction de synthés dans le serveur et sont utilisés pour générer ou traiter les signaux d'audio et de contrôle (avec le message .ar (audio rate) ou .kr (control rate). Ils fonctionnent à des taux différents : 44100, 48100... échantillons par seconde pour l'audio, 690 pour le taux de contrôle ou un valeur tous le 64 valeurs de l'audio rate). Chaque synthé a aussi une enveloppe simple (env) pour adoucir les entrées et les extinctions du synthé : env = Linen.kr(gate, 2, 1, 2, 2); les arguments correspondent à : Linen.kr( gate = 1.0, attackTime = 0.01, susLevel = 1.0, releaseTime = 1.0, doneAction = 0 ) l'argument "donneAction" permet de déterminer une action à accomplir lors de la fin de l'enveloppe ainsi :


15

0 ne rien faire 1 pause le synthé mais ne le libère pas 2 libère le synthé 3 libère le synthé et le nœud précédent 4 libère le synthé et le nœud suivant 5 libère le synthé, si le nœud précédent est un groupe donc libère-le 6 libère le synthé, si le nœud suivant est un groupe donc libère-le 7 libère le synthé et tous les nœuds précédents dans ce groupe 8 libère le synthé et tous les nœuds suivants dans ce groupe 9 libère le synthé et pause le nœud précèdent 10 libère le synthé et pause le nœud suivant 11 libère le synthé et tous les groupes précédents 12 libère le synthé et tous les groupes suivants 13 libère le synthé et tous les groupes précédents et suivants 14 libère tous les groupes et tous les nœuds La méthode .writeDefFile permet d'écrire cette définition dans le disque dur et ainsi on peut créer des instances de cette définition sans les déclarer à chaque fois, car au démarrage du serveur elles sont automatiquement chargées. Le synthétiseur numéro 2 est celui qui me permet de lire des archives sonores

2.2.2. Lecture de fichiers sons

// Lecteur de Fichiers Sons SynthDef(\samples, {|bufnum=0,rate=1,t_trig=1,start=0,end=1,vol=1,loop=1,t_gate=1, numchannels=1,dur=1,out1=20,out2=21,out3=22,out4=23,out5=24,out6=25,out7=26,out8=27,out9=28,out10=29,out11=30,out12=31,out13=32,out14=33, out15=34,amp1=0,amp2=0,amp3=0,amp4=0,amp5=0,amp6=0,amp7=0,amp8=0,amp9=0,amp10=0,amp11=0,amp12=0,amp13=0,amp14=0,amp15=0| var sig,val,phase,imp,delimp,env,ch1,ch2,ch3,ch4,ch5,ch6,ch7,ch8,ch9, ch10,ch11,ch12,ch13,ch14,ch15; val = BufFrames.kr(bufnum); imp = Impulse.kr(10); delimp = Delay1.kr(imp); env = Env.linen(0.2,dur,0.2,1,'welch'); phase=Phasor.ar(t_trig,BufRateScale.kr(bufnum)*rate,start*val,end*val);


16

sig = BufRd.ar(1,bufnum,phase,loop,4); sig = sig * (EnvGen.kr(env,t_gate,doneAction:2)); sig =sig*vol; SendReply.kr(imp, 'phasor', phase); SendReply.kr(imp,'levels', [Amplitude.kr(sig),K2A.ar(Peak.ar(sig, delimp).lag(0, 3))]); sig=[sig*amp1,sig*amp2,sig*amp3,sig*amp4,sig*amp5,sig*amp6,sig*amp7, sig*amp8,sig*amp9,sig*amp10,sig*amp11,sig*amp12,sig*amp13,sig*amp14,sig*amp15] #ch1,ch2,ch3,ch4,ch5,ch6,ch7,ch8,ch9,ch10,ch11,ch12,ch13,ch14,ch15 = DistributedOut.ar([out1,out2,out3,out4,out5,out6,out7,out8,out9,out10,out11,out12,out13,out14,out15],sig); }).writeDefFile(SynthDef.synthDefDir); Ce synthé lit un buffer chargé en mémoire avec une indexation produit par un oscillateur Phasor sur lequel on peut contrôler la fréquence donc la vitesse de lecture du fichier, le point de départ et le point de fin en frames (quantité d'échantillons fois les canaux). La classe BufFrames retourne la quantité des frames dans le buffer et la classe BufRateScale permet de varier la vitesse de lecture du buffer. Autre détail est l'argument t_trig est t_gate qui déclenchent l'oscillateur ou l'enveloppe à chaque fois qu'on les appelle trigger sans le préfixe t_ les déclenchements n'auraient lieu quʼà chaque transition, des valeurs négatives vers des valeurs positives.

2.2.3. Synthèse

Les trois synthés suivants produisent des données audio en utilisant trois algorithmes différents de synthèse.

2.2.3.1. Modulation de Fréquence

// FMPlayer SynthDef(\fm,{|gate=1,rate=20,freq=440,modfreq=200, index, amp, dur=0.2 out1=20,out2=21,out3=22,out4=23,out5=24,out6=25,out7=26,out8=27, out9=28,out10=29,out11=30,out12=31,out13=32,out14=33,out15=34, amp1=0,amp2=0,amp3=0,amp4=0,amp5=0,amp6=0,amp7=0,amp8=0,amp9=0,amp10=0,amp11=0,amp12=0,amp13=0,amp14=0,amp15=0| var sig,imp,delimp; var ch1,ch2,ch3,ch4,ch5,ch6,ch7,ch8,ch9,ch10,ch11,ch12,ch13,ch14,ch15;


17

sig = FMGrain.ar(Impulse.ar(rate),dur,freq,modfreq,index, EnvGen.kr(Env([0, 1, 0], [1, 1], \sin, 1),gate,doneAction: 2))*amp; imp = Impulse.kr(10); delimp = Delay1.kr(imp); SendReply.kr(imp, 'levels',[Amplitude.kr(sig), K2A.ar(Peak.ar(sig, delimp).lag(0, 3))]); sig = [sig*amp1,sig*amp2,sig*amp3,sig*amp4,sig*amp5,sig*amp6,sig*amp7, sig*amp8,sig*amp9,sig*amp10,sig*amp11,sig*amp12,sig*amp13,sig*amp14, sig*amp15]; #ch1,ch2,ch3,ch4,ch5,ch6,ch7,ch8,ch9,ch10,ch11,ch12,ch13,ch14,ch15 = DistributedOut.ar([out1,out2,out3,out4,out5,out6,out7,out8,out9,out10,out11,out12,out13,out14,out15],sig); }).writeDefFile(SynthDef.synthDefDir) ; Ce synthé basé sur le paradigme de la modulation de fréquence9 a pour UGen principale FMGrain écrite par Joshua Parmenter de l'Université de Washington, et fait partie d'une librairie sur la synthèse granulaire. Il sʼagit donc dʼune combinaison de deux techniques, la modulation de fréquence et la synthèse granulaire. Je lʼai choisi par le résultat sonore très riche et sa simplicité pour être intégré dans un environnement multi traitement comme Jabalion. Cette classe a pour arguments : *ar(trigger, dur, carfreq, modfreq, index, mul, add) ;

Le trigger que retourne un nouveau grain à chaque impulsion, dur qui représente la taille du grain, puis pour chaque grain carfreq ou Fréquence Porteuse, modfreq ou Fréquence Modulante, index de modulation ou profondeur et comme dans tous les UGens dans SuperCollider mul et add, mul est un facteur multiplicateur de la sortie, c'est à dire dans de signaux audio le résultat sera un incrément de niveau, le valeur par défaut est 1, ainsi le signal oscille entre -1 et 1, 0 étant le silence. add est un facteur qui s'ajoute ou se somme à la sortie, ceci est intéressant pour le calibrage des signaux contrôle pour les limiter dans une échelle des valeurs. Celui-ci est un synthétiseur très puissant du point de vue expressif car chaque modification dans les paramètres est très saisissante pour la perception. Comme je vais lʼexpliquer plus loin tous les paramètres de contrôle ont été normalisés entre 0 et 1, ceci oblige à manier des valeurs relatives sur le synthétiseur plus que de valeurs absolues. Par exemple les fréquences porteuse et modulante oscillent entre 20Hz et 20kHz mais une interpolation exponentielle permet de passer à des valeurs de 0 et 1 faisant le contrôle plus intuitif que mathématique.

9 Les implications musicales de la synthèse par modulation de fréquence ont été étudies par John Chowning dans les années soixante-dix à l’université de standford et une partie de ses résultats figure dans « Synthesis of Complex Audio Spectra by Means of Frequency Modulation » dans le journal of the audio engineering society 21 (7) 1973.


18

2.2.3.2. Gendy

SynthDef(\gendy, {|gate=1,ampdist=1,durdist=1,adparam=1,ddparam=1, minfreq=30,maxfreq=100,ampscale=0.3,durscale=0.05,initCPs=5,knum=12, vol=1.0, out1=20,out2=21,out3=22,out4=23,out5=24,out6=25,out7=26,out8=27, out9=28,out10=29,out11=30,out12=31,out13=32,out14=33,out15=34, amp1=0,amp2=0,amp3=0,amp4=0,amp5=0,amp6=0,amp7=0,amp8=0,amp9=0,amp10=0,amp11=0,amp12=0,amp13=0,amp14=0,amp15=0| var sig,imp,delimp; var ch1,ch2,ch3,ch4,ch5,ch6,ch7,ch8,ch9,ch10,ch11,ch12,ch13,ch14,ch15; sig = Gendy1.ar(ampdist, durdist, adparam, ddparam, minfreq, maxfreq, ampscale, durscale, initCPs,knum, EnvGen.kr(Env([0, 1, 0], [1, 1], \sin, 1),gate,doneAction: 2),0) * vol; imp = Impulse.kr(10); delimp = Delay1.kr(imp); SendReply.kr(imp, 'levels',

[Amplitude.kr(sig), K2A.ar(Peak.ar(sig, delimp).lag(0, 3))]); sig = [sig*amp1,sig*amp2,sig*amp3,sig*amp4,sig*amp5,sig*amp6,sig*amp7, sig*amp8,sig*amp9,sig*amp10,sig*amp11,sig*amp12,sig*amp13,sig*amp14, sig*amp15]; #ch1,ch2,ch3,ch4,ch5,ch6,ch7,ch8,ch9,ch10,ch11,ch12,ch13,ch14,ch15 = DistributedOut.ar([out1,out2,out3,out4,out5,out6,out7,out8,out9,out10,out11,out12,out13,out14,out15],sig); }).writeDefFile(SynthDef.synthDefDir)) Ce synthétiseur est une implémentation de la synthèse dynamique stochastique, décrite par Iannis Xenakis dans "Formalized Music"10. Le programme de base a été écrit par Marie-Helene Serra. La méthode consiste à calculer chaque période de la forme d'onde à l'aide des distributions stochastiques. Les variables sont : la quantité des points sur lesquelles on pourra contrôler les positions bidimensionnelles dans un plan où les ordonnées représentent l'amplitude et les abscisses le temps, les limites maximum et minimum pour l'ensemble des points et le type de distribution dans les options suivantes : 0- LINEAR, 1- CAUCHY, 2- LOGIST, 3- HYPERBCOS, 4- ARCSINE, 5- EXPON, 6- SINUS Ainsi, une fois calculée la première période d'onde, chaque point suit l'opération de distribution et obtient une nouvelle valeur. Cette période en millisecondes sera égale à la somme des positions de chaque point sur l'axe des "x" et peut être normalisé de façon à avoir une périodicité mais un contenu spectral très complexe.

10 Iannis XENAKIS dans "Formalized Music" 1992, Stuyvesant, NY: Pendragon Press chapitre 9 (pp 246-254) et chapitres 13 et 14 (pp 289-322).


19

Le graphique suivant est une illustration de ce procédé. On peut constater comme la forme dʼonde varie un peu capricieusement ce qui produit des sons très riches et vivants quand on les enchaîne. La longueur et donc la période de chaque variation est modifiée avec le même procédé stochastique.

Figure 1 Formes d’ondes obtenues avec le procédé stochastique employé en Gendy


20

2.2.3.3. k-means

Passons maintenant au dernier procédé de synthèse utilisé dans ce travail. Il sʼagit de k-means, encore une technique basée dans un procédé de calcul de probabilités : Le partitionnement de données (data clustering en anglais) est une méthode statistique d'analyse des données qui a pour but de regrouper un ensemble de données en différents paquets homogènes, en ce sens que les données de chaque sous-ensemble partagent des caractéristiques communes, qui correspondent le plus souvent à des critères de proximité que l'on définit en introduisant des mesures de distance. Cʼest à dire à partir dʼun flux aléatoire on répète itérativement un regroupement des données dans un espace à deux dimensions pour obtenir de formes dʼonde, joués par un oscillateur. Cette technique est donc très proche dans le résultat sonore de ceux obtenus avec la synthèse dynamique stochastique de Xenakis. Les paramètres de contrôle de cet algorithme sont : freq- fréquence de lʼoscillateur numdatapoints- Nombre initial de points. maxnummeans- Maximum nombre de « means » ou mesures de distance nummeans- Nombre actuel de « means » tnewdata- Si un trigger est reçu réinitialiser le flux de données (k-rate) tnewmeans- Si un trigger est reçu réinitialiser means (k-rate) soft- Taux dʼactualisation de « means ». 1.0 actualisation immédiate, 0.0 pas dʼactualisation. bufnum- cette option permet dʼutiliser les donnés stockés dans un buffer comme point de départ pour les donnés sur lequel lʼopération de probabilité seront effectués. Ici le code pour lʼimplémentation de cet algorithme dans mon programme. // Kmeans SynthDef(\kmeans,{|gate=1, freq=220, nummeans=4, soft=0.01, rate=10, vol=0.1,out1=20,out2=21,out3=22,out4=23,out5=24,out6=25,out7=26, out8=27,out9=28,out10=29,out11=30,out12=31,out13=32,out14=33,out15=34, amp1=0,amp2=0,amp3=0,amp4=0,amp5=0,amp6=0,amp7=0,amp8=0,amp9=0,amp10=0,amp11=0,amp12=0,amp13=0,amp14=0,amp15=0| var sig,imp,delimp,env; var ch1,ch2,ch3,ch4,ch5,ch6,ch7,ch8,ch9,ch10,ch11,ch12,ch13,ch14,ch15; env = Linen.kr(gate, 2, 1, 4, 2); sig = Mix(vol*env*KmeansToBPSet1.ar(freq*[1,3/2,5/4,7/6],20,4,nummeans, Impulse.kr(0.2),Impulse.kr(rate),soft));


21

imp = Impulse.kr(10); delimp = Delay1.kr(imp); SendReply.kr(imp,'levels', [Amplitude.kr(sig),K2A.ar(Peak.ar(sig,delimp).lag(0, 3))]); sig = [sig*amp1,sig*amp2,sig*amp3,sig*amp4,sig*amp5,sig*amp6,sig*amp7, sig*amp8,sig*amp9,sig*amp10,sig*amp11,sig*amp12,sig*amp13,sig*amp14 sig*amp15]; #ch1,ch2,ch3,ch4,ch5,ch6,ch7,ch8,ch9,ch10,ch11,ch12,ch13,ch14,ch15 = DistributedOut.ar([out1,out2,out3,out4,out5,out6,out7,out8,out9, out10,out11,out12,out13,out14,out15],sig); }).writeDefFile(SynthDef.synthDefDir));

2.3. Traitements du Signal

Dans Jabalion il y a huit modules de traitement du signal et comme je lʼai mentionné plus haut, ces modules sont des nœuds de synthèse dans lʼarborescence de SuperCollider, donc dans le code ils sont aussi écrits comme synthétiseurs. - Pitch shifter. - Modulations. - Retardes modulés. - Réverbération. - Multi-delays. - Vocodeur de phase - Freezer et time stretching. - Granulateur. Dʼun point de vue technique ces modules sont des implémentations de différentes familles de traitements : de lignes à retard, modulations, transformés de Fourier et synthèse granulaire. Lʼordre indiqué ci-dessus est celui présenté dans le logiciel et si bien semble un peu arbitraire, il sʼest conformé dʼaprès une exploration de ces différentes techniques. Pour des raisons dʼanalyse et de clarté je vais les présenter ici en suivant le type de technique utilisé dans chaque algorithme : modulations, lignes à retard, transformées de Fourier et synthèse granulaire.


22

2.3.1 Modulations

Dans ce synthétiseur il sʼagit dʼune implémentation de la modulation dʼamplitude unipolaire. Toutes les composantes du signal sont « décalées » par un facteur fixe. // modulation d’amplitude et wah ( SynthDef(\modulations,{|inBus=22, gate=1, wet=1, modfreq=100, modlevel=0, lforate=1, filtfreq=100, lfovol = 1, out1=20,out2=21,out3=22,out4=23,out5=24,out6=25,out7=26,out8=27, out9=28,out10=29,out11=30,out12=31,out13=32,out14=33,out15=34, amp1=0,amp2=0,amp3=0,amp4=0,amp5=0,amp6=0,amp7=0,amp8=0,amp9=0,amp10=0,amp11=0,amp12=0,amp13=0,amp14=0,amp15=0| var sig,mix,ring,wah,mixwet; var imp,delimp,env,ch1,ch2,ch3,ch4,ch5,ch6,ch7,ch8,ch9,ch10,ch11,ch12, ch13,ch14,ch15; imp = Impulse.kr(10); delimp = Delay1.kr(imp); env = Linen.kr(gate, 2, 1, 4, 2); sig = InFeedback.ar(inBus); ring = FreqShift.ar(sig, modfreq,0) * modlevel; wah = RLPF.ar(sig, LinExp.kr( LFNoise1.kr(lforate), -1, 1, 200, filtfreq), 0.1) * lfovol; mix = Mix.new([ring,wah]); sig = (sig * (1 - (wet*env))) + (mix * (wet*env)); SendReply.kr(imp, 'levels', [Amplitude.kr(sig), K2A.ar(Peak.ar(sig, delimp).lag(0, 3))]); sig = [sig*amp1,sig*amp2,sig*amp3,sig*amp4,sig*amp5,sig*amp6,sig*amp7,sig*amp8,sig*amp9,sig*amp10,sig*amp11,sig*amp12,sig*amp13,sig*amp14,sig*amp15]; #ch1,ch2,ch3,ch4,ch5,ch6,ch7,ch8,ch9,ch10,ch11,ch12,ch13,ch14,ch15 = DistributedOut.ar([out1,out2,out3,out4,out5,out6,out7,out8,out9,out10,out11,out12,out13,out14,out15],sig); }).writeDefFile(SynthDef.synthDefDir) ); Ce synthétiseur réalise deux types de traitement, le signal dʼentrée « sig » est passé par la modulation dʼamplitude freqShift, La fréquence de modulation est contrôlée par la variable modfreq et le niveau par la variable modlevel. En parallèle le signal est routé à travers un filtre passe bas RLPF dont la fréquence de coupure meut entre une valeur maximum filterfreq et une valeur aléatoire


23

produit au taux lforate par lʼoscillateur LFNoise1. Ces valeurs sont interpolées par une ligne convertissant des valeurs linaires dans des valeurs logarithmiques LinExp. Cet effet dont on module la fréquence de résonnance dʼun filtre est connu comme « wah » Pour illustrer ces deux traitements et les exemples suivants, je vais utiliser un échantillon (son 1 plage1 CD) de son de guitare : un mi3 joué à la première corde à vide, enregistré avec un microphone statique cardioïde à 15 cm du point dʼattaque (12cm du chevalet) la fréquence dʼéchantillonnage est de 44.1 khz avec une résolution dʼamplitude à 16 bits; lʼenregistrement est normalisé et pour des raisons de facilité des calculs la durée a été fixée à1000 ms. Le sonagramme suivant illustre lʼeffet de « frequency shift ». Lʼanalyse est faite avec une taille de FFT de 4096 et un type de fenêtre «Hanning» le range fréquentielle de 0 à 12 khz et la durée est de 22 secondes.

Figure 2 Frequency Shift, déplacement spectral CD plage 2 Le son 1 est joué en bouclé, dans les deux premières attaques il nʼy a pas de traitement, cʼest la référence, à partir du troisième une modulation de 10 hz est introduite et mixé avec lʼarchive dʼorigine, la résolution fréquentielle de lʼanalyse ne permet pas de mettre en valeur cette variation mais sur les huit attaques qui suivent, une ligne entre 10 et 2000 hz contrôle la fréquence de modulation qui est clairement illustrée. À la quinzième seconde de lʼexemple la ligne recommence avant la seizième attaque. On constate sur le sonagramme que toutes les composantes du spectre sont décalées et le spectre originel diminue en amplitude.


24

Dans lʼexemple suivant le son 1 est joué en bouclé et traité par le filtrage du type wah décrit plus haut. La fréquence de coupure du filtre est réglée à 5khz. Les paramètres dʼanalyse sont les mêmes que pour lʼexemple précédent.

Figure 3 Modulations « wah » CD plage 3

Il y a cinq moments dans cet exemple : le premier est le son de référence (trois attaques), après le taux de variation pour lʼoscillateur aléatoire est réglé à 5% (six attaques), puis à 100% (six attaques), puis à 25% (trois attaques), 5%(trois attaques) et pour finir à 0% (deux attaques). Cet effet est très riche dʼun point de vue sonore car amène une certaine vie à lʼintérieur du spectre, il a été très exploité par exemple dans la musique rock11. Ici, le fait dʼavoir introduit un degré dʼimprévisibilité avec lʼoscillateur aléatoire permet de jouer sur la complexité du spectre en ajustant le taux de variation, tout en gardant un contrôle conscient du traitement.

2.3.2 Lignes à retard

Cette technique est très riche dans ces résultats sonores et produit donc une grande variété dʼeffets en suivant les valeurs du retard, lʼitération de ceux-ci et le taux de réinjection : échos, réverbération, modulations, filtrages. Quand la valeur du retard dépasse 50 ms (cette valeur de discrimination peut changer avec les sujets et le type de son étudié)12 une répétition, un écho devient clair ; entre 1 ms et 10 ms approximativement une modification spectrale du type filtrage (filtre un peigne) est perçu, ce sont les « delays » courts; entre 10 et 50 ms le mixage des deux signaux son direct son retardé, peut conduire à des annulations de phase. Cela se traduit par un éclaircissement de la fondamentale et de partiels supérieurs, cʼest une technique utilisé dans les effets de flanger et chorus.

11 MOORE Allan, Rock, « The Primary Text. Developing a musicology of rock », éditions Open University Press, 1994, Buckingham and Philadelphia. 12 ROADS Curtis, « The computer Musical Tutorial » The MIT press Cambridge 1996, Fixed Delay Effects, pag. 435


25

2.3.2.1 Réverbération

Mon premier exemple de ligne à retard est la réverbération, il sʼagit dʼun traitement très saisissable, car perceptivement il peut sʼassocier à un concept dʼespace. La réverbération est un effet physique produit par la réflexion des ondes sur des surfaces et donc arrivant à lʼauditeur avec de petits retards temporels par rapport au son direct. Le taux dʼarrivée de ces réflexions change dans le temps en fonction de la taille et la forme de lʼespace où le son se produit. Les paramètres de contrôle peuvent être très nombreux dans les simulations numériques de la réverbération, quelques fois en faisant allusion à des paramètres perceptifs ou des fois très techniques : temps de réverbération, facteur de diffusion, amortissement, taille de la salle, facteur dʼabsorption, « predelays », « gate time », « gate decay time », « gate threshold » et bien dʼautres. La réverbération est tellement usée dans le traitement du signal en studio et en concert que de nos jours les « de-réverbérators » ou « enleveurs » de réverbération en différentes formes algorithmiques ont vu le jour et sont devenus à la mode pour nettoyer les signaux13. Dans cette implémentation, jʼutilise un algorithme dʼaprès les travaux réalises par Manfred Schroeder14 des Laboratoires Bell et écrite en C++, de distribution libre appelé « Freeverb ». Pour simuler les effets de la réverbération, les algorithmes de Schroeder proposent l'utilisation de délais, de filtres passe-tout et de filtres en peigne. Les délais sont utilisés pour reproduire les réflexions primaires de la salle et les filtres sont ensuite connectés en série et en parallèle pour créer un nuage très dense de réverbération. Dans le diagramme des bloques que suit il y a donc quatre filtres passe-tout en série et huit filtres en peigne en parallèle pour chaque canal audio.

Figure 4 Diagramme des bloques réverbération d’après l’algorithme de SCHROEDER

13 « Signal-Based Performance Evaluation of Dereverberation Algorithms » Patrick NAYLOR, Nikolay GAUBITCH, and Emanuël HABETS. Communications and Signal Processing Group, Department of Electrical and Electronic Engineering, Imperial College, London. 14 SCHROEDER Manfred, « Natural sounding artificial réverbération », Journal of the Audio Engineering Society 10, 1961.


26

Le code suivant est lʼimplémentation de cette réverbération dont les paramètres de contrôle sont la taille de la salle room, un facteur dʼamortissement damp un mixage avec le son direct wet et le niveau du traitement level. // Freeverb ( SynthDef(\reverb, {|inBus=24,gate=1, wet=1, room=0.15, damp=0.5, vol=0 out1=20,out2=21,out3=22,out4=23,out5=24,out6=25,out7=26,out8=27, out9=28,out10=29,out11=30,out12=31,out13=32,out14=33,out15=34, amp1=0,amp2=0,amp3=0,amp4=0,amp5=0,amp6=0,amp7=0,amp8=0,amp9=0,amp10=0,amp11=0,amp12=0,amp13=0,amp14=0,amp15=0| var sig; var imp,delimp,env,ch1,ch2,ch3,ch4,ch5,ch6,ch7,ch8,ch9,ch10,ch11,ch12, ch13,ch14,ch15; imp = Impulse.kr(10); delimp = Delay1.kr(imp); env = Linen.kr(gate, 2, 1, 4, 2); sig = InFeedback.ar(inBus); sig = FreeVerb.ar(sig,wet,room,damp,vol); SendReply.kr(imp, 'levels', [Amplitude.kr(sig), K2A.ar(Peak.ar(sig, delimp).lag(0, 3))]); sig = [sig*amp1,sig*amp2,sig*amp3,sig*amp4,sig*amp5,sig*amp6,sig*amp7,sig*amp8,sig*amp9,sig*amp10,sig*amp11,sig*amp12,sig*amp13,sig*amp14, sig*amp15]; #ch1,ch2,ch3,ch4,ch5,ch6,ch7,ch8,ch9,ch10,ch11,ch12,ch13,ch14,ch15 = DistributedOut.ar([out1,out2,out3,out4,out5,out6,out7,out8,out9,out10, out11,out12,out13,out14,out15],sig); }).writeDefFile(SynthDef.synthDefDir)); Sur la page suivante je présente un sonagramme quʼillustre ce traitement et notamment le facteur dʼamortissement « dump » sur mon archive source (son 1). Le première attaque est le son de référence, les trois suivantes ont la variable « taille de la salle » (room size) à 100% puis respectivement le facteur dʼamortissement à 100%, 50% et 1%. Bien que jʼai borné lʼanalyse à 12Khz le spectre présente encore des composantes aiguës au-dessus de cette limite, car je voulais focaliser lʼobservation dans lʼenrichissement du spectre.


27

Figure 5 Effet de réverbération CD plage 4

On voit comment au fur et à mesure que le facteur dʼamortissement diminue les composantes aigües ont une durée plus longue, on entend les retards se mêlant comme de rebondissements très diffus de lʼattaque. Lʼénergie de la fondamentale est réduite et un sentiment de nuage sonore ou de grand espace lié aussi à la disparition des transitoires dʼattaque.

2.3.2.2 Retards Longs et Structures Rythmiques

Passons maintenant à des retards longs. Jʼai dit plus haut que les retards du signal autour de 50 ou 100 ms en présence du son direct commencent à se différencier dans lʼattaque, dont un effet dʼécho est perçu. Ceci est très intéressant de point de vue musical car on peut construire des structures rythmiques où on contrôle le temps de séparation entre les attaques, le niveau et la quantité de ces répétitions15. On peut imaginer des retards très longs où la seule limite est la mémoire vive de lʼordinateur et donc la taille du buffer qui va stoker le signal. Le principe consiste donc à avoir un buffer qui reçoit le signal dʼentrée en permanence et sur lequel on bien lire à différents moments ce signal. Dans lʼimplémentation qui suit, jʼutilise un buffer de 20 secondes et un vecteur de lecture de 20 valeurs possibles. Ce qui veut dire que le buffer peut être lu à 20 moments différents et la distance temporelle maximum entre deux lectures consécutives est limité à 1 seconde.

15 McAdams and BERGMAN, « Hearing Musical Streams », computer musical journal 3, pag, 26-44, 1979.


28

// MultiDelay (SynthDef(\multidelay, { |inBus = 25,gate=1,wet=1,vol=1,buf=20, timedel1,timedel2,timedel3,timedel4,timedel5,timedel6,timedel7, timedel8,timedel9,timedel10,timedel11,timedel12,timedel13,timedel14, timedel15,timedel16,timedel17,timedel18,timedel19,timedel20, ampdel1,ampdel2,ampdel3,ampdel4,ampdel5,ampdel6,ampdel7,ampdel8, ampdel9,ampdel10,ampdel11,ampdel12,ampdel13,ampdel14,ampdel15,ampdel16,ampdel17,ampdel18,ampdel19,ampdel20, out1=20,out2=21,out3=22,out4=23,out5=24,out6=25,out7=26,out8=27, out9=28,out10=29,out11=30,out12=31,out13=32,out14=33,out15=34, amp1=0,amp2=0,amp3=0,amp4=0,amp5=0,amp6=0,amp7=0,amp8=0,amp9=0,amp10=0,amp11=0,amp12=0,amp13=0,amp14=0,amp15=0| var in,phase,tap1,tap2,tap3,tap4,tap5,tap6,tap7,tap8,tap9,tap10,tap11, tap12,tap13,tap14,tap15,tap16,tap17,tap18,tap19,tap20,env,sig,mix, imp,delimp; var ch1,ch2,ch3,ch4,ch5,ch6,ch7,ch8,ch9,ch10,ch11,ch12,ch13,ch14,ch15; in = InFeedback.ar(inBus); phase = DelTapWr.ar(buf, in); // literal Array of times, 4 = interpolation (cubic) #tap1,tap2,tap3,tap4,tap5,tap6,tap7,tap8,tap9,tap10,tap11,tap12, tap13,tap14,tap15,tap16,tap17,tap18,tap19,tap20 = DelTapRd.ar(buf, phase, [timedel1,timedel2,timedel3,timedel4,timedel5,timedel6,timedel7, timedel8,timedel9,timedel10,timedel11,timedel12,timedel13,timedel14, timedel15,timedel16,timedel17,timedel18,timedel19,timedel20],4, [ampdel1,ampdel2,ampdel3,ampdel4,ampdel5,ampdel6,ampdel7,ampdel8, ampdel9,ampdel10,ampdel11,ampdel12,ampdel13,ampdel14,ampdel15,ampdel16,ampdel17,ampdel18,ampdel19,ampdel20]); env = Linen.kr(gate, 2, 1, 4, 2); mix = Mix([tap2+tap4+tap6+tap8+tap10+tap12+tap14+tap16+tap18+tap20+ tap1+tap3+tap5+tap7+tap9+tap11+tap13+tap15+tap17+tap19]); mix = mix * vol; sig = (in * (1 - (wet*env))) + (mix * (wet*env)); imp = Impulse.kr(10); delimp = Delay1.kr(imp); SendReply.kr(imp, 'levels', [Amplitude.kr(sig), K2A.ar(Peak.ar(sig, delimp).lag(0, 3))]); sig = [sig*amp1,sig*amp2,sig*amp3,sig*amp4,sig*amp5,sig*amp6,sig*amp7, sig*amp8,sig*amp9,sig*amp10,sig*amp11,sig*amp12,sig*amp13,sig*amp14,sig*amp15]; #ch1,ch2,ch3,ch4,ch5,ch6,ch7,ch8,ch9,ch10,ch11,ch12,ch13,ch14,ch15 = DistributedOut.ar([out1,out2,out3,out4,out5,out6,out7,out8,out9,out10,out11,out12,out13,out14,out15],sig); }).writeDefFile(SynthDef.synthDefDir) );


29

Les classes centrales dans cette implémentation sont DelTapWr et DelTapRd lesquelles permettent respectivement dʼécrire et lire dans le buffer. Le buffer est passe comme un argument nommé buf. timedel et ampdel sont des arguments pour déterminer la durée et lʼamplitude de chaque retard.

Sur lʼinterface graphique on découvre le moyen de contrôler ces deux vecteurs : avec deux multisliders, dont les valeurs sont normalisés à 1. Pour le vecteur de temps de retard il faudra donc penser calculer le temps absolu avec une opération dʼintégration. En haut à droite il y a deux menus qui permettent de choisir des configurations du type : ritardando, accelerando, crescendo, diminuendo, aléatoire. Puis les configurations trouvées à la main peuvent être stockées dans des archives textes et charges postérieurement.

Figure 6 Interface Graphique pour le contrôle des multidelay

Figure 7 Forme d’onde multidelays CD plage 5


30

Dans le graphique, on voit sur la forme dʼonde la structure rythmique des vingt retards (le premier étant la référence) avec une distribution aléatoire des amplitudes pour chaque retard. Ce traitement permet de produire des structures rythmiques assez complexes et intéressantes. Toutefois la limite de 20 retards est une contrainte car il faudrait modifier le code de lʼinterface graphique. Pour manipuler les vecteurs de temps et dʼamplitude depuis une ligne de commande :

~values.multidelay.settimes_(Array.fill(20,{|i|i+i}).normalize.reverse) ~values.multidelay.setvols_(Array.fill(20,{|i|i+i}).normalize)

Soit on peut choisir dʼécrire une fonction avec lʼargument i soit bien écrire le vecteur à la main. Jʼai beaucoup travaillé dans lʼimplémentation dʼune interpolation entre deux configurations sauvegardées en mémoire, mais les résultats ne sont pas optimaux car pour changer le temps de retard un par un dans les composantes du vecteur il faut atteindre à ce que le retard soit joué, puis faire une ligne descendante dans le volume, puis changer la valeur et finalement ramener le volume à la valeur désirée. Malgré des grands efforts de calcul je continue à avoir des clics et des distorsions, donc il faut encore imaginer des solutions pour bien gérer cette interpolation.

2.3.2.3 Modulation du temps de retard

Une troisième application de cette technique de ligne à retard consiste à varier le temps de retard dʼune façon continue, ainsi on obtient comme son résultant des versions transposées du signal dʼorigine. Ou de glissements dans la hauteur quand les changements de vitesses sont continus. Un oscillateur du type « lfo » peut être sur la tâche de modifier le point de lecture sur le buffer16. Un problème qui se présente est celui de clics ou de sons non désirés produits par le fait de lire le buffer à des endroits et vitesses différentes, donc il peut arriver de coïncider sur un point qui est en train dʼêtre écrit, ou quand la lecture se boucle dans lʼenchaînement de début et fin du fichier17. Pour contourner cette problématique, voici ma stratégie : dʼabord, il faut avoir un buffer suffisamment long pour laisser lʼespace nécessaire à lʼécriture de la ligne à retard sans « retomber sur ses pieds », puis le signal est passé par deux lignes de retard parallèles mais retardées entre elles par la période de lʼoscillateur lecteur (lfo), après, lʼamplitude de chaque ligne est contrôlée par deux oscillateurs triangulaires pour produire un « crossfader » au début de la lecture du fichier sur chaque répétition. Finalement une troisième ligne à retard sert à contrôler le taux de réinjection.

16 PUCKETTE Miller, « Theory and Technique of Electronic Music », World Scientific Publishing Co. Pte. Ltd. 2007, pages 209 - 210. 17 Idem, section 4.3.2 Switch-and-ramp


31

// Ligne à retard modulé

(SynthDef(\delmod,{|inBus=23,gate=1,wet=1,transposition=0.5,delay=0.01,feedback=0,vol=1,buf=22, out1=20,out2=21,out3=22,out4=23,out5=24,out6=25,out7=26,out8=27, out9=28,out10=29,out11=30,out12=31,out13=32,out14=33,out15=34, amp1=0,amp2=0,amp3=0,amp4=0,amp5=0,amp6=0,amp7=0,amp8=0,amp9=0,amp10=0,amp11=0,amp12=0,amp13=0,amp14=0,amp15=0| var sig,mixwet,local,lfo,del1,del2; var imp,delimp,env,ch1,ch2,ch3,ch4,ch5,ch6,ch7,ch8,ch9,ch10,ch11,ch12, ch13,ch14,ch15; imp = Impulse.kr(10); delimp = Delay1.kr(imp); env = Linen.kr(gate, 2, 1, 4, 2); sig = InFeedback.ar(inBus); local = LocalIn.ar(1) + sig; //buf = LocalBuf((44100*2),1); lfo = LFSaw.kr(transposition,0).range(0,1); del1 = BufDelayC.ar(buf,local,lfo,1)* LFTri.kr(transposition.abs,0).range(0,1)*vol; del2 = DelayC.ar(BufDelayC.ar(buf,local,lfo,1)* LFTri.kr(transposition.abs,0).range(0,1)* vol,20,transposition.reciprocal); local = SwitchDelay.ar (del1+del2,delayfactor:feedback,wetlevel:0.8,delaytime:delay) *feedback; local = LeakDC.ar(local); local = Limiter.ar(local,1,0.01); sig = (sig * (1 - (wet*env))) + (local * (wet*env)); LocalOut.ar(local * feedback); SendReply.kr(imp, 'levels', [Amplitude.kr(sig), K2A.ar(Peak.ar(sig, delimp).lag(0, 3))]); sig = [sig*amp1,sig*amp2,sig*amp3,sig*amp4,sig*amp5,sig*amp6,sig*amp7, sig*amp8,sig*amp9,sig*amp10,sig*amp11,sig*amp12,sig*amp13,sig*amp14, sig*amp15]; #ch1,ch2,ch3,ch4,ch5,ch6,ch7,ch8,ch9,ch10,ch11,ch12,ch13,ch14,ch15 = DistributedOut.ar([out1,out2,out3,out4,out5,out6,out7,out8,out9,out10,out11,out12,out13,out14,out15],sig); }).writeDefFile(SynthDef.synthDefDir)); Pourtant les clics produits par le changement de valeur dans la durée du retard, ne sont pas évites. Pour ceci comme il est bien illustré dans les tutoriaux de MAXMSP sur les objets « tapin » et « tapout » il faudrait faire une limitation dans la vitesse de changement de cette valeur, puis faire une ligne dans lʼamplitude de façon à réaliser le changement quand le signal est à zéro. Toutefois ces clics ou artefacts sonores peuvent être exploités musicalement.


32

Les paramètres de contrôle de ce synthétiseur seront donc la fréquence du lfo, (ici lʼargument : transposition), jʼutilise un oscillateur en dent de scie et sa fréquence oscillant entre -1 et 1, à -1 une inversion de phase dans lʼoscillateur est produite et donc la forme dʼonde de celui-ci correspond à une rampe descendante ; le temps du retard de la troisième ligne qui varie de 1ms à 1 seconde et le taux de réinjection exprimé en pourcentage du signal renvoyé à lʼentrée. Un dernier commentaire sur lʼarchitecture de ce synthétiseur : remarquer la présence dʼun filtre et un limiteur avant de réinjecter le signal pour nettoyer les possibles effets de repliement spectral dus aux lignes de retards18. Pour illustrer la puissance génératrice du taux de réinjection voici un son de 24 secondes obtenu avec une impulsion de mon archive source « son1 » puis un temps de retard de 3ms, la fréquence du lfo variant de -1 à 1 et le taux de réinjection ou feedback à 100% Les paramètres dʼanalyse ont changé dans la résolution fréquentielle : taille de lʼanalyse FFT 1024 et la représentation graphique allant jusquʼau 22KHz, tous les restes sont conservés comme dans les analyses précédents.

Trois remarques dans ce son. Le mouvement des composantes spectrales en forme de triangle, dû à la fréquence de modulation du temps du retard dʼabord dent de scie puis rampe, produit par lʼinversion de phase quand la fréquence traverse des côtés négatifs vers les positifs. Deuxième remarque, la réapparition de lʼattaque déclencheur qui se nourrit en composantes avec la réinjection. Et troisième remarque, le creux spectral quand la fréquence de modulation approche le zéro. 18 Le crénelage (ou crènelage) ou repli de spectre (Aliasing en anglais) est un phénomène qui peut se produire lors du traitement numérique d'un signal, lorsque des fréquences qui ne sont pas représentées dans le signal original sont introduites par erreur dans le signal

Figure 8 Réinjection ligne à retard modulé CD plage 6


33

2.3.3 Analyse de Fourier

Les traitements étudiés jusquʼici ont lieu dans le domaine temporel, manipulant les échantillons dans son amplitude pour les modulations ou bien dans le temps comme dans les lignes à retards et filtres. Lʼanalyse de Fourier, permet de traduire les signaux audio dans le domaine fréquentiel et de réaliser les traitements directement sur le spectre. Mathématiquement, la transformée de Fourier est déniée sur des fonctions continues de −∞ à +∞, dans le cas de signaux numériques on doit utiliser un type de transformée de Fourier appelée « discrète » sur un intervalle de temps fini correspondant à N échantillons19. Avant de continuer dans les implémentations, je voudrais réviser quelques définitions que lʼon trouve souvent dans le vocabulaire technique quand il sʼagit dʼAnalyse de Fourier : Fenêtrage : le fenêtrage est utilisé dès que l'on s'intéresse à un signal de longueur volontairement limité. En effet, un signal réel ne peut qu'avoir une durée limitée dans le temps ; de plus, un calcul ne peut se faire que sur un nombre de points fini. Pour observer un signal sur une durée finie, on le multiplie par une fonction fenêtre d'observation (également appelée fenêtre de pondération). Parmi les fonctions les plus courantes, il y a la fenêtre rectangulaire, de Hanning, de Hamming, et de Blackman. La Transformée de Fourier (TF) du signal analysé est convoluée avec la TF de la fenêtre20 ; dans l'idéal, pour ne pas biaiser le spectre initial, il faudra que l'allure de la fenêtre spectrale soit une fonction de Dirac. Or, le signal temporel ayant un spectre en fonction de dirac est un signal constant infini, ce qui est impossible en pratique. Les allures spectrales des fenêtres de pondérations présentent une succession de lobes : pour se rapprocher d'une fonction de Dirac, il faut que le lobe principal soit le plus étroit possible, tandis que les lobes secondaires doivent être les plus faibles possible. Plus le lobe principal d'une fenêtre aura tendance à être étroit, plus ses lobes secondaires seront importants. Il y a donc toujours un compromis à faire entre largeur du lobe principal et importance des lobes secondaires. Plus la fenêtre choisie aura une grande durée temporelle, plus elle sera étroite dans le domaine fréquentiel. Le taux de recouvrement des fenêtres « overlap » permet de lisser le signal à l'analyse et à la résynthèse.

19 CROQUETTE Vincent, « La transformée de Fourier discrète » Février 2009, Ecole Normale Supérieure de Paris 20 HARRIS « On the use of Windows for harmonic analysis with the discrète Fourier transform »,1978, Proceedings of the IEEE N° 66.


34

Taille de lʼanalyse : ce facteur détermine la précision fréquentielle de l'analyse, et sʼexprime en nombre dʼéchantillons. La transformée de Fourier discrète faite en appliquant directement son équation mathématique nécessite N multiplications pour calculer un coefficient de Fourier ak, comme il y en a également N le temps de calcul de la transformée de Fourier serait de N2 multiplications. Cʼest donc une opération lourde en calcul, heureusement Cooleyet Tukey21 ont remarqué que si N est une puissance de 2 on peut faire le calcul beaucoup plus vite. En effet en utilisant les symétries paires impaires, il est possible de réduire le nombre dʼopérations à N.log2N. Si nous voulons faire une transformée de Fourier sur 1024 points (210) on passe de 106 à 104 opérations soit un gain dʼun facteur 100. Si on effectue une analyse de Fourier sur une fenêtre de 1024 échantillons extraits du signal, on obtiendra une analyse en 1024 points ou bins ou tranches ou paniers de fréquences. On comprend donc que plus la fenêtre est large, plus on a de points dans lʼanalyse spectrale et plus elle est précise au niveau fréquentielle. Par contre, l'information étant estimée sur toute la longueur de l'analyse, les évènements très rapides, comme les attaques, seront adoucis par la moyenne effectuée sur plusieurs échantillons. Le compromis est inévitable.22 Par exemple, si on utilise une fenêtre de 1024 échantillons, on obtient un spectre de 1024 points. Ces 1024 points sont répartis de 0 à 44100 Hz, donc, en réalité, on nʼa que 512 points de 0 à 22050 Hz (fréquences positives). Les points sont espacés de 44100/1024 = 43 Hz. Imaginaire et Réel : la transformée de Fourier dʼun signal réel est un signal complexe, cʼest-à-dire un signal à deux dimensions car chaque composante est définie par deux paramètres: son amplitude et sa phase. L'ensemble des nombres complexes est l'ensemble des nombres de la forme : Z = a + bi où a et b sont des réels quelconques et i un nouveau nombre tel que i ²= -1. Le nombre a est appelé partie réelle de z et noté parfois Re(z). Le nombre b est appelé partie imaginaire de z et noté parfois Im(z). La forme z = a + bi est appelée forme algébrique de z. On peut aussi représenter un nombre complexe suivant ses coordonnées polaires. Les coordonnées sont alors lʼamplitude (r) et lʼangle (a) (phase). Sa magnitude ou valeur absolue étant la distance à lʼorigine dans le plan complexe23. Z = reia Avec : eia = cos a + i sin a 21 COOLEY and TUKEY, « An algorithm for the machine computation of complex Fourier series », Mathematical Computation N°19, 1965 22 ARFIB Daniel et KRONLAND-MARTINET Richard « Transformer le son : modeler, modéliser » Les Cahiers de L’IRCAM, 1993, Paris 23 J.-R. ARGAND « La représentation dans le plan des nombres complexes », 1806, Bibliothèque Nationale de France Paris.


35

Dans SuperCollider plusieurs UGens supportent des traitements basés sur le FFT, les plus basiques étant FFT et IFFT, ces deux classes permettent de passer du domaine temporel au domaine fréquentiel et vice-versa. Le contenu spectral du signal est placé dans un « buffer local » dont la taille qui est une puissance de deux correspondra à la taille de lʼanalyse. Dans ce buffer on stocke les données dans lʼordre suivant : DC offset, nyquist, real 1f, imag 1f, real 2f, imag 2f... real (N-1)f, imag (N-1)f, où f est la fréquence relative à la taille de la fenêtre, et N est la taille de la fenêtre sur 2.Le taux de recouvrement des fenêtres est par defaut de 50%, le type de fenêtre est « Hanning » Parmi toutes les opérations possibles sur lʼinformation spectrale, SuperCollider propose dans sa distribution publique les implémentations suivantes FFT Fast Fourier Transform IFFT Inverse Fast Fourier Transform PV_Add somme de coefficients complexes PV_BinScramble brouillage de bins (tranches, paniers de fréquences) PV_BinShift déplacement et élargissement de positions de bins PV_BinWipe combinaison de bas et hauts bins sur deux entrées PV_BrickWall zéro bins PV_ConformalMap attaque dans le plan complexe PV_Copy copier un FFT buffer PV_CopyPhase copier magnitudes et phases PV_Diffuser aléatoire déplacements de phase PV_LocalMax passe bins lesquels ont un maximum local PV_MagAbove passe bins sur une limite PV_MagBelow passe bins en dessous une limite PV_MagClip clip bins sur un limite PV_MagFreeze geler les magnitudes PV_MagMul multiplier les magnitudes PV_MagDiv division de magnitudes PV_MagNoise multiplication de magnitudes avec bruit PV_MagShift déplacement et élargissement de magnitudes de bins PV_MagSmear appliquer une moyenne aux magnitudes pour tous les bins PV_MagSquared carré des magnitudes PV_Max maximum magnitude PV_Min minimum magnitude PV_Mul multiplication de complexes PV_PhaseShift déplacement de phase pour tous les bins PV_PhaseShift270 déplacer la phase de 270 dégrées PV_PhaseShift90 déplacer la phase de 90 dégrées PV_RandComb passe aléatoirement de bins PV_RandWipe crossfade dans un ordre aléatoire des bins PV_RectComb faire distances ou trous dans le spectre UnpackFFT, PackFFT, Unpack1FFT "unpacking" components


36

2.3.3.1 Conformal Map

Une transformation conforme, (conformal map), également appelée une carte « mapping » conforme, transformation de préservation de l'angle, ou carte biholomorphe, est une transformation qui préserve la magnitude des angles locaux. Une fonction analytique est conforme en tout point où elle a une dérivé non nul. Inversement, toute transformation conforme d'une variable complexe qui a des dérivées partielles continues est analytique24. Ce synthétiseur applique la transformée conforme aux bins issus de le FFT chainA avec des coefficients réels et imaginaires donnés comme argument à lʼUgen. Cette transformation spectrale au signal dʼentrée, donne comme résultat un signal fourni de « perturbations » sonores remplissant le haut du spectre, perceptivement je dirai que il sʼagit dʼun effet de clochettes qui se ajoutent au son du départ. SynthDef(\complexattack,{|inBus=26,gate=1,wet=1,vol=1,real=0.5,img=0.5, out1=20,out2=21,out3=22,out4=23,out5=24,out6=25,out7=26,out8=27, out9=28,out10=29,out11=30,out12=31,out13=32,out14=33,out15=34, amp1=0,amp2=0,amp3=0,amp4=0,amp5=0,amp6=0,amp7=0,amp8=0,amp9=0,amp10=0,amp11=0,amp12=0,amp13=0,amp14=0,amp15=0| var in,sig,chain,chainA,chainB,imp,delimp,env; var ch1,ch2,ch3,ch4,ch5,ch6,ch7,ch8,ch9,ch10,ch11,ch12,ch13,ch14,ch15; in = InFeedback.ar(inBus); imp = Impulse.kr(10); delimp = Delay1.kr(imp); env = Linen.kr(gate, 2, 1, 4, 2); chainA = FFT(LocalBuf(2048),in); chainB = PV_Copy(chainA, LocalBuf(2048)); chainA = PV_ConformalMap(chain,real,img); chainB= PV_BinScramble(chainB,img,real,A2K.kr(Peak.ar(in,delimp)>0.5)); chain = PV_Add(chainA, chainB); sig = IFFT(chain)*vol; sig = LeakDC.ar(sig); sig = (in * (1 - (wet*env))) + (sig * (wet*env)); SendReply.kr(imp, 'levels',[Amplitude.kr(sig), K2A.ar(Peak.ar(sig, delimp).lag(0, 3))]); sig = [sig*amp1,sig*amp2,sig*amp3,sig*amp4,sig*amp5,sig*amp6,sig*amp7, sig*amp8,sig*amp9,sig*amp10,sig*amp11,sig*amp12,sig*amp13,sig*amp14, sig*amp15]; #ch1,ch2,ch3,ch4,ch5,ch6,ch7,ch8,ch9,ch10,ch11,ch12,ch13,ch14,ch15 = DistributedOut.ar([out1,out2,out3,out4,out5,out6,out7,out8,out9,out10, out11,out12,out13,out14,out15],sig); }).writeDefFile(SynthDef.synthDefDir)

24 TROTT, M. « The Mathematica GuideBook for Programming », Springer-Verlag, 2004 New York


37

Comme on peut le voir dans le code au-dessus, un deuxième traitement est réalisé en parallèle, il sʼagit de « bin scramble », pour ceci il faut copier lʼanalyse dans un nouveau buffer chainB. Ce traitement réarrange lʼordre des bins dʼune façon aléatoire dont on peut contrôler le pourcentage de distorsion, cʼest à dire la distance maximale de lʼéloignement du point dʼorigine de chaque bin. On a besoin aussi de donner un « trigger » ou déclenchement pour recalculer une nouvelle disposition dans lʼordre des bins, jʼutilise lʼattaque pour ceci, cʼest à dire on détermine le pourcentage dʼaléatoire puis avec chaque attaque on réorganise le spectre. Le résultat étant des sonorités proches de la modulation dʼamplitude dont on découvre des nouvelles versions du spectre à chaque attaque. Finalement une troisième Class réalise lʼaddition de signaux dans le domaine fréquentiel de la façon suivante : Réel A + Réel B, Imaginaire A + Imaginaire B. En suite pour revenir dans le domaine temporel lʼinverse de FFT (IFFT) est nécessaire.

Figure 9 Application de la transformée conforme au son1 CD plage 7

Lʼexemple précédent montre 12 attaques dont les quatre premières sont le son source sans traitement. Les quatre suivantes montrent une réorganisation aléatoire des bins fréquentielles et les quatre dernières sont les processus de conformal map, et on voit comme le spectre est sombré par un bruit de fond très riche en fréquences et le Bin Scrumble est une redistribution de lʼénergie dans les composantes spectrales donnant ainsi une inharmonicité similaire à celle produit par la modulation dʼamplitude. Le traitement mis en place par ce synthétiseur permet de colorer le spectre en le rendant plus sombre par le bruit et en altérant lʼordre et le poids dans les composantes spectrales ; le contrôle de celui-ci est assuré par deux arguments real,img dont les valeurs normalisées entre 0 et 1 affectent parallèlement les deux procédés décrits plus haut.


38

2.3.3.2 Freezer

Toujours dans le domaine de lʼanalyse FFT, je propose un autre traitement, assez connu dʼailleurs dans le monde du traitement du signal : le « freezer ». Ce traitement gèle les magnitudes de lʼanalyse à un moment donné ainsi nous avons en sortie le spectre instantané du son dʼentrée qui se conserve de façon continu jusquʼà ce quʼun nouveau déclenchement vienne modifier le point de lecture. Pour implémenter cette technique, jʼutilise une architecture en deux niveaux, avant tout il faut créer les buffers pour lʼanalyse, le traitement et la lecture, la ligne de code pour ceci est : server.sendMsg(\b_alloc,24,1024,1,("buffer freezer loaded".postln)); server.sendMsg(\b_alloc,25,1024,1,("buffer2 freezer loaded".postln)); server.sendMsg(\b_alloc,26, (2.calcPVRecSize(1024,0.25)),1,("buffer3 freezer loaded".postln)); La taille des deux premiers buffers étant fixe à 1024 puis pour le troisième une méthode implémentée par Joshua Parmenter (Washington University) calcPVRecSize permet de calculer la taille nécessaire du buffer où seront enregistrées les donnés de lʼanalyse. Cʼest aussi à lui à que lʼon doit plusieurs implémentations des procédés, calculs et traitement dans le domaine de lʼanalyse spectrale et la synthèse granulaire. Un synthétiseur est programmé pour enregistré les donnés FFT de la façon suivante : // PV_recorder SynthDef(\pvrec, { |inBus = 27, bufnum=24, recBuf=26| var in, chain; in = InFeedback.ar(inBus); chain = FFT(bufnum, in, 0.25, 1); chain = PV_RecordBuf(chain, recBuf, 0, 1, 1, 0.25, 1); }).writeDefFile(SynthDef.synthDefDir); Puis le lecteur et le freezer lissant les données écrites, ce synthétiseur comporte notamment deux arguments : rate pour contrôler la vitesse de lecture donc sans modifier les contenus fréquentiels, et un trigger qui permettra de déclencher le moment où on voudra geler le spectre. Le déclenchement a lieu à chaque fois quʼune valeur supérieure à un seuil déterminé est reçue. Par défaut 0.


39

// Freezer SynthDef(\freezer, {|gate=1,rate=1,vol=1,trigger=1,buf=25,recBuf=26, out1=20,out2=21,out3=22,out4=23,out5=24,out6=25,out7=26,out8=27, out9=28,out10=29,out11=30,out12=31,out13=32,out14=33,out15=34, amp1=0,amp2=0,amp3=0,amp4=0,amp5=0,amp6=0,amp7=0,amp8=0,amp9=0,amp10=0,amp11=0,amp12=0,amp13=0,amp14=0,amp15=0| var sig,chain,imp,delimp,env; var ch1,ch2,ch3,ch4,ch5,ch6,ch7,ch8,ch9,ch10,ch11,ch12,ch13,ch14,ch15; imp = Impulse.kr(10); delimp = Delay1.kr(imp); env = Linen.kr(gate, 2, 1, 4, 2); chain = PV_PlayBuf(buf, recBuf, rate.linexp(0,1,0.001,10), 0, 1); chain = PV_Freeze(chain, trigger ); sig = IFFT(chain); sig = (Limiter.ar(LeakDC.ar(sig),1,0.01)*vol)*env; SendReply.kr(imp, 'levels', [Amplitude.kr(sig), K2A.ar(Peak.ar(sig, delimp).lag(0, 3))]); sig = [sig*amp1,sig*amp2,sig*amp3,sig*amp4,sig*amp5,sig*amp6,sig*amp7, sig*amp8,sig*amp9,sig*amp10,sig*amp11,sig*amp12,sig*amp13,sig*amp14, sig*amp15]; #ch1,ch2,ch3,ch4,ch5,ch6,ch7,ch8,ch9,ch10,ch11,ch12,ch13,ch14,ch15 = DistributedOut.ar([out1,out2,out3,out4,out5,out6,out7,out8,out9,out10,out11,out12,out13,out14,out15],sig); }).writeDefFile(SynthDef.synthDefDir);

Figure 10 Effet de freezer, spectre gelé CD plage 8

Cet exemple montre le son1 lu avec un facteur de ralentissement de 2% puis son spectre gelé à deux instants différents. On voit clairement comme le spectre est conservé tout au long du traitement.


40

2.3.4. Granulation

Les méthodes de granulation du signal consistent à produire des textures sonores en manipulant des grains de son, par transposition, dilatation et compression temporelle, entre autres. Les grains sont produits en multipliant échantillons sonores, typiquement dʼune durée entre 10 et 50 millisecondes par une enveloppe de la même longueur. Les densités typiques de grain varient au tour de plusieurs centaines de grains par seconde, où le grain lui-même peut être généré à partir d'une forme d'onde obtenue par synthèse additive ou par synthèse FM ou extraite d'un fichier audio, ou bien dʼun signal dʼentrée directe. 25 Le grain constitue une entité sonore « atomique ». Dans ce sens, beaucoup des écrits sur la synthèse granulaire font référence à Denis Gabor, qui évoque en premier lʼidée dʼun « quantum acoustique ». Effectivement, Gabor a fait une critique de la notion dérivée de Helmholtz selon laquelle lʼécoute subjective était mieux représentée par lʼanalyse de Fourier. « Quʼest ce quʼon écoute? Selon les théories de Ohm et de Helmholtz, lʼouïe analyse le son en le décomposant en forme de spectre, et nos sensations se produisent à partir de la valeur absolue des composantes du spectre (composantes de Fourier). Mais lʼanalyse de Fourier est une description qui ne tient pas compte du facteur temps, et qui considère les composantes spectrales comme des ondes périodiques sinusoïdes exactes de durée infinie. Or, notre expérience la plus élémentaire est que le son est constitué autant par un motif temporel que par un motif de fréquence. La dualité de nos sensations ne sʼexprime pas seulement dans la description du son comme un signal en fonction du temps s(t), ni dans sa représentation par composantes de Fourier S(f). Par conséquence, une description mathématique qui tient compte de cette dualité est nécessaire ».26 Cʼest dans les écrits de Gabor quʼon trouve pour la première fois une description à la fois mathématique et acoustique dʼune « particule » sonore. On peut facilement saisir l'intérêt de Gabor de démontrer sa théorie sur les « quanta acoustiques, » autant dans une perspective mathématique que dans une perspective de la perception auditive. Cette nouvelle théorie de la représentation sonore est basée sur la théorie quantique de Planck et sur la théorie de l'incertitude de Heisenberg.

25 Manuel ROCHA ITURBIDE « Searching for a global synthesis technique through a quantum conception of sound », Pas encore publié. 2001. http://artesonoro.net 26 Denis GABOR « Acoustical quanta and theory of hearing » 1947, Nature Vol.159, page 591


41

Cette technique a besoin dʼun nombre important des variables lesquelles dépendent de chaque réalisation informatique, parmi les plus courantes :

• Type de fenêtre – forme dʼonde de lʼenveloppe de fenêtrage • Taille de la fenêtre – durée du grain (de 1 à 100 ms habituellement) • Largeur de bande des grains (nuages cumulus - basses fréquences -

et stratus - hautes fréquences) • Distance temporelle de fenêtrage • Densité • Enveloppe dynamique de la masse sonore • Variation fréquentielle de la masse sonore

Regardons aussi par exemple les variables du programme «granule» développé par Allan Lee (Belfast 1996), inspiré des travaux de Barry Truax et Curtis Roads27 et écrit en Csound :

• xamp - amplitude • ivoice - nombre de voix • iratio - rapport entre la vitesse du pointeur gskip et le taux d'échantillonnage

du signal audio de sortie (ex : 0.5 sera la moitié de sr). • imode - le pointeur de grain se déplace : +1 : avant , -1 : arrière, 0 : hasard. • ithd - seuil (threshold) tel que si le signal échantillonné est plus petit

que ithd, il est passé par le pointeur (cela permet d'éviter les silences entre les mots d'une phrase par exemple).

• ifn - numéro de la table de fonction pour la source sonore • ipshift - contrôle de la transposition (pitch shift). • igskip - nombre de secondes à partir duquel la table contenant la source est

lue (permet de passer un silence au début du fichier par exemple). • igskip_os - variation aléatoire du pointeur gskip (0 = pas d'offset). • ilength - longueur de la table à utiliser à partir de igskip en secondes. • kgap - délai entre les grains en secondes • igap_os - amplitude de la variation aléatoire du délai entre les grains en %

de la durée du délai (0 = pas de variation). • kgsize - durée des grains en secondes • igsize_os - amplitude de la variation aléatoire de la durée des grains en %

(0 = pas de variation). • iatt - attaque de l'enveloppe des grains en % de leur durée • idec - atténuation de l'enveloppe des grains en % de leur durée • [iseed] -optionnel, point de départ pour le générateur de nombres aléatoires • [ipitch1], [ipitch2], [ipitch3], [ipitch4] - optionnel, paramètres de transposition • [ifnenv] - optionnel - numéro de la table fonction pour l'enveloppe des grains

27 Curtis ROADS « Granular synthesis of sound » 1985.Cambridge, The MIT Press


42

En SuperCollider, plusieurs classes sur la synthèse granulaire ont été écrites, les opérations dʼéchantillonnage et les fonctions de fenêtrage peuvent être réalisées directement avec des classes basiques comme PlayBuf, BufRd, EnvGen, ou bien avec dʼautres classes et UGens spécialement conçus pour les opérations de granulation Warp1, Tgrains, GrainBuf. Jʼai réalisé plusieurs expérimentations avec chacune de ces classes, car une de mes plus grandes inquiétudes a été dʼécrire un synthétiseur qui puisse traiter à la fois une entrée analogique et des fichiers. Bien que chaque implémentation comporte de très intéressantes qualités comme la possibilité de fournir son propre enveloppe, contrôle du taux de recouvrement des fenêtres, dʼamplitude globale, de position spatiale, elles sont spécialisées dans le traitement dʼun fichier ou dans le traitement dʼun signal dʼentrée, donc ma solution a été de programmer un étage supérieur où le signal dʼentrée est routé par un bus et stocké de façon continue, (en boucle) dans un buffer et sur ce buffer on réalise la granulation. //Granulator Warp1 SynthDef(\granulator,{|inBus=28,gate=1,buf=23,rate=0.2,pitchdepth=0.6,density=0.3,duration=0.4,posrate=1,posdisp=0,wet=1,grainslevel=0.7, out1=20,out2=21,out3=22,out4=23,out5=24,out6=25,out7=26,out8=27, out9=28,out10=29,out11=30,out12=31,out13=32,out14=33,out15=34, amp1=0,amp2=0,amp3=0,amp4=0,amp5=0,amp6=0,amp7=0,amp8=0,amp9=0,amp10=0,amp11=0,amp12=0,amp13=0,amp14=0,amp15=0| var sig,in,grains,env,imp,delimp, envin = Linen.kr(gate,0.5,1,1,2); var ch1,ch2,ch3,ch4,ch5,ch6,ch7,ch8,ch9,ch10,ch11,ch12,ch13,ch14,ch15; var pointer,ratepointer,freq,ratefreq,overlaps; in = InFeedback.ar(inBus)*envin; RecordBuf.ar(in,buf,0,1,1,loop:1); env = Linen.kr(gate, 2, 1, 4, 2); ratepointer = posrate.linlin(0,1,0.01,10); ratefreq = rate.linlin(0,1,1,100); overlaps = density.linlin(0,1,1,10); pointer= LFNoise1.ar(ratepointer).range(0,posdisp); freq= LFNoise1.ar(ratefreq).range(0,pitchdepth.linlin(0,1,0,2)); grains = Warp1.ar(1,buf,pointer,freq,duration,-1,overlaps,0,2); sig = (in * (1 - wet)) + (grains * wet); sig = Limiter.ar(LeakDC.ar(sig),1,0.01)*env*grainslevel; imp = Impulse.kr(10); delimp = Delay1.kr(imp); SendReply.kr(imp, 'levels',

[Amplitude.kr(sig), K2A.ar(Peak.ar(sig, delimp).lag(0, 3))]); sig =[sig*amp1,sig*amp2,sig*amp3,sig*amp4,sig*amp5,sig*amp6,sig*amp7, sig*amp8,sig*amp9,sig*amp10,sig*amp11,sig*amp12,sig*amp13,sig*amp14, sig*amp15]; #ch1,ch2,ch3,ch4,ch5,ch6,ch7,ch8,ch9,ch10,ch11,ch12,ch13,ch14,ch15 = DistributedOut.ar([out1,out2,out3,out4,out5,out6,out7,out8,out9,out10, out11,out12,out13,out14,out15],sig); }).writeDefFile(SynthDef.synthDefDir) );


43

Jʼai donc choisi de travailler dans deux synthétiseurs autour des classes Warp1 et PitchShift dans lʼexemple précédent deux oscillateurs produisent des nombres aléatoires LFNoise1 contrôlent la position de lecture dans le buffer et le décalage fréquentiel global. À son tour lʼamplitude et la fréquence dʼoscillations de ces deux oscillateurs sont contrôlés par deux variables posrate et rate pour les fréquences ou quantité des nombres par unité de temps et posdisp et pitchdepth pour lʼamplitude. Les autres paramètres de contrôle étant la duration de chaque grain exprimé en millisecondes et le taux de recouvrement traduit pour la densité ou la quantité de grains par seconde. // PitchShifter

SynthDef(\pitchShifter,{|inBus=21,vol=1,wet=1,gate=1,grainsize=0.5, pitchrate=1, pitchdisp=0.1,timedisp=0.4, out1=20,out2=21,out3=22,out4=23,out5=24,out6=25,out7=26,out8=27, out9=28,out10=29,out11=30,out12=31,out13=32,out14=33,out15=34, amp1=0,amp2=0,amp3=0,amp4=0,amp5=0,amp6=0,amp7=0,amp8=0,amp9=0,amp10=0,amp11=0,amp12=0,amp13=0,amp14=0,amp15=0| var in,sig,imp,delimp,env,ch1,ch2,ch3,ch4,ch5,ch6,ch7,ch8,ch9,ch10, ch11,ch12,ch13,ch14,ch15; imp = Impulse.kr(10); delimp = Delay1.kr(imp); in = InFeedback.ar(inBus); env = Linen.kr(gate, 1, 1, 1, 2); sig = PitchShift.ar(in, grainsize, pitchrate,pitchdisp,timedisp)*env; sig = (in * (1 - wet)) + (sig * wet); sig = Limiter.ar(LeakDC.ar(sig),1,0.01)*vol; SendReply.kr(imp, 'levels', [Amplitude.kr(sig), K2A.ar(Peak.ar(sig, delimp).lag(0, 3))]); sig = [sig*amp1,sig*amp2,sig*amp3,sig*amp4,sig*amp5,sig*amp6,sig*amp7, sig*amp8,sig*amp9,sig*amp10,sig*amp11,sig*amp12,sig*amp13,sig*amp14, sig*amp15]; #ch1,ch2,ch3,ch4,ch5,ch6,ch7,ch8,ch9,ch10,ch11,ch12,ch13,ch14,ch15 = DistributedOut.ar([out1,out2,out3,out4,out5,out6,out7,out8,out9,out10, out11,out12,out13,out14,out15],sig); }).writeDefFile(SynthDef.synthDefDir) ); Dans ce deuxième synthétiseur, la classe PitchShift réalise les opérations de granulation avec une fenêtre glissante (triangulaire et avec un taux fixe de recouvrement de 4 :1) sur le signal dʼentrée les paramètres sont contrôlés par des variables directs (sans oscillateur) et sont :

• windowSize la taille de chaque grain • pitchRatio un facteur de 0 à 4 pour la déviation fréquentielle globale • pitchDispersion un facteur de range aléatoire du pitchRatio • timeDispersion un facteur aléatoire pour le retard de grains.


44

Comme je lʼai remarqué plus haut la matière première sur laquelle on réalise le fenêtrage et les opérations de retard, transposition… peut être issue dʼun procédé de synthèse ou dʼun fichier son. Ainsi certains chercheurs comme Monsieur Olivier Bélanger dans son cours dʼélectroacoustique à lʼuniversité de Montréal28, considèrent cette distinction basée sur la nature de la matière sonore. Dʼautres comme Nathan Edwin Wolek à lʼuniversité dʼIllinois ont travaillé largement sur les conséquences perceptives de la granulation, ainsi apparaît un vecteur de métamorphose du signal dʼorigine allant du traitement à la synthèse29. Sujet passionnant, la synthèse granulaire a inspiré chercheurs, compositeurs, musiciens et ingénieurs autour du globe et plusieurs branches de la pensée ont été explorées, traitant ainsi des rapports avec la philosophie, la physique et lʼesthétique, mettant un contraste les théories corpusculaires et les théories laminaires de la matière30. En ce qui concerne mon travail, je me suis concentré dans lʼécriture dʼun outil informatique qui permet de jouer aisément dans un contexte dʼimprovisation dont les issues et le champ dʼinvestigation de ce domaine dépassent les bornes que je me suis donné au départ. Sur le contrôle de la granulation, un chapitre très détaillé a été écrit par Manuel Rocha Iturbide31, traitant dʼautomatismes, gestes, contrôle stochastique, chaotique déterminisme et indéterminisme. Donc un document très riche que propose plusieurs champs de recherche possibles sur la question : comment jouer de ces algorithmes ? En situation de jeu, où une réactivité très développée est nécessaire pour se fondre, sʼopposer ou proposer des idées musicales à un groupe des musiciens y compris avec dʼinstruments acoustiques ou même en solo, la quantité hallucinante de paramètres et de variables ne peuvent quʼêtre groupée pour permettre un contrôle multiparamétrique tout en gardant la possibilité dʼune complexité ou dʼune simplicité dans la façon dʼénoncer et dʼexprimer la pensée musicale. Bien quʼil pourrait paraître réducteur de voir dans la granulation un module de plus dans une chaîne de traitement et de synthèse où une prolifération importante de variables est déjà en jeu, je ne pouvais pas me passer 28 Olivier BELANGER et Dominic THIBAULT, « Analyse Synthèse et Traitement des Sons », 2009, Faculté de Musique, Université de Montréal 29 Nathan Edwin WOLEK « A Simplified Interface for Granular Processing Based on Perceptual Research » North Western University, 2005, Illinois 30 A ce moment-là, on a considéré que la lumière était constituée par ondes électromagnétiques de caractère continu; cette théorie n’était pas réfutée par Einstein, car De Broglie a confirmé que la lumière pouvait se manifester en forme d’ondes ou en forme de particules quantiques.31 ROCHA ITURBIDE, « Les techniques granulaires dans la synthèse sonore ». Thèse Doctoral sous la direction d’Horacio Vaggione. University of Paris VIII. 1999 France.


45

de placer cette couleur dans la palette de mes espaces composables et jʼai beaucoup appris des concepts issus de cette technique pour diriger ou participer dans des groupes dʼimprovisation, ainsi la densité ou nombre dʼévénements par unité de temps, lʼallure dynamique, les trajectoires fréquentielles sont des concepts très prégnants et saisissables pour tous les musiciens.

2.4 Matrix et Audio Mappings.

Passons maintenant à un point très délicat dans lʼarchitecture de tout programme proposant une connectivité possible entre sources et traitement audio, lʼacheminement ou mapping de signaux32. Ceci est tellement important quʼon pourrait présenter les deux programmes décrits dans cette mémoire comme deux matrices de contrôle et de signal. Effectivement, le paradigme sous-jacent dans mon travail est celui de la création sonore par combinaison, cʼest-à-dire avoir à portée de main des fichiers sons de modules de synthèse, dʼentrées analogiques, de traitements et puis des outils de contrôle pour construire et jouer spontanément dʼarborescences de synthèse. Tel a été aussi mon parti pris quand jʼai choisi le chemin opposé à la programmation basée sur des modèles dʼapprentissage. Je voulais être le dernier à prendre des décisions sur le résultat sonore, je voulais être conscient de la chaine de synthèse et y définir les stratégies de connexion puis avoir une incidence directe sur les paramètres de synthèse. Bref, une approche plus de musicien interprète que de scientifique, cʼest-à-dire pouvoir interagir avec le son dans une boucle perceptive et non dʼune façon où lʼon pose des hypothèses et on observe le processus et le résultat. Cette matrice elle peut être abstraite ou graphique. Par exemple dans le logiciel IXIQuarksPro écrit en SuperCollider par le collective IXISoftware33, la matrice est abstraite, chaque module (instruments, effets, filtres) comporte un menu où on peut diriger le signal vers de buses monophoniques ou couplés en stéréo et aussi, naturellement, un menu (quand cʼest le cas) pour les buses dʼentrée. Donc la visualisation des enchaînements et de lʼarborescence de synthèse nʼest pas explicite mais se réfère à chaque module. Il faut à ce point se souvenir de lʼattention quʼil faut prêter en SuperCollider à lʼordre des nœuds de synthèse et le moment où ils arrivent, point que jʼai expliqué plus haut. Pour manier ceci, les auteurs ont ajouté à chaque module un menu avec les options pour déplacer les nœuds de synthèse à la tête, à la queue avant ou après un groupe de synthétiseurs et un target ou nœud cible comme point de référence.

32Dans cette section je vais m’occuper du mapping audio, le contrôle étant développe à la section 2.1.6. 33 Thor MAGNUSSON « The IXIQUARKS: Merging code and gui in one créative space » 2008, Creative Systems Lab Department of Informatics University of Sussex, Angleterre.


46

Si on ajoute ces deux facteurs : 52 buses audio et la logique (facile mais délicat) dans lʼordre de lʼarbre de synthèse le mapping en cours de jeu demande beaucoup de concentration, toutefois la sauvegarde de configurations est possible et permet de préparer et naviguer entre constructions réfléchies et étudiées à lʼavance. La solution de connectique par buses dont on nʼa pas un feedback visuel a lʼavantage de permettre un nombre élevé de connexions possibles qui seraient autrement difficiles à représenter dans une interface graphique, et donc aussi avoir un grand nombre de modules et de versions différentes. Ici, une capture dʼécran de lʼinterface graphique dʼun module de réverbération sur IXIQuarks Pro, pour illustrer les options menus pour les buses dʼentrée et sortie du traitement, puis le menu contextuel pour déplacer le traitement au long de la chaine de synthèse. Une autre solution peut être illustrée par le travail de Jean Lochard (IRCAM 2009) qui a développé une application pour MAXMSP : Najo Max Interface dont les configurations sont sauvegardées comme projets et la logique de construction obéit à celle de la programmation en MAXMSP, cʼest à dire une connectique entre objets graphiques puis une table de mixage graphique avec 8 canaux dʼentrée et 8 canaux de sortie. Lʼinterface graphique est divisée en deux, une partie réservée à lʼédition du patch et une deuxième au contrôle.

Figure 11 Module de réverbération IXIQuarks

Figure 12 Najo Max Interface


47

Le caractère très attractif de lʼinterface graphique pour chaque module qui peut sʼéditer et contrôler les paramètres avec des courbes dont on peut varier la forme et la vitesse de lecture, disparaît quand le patch devient complexe et la limite de place apparaît, donc on revient sur les encapsulations dans des sub-patchers propres à MAXMSP. Toutefois lʼanalogie avec une table de mixage est une idée intéressante et facilite lʼaccès à ceux qui sont un peu familiarisés avec la programmation graphique. Inspiré de lʼobjet « matrixctrl » de MAXMSP, je lʼai implémenté sur SuperCollider, le principe est celui dans Switch qui permet de diriger les signaux vers des ports dans un système de coordonnées cartésiennes. Cet objet graphique a lʼintérêt de permettre une rapide visualisation du mapping, mais à lʼopposé des exemples présentés plus haut le nombre de modules est limité car on doit fixer la quantité dʼentrées et de sorties pour la matrice et pour les synthétiseurs, car comme je lʼai montré dans chaque synthétiseur décrit plus haut, le nombre de sorties est géré par la classe DistributedOut (réalisation personnelle) qui permet de sélectionner des canaux de sortie non conjoints avec un contrôle indépendant de lʼamplitude. Avant de continuer dans la description de cette matrice élaboré en SuperCollider je voudrais signaler le travail de Tom Mays qui a developpé une application « Tapemovie » sur MAXMSP qui accepte au moment de la création et de la configuration du projet de définir le nombre des modules audio, traitement, contrôle, et un script construit la matrice avec le nombre correct de sorties et dʼentrées en plus dʼun contrôle de niveau à chaque point de celle-ci. Figure 13 Matrix Logiciel Tapemovie


48

De cette façon il a contourné les deux problèmes que jʼai remarqués plus haut, un retour visuel pour comprendre les enchainements des signaux et une matrice qui sʼadapte à un nombre variable de modules. Voici à quoi ressemble lʼinterface graphique de la matrice en Jabalion.

Regardant maintenant le code de plus près, expliqué pas à pas. Matrix { var matrixwindow,backgroundmatrix,xpos=6,ypos=640,but,bat,bot,<>clear; var <>rows=10,<>columns=10, rowstexts,columntexts,cordonates,function;

var fmatrixint; *new { |columns,rows,xpos,ypos,function| ^super.new.initMatrixClass(columns,rows,xpos,ypos,function) } initMatrixClass {|argcolumns,argrows,argxpos,argypos,argfunction| columns = argcolumns; rows = argrows; xpos = argxpos; ypos = argypos; function = argfunction; this.gui; cordonates = [] }

Figure 14 Matrix Jabalion


49

Tout dʼabord la classe se définit comme une fonction suivie par ces variables, les signes < > déterminent si la variable est accessible depuis lʼextérieur (il sʼagit dʼun raccourci pour les méthodes set et get), dans lʼordre, ces variables sont : la fenêtre où tout sera placé, une sub-classe (background) pour placer la grille, la position dans lʼécran dans les axes x et y, trois vecteurs de buttons pour sa manipulation et création, le bouton pour nettoyer ou enlever tous les connexions, le nombre de rangs ou lignes et le nombre de colonnes, deux variables pour traiter le nom associés à chaque rang et à chaque colonne, cordonates est un vecteur pour traiter la fonction value, function est la fonction qui sera assignée à chaque connexion, finalement une fonction dʼinitialisation. La méthode *new retourne un nouveau objet dʼaprès cette classe, (*indique un méthode de classe), ses arguments sont : nombre de colonnes, nombre des rangs, position x et y dans lʼécran, fonction. ^super.new.initMatrixClass… est la façon de passer des arguments pour la création dʼune nouvelle « instance » ou cas. initMatrixClass est la fonction avec lʼordre des arguments et « actions » à réaliser quand on crée lʼobjet, ici jʼinitialise la variable cordonates comme un vecteur sans taille fixe, et this.gui appelle la méthode gui (décrite ci-dessous) pour construire lʼinterface graphique. gui { // La fenêtre principale, remarquer comment la quantité des rangs et de //colonnes modifient la taille matrixwindow = GUI.window.new("matrix", Rect(xpos,ypos, (25*rows+90), (25*columns+70)),resizable:false); matrixwindow.view.background = Color.white; // Le fond backgroundmatrix = CompositeView(matrixwindow, Rect(5,5,(25*rows+80), (25*columns+60))) .background_(Color.grey.alpha_(0.3)); // Dessiner la grille GUI.userView(backgroundmatrix,Rect(0,0,(25*rows+80),(25*columns+60))) .drawFunc = {Pen.strokeColor = Color.black(0.2); columns.do({|i| Pen.moveTo(60@(25*i+75)); Pen.lineTo((25*rows+70)@(25*i+75)); Pen.stroke}); rows.do({|i| Pen.moveTo((25*i+75)@60); Pen.lineTo((25*i+75)@(25*columns+70)); Pen.stroke});};


50

// Composer une tablete pour repérer la position de la souris et ainsi // rendre visibles les boutons (voir au dessous) GUI.tabletView(backgroundmatrix,Rect(0,0,(25*rows+80),(25*columns+60))) .mouseDownAction = {|view,x,y|var bat,z; bat=but.clump(rows); rows.do({|j| columns.do({|i| if((x > (60+(j*25))) && (x < (80+(j*25))) && (y > (60+(i*25))) && (y < (80+(i*25))), {bat[i][j].visible_(true); bat[i][j].valueAction_(1)});});}); //ici c’est une routine pour placer les nouveaux synthés dans le bon //ordre pour SuperCollider et si la fenêtre d’affichage de l’arbre de //synthèse est ouverte l’actualiser r{0.5.wait; if(~values.ids[this.value[1]-1] != 0) {Server.local.sendMsg(\n_before, (1300+(this.value[0]-7)),(1300+(this.value[1]-1)))}; Window.allWindows.do({|i|if (i.name == "localhost Node Tree"){ r{i.close;0.1.wait;Server.local.plotTree}.play(AppClock)}}); }.play(AppClock)}; // Créations des buttons, ils sont invisibles, jusqu’au qu’on click // dessus, l’action à exécuter est celle passée comme argument lors de // la création de l’initialisation de la classe bot = Array.newClear(columns); but = List.new; rowstexts = Array.newClear(columns); columntexts = Array.newClear(rows); columns.do({|i| rows.do({|j|

bot[i] = GUI.button.new(backgroundmatrix, Rect(70+(j*25),70+(i*25), 10, 10)).canFocus_(false);

bot[i].states_([["",nil,Color.grey.alpha_(0.3)], ["",nil,Color.red]]); bot[i].visible_(false); bot[i].action_({|but| this.fmatrixint(j,i,but.value); function.value; if(but.value == 0) {bat[i][j].visible_(false)} {bat[i][j].visible_(true)}}); but.add(bot[i]);});});


51

// donner un nom à chaque colonne et chaque rang columns.do({|i| rowstexts[i] = GUI.staticText.new(backgroundmatrix, Rect(4,65+(i*25), 80, 20)) .string_("output " ++ (i+1)).font_(Font(\Monaco,10)) .stringColor_(Color.black(0.8,0.4));}); rows.do({|i| columntexts[i] = GUI.staticText.new(backgroundmatrix, Rect(75+(i*25),-40, 9, 100)) .string_("In "++ (i+1)).font_(Font(\Monaco,10)) .stringColor_(Color.black(0.8,0.4));}); // Le bouton pour effacer les connexions clear = GUI.button.new(matrixwindow,Rect(10,10,35,20)).canFocus_(false) .states_([["clear",Color.black,Color.blue(0.8,0.4)]]) .font_(Font(\Times,10)) .action_({(but.size).do({|i| but[i].valueAction_(0); but[i].visible_(false)});cordonates = []; // Un test pour actualiser la fenêtre d’affichage de l’arbre de //synthèse si ouverte Window.allWindows.do({|i|if (i.name == "localhost Node Tree"){ r{i.close;0.5.wait;Server.local.plotTree}.play(AppClock)}}); }); } à partir dʼici les méthodes auxquelles lʼobjet matrix va répondre //Retourne le rang, la colonne et la valeur du dernier bouton. value { ^cordonates;} // Commande pour établir de connexions et les afficher sur l’interface valueAction_ {|j,i,k| bat=but.clump(rows); if (k==1) {bat[i][j].visible_(true)}{bat[i][j].visible_(false)}; bat[i][j].valueAction_(k)} // Retourne tous les valeurs de la matrice à chaque point dump {var dump = []; bat=but.clump(rows); rows.do({|j|columns.do({|i|dump=dump.add(bat[i][j].value)})}); dump = dump.clump(columns); ^dump;}


52

// Retourne les valeurs d’un rang getRow {|n| var dump = []; rows.do({|j|columns.do({|i|dump=dump.add(bat[i][j].value)})}); dump = dump.clump(rows); ^dump[n]; } // Retourne les valeurs d’une colonne getColumn {|n| var dump = []; rows.do({|j|columns.do({|i|dump=dump.add(bat[i][j].value)})}); dump = dump.clump(columns); ^dump[n]; } //Retourne une liste avec tous les coordonnées et sa valeur 1 active 0 //inactive dumpAll {var dump = [],result=[],out=[]; (columns*rows).do({|i|dump = dump.add(but[i].value)}); dump=dump.clump(columns); columns.do({|i|rows.do({|j|result=result.add([i,j])})}); (columns*rows).do({|i| out=out.add(result[i].add(dump[i]))}); ^out; } // Retourne la sum d’une colonne integrateColonne_ {|n| var z =[]; bat=but.clump(rows); columns.do({|i| z = z.add(bat[i][n].value)}); ^z.sum } // Commande pour changer les textes sur chaque rang setRowText_ {|j,text| rowstexts[j].string_(text); matrixwindow.refresh; } // Commande pour changer les textes sur chaque colonne setColumnText_ {|j,text| columntexts[j].string_(text); matrixwindow.refresh; } // Rendre visible/invisible la fenêtre principale front_ {|val|

if (val == true) {matrixwindow.visible_(true)} {matrixwindow.visible_(false)} }

// Changer le nom de la matrice name_ {|newname| matrixwindow.name_(newname) }


53

// Methode pour permettre ou empcher la fermeture de la fenêtre canClose_ {|bol| if (bol == true) {matrixwindow.userCanClose_(true)} {matrixwindow.userCanClose_(false)} } // Commande pour ajouter une nouvelle action aux boutons newAction_ {|func| (columns*rows).do({|i|but[i].mouseDownAction_(func)}) } Celle-ci est la fonction passée pour lʼactivation / désactivation des sorties sur chaque synthétiseur. fmatrixpros = { var id,cor,dump; cor=~values.matrixprocessing.value; dump=~values.matrixprocessing.dump; ~values.put('matrixout',dump); j=cor[0];i=cor[1];k=cor[2]; if ((j == 0) && (~values.matrixprocessing.integrateColonne_(0) >= 1) && ((~values.newidadc[0] == 0)||(~values.newidadc[0] == nil))) {~values.adc.play[0].valueAction_(1); server.sendMsg(\n_set,1198,("amp"++ (i+1)).asSymbol,k)}; if ((j == 0) && (~values.matrixprocessing.integrateColonne_(0) == 0) &&

(~values.newidadc[0] == 1198)) {~values.adc.play[0].valueAction_(0)}; if (j == 0) {id = 1198; if (~values.newidadc[0] != nil) {if(~values.newidadc[0] == id) {server.sendMsg(\n_set,id,("amp"++ (i+1)).asSymbol,k)}}}; Il sʼagit dʼun test en trois étages « j » étant la valeur de la colonne ~values.matrixprocessing.integrateColonne_(0) teste si la colonne a ete activé ou désactivée et ~values.newidadc[0] test si le synthétiseur est en train de jouer déjà. Cette opération sʼapplique à chaque colonne et respectivement à chaque synthétiseur, une suite de test logique de ce type sʼappele « case », donc la fonction pour cette matrice calcule un case à 19 possibilités. Une deuxième matrice est utilisée pour le mapping octophonique de sorties. Cʼest une avantage de la programmation pour objets une fois le modèle écrit on peut reconstruire autant de versions de lʼobjet quʼon veut. Pour le cheminement des signaux audio, cette matrice sʼavère un outil efficace, bien que ses limites soient durement surmontables car le fait dʼajouter un module de plus de synthèse ou de traitement équivaut à remanier le code dans plusieurs endroits ; mais, quel instrument ne connaît pas de limites ?


54

2.5 GU Interface Graphique

Dans la section précédente jʼai touché un point clé dans la programmation dʼun logiciel, celui de lʼinterface graphique. Effectivement, le retour visuel pour piloter, modifier, ou interagir avec le logiciel et ses fonctions peut être un critère de jugement sur la praticité ou jouabilité de chaque programme. Toutefois les goûts individuels peuvent être contrastés et personne nʼa le dernier mot à ce sujet. Par exemple, personnellement je considère que sʼagissant des applications audio le focus devrait être porté sur les opérations sonores et lʼinterface graphique devrait être le plus simple possible, mais pas inexistante évidemment, car on doit pouvoir retrouver facilement certaines informations sur lʼactivité, les envois, les réponses, les niveaux et les cheminements des signaux. Si je peux me permettre un détour par mon vécu et mes appréciations personnelles, par ma formation comme instrumentiste, jʼadore jouer avec les yeux fermés, ça me permet de mieux me concentrer et de rêver ou de construire un imaginaire très subjectif en jouant, je donne beaucoup dʼimportance au développement de la proprioception. Cet amour pour lʼobscurité nécessaire à lʼécoute mʼa posé certains problèmes en concert. Par exemple jʼabandonne progressivement lʼutilisation des capteurs ou interfaces qui demandent une attention visuelle trop importante (photosensors, caméras…), Mon opinion est celle dʼun interprète et pas celle dʼun analyste, chercheur ou musicologue pour qui le processus de visualisation prend une toute autre dimension avec des intérêts profonds sur la physiologie et la perception. Tel que lʼa très bien montré Mme Anne Sedes34 avec son groupe de recherche sur la visualisation et émulation artistique et la représentation scientifique du son, à la maison des Sciences de l'Homme Paris Nord. Mis à part le goût personnel pour des interfaces embellies, pleines de couleurs et dʼinformations ou des interfaces plus sèches et simples, il faut prendre en compte le fait que le coût des processus visuels en temps réel nʼest pas négligeable pour la CPU et le processeur. Ainsi plusieurs environnements permettent de donner priorité aux calculs des traitements sonores sacrifiant la mise à jour des interfaces graphiques qui se bloquent parfois à cause du taux important de calcul quand il sʼagit de synthèse granulaire, analyse de Fourier, commandes de contrôle, etc.

34 Anne SEDES « De l’espace sonore à la visualisation du son : un parcours musicologique, technologique et artistique » Dossier d’habilitation à diriger des recherches, Université Paris VIII, 2007


55

En guise dʼillustration du contraste de choix de programmateurs en rapport de lʼinterface graphique, voici deux exemples de deux logiciels construits pour lʼimprovisation. Le premier « Omax » développé par G. Assayag, G. Bloch, M. Chemillier et M. Shlomo Dubnov à lʼéquipe de représentations musicales de lʼircam, 2008.

Figure 15 Intreface graphique OMAX

La première impression est celle dʼun environnement complexe avec un écran fourni en boutons, commandes, consoles et objets dʼune taille un peu réduite. Et il est complexe, car il utilise MAXMSP pour calculs et décisions rapides en temps réel communiquant avec une version de Open Music qui tourne sur LISP pour une analyse et prédiction approfondie des événements passés et/ou futurs. Le tout communiquant par des messages OSC et établissant un modèle de séquences dʼévénements « oracle » pour produire une proposition qui peut se rapprocher ou sʼéloigner du style et du langage du musicien35. Ainsi sʼexplique le besoin de deux consoles, une pour MAXMSP, lʼautre pour Lisp, les deux autres fenêtres sont des commandes générales et des commandes dʼimprovisation, il y a aussi quelques menus et fenêtres secondaires pour gérer les buffers et certaines informations dʼutilisation. Son usage nʼest pas très intuitif mais lʼinterface graphique concentre le plus important pour le pilotage et lʼaffichage des événements musicaux sur un écran. En jouant en solo il faut être très attentif aux réglages pour automatiser les processus et il faut également une écoute délicate des propositions du logiciel. En duo le musicien au pilotage du logiciel a un champ de liberté qui permet au deuxième de se concentrer sur son matériau. Plusieurs musiciens très

35 Gerard ASSAYAG « Omax the software improviser Tutorail » Ircam 2008


56

reconnus36 dans le monde de lʼimprovisation ont été invités à explorer le programme, leurs retours son consultables en ligne 37, lʼimpression générale étant plutôt positive. Mon deuxième exemple est IXILang, récemment développé dans SuperCollider par Thor Mangson à lʼuniversity of Sussex (jʼai déjà cité son travail avec le collective IXISoftware). Dans cette application, aussi destinée à lʼimprovisation, tout est texte : une fenêtre à fond noir avec les polices du texte en blanc et une fenêtre console cʼest tout. Il faut dire que cette application ne permet pas de traiter de sons instrumentaux joués par dʼautres musiciens, et elle sʼinscrit dans le mouvement du « live coding » ou programmation en temps réel38. XiiLang() tuning just // choose a tuning scale minor // set the scale // score mélodique jimi -> guitar[1 2 6 2 ]// un motif de 4 notes appelé jimi jimi -> guitar[1 2 6 2 ]+12 // jimi transpose d’une octave jimi -> guitar[1 2 6 2 ]!16 // silence de 16 notes jimi -> guitar[1 2 6 2 ]+12!16 // combinaison de deux // score percussive ringo -> |o x o x | //les letres son mappés à synthétiseurs ringo2 -> | ii s n | ringo3 -> | o o d sd |!12 // silence pendant 12 pulsations // score concrète pierre -> water{0 2 8 4 1 0 } // les nombres sont amplitudes henry -> water{0 2 8 }!14 schaeffer -> water{0 2 8 }*4!14 Voici a quoi ressemble lʼécran du programme (avec quelques commentaires explicatifs), les modèles ou patrons peuvent être rythmiques, mélodiques ou avec des échantillons, en suivant le type dʼaccolade utilisé « [] », « {} », « || », à lʼintérieur les caractères, chiffres ou lettres représentent notes MIDI ou instruments ou amplitudes, les distances entre les caractères représentent les durées, le nom de chaque patron permet de les grouper, les traiter avec quelques effets, les programmer dans le futur, le faire taire, transposer, changer le tempo. Il est évident quʼici cʼest presque sinon complètement impossible de jouer avec les yeux fermés, lʼapproche étant complètement différente.

36BernardLUBAT,MikeGarson,PhilippeLECLERC,HélèneSCHWARZ,GuerinoMAZZOLA37http://www.ircam.fr/equipes/repmus/OMax38http://www.vimeo.com/ixi


57

Mon approche sera donc une interface simple. En plus de la matrice jʼai écrit pour chaque synthétiseur une classe qui permet de surveiller et contrôler les arguments avec des potentiomètres linaires. Tous les paramètres sont normalisés entre 0 et 1 et un indicateur de niveau accompagne chaque synthétiseur pour être sûr quʼil fonctionne correctement en envoyant du signal. Voici par exemple une capture dʼécran de la fenêtre qui regroupe trois traitements. Cette fenêtre peut être ouverte depuis une fenêtre de commande qui est toujours au front du logiciel Ou depuis le « menu bar » dans le menu principal du logiciel ou avec un raccourci clavier

Figure 16 Jeu de potentiomètres Jabalion

Figure 17 Fenêtre Principale et menu Jabalion


58

2.5.1. Potentiomètres et indicateurs de niveau

Je vais présenter un seul exemple tiré de la classe écrite pour le pilotage de la granulation mais en tout il y a 22 classes qui peuvent être examinées dans le dossier SCClassLibrary de lʼapplication39. /* Cette première partie comme pour la classe Matrix, est le lieu où on déclare les variables et les fonctions d’initialisation, une particularité ici est la possibilité d’inscrire toute l’interface dans une fenêtre existante, autrement une nouvelle fenêtre est crée. Chaque slider est un objet dont on peut demander ou saisir les valeurs depuis l’extérieur, id est la variable qui détermine l’identifiant du synthétiseur, ici 1307, donc dans l’arborescence de synthèse on peut le retrouver facilement car son nom associé sera granulator */ Granulator { var window,background,<bounds,<>rate,<>density,<>wet,<>grainslevel; var <>pitchdepth,<>posrate,<>posdisp,levelview,<>duration; var xpos=300,ypos=500,width= 260,heigth= 15; var osc1,osc2,osc3,id,granulatorId,server, c;//midicontrollers *new {|window,bounds| ^super.new.initGranulatorClass(window,bounds)} initGranulatorClass {|iwindow,ibounds| if (ibounds == nil){bounds = Rect(10,5,290,250)} {bounds = ibounds};

if (iwindow == nil) {window = GUI.window.new("Grains",Rect(xpos,ypos,300,260),resizable:false) window.view.background_(Color.new(0.2,0.025,0.08,0.4));} {window = iwindow}; server = Server.default; id = 1307; if (~values == nil) {~values = ()}; if (~midi == nil) {~midi = ()}; c = Array.newClear(8);this.gui;} /* Dans la fonction interface graphique (gui) je ne montrerai qu’un seul potentiomètre linaire (slider) pour illustrer la façon dont les actions ou fonctions y sont associées. Remarquez aussi la façon de saisir le nom du texte accompagnant le fond, car la fenêtre est optionnelle */

39J’utilise aussi d’autres objets graphiques tirés de librairies, soit celle de la distribution standard comme pour la fenêtre du « Serveur » et « dump tree » ou bien celle distribuée par l’université de Weysellan pour les fenêtres « sound test » et « midi test ».


59

gui {background = GUI.compositeView.new(window,bounds) .background_(Color.grey.alpha_(0.3)); GUI.staticText.new(background,Rect(8,-70,10,220)) .string_("Grains").font_(Font(\Monaco,12));

/* celui-là est le sider associé à l’oscillateur qui contrôle les variations du pitch dans les grains tel que décrit plus haut */

rate = EZSlider(background,Rect(10, 10, width, heigth),"PitchRate ",

//normalisation des valeurs ControlSpec(0, 1, \lin, 0.01,0.2),

//fonction, message OSCpour le synthétiseur {|ez| var val=ez.value; server.sendMsg(\n_set,id,\rate,val)}, // valeur par défaut 0.2,unitWidth:30, numberWidth:50,layout:\horz) // Police et couleurs .font_(Font("Times",10)) .setColors(Color.clear,Color.yellow, Color.grey(0.7), Color.clear, Color.yellow, Color.yellow); /* Avec cette fonction on peut assigner un contrôleur midi quand le slider est sélectionné en appuyant la touche m, ou l pour l’effacer, 66 est le nombre de ce contrôleur qui pourra être accessible grâce à un dictionnaire ou à chaque paramètre de contrôle pourra être assigné un contrôleur midi à la main. « defer » est une méthode pour actualiser les objets graphiques en utilisant l’horloge du système, plus rapide et précis que celui de l’application */ rate.sliderView.keyDownAction_(UnicodeResponder.new.normal(

$m -> {c[0]=CCResponder({|src,chan,num,value| {rate.sliderView.valueAction_(value/127)}.defer; ~midi.cc13071=[src,chan,num]; if (~fsetmidimapping != nil) {{~fsetmidimapping.(66,src,chan,num)}.defer}{}}).learn}, $l -> {c[0].remove;~midi.cc13071=[];

if (~fsetmidimapping != nil) {{~fsetmidimapping.(66,0,nil,nil)}.defer}{}}));

// L’indicateur de niveau de sortie du synthétiseur levelview = GUI.levelIndicator.new(background, Rect(72, 210, 116, 16)) .style_(0).warning_(0.6) .critical_(0.9) .canFocus_(false)}


60

/* Jusqu’ici les objets graphiques ont été créés, maintenant vient le moment de déclarer les méthodes, par exemple en appelant la méthode run_(1), cette classe regarde la valeur de chaque slider, puis suit un test pour vérifier s’il y a des sorties déjà choisies dans la matrice et elle crée un nœud de synthèse, si la valeur est 0, fermer le gate du synthétiseur avec un temps de relâche de 2 secondes */ run_ {|but| if (but == 1) { server.sendMsg(\s_new, \granulator, id, 1,3); server.sendMsg(\n_set,id,\wet,wet.value,\rate,rate.value, \density,density.value,\pitchdepth,pitchdepth.value, \duration,duration.value,\grainslevel,grainslevel.value, \posrate,posrate.value, \posdisp,posdisp.value); if (~values.matrixout != nil) {if (~values.matrixout[14].sum >= 1) {this.setoutputs(~values.matrixout[14])}}; server.queryAllNodes}; if (but == 0) { server.sendMsg(\n_set, id,\gate, -2); ~values.granulatorId = 0; };} /* Cette série de méthodes permet de manipuler les valeurs de chaque paramètre tout en ayant un retour graphique */ setrate_ {|val|rate.valueAction_(val)} setpitchdepth_ {|val|pitchdepth.valueAction_(val)} setdensity_ {|val|density.valueAction_(val)} setduration_ {|val|duration.valueAction_(val)} setposrate_ {|val|posrate.valueAction_(val)} setposdisp_ {|val|posdisp.valueAction_(val)} setwet_ {|val|wet.valueAction_(val)} setvol_ {|val|grainslevel.valueAction_(val)} setoutputs {|matrix| if (~values.granulatorId == id) {matrix.do({|item,i| server.sendMsg(\n_set,id,("amp"++ (i+1)).asSymbol,item)})}; }


61

/* Voici les fonctions pour déclarer ou enlever la communication entre le moteur de synthèse et cette classe, pour récupérer les informations de niveau de sortie du synthétiseur, pour envoyer un message quand il démarre, pour stocker son identifiant et pouvoir le contrôler dans la matrice, pour envoyer un message quand le synthé s’arrête, et pour nettoyer les variables et l’affichage du contrôle de niveau*/ fosc {osc1 = OSCresponderNode.new(server.addr,'levels', {arg time, resp, msg; {if(msg[1] == id,{ levelview.value = msg[3].ampdb.linlin(-40, 0, 0, 1); levelview.peakLevel = msg[4].ampdb.linlin(-40, 0, 0, 1); })}.defer;}).add; osc2 = OSCpathResponder(server.addr,['/n_go',id],{|time,resp,msg| ~values.put('granulatorId',granulatorId = msg[1]); ~values.ids.put(7,msg[1])}).add; osc3 = OSCresponderNode(server.addr,'/n_end',{arg time,resp,msg; {if(msg[1] == 1307,{("Granulator " ++ "stoped").postln; ~values.ids.put(7,0); levelview.value_(0)})}.defer}).add} oscadd {this.fosc} oscremove {osc1.remove;osc2.remove;osc3.remove; ^"osc Granulator removed".postln } /* Les quatre dernières méthodes concernent l’affichage de la fenêtre principale, canClose_(true/false) pour empêcher l’utilisateur de fermer la fenêtre avec le bouton rouge en haut de chaque fenêtre, autrement en fermant l’interface on serait obligé d’appeler à nouveau la création de la classe, chose possible uniquement avec une ligne à commande, la méthode front_(true/false) rend la fenêtre visible ou invisible, bounds change la taille et position de la fenêtre dans l’écran */ canClose_ {|bol|if (bol == true) {window.userCanClose_(true)} {window.userCanClose_(false)}} front_ {|val|if (val == true) {window.visible_(true)}

{window.visible_(false)}} bounds_ {|newbounds| background.bounds_(newbounds);^window.refresh} boundsWindow_ {|newbounds| window.bounds_(newbounds);^window.refresh}}


62

2.5.2 Panoramique

Ci-contre la fenêtre « panus ». Elle permet de spatialiser le son dans un système octophonique. Le cercle étant juste un repère pour visualiser la position des haut-parleurs, cʼest à dire quʼils peuvent être disposés dans une autre configuration et en déplaçant le point vert le niveau associé à chaque point rouge sera plus important. Certaines trajectoires sont proposées dans le menu : circulaire vers la gauche, circulaire vers la droite, croix, petit carré, grand carré, spirale depuis le centre, spirale vers le centre et déplacements aléatoires. La variable « rate » permet de varier la vitesse de déplacement.

On peut aussi enregistrer ses propres déplacements avec lʼobjet automator que je vais présenter dans la section 2.6.5 Les déplacements automatisés ont été écrits comme des routines ou un compteur va de 0 à 360 puis cette valeur est transformée en coordonnées cartésiennes avec la méthode point et finalement assignée au contrôle bidimensionnel (abscisses et ordonnées) de lʼobjet GUI.slider2D. Voici deux exemples du code pour réaliser cette opération. /* Un test de précaution permet d’empêcher de jouer plusieurs routines à la fois, puis la méthode « case » sélectionne le type de routine (Task) à jouer en suivant la valeur choisie dans le menu */ if (task.isPlaying == true) {"Already playing stop first to change".warn}{case

Figure 18 Panoramique


63

/* Déplacements vers la droite, le compteur « i » va de 0 à 360, j’ajoute 90 pour commencer au point centre-haut. La division par 360*2pi ramène les valeurs à l’échelle -1 et 1, puis la méthode « lilnlin » les convertit dans le rang compris par l’interface graphique 0,1. La deuxième formule inverse simplement le compteur « reverseDo » de façon à commencer par 360 et ainsi avoir un déplacement vers la droite */ {menu.value == 2} {task=Task({loop({360.do({|i|var val=1.polar(i+90/360*2pi).asPoint; {slider2d.setXYActive(val.x.linlin(-1,1,0,1), val.y.linlin(-1,1,0,1))}.defer; (rate.value).wait})})})} {menu.value == 3} {task=Task({loop({360.reverseDo( {|i|var val=1.polar(i+90/360*2pi).asPoint; {slider2d.setXYActive(val.x.linlin(-1,1,0,1), val.y.linlin(-1,1,0,1))}.defer; (rate.value).wait})})})} // Plus complexe, cette routine met en place huit déplacements, 1) on commence sur le point au centre bas, donc la valeur des ordonnées est 0.5 puis on ajoute la valeur de 0 à 1 i=0,100 puis on multiplie par 0.01 déplaçant le point jusqu’à haut centre. {menu.value == 4} {task=Task({loop({ 100.do({|i|{slider2d.setXYActive(0.5,i*0.01)} .defer;(rate.value).wait}); (rate.value*4).wait; 2) Depuis là on se déplace d’un quart d’arche, de 0 à 90° vers la gauche 90.do({|i|var val=1.polar(i+90/360*2pi).asPoint; {slider2d.setXYActive(val.x.linlin(-1,1,0,1), val.y.linlin(-1,1,0,1))}.defer; (rate.value).wait}); (rate.value*4).wait; 3) nous sommes au point le plus à gauche centre, et on réalise un déplacement vers l’extrême droite en gardant la position dans les ordonnées de 0.5 100.do({|i|{slider2d.setXYActive(i*0.01,0.5)} .defer;(rate.value).wait}); (rate.value*4).wait;


64

4) encore un quart d’arche toujours vers la gauche ce qui nous amène au point 2 90.do({|i|var val=1.polar(i+360/360*2pi).asPoint; {slider2d.setXYActive(val.x.linlin(-1,1,0,1), val.y.linlin(-1,1,0,1))}.defer; (rate.value).wait}); (rate.value*4).wait; 5) chemin numéro 1 à l’inverse, donc on revient au point départ. 100.reverseDo({|i|{slider2d.setXYActive(0.5,i*0.01)}.defer; (rate.value).wait}); (rate.value*4).wait; 6) même formule qu’au chiffre deux mais à l’inverse donc déplacement depuis centre bas vers gauche centre. 90.reverseDo({|i|var val=1.polar(i-180/360*2pi).asPoint; {slider2d.setXYActive(val.x.linlin(-1,1,0,1), val.y.linlin(-1,1,0,1))}.defer; (rate.value).wait}); (rate.value*4).wait; 7) traversée en ligne jusqu’à l’extrême droite au milieu des abscisses 100.do({|i|{slider2d.setXYActive(i*0.01,0.5)}.defer; (rate.value).wait}); (rate.value*4).wait; 8) retour à la position de départ avec un quart d’arche dans le sens des aiguilles d’une montre. Le tout est bouclé donc l’opération se répète indéfiniment jusqu’à l’arrêt explicite avec le bouton marche/arrêt 90.reverseDo({|i|var val=1.polar(i+270/360*2pi).asPoint; {slider2d.setXYActive(val.x.linlin(-1,1,0,1), val.y.linlin(-1,1,0,1))}.defer; (rate.value).wait}); (rate.value*4).wait;})})}


65

2.5.3 Lecteur de Fichiers

Lʼinterface graphique pour contrôler et afficher les archives sonores mʼa demandé un investissement considérable, car je voulais avoir certaines facilités comme par exemple, créer un modèle pour pouvoir le reproduire cinq ou six fois, avoir un facile accès à une liste dʼarchives et pouvoir sélectionner et jouer des sections différentes, accepter plusieurs formats des fichiers (aiff,wave,map3…), avoir un curseur indiquant la position de lecture dans le fichier, et en plus des fonctions habituelles de « play, stop, pause, loop, vitesse » avoir une fonction de lecture « crazy » qui lirai lʼarchive en sautant aléatoirement à différentes places du fichier.

Avec ces contraintes, jʼai dû étudier à fond les classes Buffer, PlayBuf, lʼenvoi et lʼinterprétation de messages OSC du SCSynth vers SClang, le décodage des fichiers mp3, les fonctions « drag and drop » la gestion de listes, lʼécriture des fonctions à lʼintérieur dʼune classe et la gestion des ordres parallèles pour lʼinterface graphique et le moteur de synthèse. Je ne détaillerai dans cette classe que deux fonctions, car le code entier sans commentaires fait cinq pages. Toutefois avec les explications que jʼai donné au fur et à mesure et vu que jʼai cherché à avoir une grammaire claire en appliquant systématiquement les mêmes ordres, le code donné en annexe devrait être assez accessible. /* Les modules sont groupés dans un vecteur de 5 players, ainsi cette fonction aura pour argument un nombre entier qui désigne un des cinq modules auquel le message s’adresse, par exemple en appelant Polysampler.fplay(0), c’est le premier player qui se mettra à jouer « id » étant l’identifiant du synthétiseur */ fplay {|n|var id;id = 1200 + n; /* un premier test pour empêcher l’appel de la fonction si aucun fichier est sélectionné */ if(choosefile[n].value == 0) {"select first a sound file".warn; play[n].value_(0);}{

Figure 19 Forme d’onde et Liste d’archives Lecture des fichiers


66

/* maintenant la routine qui sera jouée par l’horloge de l’application car des objets graphiques sont en jeu, une autre possibilité aurait été d’encapsuler la routine dans une fonction et d’appeler la méthode « .defer » pour ainsi utiliser l’horloge du système */ r{ server.sendMsg(\s_new, \samples,id,0,2); server.sendMsg(\n_run,id,0); 0.1.wait; /* Une fois le synthétiseur créé on empêche l’utilisateur d’appuyer sur les boutons loop ou crazy car celà appellerai une fois de plus la création d’un synthétiseur */ loop[n].enabled_(false); crazy[n].enabled_(false); /* Maintenant on initialise le synthé avec les valeurs de l’interface graphique, ceci permet d’arrêter le synthé et puis au moment de le rappeler il ne vient pas aux valeurs par défaut mais à celles qui étaient avant l’arrêt */ server.sendMsg(\n_set,id,\bufnum,n,\vol,~values.playersf.vol[n].value, \rate,~values.playersf.rate[n].value); /* Ce test demande à la matrice dans quelles sorties doit jouer le synthétiseur */ if (~values.matrixout != nil) {if(~values.matrixout[n+2].sum >= 1) {this.setoutputs(~values.matrixout[n+2],n)}}; 0.1.wait; /* Ici, on vérifie s’il y a une sélection dans une région du fichier ou bien s’il doit être joué en entier, s’il y a une région les valeurs ont été stockées dans les variables, start, end, dur */ if ((~values[("newdur" ++ n).asSymbol] == 0) || (~values[("newdur" ++ n).asSymbol] == nil)) {server.sendMsg(\n_set,id,\start, 0,\end, 1, \dur,~values.durations[n],\t_trig,1,\t_gate,1)} {server.sendMsg(\n_set,id,\start, (~values[("newstart" ++ n).asSymbol]), \end, (~values[("newend" ++ n).asSymbol]), \dur, (~values[("newdur" ++ n).asSymbol]), \t_trig,1,\t_gate,1)}; server.sendMsg(\n_run, id,1); }.play(AppClock)}}


67

2.5.4 Lecteur de tables

Lʼobjet graphique suivant est celui de la lecture de tables, une table est une courbe sur laquelle on peut fixer son rang et sa vitesse de lecture, les valeurs ainsi lues seront affectées aux paramètres de contrôle de chaque synthétiseur. Ce procédé sera décrit dans le chapitre suivant quand je rentrerai dans le détail par rapport aux différentes modalités de contrôle. Ces courbes peuvent être dessinées à la main ou appelées dʼun menu qui a déjà plusieurs fonctions par défaut.

/* L’objet popwave fait partie d’un vecteur, ainsi plusieurs instances ou modèles peuvent être créés avec le même code, avant de définir ses fonctions on déclare son contenu et son apparence */ popwave[i] = GUI.popUpMenu.new(background[i],Rect(210,35,65,24)).canFocus_(false) .items_(["wave","-","gaus","spring","ramp","saw","triangle", "noise","hills","constant","one","zero"]) .font_(Font(\Times,14)) .action_({|menu|var case,val=menu.value;val.postln; /* Une fois de plus la fonction est composée d’une série de cas, en suivant le choix de l’utilisateur. Chacune de ces possibilités est un multislider à 100 points où l’on peut modifier le rang, c’est-à-dire le minimum et le maximum de la valeur de sortie et le débit en secondes auquel ces valeurs sortiront */ case = case /* Cette première courbe remplit le tableau en multipliant un indice v (entre 0 et 100) par pi et une fois la valeur du sinus calculée on l’élève au carré, le résultat est une courbe du type gaussienne */ {val == 2}{waveview[i].valueAction_( Array.fill(100,{|v|((v*0.01)*pi).sin*((v*0.01)*pi).sin}))}

Figure 20 Multislider à 100 points, liste de paramètres à affecter, vélocité. Tables


68

/* Cette courbe que j’appelle « spring » ou ressort est une somme de 200 fonctions sinus dont les amplitudes des 5 premières composantes sont normalisées à 1, donc une onde carré très sommaire, puis on remplit le vecteur de 100 unités en sautant une valeur sur deux de cette onde carrée et en multipliant sa valeur par l’indice du vecteur */ {val == 3}{waveview[i].valueAction_( Array.fill(100,{|v|var z=Signal.sineFill(200,[1,1,1,1,1]).asArray; z.at(v)}))} /* Celle-là est une courbe en forme dent de scie, une courbe remplie avec 100 valeurs ascendantes */ {val == 4}{waveview[i].valueAction_(Array.fill(100,{|v| v*0.01}))} /* Pareil que la précédente mais dans le sens descendant */ {val == 5}{waveview[i].valueAction_((Array.fill(100,{|v| v*0.01})) .reverse)} /* Courbe triangulaire */ {val == 6}{waveview[i].valueAction_( (Array.fill(100,{|v|((v*0.01)*pi).sin})).asin.normalize)} /* Valeurs aléatoires pour chaque x */ {val == 7}{waveview[i].valueAction_(Array.fill(100,{|v| 1.0.rand}))} /* Multiplication de deux vecteurs (sinus, cosinus en valeurs absolues et avec décalage de phase) le résultat est une courbe avec plusieurs pics sinusoïdaux */ {val == 8}{waveview[i].valueAction_( (Array.fill(100,{|v|(v*0.1).cos.abs}).reverse)* (Array.fill(100,{|v|(v*0.01*2pi+5).sin.abs})))} /* Valeur constante à 0.5,1 et zéro */ {val == 9}{waveview[i].valueAction_(Array.fill(100, {|v| 0.5}))} {val == 10}{waveview[i].valueAction_(Array.fill(100,{|v| 1}))} {val == 11}{waveview[i].valueAction_(Array.fill(100,{|v| 0}))};}); Cette même interface graphique sera utilisée pour le contrôleur Arduino sauf que les courbes seront dessinées directement par le capteur.


69

2.5.5 Tableau MIDI

Dans cette interface graphique il sʼagit dʼun tableau où les contrôleurs midi sont assignés aux contrôleurs de synthétiseurs. Voici la partie supérieure de ce tableau, les boutons, defaults, reset, load, save,

permettent de modifier toute la liste. Defaults, fait appel à la configuration avec lʼinterface u-control de beringher. Reset, efface toutes les assignements. Load, charge une configuration sauvegardée préalablement et save fait la sauvegarde. Ensuite chaque paramètre de contrôle dans la liste peut être modifié à la main en sélectionnant dans le menu lʼinterface MIDI disponible et en écrivant les canaux et les nombres des contrôleurs. Ou bien avec les boutons verts pour valider le choix, jaunes pour effacer et rouges pour assigner un contrôleur depuis lʼinterface MIDI, cette action learn est aussi disponible avec les touches « m » ou « l » en sélectionnant lʼobjet graphique à contrôler. Lʼinterface se mettra à jour automatiquement en utilisant ce procédé. En introduisant plusieurs objets graphiques je voulais montrer mes choix de programmation : simplicité, clarté, importance secondaire, priorité sur le son. Effectivement, je me suis entraîné à jouer simplement avec la matrice et les lecteurs de fichiers à lʼécran, tout le reste caché mais accessible via le contrôle midi, et jʼai éprouvé une liberté particulière à ne pas être plongé constament dans lʼécran de lʼordinateur.

Figure 21 Tableau du MIDI mapping


70

2.5.6 Clavier de lʼordinateur

Cette interface graphique a pour objet la gestion de paramètres depuis le clavier de lʼordinateur. Pour programmer cette interface je suis parti de lʼexemple de James Mc Cartney disponible dans les exemples fournis avec la distribution publique de SuperCollider. Toutefois cet exemple a pour objet de déclencher des fonctions audio depuis le clavier. Jʼai dû faire des modifications profondes dans le code pour avoir entre autre la possibilité de glisser depuis la liste le paramètre quʼon désire manipuler, avoir une série de boutons pour sauvegarder la configuration, la recharger, pour mettre une configuration donnée par défaut, pour connaître tous les paramètres actifs dans les clavier et une fonction « clean » pour effacer les actions stockées dans chaque touche. Jʼai dû faire face à deux autres problèmes. Premièrement chaque touche dans les claviers des ordinateurs a un nombre « unixcode » assigné par sa position physique mais le caractère associé à celle-ci varie en fonction du langage de chaque clavier, le problème est donc lʼaffichage des caractères. Pour le résoudre : au moment de toucher le clavier avec la fenêtre active, une fonction vérifie si lʼaffichage est correct, sinon le caractère est modifié : window.view.keyDownAction = {|view, char, modifiers, unicode, keycode| if (modifiers!=1835305) {keycodes.collect({|i,j| if keycode==keycodes[j]){keys[j].string_(char.asString)}})}} } La deuxième difficulté a été la polyphonie dʼactions et je ne lʼai pas résolue, toutefois dans lʼavenir jʼimagine une fonction qui pourrait suivre plusieurs ordres en parallèle, pour lʼinstant une seule action est possible à la fois.

Figure 22 Interface Clavier pour assigner le contrôle des paramètres


71

2.6. Contrôle

Les paramètres de contrôle du programme sont les variables ou plus précisément les arguments des synthétiseurs. Ces arguments sont accessibles et modifiables de façons différentes : soit directement sur lʼinterface graphique, avec une interface MIDI (potentiomètres, boutons, joysticks, ou capteurs analogiques) ou par des valeurs issues de lʼanalyse du son. La liste de 108 paramètres est stockée dans un dictionnaire. On peut assigner à chaque entrée une définition puis lʼappeler pour retrouver la valeur correspondante. Pour cela il faut chercher dans le dictionnaire lʼentrée désirée comme dans lʼexemple ci-après. ~midilistaview = Dictionary[ 0 -> 'cc1198play', 1 -> 'cc1199play', Le dictionnaire ~midilistaview a pour valeur 'cc1198play' correspondant à lʼentrée 0, donc en appelant ~midilistaview[0], la réponse sera 'cc1198play'. Voici la liste complète des paramètres modulables dans Jabalion pour chaque synthétiseur Entrées analogiques (2) :

• Marche/arrêt • Volume

Lecteur de fichiers sons (5) : • play/pause • Loop/pause • Crazy play/stop • Taux de changement / crazy • Rate ou vitesse de lecture • Volume

PitchShifter • Taille des grains • Taux de variation des hauteurs • Etendue des variations

dʼhauteur • Densité • wet • Volume

Modulations • Fréquence de modulation • Volume de modulation • Fréquence du filtre • Fréquence du LFO

• Volume du LFO • wet

Ligne à retard modulée

• Transposition • Durée du retard • Réinjection • wet • Volume

Réverbération • Taille de la salle • Amortissement • wet • Volume

Multidelay • Courbe dynamique • Valeurs rythmiques • wet • Volume

ComplexAttack • Coefficient réel • Coefficient imaginaire • wet • Volume


72

Freezer • Déclencheur • Vitesse de lecture • Volume

Granulator • Variations dʼhauteur • Densité • Taille de grains • Variation position • Variation dʼamplitude • wet • Volume

FM • Rate • Fréquence porteuse • Fréquence modulante • Index de modulation • Durée • Volume

Gendy • Distorsion dʼamplitude • Distorsion de durée • ad paramètre • dd paramètre • Fréquence minimale

• Fréquence maximale • Graduation dʼamplitude • Graduation de durée • Volume

Kmeans • Fréquence • Rate • Soft • Nummeans • Volume

Panoramique (2) • Type de courbe • marche/arrêt • vitesse • Master volume

Recorder • Marche / arrêt • Durée • Vitesse de lecture • Volume

Master Volume

Les paramètres de contrôle expriment les degrés de liberté de lʼalgorithme, sa courbe de variation, ses limites maximum et minimum. Ces bornes sont fixées au moment de la compilation et ne peuvent pas être modifiés au cours du jeu. Pour cela il faudrait recompiler la librairie de synthés et recommencer. Tous les paramètres ont été normalisés entre 0 et 1 pour des économies de calcul au moment de lʼinterprétation. Ainsi le facteur fréquence qui varie de 0 à 1 est, en vérité, une interpolation exponentielle des valeurs entre 200/20000 Hz.40 Cent huit paramètres est un nombre important. Il faut donc imaginer des stratégies pour les grouper et pour être dans une logique de contrôle multiparamétrique. Sinon le contrôle devient « incontrôlable », une sorte de jungle où on ne sait jamais qui fait quoi, quand et où.41 Je vais examiner trois possibilités de solution : lʼinterface ordinateur, les interfaces MIDI et la capture du geste, et finalement le son contrôleur. 40 Pour connaître les valeurs réelles de chaque paramètre il faut se reporter au code décrit pour chaque synthétiseur dans la section 2.3. 41 Sur la manque de contrôle conscient dans l’électronique en temps réel et dans l’improvisation, portent les critiques les plus sévères comme celles de Jean Claude Risset, exprimées lors d’une conférence à l’université de Paris VIII (décembre 2009).


73

2.6.1 Lʼinterface ordinateur

Jouer (contrôler les algorithmes de synthèse) directement sur lʼordinateur sans interface externe ou microphone peut être une tâche très difficile mais pas impossible42. Aujourdʼhui nous voyons la technologie dʼécrans tactiles multipoints se démocratiser ; il est même à portée de mains dans les machines personnelles, cette technique a été implémentée dans plusieurs interfaces destinées à la musique43. Si lʼon met de côté le « tracking motion » ou suiveur de mouvements, la détection des couleurs, ou de positions, qui sont possible avec des outils comme Jitter et les webcams intégrées dans les ordinateurs portables, il nous reste que le clavier et le track-pad (ou souris dans les portables) comme interface. Ceci nʼest pas grand-chose pour parler de degré de liberté instrumentale car le clavier ne permet quʼun geste de sélection44, et le curseur un geste de modification par son déplacement dans lʼécran. Jʼai cependant réalisé des expériences pour enrichir ces possibilités. Par exemple la valeur dʼun paramètre peut être modifiée par la quantité de touche du clavier jouées par unité de temps : Plus jʼappuie rapidement sur les touches, plus la valeur sera grande. Inversement, plus le temps entre chaque impact est long plus la valeur est petite. Une certaine gestualité instrumentale est retrouvée avec la dépense physique et lʼaugmentation ou la diminution dʼun paramètre. Au cours de cette expérience, jʼai rapidement retrouvé les limites de réactivité liées à cette technique et jʼai crains pour la survie du clavier, qui nʼa pas été prévu pour de tels exercices. Une autre possibilité liée au temps a été étudiée : le temps dʼenfoncement des touches. Plus une touche reste enfoncée plus la valeur croît ; moins elle reste enfoncée, moins grandes les valeurs seront. Cette technique présente deux particularités : Tout dʼabord il faut une touche par action. Cʼest-à-dire que monter ou descendre les valeurs nécessite une combinaison de touches différentes. Ensuite il faut permettre à lʼutilisateur de régler la sensibilité du clavier. En effet les valeurs fixes peuvent être perçues comme trop rapides ou trop lentes. Un clavier trop sensible demandera un temps plus court pour arriver à la valeur maximale ou minimale, contrairement à une sensibilité plus rigide qui demandera de plus de temps dʼenfoncement pour arriver aux valeurs souhaitées. Dans ma version du logiciel sur MAXMSP ce paramètre sera visible dans 42 En ayant dans l’esprit, l’ordinateur comme une « représentation instrumentale », dû au relais énergétique pour l’excitation ou mise en vibration produite par l’électricité. 43 Lemur « Interface Jazzmutant Manuel de l’utilisateur » 2008 BORDEUX, France. 44 Claude CADOZ « Musique Geste Technologie » Les Nouveaux Gestes de La Musique, Editions, Parenthèses, 1999


74

lʼinterface graphique. Dans lʼimplémentation sur SuperCollider, ce paramètre de sensibilité est un facteur fixe lié à lʼincrément des objets graphiques. Son rang est le taux de signaux de contrôle établi au départ. Ce premier paramètre lié à la réactivité dynamique donne la possibilité dʼavoir un contrôle permanent et instantané sur lʼamplitude globale et permet ainsi de faire des silences « subitos » ou des crescendos et des decrescendos mesurés à lʼintuition. Il permet également de prévenir des montées de niveau inattendues par une mauvaise manipulation, par une réinjection bouclée, ou par une panne de logiciel. Un contrôle du Master Volume interne au logiciel est attribué aux touches : cmd+alt+ctrl+9 et cmd+alt+ctrl+045 Pour éviter dʼaller vers chaque fenêtre, puis vers chaque objet graphique, tous les paramètres sont assignables en les glissants depuis lʼinterface graphique vers lʼinterface clavier. Comme je lʼai signalé plus haut, un problème avec la commande de paramètres depuis le clavier de lʼordinateur est la quantité à laquelle on a accès, qui est limitée à un. Ce clavier contrôleur est très vite épuisé et remis en question avec ce paradigme. De plus, je nʼai pas réussi à manier le contrôle multiparamétrique dont jʼai déjà signalé lʼimportance. Malgré ces critiques face au contrôle depuis le clavier de lʼordinateur et bien quʼune interprétation au seul ordinateur ne soit pas très riche du point de vue de lʼexpressivité histrionique et gestuelle, certaines fonctions se comportent très bien et on ne saurait pas sʼen passer. Lʼouverture, la fermeture de fenêtres, les taches liées ou nécessitant la saisie des noms ou des clés, ainsi que la sauvegarde ou le chargement par nom de fichier, ou encore le design manuel des courbes de contrôle sont des exemples de fonctions indispensables. Cette liste non exhaustive peut être complétée par les tâches liées à une sélection binaire type Switch on/off ou déclencheur des touches des fichiers audio (jouer, arrêt, boucle, pause). Dʼailleurs, dans lʼobjet graphique des fichiers audio, un raccourci clavier est disponible par défaut quand la forme dʼonde ou un des boutons assignés à celle-ci est sélectionné : taper espace pour déclencher ou arrêter la lecture des fichiers. backgroundsf[i].keyDownAction_(UnicodeResponder.new.normal(32 -> { if (rspacebar.nextN(1)[0]==1) {this.floop(i)}{this.fstop(i)}})); Se poser la limite dʼun jeux de boutons et dʼune surface sensible à la position a été un exercice très intéressant et stimulant pour la créativité. Jʼai en effet été confronté à une minimisation des possibilités expressives et à un cadre très restreint dʼutilisation de lʼénergie physique. Ca a donc été un exercice enrichissant pour la pensée instrumentale. 45 Cependant dans la pratique j’ai toujours fait confiance à une pédale de volume externe pour gérer séparément le contrôle du niveau globale.


75

2.6.2 LʼInterface MIDI

Passons maintenant à un autre point qui a donné lieu à beaucoup dʼétudes et de réflexions, tant du point de vu de lʼingénierie et de la technologie comme du point de vu des utilisateurs musiciens amateurs ou professionnels : la norme MIDI. Mise au point vers le début des années 80, le MIDI cherchait une standardisation dans les protocoles de communication entre les machines numériques. Il doit ses caractéristiques aux possibilités technologiques de lʼépoque. Fortement critiqué pour son codage fortement lié au piano, soit pour calcul de lʼamplitude lié aux vélocités dʼattaques46, pour son cryptage dʼhauteur par touche enfoncée, pour son rang restreint à 128 valeurs (0-127) et « lʼillusion » polyphonique de 16 canaux47, le MIDI a permis à dʼautres protocoles de voir le jour. La question du codage et de la numérisation du geste instrumentaux reste quant à elle ouverte pour plus dʼexplorations. Avant de traiter le sujet passionnant de la captation du geste, je vais mʼoccuper des interfaces du type contrôleur MIDI. Elles sont semblables aux tables de mixage, potentiomètres linaires et angulaires avec boutons sélecteurs et déclencheurs. Ce choix est déterminé par la popularisation de ce type dʼinterfaces qui font le pont entre les outils et le matériel électroacoustique « traditionnel » et les interfaces plus expérimentales, qui sʼéloignent plus au moins des paradigmes instrumentaux « classiques ». Ces interfaces font donc parti du répertoire gestuel de la musique électroacoustique. Jʼai utilisé pour mes expériences le contrôleur « évolution u-control uc-33 ». Il sʼagit dʼune interface avec un rang de 9 potentiomètres linaires (faders) et de 24 potentiomètres angulaires organisés dans trois rangés, puis 16 boutons. Chaque contrôleur peut être assigné à un des seize canaux, ou à un nombre de contrôleur entre 0 et 127, ou encore à une note on/off avec une vitesse dʼattaque préfixée. La possibilité d ʻenregistrer les réglages dans 33 mémoires donne une possibilité incroyable de combinaisons. Quatre de ces mémoires ont un accès rapide avec des boutons dédiés. Lʼaspect physique (bien quʼun peu petit) de cette interface ressemble à huit « tranches » dʼune table de mixage. Du point de vue de lʼinterprétation avec une interface de ce type on a gagné, par rapport au seul contrôle de lʼordinateur, un accès poly-paramétrique soit la possibilité dʼaccéder simultanément à plusieurs paramètres. Ainsi le son devient plus malléable. Toutefois lʼutopie serait dʼavoir une interface construite et dédiée 46 Par exemple dans la guitare la durée d’une note est liée au caractéristiques acoustiques de celle-ci et pas au temps d’enfoncement d’une touche, c’est à dire qu’avec le codage MIDI classique associant la guitare à un synthétiseur, le première phénomène est d’avoir des sons bas très longs par rapport aux sons aigus dont la durée est beaucoup moins importante. Des enveloppés ou des durées fixes peuvent aider à manier cet effet mais un algorithme de correction peut être plus intéressant. 47 Les messages MIDI multicanaux sont bien une suite sérielle de valeurs.


76

pour le logiciel. Malgré la versatilité dʼassignements possible sur lʼinterface MIDI, on doit garder une interprétation mixte avec lʼordinateur pour accéder à des objets clés comme la matrice, les tables, la sélection dʼarchives, ou le chargement de presets. Le fait dʼavoir 108 paramètres de contrôle dans le logiciel et 33 contrôleurs continus dans lʼinterface nous oblige à faire des assignements multiples, qui peuvent être joués séparément en altérant les canaux stockés dans les mémoires. Cette solution amène un nouveau fait à manier : en changeant de paramètre sur le même potentiomètre on laisse un paramètre dans une valeur, puis on attaque le suivant à cette valeur, on modifie alors sa valeur et quand on revient sur le premier paramètre il est toujours à la même valeur, mais le potentiomètre, lui, est dans une valeur différente ce qui produit de sauts dans le paramètre. Ces sauts peuvent être très ennuyants, notamment dans le contrôle de niveaux où des pics non voulus dʼamplitude peuvent survenir et altérer le discours musical. Conscients de ceci, les constructeurs dʼinterfaces ont mis au point des potentiomètres automatisés qui reviennent sur la valeur en changeant de configuration. Mais cette solution plutôt coûteuse nʼest souvent disponible que dans des tables de mixage pour des studios. Toutefois une solution logicielle est imaginable en programmant une contrainte pour empêcher les sauts dans les valeurs qui modifient un paramètre. Il faut également mentionner le besoin de deux mappings ou dʼassignement préalables nécessaires sur lʼinterface MIDI et sur lʼinterface logicielle. Ces réglages de lʼordre de la calibration ou dʼaccordage pour le logiciel peuvent être stockés dans un archive texte. Dans celui-ci est écrit le paramètre à contrôler, lʼidentifiant de lʼinterface MIDI, le canaux et le nombre du contrôleur, ainsi quʼéventuellement le port de connexion. Cette possibilité est implémentée dans Jabalion (c.f. la section interface graphique tableau MIDI). Une dernière situation à remarquer dans lʼutilisation de cette interface MIDI est la complexité dans la distribution spatiale des contrôleurs, alors que sa logique est très simple dans lʼinterface : un potentiomètre linaire pour chaque trois angulaires. Cette logique ne correspond pas à lʼarchitecture des synthétiseurs programmés où les arguments varient entre 3 et 9 paramètres. Par conséquent, il est difficile de trouver une logique cohérente de disposition. Une solution possible serait que les potentiomètres linaires contrôlent toujours et dans tous les canaux, les niveaux de fichiers son (5), dʼentrés analogiques (2), de lʼenregistreur (1) et un Master. Puis le trois rangés de huit potentiomètres angulaires assignés pour le canal 1, les traitements de modulation, retards et réverbération, le canal 2, synthèse granulaire et FFTs le canal 3, les synthétiseurs FM, Gendy et Kmean. Finalement les boutons déclencheraient les automatisations et les fichiers sons.


77

2.6.3. Arduino, captation du geste

Dans une progression des outils de contrôle allant de lʼinterface graphique vers la matérialisation du concept de potentiomètre, nous arrivons aux frontières de lʼinstrument de musique, où lʼinformatique musicale pose bien de problèmes et pas seulement technologiques mais aussi dʼordre théorique comme lʼa bien signalé Hugues Dufourt dans son livre Mathesis et Subjectivité : « Au XXème siècle, lʼordinateur, en portant notre audition normale à lʼéchelle de lʼaudition microscopique, a rompu la coordination entre la vue, lʼouïe et le toucher quʼassurait lʼinstrument de musique traditionnel. En dissociant la construction de lʼobjet sonore du geste et de la motricité, la technologie a renversé en musique, les rapports du mouvement et de lʼespace. Elle soustrait le mouvement à son contexte biologique et le conçoit comme la résultante dʼune opération dans lʼespace. En outre, la technologie a séparé la sensibilité de la motricité, et la sensation du mouvement. Cette séparation en composantes motrices et sensorielles pose le problème technique et esthétique de leur coordination ultérieure, de leur reconstruction et de leur réunion artificielles. En rompant le caractère unitaire de la perception auditive et du geste instrumental, lʼinformatique musicale ouvrait la voie à des interrogations inédites. Quʼest ce quʼune musique sans mouvement ou une musique dont le mouvement serait tout entier intériorisé ? On peut en trouver lʼexemple dans les œuvres de Chowing et Risset. Que serait, à lʼinverse, une musique issue du mouvement ? Il faudrait alors se tourner vers la synthèse par modèles physiques et vers les études sur la causalité instrumentale. Jean Claude Risset a imaginé une sensorialité indépendante de la motricité, Claude Cadoz une motricité indépendante de la sensorialité. Mais comme la sensorialité peut-elle réagir à des propositions de structure qui ignorent délibérément les lois du mouvement volontaire ? Lʼévolution technique de la musique pose donc, aujourdʼhui comme au XVIIème siècle, le problème de la substitution des processus physiques à des actes organiques. » 48 Ce qui semble inquiéter Monsieur Dufourt est le concept du mouvement et de motricité. Effectivement avec des appareils électroacoustiques nous ne sommes plus dans la consommation dʼénergie physique traduite en son. Les paradigmes gestuels sont dʼun autre ordre. On peut vérifier cette inquiétude dans plusieurs domaines, avec des compétitions comme « Guthman Musical Instrument Competition » du Georgia Tech Center for Music Technology qui organise chaque année un prix pour les inventeurs des instruments, ou « NIME International Conference on New Interfaces for Musical Expression » qui a lieu chaque année dans différents pays. Dans le milieu académique plusieurs centres 48 Hugues DUFOURT « Mathesis et Subjectivité », Des conditions historiques de possibilité de la musique occidentale. Editions MF, avril 2007


78

de technologie musicale dédient un espace à la création de nouveaux instruments par exemple « Sir John Cass Department Of Art Media and Design » de Metropolitan London University qui offre des programmes en manufacture instrumentale ou « Media Laboratory Masachusets Institute of Technologie » avec Tod Machover49 et son travail sur les Hyper Instruments pour ne nommer que quelques uns. Ainsi on voit la liste des interfaces musicales sʼélargir et le répertoire organologique suit deux directions principalement, les modifications sur de paradigmes instrumentaux existants et la création de nouveaux paradigmes gestuelles.

La recherche sur le geste musical menée par Claude Cadoz donne un cadre théorique pour une typologie du geste, instrumentale ou non, gestes dʼexcitation, de modification, de sélection dʼextinction. On en déduit que les interfaces gestuelles dédiées à la captation du geste ne peuvent quʼassurer une partie des gestes de sélection et de modification et des gestes du type non instrumental, car ils sont de caractère unidirectionnel. « Les périphériques gestuels sont également particuliers par le fait quʼils doivent prendre en compte la bidirectionnalité (effectrice et réceptrice) du canal gestuel. Tous les systèmes gestuels ne répondent pas à cette particularité, cʼest même ce qui caractérise leur développement jusquʼà une période récente. Les dispositifs habituels, du clavier alphanumérique à la souris, ne sont que des capteurs de geste, ils ne remplissent pas la fonction symétrique. Les claviers de synthétiseurs et les divers « contrôleurs MIDI » qui reproduisent de près ou de loin lʼergonomie de certains instruments traditionnels (manches de guitare, saxophone, etc.) sont également unidirectionnels, capteurs exclusifs » 50 La captation du geste nʼaboutit pas à un instrument mais à un contrôleur. Pour explorer personnellement ce concept et après mes expériences avec une guitare munie des capteurs51, je me suis servi du module « Arduino Diecimila » et dʼun jeu des capteurs de pression par la compagnie Interface Z52 à Paris. Jʼessaie dʼouvrir cette possibilité dans mon application logicielle pour permettre à un utilisateur de connecter ses propres capteurs, de leur assigner le contrôle des paramètres de synthèse dʼune façon facile et de pouvoir calibrer les valeurs sans besoin dʼun programme tiers. Un Module Arduino est construit autour du microcontrôleur Atmel AVR, chaque

49 Tod MACHOVER, « Hyperinstruments: a progress report », 1987-1991, Massachusetts Institute of Technology. Media Laboratory 50 Claude CADOZ dans Les Nouveaux Gestes de La Musique Editions, Parenthèses 199951 OLARTE « Guitanthetizeur, une Interface gestuelle pour le pilotage de la synthèse » présenté pour l’obtention du prix d’acoustique musicale au Conservatoire National de Musique et Danse de Paris, 2008 52 http://www.interface-z.com/index.htm


79

module possède au moins un régulateur linéaire 5V et un oscillateur à quartz 16 MHz (ou un résonateur céramique dans certains modèles). Le microcontrôleur est préprogrammé avec un bootloader53 de façon à ce qu'un programmateur dédié ne soit pas nécessaire. Les modules sont programmés au travers d'une connexion USB. Le module possède 14 entrées/sorties numériques, dont 6 peuvent produire des signaux PWM, et 6 entrées analogiques. Les connexions sont établies au travers de connecteurs femelle HE14 situés sur le dessus de la carte. Les modules d'extension viennent s'empiler sur l'Arduino. Plusieurs sortes d'extensions sont disponibles dans le commerce.54 Un capteur de force/pression FSR Force Sensitive Resistor, est une résistance qui varie en fonction de la pression exercée sur la zone sensible. Ceux dont je me sert ont une taille de : pastille 61 mm x 15 mm, zone sensible 61 mm x 12,5 mm. Pour permettre de communiquer avec Arduino, jʼai écrie une classe KrArduino dont voici les principaux points du code. GUI.button.new(window,Rect(5,4,70,20)).canFocus_(false)

.states_([["Conect",Color.white,Color.yellow(0.9)], ["Disconect",Color.white,Color.red(0.9)]])

.action_({|but| if (but.value==1) {r{ pin = SCPyduino.new(SerialPort.devices[2]); 4.wait; n.do({|i|pin.analog[i].active_(1)}); 0.5.wait; n.do({|i|krtask2[i].start}); 0.5.wait; n.do({|i|krtask[i].start}); }.play} {n.do({|i|pin.analog[i].active_(0); krtask[i].stop;krtask2[i].stop;pin.close; SerialPort.closeAll})}}); Ici, un bouton est créé pour initialiser ou fermer une connexion via le port serial. Une routine est nécessaire car cette initialisation peut prendre quelques

53 Un chargeur d'amorçage (ou bootloader) est un logiciel permettant de lancer un ou plusieurs systèmes d'exploitation (multi-boot), c'est-à-dire qu'il permet d'utiliser plusieurs systèmes, à des moments différents, sur la même machine. 54 Le design matériel de l'Arduino est distribué sous licence Creative Commons Attribution Share-Alike 2.5 et est disponible sur le site d'Arduino. Les schémas ainsi que les typons de circuits sont également disponibles. Le code source de l'environnement de programmation et les librairies embarquées sont disponibles sous licence LGPL.


80

secondes et doit suivre plusieurs étapes : activer les entrées analogiques et numériques, puis actualiser les valeurs sur lʼinterface graphique et les affecter au paramètre souhaité. Du point de vue de lʼinterface graphique cette classe se présente comme une lecture de tables dont la courbe est dessinée en temps réel par les variations des valeurs produites par le capteur. /* Cette Tâche actualise les valeurs pour chaque entrée analogique et les normalises */ krtask2[i]= Task{loop{pin.iterate; zpin.put(i,((pin.analog[i].value/1023).linlin(0.34,0.99,1,0)))}}; /* La valeur obtenue dans l’étape précédente peut être calibrée avec deux boites numériques qui fixent les extrêmes d’une fonction d’interpolation. Cette nouvelle valeur est affichée et envoyée au paramètre choisie dans la liste */ krtask[i] = Task({loop({100.do({|k| var spec = ControlSpec( krnumbermin[i].value,krnumbermax[i].value,\lin,0.01),valor; valor = spec.map(zpin[i]); {krtxtinfo[i].string_(valor); krwaveview[i].index_(k); krwaveview[i].currentvalue_ (zpin[i])}.defer; 0.1.wait})})}); Ma stratégie dʼinterface physique a été de construire une pédale. En effet les mains sont déjà bien occupées avec le clavier de lʼordinateur, lʼinterface MIDI, et les entrées analogiques. Cette pédale se compose dʼune surface circulaire avec un capteur à chaque point cardinaux, une pédale de volume (potentiomètre angulaire) et une série de boutons. La cadence à laquelle les valeurs sont actualisées joue un rôle prépondérant dans le résultat sonore. Avec des traitements et des synthèses on obtient un

contrôle très « plastique » du son. Mais par la disposition des capteurs il est presque impossible dʼexercer une pression constante maximale sur les quatre points sans abimer les capteurs, donc il y aura toujours un ou deux points dont les valeurs seront mises en avant.

Le contrôle au pied peut être exploité encore plus avec des surfaces sensibles et en étudiant dʼautres types de capteurs et peut être une interface intéressante pour personnes avec mobilité réduite des membres supérieurs.

Figure 23 Pédale circulaire Arduino


81

3.8ms

0

2.6.4. Le son contrôleur

Le son lui même peut être aussi étudié comme un contrôleur. Lʼanalyse du signal sonore cherche à connaître la fréquence fondamentale, lʼamplitude énergétique, et la richesse spectrale. Lʼimplémentation de cette technique la plus courante consiste à détecter la période fondamentale de la hauteur dans le domaine temporel. Le signal est considéré comme une amplitude fluctuante autour du zéro qui progresse dans le temps. Lʼalgorithme cherche la périodicité du signal en regardant les passages par zéros répétitifs, ou bien en comparant lʼécart entre pics de même amplitude. Voici un signal de la note DO3 jouée à la guitare vue à lʼoscilloscope :

La première étoile montre les passages par zéro, la deuxième étoile correspond à une composante de haute fréquence ; la flèche indique les pics dʼamplitude séparés de 3.8 ms. La période étant lʼenvers multiplicatif de la fréquence donc DO3.

La détection de périodicité a été mise au point dans

dʼautres algorithmes qui utilisent par exemple des fonctions de corrélations. Celles-ci comparent le signal point par point avec des versions retardées de lui-même, par des intervalles successifs en cherchant des modèles répétitifs. On peut mentionner aussi lʼimplémentation par des filtres adaptatifs et des circuits détecteurs de différences qui font converger la fréquence de coupure dʼun filtre passe bande à la fréquence du signal dʼentrée. Un point faible des méthodes de détection de périodicité est le temps dʼanalyse nécessaire pour calculer et pour faire lʼestimation de hauteur. Lʼalgorithme ne peut pas réagir aux transitoires dʼattaque car ceux-ci sont très riches en contenu fréquentiel et ne correspondent pas à des modèles harmoniques. Une fois le temps du transitoire dʼattaque écoulé, il faut attendre au moins deux périodes du signal pour que lʼalgorithme puisse calculer et puisse prendre une décision. Ce temps de réaction entre la note jouée et la réponse informatique est appelé « latence ». Plus évidente dans les basses fréquences, cette latence peut être gênante, mais il faudrait se souvenir de la « latence acoustique » à laquelle sʼhabituent les organistes et qui peut également aller jusquʼà plusieurs dixièmes de seconde sans pour autant empêcher une maîtrise de lʼinstrument.

Figure 24 Détection d’hauteur par zéro crossing


82

La détection de hauteur dans le domaine fréquentiel est effectuée grâce à lʼanalyse de Fourier55. Ainsi nous pouvons connaître le poids des différentes composantes fréquentielles contenues dans le signal et donc isoler la fréquence dominante, ou en déduire si elle nʼest pas présente par un examen des relations harmoniques. Un problème dans les algorithmes écrits à partir de la transformée de Fourier est la résolution fréquentielle. En effet, la bande des fréquences audio est divisée de façon linéaire et la perception humaine de hauteur est plutôt logarithmique, ce qui signifie que les basses ne peuvent êtres suivies avec la même précision que les aiguës. Michèle Castellengo explique dans son cours dʼacoustique56 musicale que la perception de la hauteur est un procès complexe qui met en jeu plusieurs stratégies dʼécoute et différents mécanismes physiologiques et cognitifs. Ainsi les modèles dʼanalyse et de détection de hauteur sont toujours en cours dʼévolution. Récemment un groupe dʼingénieurs allemands ont mis au point la technologie « réseaux neuronaux » pour le suivi de hauteur dans la guitare, disponible dans lʼinterface AXON de Terratec. « Un réseau de neurones (ou Artificial Neural Network) est un modèle de calcul dont la conception est très schématiquement inspirée du fonctionnement de vrais neurones (humains ou non). Les réseaux de neurones sont généralement optimisés par des méthodes dʼapprentissage de type statistique, si bien quʼils sont placés dʼune part dans la famille des applications statistiques, quʼils enrichissent avec un ensemble de paradigmes permettant de générer de vastes espaces fonctionnels souples et partiellement structurés, et dʼautre part dans la famille des méthodes de lʼintelligence artificielle quʼils enrichissent en permettant de prendre des décisions sʼappuyant davantage sur la perception que sur le raisonnement logique formel ».57 La détection dʼhauteur nʼest pas une tâche évidente car lʼanalyse est contrainte au type de capteurs, à la richesse des modes de jeu, à la vitesse de calcul de processeurs et à la flexibilité des algorithmes. Nicholas Collins dans sa thèse de Doctorat58 a réalisé une recherche approfondie dans la mise au point dʼalgorithmes dʼanalyse dans le domaine 55 Pour des détails à propos de la transformée discrète et rapide de Fourier voir le chapitre Curtis ROADS « Spectrum Analysis » Computer Music Tutorial, 1996 56 Cours d’Acoustique Musical, Conservatoire National de Musique et Danse de Paris (2003) 57 Application de réseaux de neurones artificiels à la reconnaissance automatique de caractères manuscrits, Faculté Polytechnique de Mons, Bernard GOSSELIN 58 Towards Autonomous Agents for Live Computer Music: Realtime Machine Listening and Interactive Music Systems Nicholas M. Collins, St.John’s College Centre for Music and Science Faculty of Music University of Cambridge 2008


83

rythmique, mélodique, et harmonique. Parmi ses résultats il a distribué une série des classes et des outils pour SuperCollider. Voici une comparaison entre deux algorithmes dédiés à calculer la fréquence fondamentale : Pitch de la distribution standard et Tartini écrit par Nicholas Collins.

Dans ce premier exemple je joue 5 fois lʼarchive son1 décrit dans les chapitres précédents. Il sʼagit de la corde mi3 de la guitare jouée à vide. Les deux courbes ont été normalisées, celle du haut est le résultat de lʼanalyse avec la classe Pitch, celle du dessous est Tartini. On peut noter que la différence principale se trouve dans lʼattaque, ou la précision temporelle de la deuxième courbe semble supérieure à celle de la première. Toutefois, vu la complexité du spectre dans le transitoires dʼattaques on ne peut pas prétendre à avoir une reconnaissance dʼhauteur précise. Dans le deuxième exemple il sʼagit des six premières mesures de « Forlorne Hope Fancy » de John Dowland, une construction en fugue avec un thème chromatique.

Figure 25 Plot, courbe comparative détection d’hauteur d’une note répétée

Figure 26 Début de la tablature Forlorn Hope Fancy de John Dowland, thème chromatique


84

Jʼai choisi cet exemple parce que sa ligne chromatique est facilement identifiable et le moment polyphonique assez claire pour tester la réponse des algorithmes. On reconnaît que les algorithmes ont des difficultés dans une situation polyphonique. Les valeurs sautent dʼune voix à lʼautre, les pics peuvent être des entrées de voix supérieures. On note aussi lʼhésitation dʼoctave du à la forte présence du premier harmonique, le bruit avant la première note est dû aux réglages du seuil minimal dʼamplitude nécessaire pour considérer lʼanalyse. Jʼai utilisé les valeurs par défaut, peut être sûr quʼune calibration plus délicate produira dʼautres résultats. Pour mon application jʼai écrit deux synthétiseurs pour extraire les valeurs de fréquence fondamentale et lʼamplitude globale qui doivent ensuite être affectées aux paramètres de contrôle à travers deux buses agissant directement sur les synthétiseurs. /* La variable rate contrôle la fréquence à laquelle les valeurs sont envoyées au synthétiseur, min et max sont les bornes pour une interpolation des valeurs de sortie */ SynthDef(\ampFollow,{|inBus=31,outBus=10,rate=100,min=0,max=1| var in,out,count; in = InFeedback.ar(inBus); out = Amplitude.kr(in); out = out.linlin(0.01,1,min,max); count = Impulse.kr(rate); SendReply.kr(count, 'amplitude', out); Out.kr(outBus,out) }).writeDefFile(SynthDef.synthDefDir);

Bruit Hésitation d’octave

Basse Mi1

Figure 27 Comparaissons de résultats de l’analyse du morceau de Dowland CD plage 9


85

SynthDef(\pitchFollow,{|inBus=31,outBus=11,rate=100,min=0.01,max=1| var in,out,count,scale; in = InFeedback.ar(inBus); //out = Tartini.kr(in); out = Pitch.kr(in); scale = \freq.asSpec; out = scale.unmap(out[0]); out = out.explin(0.01,1,min,max); count = Impulse.kr(rate); SendReply.kr(count, 'pitch', out); Out.kr(outBus,out) }).writeDefFile(SynthDef.synthDefDir); Dans le monde de MAXMSP les travaux réalisés par Tristan Jehan59, travaillant au MIT, ont permis dʼenrichir les analyses avec dʼautres aspects saisissants du point de vue perceptif : « Loudness, Brightness, Noisiness » basé dans lʼobjet ~fiddle de Muller Puckette ont abouti à lʼalgorithme ~analyzer, lequel sera exploité dans la version MAX présentée plus loin. Lʼutilisation des paramètres du son comme contrôleurs donnent un côté vivant et très dynamique dans lʼélectronique. Les synthétiseurs son très réactifs et la boucle dans la chaine perceptive est favorisée. En effet, les gestes se synchronisent avec les résultats sonores.

2.6.5. Sauvegarde et enregistrement

Le dernier aspect que je voudrais traiter est celui de lʼenregistrement audio quand on aura retrouvé des sonorités qui peuvent être réutilisées. Cependant lʼenregistrement des contrôles, cʼest à dire les automatisations et des configurations dans lʼétat du logiciel pour les chargées à différentes moments mʼintéresse particulièrement. Je vais commencer par lʼenregistrement audio. Dans lʼarborescence de synthèse jʼai construit cinq groupes de synthétiseurs : le premier regroupe les sources, ce sont ceux qui nʼont pas besoin dʼune entrée en amont. Par exemple les fichiers audio, les entrées analogiques et le synthèses. Les deuxièmes et troisièmes groupes sont destinés aux traitements car ils reçoivent des sources et sont eux mêmes source (réinjection). Au quatrième groupe appartient lʼenregistreur qui stocke dans un buffer à durée variable tous les signaux assignés dans la matrice. Le cinquième groupe est celui des spatialisateurs. Ici on ne peut plus remonter lʼarborescence. Le synthétiseur enregistreur du quatrième groupe sʼinitialise en deux temps : Tout dʼabord on crée le buffer à la durée désirée, puis on lance lʼenregistrement. Celui-là peut être rejoué et traité à travers la matrice. Il peut donc être utilisé comme une longue ligne à retard. 59 Tristan Jehan, « Creating Music by Listening » Massachusetts Institute of Technology, 2000


86

/* Le bus audio numéro 32 est assigné depuis la matrice, un courte ligne fonctionne comme fade in, l’enregistrement tourne en boucle et s’actualise sur l’interface graphique */ SynthDef(\recorder, {|out = 0, bufnum = 31,loop=1,inBus=32|var in; in = InFeedback.ar(inBus)*XLine.ar(0,1,0.2); RecordBuf.ar(in, bufnum, doneAction: 2, loop: loop); }).writeDefFile(SynthDef.synthDefDir) Lʼenregistrement de paramètre et les automatisations demandent un procédé un peu plus long mais facilité par les classes Automation et AutomationClient et AutomationGUI écrites par Neels J. Hofmeyr60 et distribuées depuis 2009.

Cette classe enregistre les changements continus où les états de toutes les composantes de lʼinterface graphique déclarée. Les fonctions sont déclenchées par des boutons, dans lʼordre : > jouer/arrêter lʼenregistrement, << aller au début o enregistrer, [√¥] snapshot ou photographie dʼun état dans lʼinterface graphique, ^ sauvegarder la séance, … charger une séance enregistrée auparavant, le fader montre une position dans le temps, le temps dʼenregistrement est définie lors de la création par exemple 90 secondes ou plus. Touts les objets graphiques affectant paramètres dans les synthétiseurs sont accessibles depuis la syntaxe : ~values.« synthétiseur ». « paramètre », par exemple ~values.playersf.vol[2] modifiera le volume du deuxième lecteur dʼarchives son. Ainsi chaque objet est déclaré pour lʼautomatisation et ses valeurs avec un indice temporel sont enregistrées dans le dossier presets qui contient un fichier par paramètre. A son tour les fonctions de play et stop peuvent être assignées au clavier mais elles ne sont pas enregistrées, car les déclarer pourrait faire tomber le logiciel dans une boucle, bien que le programmateur ait conçu une fonction « verbose » pour « automatiser lʼautomatisation » Lʼautomatisation et lʼenregistrement des états du logiciel, ainsi que le contrôle par courbes, permettent dʼalléger lʼinterprétation. Mais ils demandent une étape préliminaire de préparation, ce qui nʼest toutefois pas contre les principes philosophiques de lʼimprovisation où de la création spontanée. 60 Neels HOFMEYR, « Elego Software Solutions », 2009, GmbH, Berlin. Germany

Figure 28 Interface Graphique de “Automatisation”


87

3. "TRANSGRESSIONS" IMPLEMENTATION SUR MAXMSP 5 Dans ce chapitre je vais parler de la version Jabalion pour MAXMSP. Cette implémentation sʼappelle « Transgressions » pour deux raisons : La première par souci dʼorganisation personnelle : développer deux logiciels sur des langages différents et avec le même nom se prête facilement à des malentendus dans les fichiers et dans les versions intermédiaires ou de transition qui souvent portent le nom de lʼapplication plutôt que celui du module ou de la version. La deuxième raison est de caractère historique car « Transgressions » est le nom dʼun projet artistique quʼa été imaginé par le chorégraphe Kenyan Opiyo Okach avec lequel jʼai travaillé en tant que musicien, et pour lequel jʼai commencé le développement de cette application. Autre que le nom et quelques qualités propres à MAXMSP et à la programmation avec des objets graphiques, les deux logiciels partagent les mêmes objectifs et cherchent à servir la même quête artistique : la création dʼun outil pour lʼimprovisation électroacoustique. La logique obéit aussi au principe dʼune matrice où on peut interconnecter des modules de synthèse et des modules de traitements, les paramètres de contrôle peuvent être modifiés depuis lʼinterface graphique, le clavier de lʼordinateur, une interface MIDI, un jeu de capteurs, une analyse du son. Le développement de cette application dans lʼenvironnement de MAXMSP mʼa permis de faire face aux problématiques du traitement du signal et de mapping de contrôle dʼune perspective totalement différente de lʼécriture du code, jʼai approfondi mes habilités dans la résolution de problèmes de interactivité et programmation dans MAXMSP. Les critiques que jʼai soulevé pour Jabalion sont aussi valables ici. Par exemple ce logiciel a aussi un caractère ferme, on ne peut pas facilement y ajouter quelque chose, que ce soit des modules de synthèse ou de traitement ou de contrôle. Cela demanderait de réviser délicatement le code, le mapping de signaux, et dʼajuster lʼinterface graphique puis de recompiler et de tester. Une solution pour ceci pourrait être dʼimaginer un système pour gérer des plugins ou ajouts pour permettre dʼajouter dʼautres patchs, objets…etc. Jʼai pu tester dans des situations de concerts les deux logiciels allant ainsi à lʼétage supérieur de la conception de lʼoutil, celui de lʼexpression artistique. Une fois sur scène la pression du publique et la concentration musicale ne laissent pas place au programmateur. Tout doit fonctionner sans soucis et les éventuelles blocages doivent être préalablement étudiés et surmontés bien avant de la représentation publique.


88

3.1. Présentation de la version MAXMSP 5

Une fenêtre principale où tous les contrôles sont à la porte de main, la matrice avec les traits distinctifs de MAXMSP, par exemple les étiquettes informatives que sʼaffichent quand la souris pointe un objet (ici lʼinformation principale est le nombre du control à assigner dans les différentes modalités dʼinteraction), des textes boutons pour ouvrir et fermer les fenêtres de chaque module, des raccourcis claviers pour visualiser ou surveiller lʼétat de la chaine de synthèse. Enfin tout dans cette fenêtre révèle une profondeur à plusieurs niveaux dans lʼarchitecture logicielle. Par exemple en cliquant sur le text-buton « FMSynth », une interface graphique donne accès aux paramètres globaux du synthétiseur (notes, enveloppes, panic bouton). Là on peut rentrer encore dans une de voix du poly pour étudier ou modifier le comportement du synthétiseur. À lʼintérieur de cette voix polyphonique plusieurs abstractions simplifient la lecture et divisent le travail à accomplir : gestion des enveloppes, oscillateurs de modulation, et organisation de liste de paramètres.

Figure 29 Fenêtre principale Transgressions


89

Voici la description de lʼarchitecture, sans trop rentrer dans les détails. Ceux-ci peuvent être explorés séparément depuis le dossier transgression dans le cd accompagnant ce travail, voici la description de lʼarchitecture du logiciel. Depuis la fenêtre principale on a accès à 33 outres fenêtres distribués comme suit. Sources ou moteurs de synthèse Nom Description Objets

principaux Paramètres de contrôle / ID

ADC entrées analogiques (2)

adc~, vst~, filtergraph, biquad~

Volume/1,2 Fréquence filtre /4,5 Dry-wet /3,221 Gate /6

File1…File6 Lecture de ficiers audio. Transposition et vitesse de lecture indépendantes (FFT)

supervplayer~ waveform~

Loop, /17 Play, /18 Crazy, /19 Crazy-spped, /29 File, /16 Transposition, /21 Speed, /22 Fréquence filtre /23 Coefficients timbre /24..28, Volume /20

Orgue Synthétiseur monophonique. Modulation de phase

cycle~ multislider

Note /144 KeyVelocity /145 Duration /147 Attack time Release time Chord 8 intervales. Random chord /191 Mute /190 Volume /143

FMSynth Synthetiseur polyphonique. Modulation de Fréquence

poly~ cycle~ function kslider

Note /144 KeyVelocity /145 Duration /147 Attack time Release time Harmonicity /147 Index de modulation Amplitude Courbe AllNotesOff Volume /148


90

Additive Synthèse additive, 20 composantes, Modulation lentes.

add_synth~ multislider

On-off /178 Freq fond. /149 Transposition /150 Shift /151 LFO transp /152 LFO freq /153 LFO profondeur /154 Random chord /155 Fréquence de 20 partiels Volume /156

Sampler Lecture polyphonique dʼun échantillon. Vitesse de lecture-notes MIDI

poly~ sfplay~ umenu

Note /144 KeyVelocity /145 Attack time /222 Release time /223 File AllNotesOff Volume /157

Granular2 Synthèse granulaire sur un fichier chargé en mémoire, polyphonique

play~ wave~ poly~ rslider

On-Off /174 Scrub /134 Position Duration /136,137 Transposition /138,139 Grains séparation /135 Play,Stop,Resume Load sound Volume /140

Recorder Enregistré et joué groove~ waveform~

Play /196 Rec /193 Transposition /197 Duration /199 Filter freq /198 Save Volume /142

Traitements Pitch Shifter Décalage

fréquentielle pit_shift~ Shift /100

Scale max shift Scale min shift Volume /101

Ring Modulation

Modulation en anneau

cycle~ scale

Reference freq /102 Factor modulation /103 Volume /104


91

Overdrive Distorsion, fonction non linéaire

overdrive~ biquad~ filtergraph

Facteur distorsion /106 Freq filtre /105 Volume /107

Flanger Ligne à retarde, modulation

flange1~ Filter tunning /108 Portamento /109 Feedback /110 Volume /111

Echos Ligne à retard, multitaping

tapein~ tapeout~ multislider coll

Taille du buffer Clear Duration liste (8) Amplitude liste (8) Feedback /169 Feedback level /112 Acumulateur liste /113 Mute /195 Volume /114

Réverbération Ligne à retard tapein~ tapeout~ allpass~ onepole~ comb~

Size /115 Decay Time /116 Damping Difussion Volume /117

Harmonizer Ligne à retard, transposition, réinjection.

harmonizerv2~ Transposition /118 Depth /119 Delay /120 Feedback /121 Volume /122

CrossSynthesis Multiplication dʼamplitudes, phases, de deux entrées, dans le domaine fréquentielle

pfft~ fftin~ fftout poltocar cartopol

Mult amplitudes /123 Mult archives / 124 Mult phases /125 Volume /126

Granulation Granulation dʼune entrée en temps réel

munger~ Grain séparation /127 Grain rate /128 Grain size /129 Size Variation /130 Grain Pitch /131 Pitch Variation /131 Presets /170 Randomisation /171 Metro Random /172 Rate random /173 Mute /179 Volume /133


92

Panus Panoramic quadraphonique

expr cos expr sin qlist pictslider

Position /176 Automatisation on /175 Tempo automat /158

Position (8) Huit sorties position dans une quadraphonie

pictslider Position /160…167

Contrôle Motion Tracking

Suivi de mouvement dʼun point avec une camera, points de déclanchement spatiale.

jit.qt.grab jit.rgb2luma cv.jit.track jit.matrix jit.submatrix

Active-Inactive Selection dʼun point dans lʼimage à suivre Zones de déclanchement

Analizer Détection dʼhauteur, des attaques, suivie de Loudness, Brightness, Noiseness. 40 envoie possibles

analizer~ scale dot.autoscale

On-Off Send to controller Speedlim Scale min, max in Scale min, max out Scale courbe Autoscale Recalibrate Umenu Source

Tables Control Cinq tables avec contrôle de vitesse

table sprintf metro

On-Off /180 Speed /181

Keyboard Assigner de contrôleurs aux touches de clavier 20 sliders, 10 toogles, 10 bangs, Un clavier MIDI dʼune octave.

key Iioa atoi zl

Active-inactive

MIDI In Six canaux notein, key velocity, neuf entrées de sensors analogiques ou contrôleurs midi, Program Change,

sensor-tamer ctlin sprintf

On-Off Port Scale

MIDI setting Permet dʼassigner un contrôleur MIDI à différents paramètres,

ctlin coll zl

CC number Clear Open Save


93

sauvegarder et charger les configurations, fonction « learn midi »

load

Score 20 qlist et deux espaces texte pour envoyer des ordres au logiciel et pour écrire la fonction init.

qlist txtedit atoi itoa timer

Play Stop Open Write Read

Sept autres fenêtres permettent de surveiller différentes parts du programme, dʼavoir des objets cachés dans des fenêtres conçues pour, et dʼéconomiser lʼusage du cpu qui est très couteux pour tous les objets graphiques de monitoring.

• CPU status • DSP status • IO matrice assignant les canaux dʼentrées et sorties • Meters un indicateur de niveau pour chaque module • MIDI test • Audio test • Readme

La syntaxe pour contrôler un de 200 paramètres est « ID control »-controlslider, La liste complète dʼIDs, est consultable dans lʼarchive « Readme », Id est une chiffre entier pour identifier numériquement chaque paramètre de contrôle. La sauvegarde de configurations et des états du logiciel sont pris en charge par sept objets pattrstorage appelles dans mon patch « partitura » pour de raisons dʼorganisation et pour les identifier séparément :

• Partitura1 : matrix • Partitura2 : paramètres de contrôle • Partitura3 : Analyzer • Partitura4 : Tables • Partitura5 : MIDI in • Partitura6 et 7 : Keyboard (clavier de lʼordinateur)

Enfin, une fenêtre shortcuts permet de configurer des raccourcis claviers en assignant une touche du clavier pour ouvrir ou fermer les fenêtres décrites plus haut. Il est aussi accompagné des fonctions de sauvegarde, de charge de configuration ; La possibilité dʼactiver ou de désactiver cette fonction est assez importante pour éviter les conflits avec lʼobjet « Keyboard »


94

3.2. Comparaison avec Jabalion

Bien que lʼapproche soit similaire dans les deux applications, les résultats, les défis, les facilités et les difficultés diffèrent. Avoir choisi de construire des architectures similaires avec deux environnements tout à fait différents mʼa permis de faire une évaluation comparative dans tous les étages dʼécriture, depuis les brouillons, la planification, l ʻécriture elle même, les tests et la présentation publique. Il nʼest pas facile de se dire que celui-ci dépasse celui-là dʼun point de vu sonore, car lʼappréciation ou le jugement objectif des qualités sonores est une opération bien complexe et sujette à des variables de caractère subjectif qui sont difficiles à maîtriser, à quantifier, voire même à identifier. Sans vouloir mʼexcuser derrière ces difficultés pour ne pas donner mon opinion dans ce sujet, je vais exposer mes ressenties. Pour ce chapitre, jʼai essayé de soumettre les deux logiciels aux mêmes conditions matérielles, cʼest à dire à une carte motu 828, à une paire dʼenceintes Bx5 de Maudio, à une fréquence dʼéchantillonnages 44.1Khz, à une taille de vecteur 64, à un ordinateur MacBook 2.4Ghz de 2G de mémoire ram avec le système opérative OS X 10.5.8, ainsi quʼau même espace acoustique dʼécoute. Je mʼappui également sur mes souvenirs et sur les traces laissées par les expérimentations et concerts. La sensation globale en jouant sur Jabalion est celle dʼun spectre qui sʼenrichie facilement, très dynamique et il y a une sorte de définition précise dans les contours. Avec Transgressions le son paraît plus opaque ou sombre une sorte de limite quelque part, une ligne plus diffuse. Ceci est peut être dû à lʼarchitecture de deux plateformes et au post traitement (?) du signal avant sa conversion numérique-analogique, ou à la précision à lʼéchantillon près (sample accuracy). Cette sensation de « luminosité », de « brillance », de « dʼéclatement » ou de « clarté », peut être mis en cause et étudié de plus près. Par exemple, les synthèses stochastiques fonctionnent très bien dans Jabalion mais je suis plus satisfait de la lecture dʼarchives avec supervplayer~, notamment dans le ralentissement très poussé. Les textures granulaires sont plus intéressantes dans Jabalion. Cependant cela dépend beaucoup de lʼarchive dʼorigine et de la construction du patch. Pourtant Granular2 donne de très bons résultats. Ici, je voudrais insister sur le fait, que dans les deux cas jʼai opté pour ne pas utiliser de filtres numériques avant la sortie car je pense quʼil est intéressante de laisser ces dernières réglages au matériel externe complétant la chaine électroacoustique : tables de mixage, amplificateurs, hautparleurs ou enfin les systèmes de diffusion propres à chaque salle.


95

La réactivité ou mieux la latence, indépendante du système et de lʼordinateur me semble légèrement plus prononcé sur Transgressions. Un temps ou une cadence est subtilement plus lourde. Encore une fois, est-ce dû à la séparation très claire entre le langage et le moteur de synthèse de SuperCollider ? Peut être. Les opinions sur ce sujet sont très variées et dans les espaces de discussion (forums internet), cela ressemble plus à une confrontation politique quʼesthétique. Il est très difficile dʼobjectiver les appréciations sans avoir les sons et les conditions dʼécoute normalisées. Au niveau du contrôle, la gestion des automatisations fait une grande différence. Les interpolations de différents états enregistrés avec la mécanique de pattstorage se différencient nettement de lʼenregistrement multiparamétrique sur un axe temporel de gestes proposés par Automation. Le résultat est vraiment différent. Il est plus facile dʼenregistrer un mouvement que dʼécrire de qlist où des enchainements dʼinterpolations dans le pattstorage. Enfin sur la gestion du temps en MAXMSP plusieurs solutions ont vu le jour, comme, par exemple lʼobjet timeline (supprimé dans la version 5). Cela ne veut pas dire que la gestion temporelle soit plus effective dans SuperCollider. La page blanche atemporelle comme point de départ est plutôt une ressemblance entre ces deux environnements. Il est vrai que le point fort de la programmation sur MAXMSP est la facilité à dessiner lʼinterface graphique : formes, tailles, couleurs, positions, ombres, angles…etc. Dans mon cas personnel, jʼai vite compris le piège de passer trop de temps à dessiner une interface graphique avec toute sorte dʼarabesques. Temps précieux pour la programmation musicale et pour les défis imposés pour les traitements du signal. Par contre jʼapprécie beaucoup les outils dʼanalyse dʼimage et la facilité à mettre en place une détection très simple avec la caméra intégrée de lʼordinateur et dans les librairies de Jitter, tâche pas si évidente que ça dans SuperCollider. Lʼinitialisation du programme a été plus facilement organisable dans Jabalion. Il y existe une classe startup dans laquelle on peut écrire une routine avec des étapes de validation de lʼutilisateur pour gérer lʼordre dʼinitialisation de la librairie, sélection des pilotes audio et MIDI, initialisation du serveur, chargement des fichiers, préparation de buffers et création de synthèse. Dans Transgressions il est dangereux de laisser cette fonction dʼinitialisation aux objets loadbang et loadmess. On est en effet jamais sûr de lʼordre et de la hiérarchie dans lequel ces messages sont évalués. Il mʼest arrivé comme à dʼautres utilisateurs avec de grands projets dʼavoir fait une erreur dans la programmation et de ne plus être capable dʼouvrir le patch car un des messages est tombé dans une boucle.


96

La seule solution a été de travailler le patch dans un format texte et dʼy retrouver et de modifier les messages posant des problèmes dans le texte. Tâche lourde de comprendre ce code quʼon ne croise presque jamais et qui est caché au profit des objets graphiques. Dans SuperCollider sʼil y a une erreur dans lʼécriture le logiciel ne sʼarrête pas et indique dans quelle ligne se trouve lʼerreur. Un dernier point que je voudrais rapporter est celui de la distribution. Il est cent fois plus facile de construire une application autonome et dʼy travailler avec SuperCollider quʼavec MAXMSP. Lʼaccès aux sources est très précieux, ajouter des méthodes personnelles à une clase est si simple quʼécrire une fonction précédée par « + » le nom de la classe, sauvegardée dans un fichier et puis placée au bon endroit et cʼest tout. En MAXMSP une fois le script de création dʼapplication autonome, évalué on nʼa plus accès au code, donc au moindre changement il faut recommencer lʼopération et les externals sont intouchables, sauf si on retrouve la source et on recompile tout en C++, mais faire circuler les sources nʼest pas du tout une habitude parmi les utilisateurs MAXMSP, tandis que pour SuperCollider on peut beaucoup apprendre grâce à la lecture de sources distribuées publiquement. Avec la prétention de sérénité et le bouclier de la subjectivité, jʼai cherché à faire une comparaison entre ces deux langages et sans vouloir le dire jʼai fini par le dire et prendre un parti silencieux pour la philosophie, lʼarchitecture logiciel et les résultats sonores produits et rencontrés dans les expériences avec SuperCollider, toutefois je suis conscient du caractère ludique de MAXMSP et le travail très important dʼénormément de musiciens et programmateurs qui ouvrent plusieurs voies pour lʼexpression électroacoustique. Jʼai beaucoup appris dans cet environnement.


97

4. ANNEXES Pour illustrer lʼutilisation des ces deux applications jʼai ajouté dans le CD accompagnant cette mémoire, trois extraits des pièces jouées au long de ces deux années.

4.1."Border Border Expres" Olarte / Okach, Electronique et Danse

Ma collaboration avec le coregraphe Opiyo Okach a commencé dans lʼannée 2007 avec la pièce « take it away » pour le festival dʼAvignon. Je me suis identifié avec la recherche dʼimprovisation dans la danse menée par Opiyo. Cet extrait montre un passage de la pièce « Border Border Express » presenté au « Basse Festival » à Birmingham en Juin 2009. Le danseur est en face dʼune projection de quelques vidéos enregistrées à la main sur les stéréotypes et les idées reçus sur le Kenya. Les manifestations, la terre tropicale, les émeutes, le discours politiques, Kenyata, Obama, lʼinfluence de la musique congolaise et Lumumba, le postcolonialisme, les tribus des Kambas, Swahilis. L ʻidée est inspirée de petits taxis charriots poussés par des jeunes à la frontière entre le Kenya et la Tanzanie et lʼidée de frontières et de transgression. Idées que collent très bien avec mes projets dans le langage musical. Jʼutilise pour ce passage des fichiers son et de traitements, pour créer une densité sonore : « le bruit du monde »

4.2."Coco duro" Olarte / Montes de Oca Torres, Guitare et électronique

Cet exemple est tiré dʼun concert au Fylkingen Stockholm, avril 2009, en duo avec le compositeur et artiste sonore Alejandro Montes de Oca Torres. Il sʼagit dʼune libre improvisation où tous les deux avons des guitares, capteurs, contrôleurs.

4.3."Workshop Helsinki Meeting Point"/ Sibelius Academy Finlande.

Entre février et Mars 2010 jʼai été invité à la Sibelius Academy de Finlande pour diriger un atelier sur improvisation électroacoustique, cela a été donc lʼopportunité pour tester les deux applications dʼun point de vue pédagogique. A la fin du séminaire nous avons réalisés une performance publique incluant trois danseurs, un comédien et six musiciens, la durée totale était dʼune heure.


98

5. CONCLUSIONS

Arrivant a ce point je doit mentionner les difficultés, les réussites, les points faibles et les leçons apprises avec ce travail. Si je reprend à mes objectifs du début, je considère avoir mené à bon terme lʼécriture de cet environnement pour lʼimprovisation. Jʼai eu lʼopportunité de lʼutiliser dans de performances publiques, ils sont arrivés au stade de « standalone application » qui est portable dʼune machine à lʼautre, tout en suivant les limites de caractéristiques du système requis (jʼai eu lʼoccasion de travailler que sur de machines Machintosh). Concernant les attentes ergonomiques et de facilités de fonctionnement je considère pouvoir aller encore un pas plus loin, car les moteurs et techniques de synthèse explorées et travaillées peuvent sʼenrichir encore plus et peuvent, par exemple, comporter de chaines de synthèse plus complexes. Toutefois, jʼai réussi à écrire un système de presets, de chargement automatique, de contrôles assignables au clavier, à une interface MIDI, à une analyse du son et à lʼinterface graphique plutôt simple. Concernant lʼimprovisation musicale, je ne suis pas complètement satisfait car jʼai réalise la tournure « technique informatique musicale » quʼa pris ce document au détriment de lʼaspect langage et esthétique propre au monde de lʼimprovisation. Malgré tout quelques réflexions issues de la réflexion technique mʼouvrent les portes pour assumer une future recherche, par exemple, un système dʼanalyse par lignes : ligne dynamique, ligne dʼévolution dans le matériel, ligne dramatique ; lʼimportance de la réactivité sonore, une possibilité de construction du logiciel au tour des axes : variation, contraste, répétition ; ou bien : densité (quantité dʼévénements par unité de temps), monophonie, polyphonie, organisation rythmique et temporelle. Enfin une étude mieux balancée entre technologique et réflexion musicale. Jʼai beaucoup appris de la programmation par code en SuperCollider et de la programmation avec des objets graphiques avec MAXMSP, ses particularités, ses différences, sa logique propre. Cette expérience dans la programmation vient compléter mon parcours qui, depuis ma formation au Conservatoire National, était plus centrée dans le développement de hardware ou de interfaces physiques et lʼexploration de geste musical. Ce nʼest pas prématuré donc dʼimaginer comme conséquence logique de cette trajectoire le cheminement vers une thèse de Doctorat où lʼobjet de la recherche porterait à la fois dans la réflexion esthétique, les outils technologiques, une méthodologie et une pédagogie de lʼimprovisation électroacoustique.


99

6. BIBLIOGRAPHIE. IMPROVISATION MUSICALE Jacques ABOUCAYA et Jean-Pierre PEYREBELLE « Du Be-Bop au Free Jazz » Presses universitaires du Mirail, 2001, Toulouse Derek BAILEY « Lʼimprovisation, sa nature et sa pratique » Editions Outre-Mesure, 1999, Paris. Traduit de lʼanglais par Isabelle Leymarie Lawrence CASSERLEY « A Digital Signal Processing Instrument for Improvised Music », Journal of Electroacoustic Music, vol 11, 1998, London Pierre-Albert CASTANET « Tout est bruit pour qui a peur, Pour une histoire sociale du son sale », Editions Michel de Maule, 2007, Paris Daniel FISCHLIN, « Improvisation and the Unnameable: On Being Instrumental » Critical Studies in improvisation, 2009, Ontario, Canada

Vinko GLOBOKAR « Réflexions sur lʼimprovisation : le point de vue dʼun praticien » Analyse Musicale n°14, 1989, Paris Wolfgang KÖNIG Vinko GLOBOKAR, « Komposition und Improvisation » Editions Breitkopf & Härtel, 1977, Wiesbaden, Allemagne Denis LEVAILLANT « Improvisation musicale : essai sur la puissance du jeu » Editions Actes Sud Beaux Arts, 1996, Paris

Lê Quan NINH « L'improvisation : une pratique libertaire » Infos & Analyses Libertaires n° 43 - novembre 1997, Toulouse Michel RATTE « L'Expressivité de l'oubli, essai sur le sentiment et la forme dans la musique de la modernité », Editions La Lettre Volée, 1999, Bruxelles Michel RATTE « Réinterpréter lʼimprovisation musicale, lʼimprovisation comme forme »Musicworks Journal ; N° 66, 1996, Toronto, Canada Alain SAVOURET « La place de lʼinvention immédiate dans les musiques dʼaujourdʼhui » Musique du 20e siècle, conférences et séminaires 1996-1998 Université de Paris-Sorbonne Patrick SCHEYDER, « Dialogue sur LʼImprovisation Musicale » Editions lʼHarmattan, 2006, Paris


100

INTERFACES

Joel CHADABE « The Voltage-Controlled Synthesizer » The Development and Practice of Electronic Music, Englewood Cliffs Editions, 1975, New Jersey Genevois HUGUES, Raphaël DE VIVO « Les nouveaux gestes de la musique » Editions Parenthèses, 1999, Marseille Gerard NICOLLET, Vincent BRUNOT « Les chercheurs de sons » Editions Alternatives, 2004, Paris Hugues VINET, François DELALANDE « Interfaces homme-machine et création musicale » Hermes Science Publications, 1999, Paris Max VANDERVORST « Lutherie Sauvage » Editions Alternatives 1997, Paris Bradley WAIT and Alain RINZLER « Guitar Synth and MIDI from the Guitar Player » Magazine. GPI Publications, 1988, Cupertino California. Collectif, « Syntetizeur, Control Devices », The New Grove Dictionary of Musical Instruments 1984, Macmillan.

INFORMATIQUE MUSICALE

Denis GABOR « Acoustical quanta and theory of hearing » 1947, Nature Vol.159 Sergi JORDA « Digital Lutherie: Crafting musical computers for new musicsʼ performance and improvisation » 2005, Ph.D. dissertation, Dept. of Computer Engineering, Universitat Pompeu Fabra, Barcelona. Robert ROWE « Interactive Music Systems: Machine Listening and Composing ». 1993, The MIT Press, Cambridge T. WINKLER « Composing Interactive Music: Techniques and Ideas Using Max » 1998, The MIT Press, Cambridge Laurent BAYLE « La synthèse sonore » Editions IRCAM, 1993, Paris PUCKETTE Miller, « Theory and Technique of Electronic Music », 2007, World Scientific Publishing Co. Pte. Ltd. California Curtis ROADS « The Computer Music Tutorial » 1996, The MIT press. Curtis ROADS « Granular synthesis of sound » 1985.Cambridge, The MIT Press


101

Manuel ROCHA ITURBIDE, « Les techniques granulaires dans la synthèse sonore ». Thèse Doctoral sous la direction dʼHoracio Vaggione. Université de Paris VIII. 1999 France.

SCHROEDER Manfred, « Natural sounding artificial réverbération », 1961 Journal of the Audio Engineering Society N°10. NewYork Nathan Edwin WOLEK « A Simplified Interface for Granular Processing Based on Perceptual Research » 2005, North Western University, ILLINOIS

Iannis XENAKIS « Formalized Music » 1992, Pendragon Press. Stuyvesant, NewYork

ESTHETIQUE

John CAGE « Silence » Editions Denoël, 2004, Paris Hugues DUFOURT. « Mathesis et Subjectivité » Des conditions historiques de possibilité de la musique occidentale. Editions MF, avril 2007, Paris Umberto ECO « Lʼœuvre ouverte » Editions du seuil 1965, Paris, traduit de lʼitalien par Chantal Roux de Bézieux George LEWIS « Too Many Notes: Computers, Complexity and Culture » Leonardo Music Journal N° 10, The MIT Press, 2000, Cambridge Pierre SCHAEFFER « Traité des objets Musicaux » Editions du seuil, 1966 Paris Wilhelm BRUCK « Pro Muisca Nove. Studies for Playing Contemporary Music For Guitar » 1992 Breitkopf & Härtel, Wiesbaden Germany. LINKS

Lʼimproviste, http://sites.radiofrance.fr/francemusique/em/improviste

Critique Improvisation http://www.criticalimprov.com/index.php/csieci/index

European Free Improvisation, http://www.efi.group.shef.ac.uk/ Hyperinstruments, http://www.media.mit.edu/hyperins/projects.html Videobass, http://www.anyma.ch/videobass/ Luthérie électronique, http://www.omf.paris4.sorbonne.fr/AUX/Lutherie.htm


102

INDEX DE FIGURES FIGURE1FORMESD’ONDESOBTENUESAVECLEPROCEDESTOCHASTIQUEEMPLOYEENGENDY.....................................19FIGURE 2 FREQUENCY SHIFT, DEPLACEMENT SPECTRAL CD PLAGE 2 ........................................................................23FIGURE3MODULATIONS«WAH»CDPLAGE3........................................................................................................................24FIGURE4DIAGRAMMEDESBLOQUESREVERBERATIOND’APRESL’ALGORITHMEDESCHROEDER ...............................25FIGURE5EFFETDEREVERBERATIONCDPLAGE4 ...................................................................................................................27FIGURE6INTERFACEGRAPHIQUEPOURLECONTROLEDESMULTIDELAY.............................................................................29FIGURE7FORMED’ONDEMULTIDELAYSCDPLAGE5 ..............................................................................................................29FIGURE8REINJECTIONLIGNEARETARDMODULECDPLAGE6..............................................................................................32FIGURE9APPLICATIONDELATRANSFORMEECONFORMEAUSON1CDPLAGE7 ...............................................................37FIGURE10EFFETDEFREEZER,SPECTREGELECDPLAGE8 ...................................................................................................39FIGURE11MODULEDEREVERBERATIONIXIQUARKS .............................................................................................................46FIGURE12NAJOMAXINTERFACE................................................................................................................................................46FIGURE13MATRIXLOGICIELTAPEMOVIE .................................................................................................................................47FIGURE14MATRIXJABALION.......................................................................................................................................................48FIGURE15INTREFACEGRAPHIQUEOMAX................................................................................................................................55FIGURE16JEUDEPOTENTIOMETRESJABALION ........................................................................................................................57FIGURE17FENETREPRINCIPALEETMENUJABALION..............................................................................................................57FIGURE18PANORAMIQUE.............................................................................................................................................................62FIGURE19FORMED’ONDEETLISTED’ARCHIVESLECTUREDESFICHIERS ...........................................................................65FIGURE20MULTISLIDERA100POINTS,LISTEDEPARAMETRESAAFFECTER,VELOCITE.TABLES.................................67FIGURE21TABLEAUDUMIDIMAPPING ....................................................................................................................................69FIGURE22INTERFACECLAVIERPOURASSIGNERLECONTROLEDEPARAMETRES...............................................................70FIGURE23PEDALECIRCULAIREARDUINO..................................................................................................................................80FIGURE24DETECTIOND’HAUTEURPARZEROCROSSING.........................................................................................................81FIGURE25PLOT,COURBECOMPARATIVEDETECTIOND’HAUTEURD’UNENOTEREPETEE.................................................83FIGURE26DEBUTDELATABLATUREFORLORNHOPEFANCYDEJOHNDOWLAND,THEMECHROMATIQUE..................83FIGURE27COMPARAISSONSDERESULTATSDEL’ANALYSEDUMORCEAUDEDOWLANDCDPLAGE9 ............................84FIGURE28INTERFACEGRAPHIQUEDE“AUTOMATISATION” ..................................................................................................86FIGURE29FENETREPRINCIPALETRANSGRESSIONS ................................................................................................................88

Jabalion - Un Environnement Informatique Pour LʼImprovisation Electroacoustique

Documents

Transcript of Jabalion - Un Environnement Informatique Pour LʼImprovisation Electroacoustique