Oggi sfrutteremo Processing per creare dei semplici visual sincronizzati con la musica attraverso il protocollo MIDI. Il software musicale che userò per fare gli esempi è Ableton Live 9 ma è possibile usare qualsiasi Digital Audio Workstation in grado di inviare messaggi MIDI.
Lo schema delle connessioni, dunque, sarà: Ableton Live gestirà la musica e invierà, attraverso dei messaggi MIDI, delle informazioni che Processing acquisirà in input per generare i visual.
MIDI e the MidiBus
Perché ho deciso di sfruttare il protocollo MIDI? Le ragioni sono molto semplici:
- è uno standard per le applicazioni musicali
- è un protocollo flessibile
- è semplice creare, inviare e monitorare i messaggi MIDI.
- rende molto semplice la sincronizzazione
Per questioni di spazio, non mi dilungherò in questo post sulla spiegazione di come funziona questo protocollo; trattandosi di uno standard sviluppato negli anni ’80, ci sono numerose risorse on-line che vi permettono di approfondire.
Libreria: the MidiBus
Anche se Java supporta nativamente il MIDI attraverso il pacchetto java.sound.midi, per lavorare con questi tipi di messaggi in Processing consiglio di installare una libreria.
Aprite Processing, andate nel menu Tool > Add new tool. Nel pannello Libraries digitate MIDI, selezionate The Midi Bus e cliccate sul pulsante Install in basso a destra.
macOS: IAC Driver
Di norma per inviare e ricevere messaggi MIDI è necessario dotarsi di una scheda e dei relativi cablaggi. Nel nostro caso, però, dovendo inviare e ricevere messaggi tra due applicazioni possiamo sfruttare lo IAC Driver: una scheda virtuale che ci permette di gestire tutte le connessioni internamente al computer.
Nota: Per Windows esistono delle applicazioni da installare che hanno la stessa funzione del driver IAC. Con una veloce ricerca su Google ho trovato LoopBe1 e MIDI Yoke che non ho provato personalmente ma sono consigliate su diversi forum.
Per configurare lo IAC Driver su macOS aprite Applicazioni > Utility > Configurazione MIDI Audio. Cliccate su Finestra > Mostra Studio MIDI ⌘2
Fate doppio click su IAC Driver e mettete la spunta su Il dispositivo è acceso.
Ora che abbiamo attivato il canale di comunicazione interno per inviare e ricevere messaggi MIDI, possiamo procedere con Processing.
Ricezione messaggi MIDI in Processing
Apriamo un nuovo sketch e verifichiamo subito che Processing veda lo IAC Driver.
/*
* Processing e Ableton: sincronizzare musica e visual via MIDI
* Federico Pepe, 05.03.2017
* http://blog.federicopepe.com/processing
*/
import themidibus.*;
void setup() {
size(100, 100);
background(0);
MidiBus.list();
}
void draw() {
}Con queste poche righe di codice abbiamo importato la libreria all’interno del nostro programma e attraverso il comando Midibus.list() possiamo verificare nella console tutte le periferiche MIDI attive.
Questo è il risultato che ottengo lanciando il programma sul mio Mac. Ovviamente potrebbe cambiare sul vostro; l’importante è che sia presente IAC Bus.
Available MIDI Devices: ----------Input---------- [0] "IAC Bus 1" [1] "Real Time Sequencer" ----------Output---------- [0] "Gervill" [1] "IAC Bus 1" [2] "Real Time Sequencer"
Progetto Ableton Live: invio del messaggio
Apriamo Ableton Live e creiamo un nuovo progetto. Apriamo le preferenze e verifichiamo che il driver IAC sia selezionato come scheda sia per l’input che per l’output.
Nella prima traccia MIDI nella parte di input/output selezioniamo MIDI To > IAC Driver. In questo modo tutti i messaggi che saranno presenti su questa traccia saranno inviati come output al driver e, di conseguenza, saranno ricevuti da Processing.
Creiamo una Clip MIDI nel primo slot contenente un C3 lungo 1/4. Assicuriamoci che la clip sia il loop quando premiamo il tasto play su di essa.
Ricezione del messaggio
Torniamo su Processing e modifichiamo il nostro programma come segue:
/*
* Processing e Ableton: sincronizzare musica e visual via MIDI
* Federico Pepe, 05.03.2017
* http://blog.federicopepe.com/processing
*/
import themidibus.*;
MidiBus myBus;
void setup() {
size(100, 100);
background(0);
MidiBus.list();
myBus = new MidiBus(this, 0, 1);
}
void draw() {
}
void noteOn(int channel, int pitch, int velocity) {
println();
println("Note On:" + " Channel: "+channel + " Pitch: "+pitch + " Velocity: "+velocity);
println("--------");
}Rispetto al codice scritto in precedenza, abbiamo aggiunto e inizializzato un oggetto di tipo MidiBus: myBus = new MidiBus(this, 0, 1);. In questa fase è fondamentale inserire i parametri corretti: il primo è il parent a cui la libreria è collegata, il secondo è l’input e l’ultimo l’output. I dati sono facilmente individuabili grazie al comando .list() dato in precedenza.
Abbiamo, infine, aggiunto una funzione che è presente all’interno della libreria: noteOn() e che restituisce i valori MIDI: canale, pitch e velocity di tutte le note ricevute.
Verifichiamo il funzionamento
Facciamo partire la nostra clip su Ableton Live e avviamo il nostro sketch su Processing. Se in console appare un messaggio come quello qui di seguito, siamo riusciti nel nostro intento:
Available MIDI Devices: ----------Input---------- [0] "IAC Bus 1" [1] "Real Time Sequencer" ----------Output---------- [0] "Gervill" [1] "IAC Bus 1" [2] "Real Time Sequencer" Note On: Channel: 0 Pitch: 60 Velocity: 127 --------
Processing sta ricevendo tramite IAC Driver un messaggio Note On con i seguenti parametri:
- Canale: 0
- Pitch: 60 (che corrisponde al C3)
- Velocity: 127
Adesso, se andiamo a modificare la clip su Ableton inserendo nuovi messaggi, possiamo verificare che anche questi siano ricevuti da Processing.
Creare i visual
A questo punto non ci resta che sviluppare in Processing i nostri visual sfruttando i parametri MIDI inviati da Ableton. Nell’esempio molto semplice che trovate di seguito, viene disegnato un quadrato al centro dello schermo la cui dimensione dipende dal valore di pitch ricevuto via MIDI. In aggiunta a quanto visto in questo post, sfrutto la funzione noteOff() per impostare la grandezza del quadrato a 0. Di certo non è il metodo più elegante ma di sicuro funziona.
/*
* Processing e Ableton: sincronizzare musica e visual via MIDI
* Federico Pepe, 05.03.2017
* http://blog.federicopepe.com/processing
*/
import themidibus.*;
MidiBus myBus;
int size;
void setup() {
size(400, 400);
background(0);
MidiBus.list();
myBus = new MidiBus(this, 0, 1);
}
void draw() {
background(0);
rectMode(CENTER);
rect(width/2, height/2, size, size);
}
void noteOn(int channel, int pitch, int velocity) {
println();
println("Note On:" + " Channel: "+channel + " Pitch: "+pitch + " Velocity: "+velocity);
println("--------");
size = pitch;
}
void noteOff(int channel, int pitch, int velocity) {
size = 0;
}Ed ecco il risultato:
Leave a Reply