Voila deux scripts qui permettent d'avoir une base minimale afin de faire communiquer processing et chuck par le protocole OSC. L'applet Processing envoie les données qui controlent la synthèse sonore, prise en charge par ChucK. OSC (Open Sound Control) est un protocole qui permet de faire communiquer entre eux instruments de musique électronique, controleurs, ordinateurs et appareils multimedia en partageant des données en temps réel par le réseau local ou par internet. C'est une tentative pour remplacer le format MIDI (implanté en 1983) qui est un peu dépassé aujourd'hui. Contrairement au MIDI, les messages transférés par OSC utilisent une syntaxe symbolique et flexible (à la manière des URL).

Pour utiliser OSC avec Processing, il faut installer la librairie oscP5 (à télécharger : oscP5). Ensuite 2 lignes au début du script permettent de l'utiliser.

Comment lancer les scripts ?

- ouvrir une première fenêtre de commande, lancer chuck avec "chuck --loop"
- ouvrir une seconde fenêtre, et ajouter le script avec "chuck + chuckosc.ck"
- puis démarrer l'applet dans processing

le script processing

Une valeur de fréquence est tirée au hasard 3 fois par secondes et envoyée sous forme de message OSC, sur le port 6449, en UDP

// 6 sept. 2007 / processing 0125 / chuck 1.2.1.0 / oscP5 0.9.0
import oscP5.*;
import netP5.*;

float zefreq = 440;
String oscP5event = "oscEvent";
OscP5 canalOsc;

void setup() {
  size(200,200);
  canalOsc = new OscP5(this, "localhost", 6449, 6543, oscP5event); 
  frameRate(3);
}

void draw() {
  OscMessage message = new OscMessage("/processing" + "/");
  zefreq = 440 + random(0, 200);
  message.add(zefreq);
  canalOsc.send(message);
}

le script chuck

Le script est en attente permanente, en écoute sur le port 6449, chaque fois qu'un évènement est reçu, la fréquence du son est modifiée.

// 6 sept. 2007 / processing 0125 / chuck 1.2.1.0 / oscP5 0.9.0
// nom de l'hote et port par défaut
"localhost" => string hostName;
6449 => int receiverPort;

<<< "port de reception pour les messages OSC:", receiverPort >>>;

// objet OSC pour la réception
OscRecv receiver;
receiverPort => receiver.port;
// commencer l'écoute sur le port
receiver.listen();
// créer une adresse réceptrice des messages, y stocker la valeur de fréquence reçue
receiver.event( "/processing" + "/" + ", f" ) @=> OscEvent oeFreq;

SinOsc s => dac;

while ( true ) {
    // en attente de l'arrivée d'un message OSC
    oeFreq => now;
	
    // capturer le nouveau message
    while ( oeFreq.nextMsg() != 0 ) { 
		oeFreq.getFloat() => s.freq;		
    }
    <<<"nouvelle frequence : ", s.freq() >>>;
}

Télécharger un zip contenant les deux scripts : chuck-processing-osc.zip

Un sniffeur de trafic réseau peut-être utile pour résoudre les problèmes d'échange réseau. Comme Ethereal ne peut pas superviser le trafic local, on peut utiliser AW Ports Traffic Analyzer disponible en version d'essai (limitation à 3Mo de l'enregistrement des logs) mise à jour : bien que ce ne soit pas annoncé sur leur site, la version d'essai a une autre limitation : elle cesse de fonctionner au bout de 15 jours!

Nouvelle version

Depuis le dernier billet sur ChucK, deux nouvelles versions sont sorties, ChucK est actuellement en version «Dracula 1.2.10». Alors quoi de neuf dans ces nouvelles sorties ?
De nouveaux unités génératives (ugens) ont fait leur apparition :
Gestion d'effets dynamiques par l'ugen "dynamics" : des fonctions de limiteur, expandeur, compresseur, noise gate, ducker (voir effets dynamiques sur wikipedia)
Capture d'échantillons en temps réel avec Lisa, Li(ve) Sa(mpling) : pour sampler à la volée du son fabriqué par ChucK, ou capturé depuis le micro
Tables de correspondance (table lookup) : les tables de correspondance permettent d'associer des valeurs, un signal est donné en entrée à la table et la sortie dépendra de ce signal et du contenu de la table

Analyse du son : une nouvelle catégories d'unités, dédiées à l'analyse du son fait son apparition, les Uana :
«Les unités d'analyse (Uana) sont des des blocs de construction, conceptuellement similaires aux unités génératives (Ugen). Ces blocs réalisent des fonctions d'analyse sur un signal sonore ou des métadonnées, et produisent des métadonnées en sortie. Les unités d'analyse peuvent être liées ensemble, ainsi Communauté. Cette différence est symbolisée par le choix d'un nouvel opérateur, l'opérateur upChucK: =^. Une autre différence importante entre les Ugens et les Uanae est que les Uanae réalisent l'analyse uniquement sur demande, par la fonction upchuck().» (d'après uana)
Un document (en anglais) des auteurs de ChucK sur le sujet est disponible : Analysis and Synthesis in chucK (pdf)

téléchargement et autres infos sur le site de ChucK

ChucK & Processing

Arthur Clemens a réalisé et mis à disposition sur son blog (visiblearea) un ensemble de scripts qui permettent de faire dialoguer ChucK et Processing via le protocole OSC (Open Sound Control). Dans ce dispositif, Processing transmet des valeurs pour le volume et la répartition stéréo, et ChucK analyse le spectre sonore et renvoie les valeurs à Processing. L'auteur propose une démonstration ou 4 extraits sonores sont assemblés en fonction des mouvements réalisés par des cercles dans l'animation graphique.


Chuck & Pure data

chuck~ est un plugin externe pour pure-data mis au point par Martin Robinson. Il permet d'intégrer un objet chuck au sein d'un patch pure-data. Les données et le signal sont transmis à l'objet chuck puis repassés à pure-data par l'intermédiaire des unités ADC et DAC de ChucK. => chuck~ (for Pure Data)

S.M.E.L.T.

S.M.E.L.T. (pour Small Musically Expressive Laptop Toolkit) est une boîte à outils de scripts chuck pour faciliter le développement d'instruments interactifs, en utilisant ce qu'il y a de disponible sur tout ordinateur : clavier, souris, trackpad (sur les portables), micro intégré, capteur de choc et de mouvement (sur certains portables). Par exemple, un script est fourni qui permet d'utiliser le micro avec le souffle, à la manière d'une flûte. => SMELT

Communauté

Autour de ChucK, il existe plusieurs listes de discussion : chuck pour les annonces, chuck-users pour les discussions ainsi qu'un wiki (ou l'on peut trouver des exemples, du son, des tutoriels) : chuck community. Les archives des listes sont conservées et accessibles publiquement, on peut également y faire des recherches par requête. Il existe également un forum anglophone sur electro-music.com (forum chuck), parmi les nombreux sujets, un est consacré aux programmes chuck ultra-courts, de la création sonore en une ligne de code! (1 line chuck)

Une nouvelle version de ChucK est parue (1.2.0.7, toujours multiplateforme et open-source). Les nouveautés, hormis la résolution de bugs et le changement de casse des instructions (SinOsc au lieu de sinosc), concernent l'ajout de nouvelles unités sonores (ugen), inspirées & aspirées des autres logiciels libres de création musicale par le code (CSound, SuperCollider 3 et Pure Data). Donc on peut maintenant utiliser une série de filtres audio (passe-haut, passe-bas, résonant, etc.) qui sont d'utilisation plus simple que les filtres mathématiques de traitement du signal. Chaque future version va s'enrichir de nouveaux générateurs.

On peut utiliser ChucK en ligne de commande, mais ce n'est pas le seul moyen. miniAudicle est une alternative simple à mettre en oeuvre, qui permet de tester les codes très facilement. Pour une découverte, c'est certainement la meilleure façon pour obtenir des résultats (gratifiants!) rapidement. C'est un environnement temps réel où l'on peut ouvrir des fenetres de code pour les scripts chuck, les ajouter, les échanger ou les retirer de la machine virtuelle. La version 0.1.3.6 contient la dernière version de ChucK, donc en quelques clics on peut profiter de tous les exemples fournis!

Pour télécharger Mini Audicle : miniAudicle

ChucK est un langage de synthèse audio en temps réel, pour la composition et l'utilisation en live. Il intégre une gestion du temps très précise, qui constitue une de ses qualités originales, ChucK permet également la modification des scripts à la volée, sans pause ni redémarrage. Une partie du langage permet de traiter les évènements dynamiques externes : clavier, souris, usb, MIDI et OSC.

Ce langage est développé pour faire du code un instrument d'expression musicale. L'utilisation basique de Chuck se fait à partir de scripts en mode "ligne de commandes", un environnement complet de programmation est en cours de développement.

Parmi les capacités du langage, on peut trouver en vrac : la gestion des échantillons (formats wav), des oscillateurs pour toutes formes d'onde (phasor, sin, pulse, square, triangle, sawtooth, etc.), des filtres, la gestion du réseau en udp, des évènements MIDI et OSC ainsi qu'une librairie d'instruments paramétrables (modélisation physique) : clarinette, flute, mandoline, moog, sitar, voix, saxophone, une librairie pour la modulation FM, etc.

ChucK est développé à Princeton pour les plateformes MacOS X, Windows ou Linux, sous licence GNU-GPL.
Site principal en anglais
ChucK sur Sourceforge


Voici une traduction en français de deux tutoriels pour se mettre à chucker : l'installation sur Windows XP, et la réalisation d'un premier script : ChucK en français. Ils sont basés sur la version 'Dracula' du langage (1.2.x.x)



Deux exemples (pas vraiment musicaux!) pour illustrer le langage :

// créer un oscillateur à onde carrée nommé 'car'
sqrosc car => dac;
// donner une valeur à la variable fréquence
20 => float frequence; 
// fixer la fréquence de l'oscillateur à 20 Hz
frequence => car.freq; 

// jouer indéfiniment en changeant 
// la fréquence toutes les 1/2 secondes
while (true) { 
  // augmenter ou réduire aléatoirement la fréquence
  std.rand2f(-2.0, 2.0) + frequence => frequence;
  frequence => car.freq; // attribuer la nouvelle fréquence
  // laisser passer une demi seconde
  0.5::second => now;
}

Voila ce que ça donne :




Avec des légères modifications :

// créer un oscillateur à onde sinusoïdale nommé 'sin'
sinosc sin => dac;
// donner une valeur à la variable fréquence
440 => float frequence; 
// fixer la fréquence de l'oscillateur à 440 Hz
frequence => sin.freq; 

// jouer indéfiniment en changeant la fréquence 
// toutes les 50 millisecondes
while (true) { 
  // augmenter ou réduire aléatoirement la fréquence
  std.rand2f(-5.0, 5.0) + frequence => frequence;
  frequence => sin.freq; // attribuer la nouvelle fréquence
  // laisser passer 50 milli-secondes
  50::ms => now;
}