3. MAX E CSOUND

E’ arrivato il momento di vedere un’applicazione pratica di Max:
un generatore di partiture per Csound.
Per capire il funzionamento dell’applicazione
ci sono nuovi Object da conoscere.
(apri la patch objects-7)



Il primo è trigger che smista in diversi outlet l’input che riceve. Il numero degli outlet è variabile e ce n’è uno per ogni argomento del trigger. Nel nostro caso abbiamo quattro argomenti che indicano anche il tipo di dato che uscirà dall’outlet corrispondente: b significa bang, i integer e f floating point. Quindi il nostro trigger riceve un numero floating e restituisce un floating, un bang, un integer e un bang.
Da notare che nell’ambiente Max c’è una priorità nell’ordine degli ingressi e delle uscite che va da destra verso sinistra, quindi l’outlet floating che sta alla destra sarà il primo ad produrre un output e il bang che sta alla sinistra sarà l’ultimo. Questo è molto importante per capire il funzionamento dei patch più complessi.
Il secondo oggetto si chiama Uzi ed è un vero e proprio mitragliatore che serve a “sparare”, in rapidissima successione, un numero arbitrario di bang (specificato dall’argomento, in questo caso 10). L’outlet sinistro di Uzi emette i bang, quello di destra emette una serie di numeri che vanno da 1 all’argomento (qui da 1 a 10) e quello centrale emette un bang quando Uzi ha finito di “sparare” (carry bang). Quando i patch diventano molto complessi diventa difficile seguire l’intreccio dei collegamenti; in questo caso si rivelano molto utili gli oggetti s (send) e r (receive). Questi oggetti hanno come argomento un simbolo arbitrario, che serve ad accoppiare un oggetto send ad un oggetto receive che ha lo stesso argomento. Tutto ciò che entra in un Object send che ha un determinato argomento esce dall’oggetto receive che ha lo stesso argomento; è come se i due oggetti fossero collegati da un cavo invisibile.
Ci possono essere più receive con lo stesso argomento, e da tutti usciranno gli stessi dati, così come ci possono essere più send con lo stesso argomento, che invieranno i dati agli stessi receive.
Nel nostro patch abbiamo due oggetti send etichettati come ‘remote’ e ‘altradest’ e ciascuno trasmette i suoi dati al receive corrispondente.
Veniamo ora al patch che permette di generare partiture per una delle orchestre del tutorial di base del Csound (contenuto nel Reference Manual), e precisamente per l’orchestra toot3.orc che abbiamo ribattezzato experiment.orc e che riportiamo qui sotto:

;experiment.orc
sr------ = 44100
kr------ = 44100
ksmps = 1
nchnls = 1
instr 3-------------------------- ; p3=durata della nota
k1 linen p4, p6, p3, p7------- ; p4=ampiezza
a1 oscil k1, p5, 1------------- ; p5=frequenza
out a1-------------------------- ; p6=tempo di attacco
endin ---------------------------; p7=tempo di rilascio

L’orchestra è un semplicissimo programma che genera note di cui si deve specificare la durata, l’ampiezza, la frequenza in hertz, il tempo d’attacco e quello di rilascio.
Aprite il patch genera-partiture1:



La funzione del patch è creare una partitura di 128 note di altezza, intensità e durata variabile. L’Object Text posto in fondo al patch si incarica di raccogliere la partitura che poi dovrà essere salvata su disco con il nome experiment.sco.
Notiamo che questo patch è molto più complesso di quelli visti in precedenza, cerchiamo di esaminare nel dettaglio come funziona.
La prima cosa da fare è inserire i dati corrispondenti alla partitura che vogliamo creare. Nel patch ci sono quattro tabelle tabelle (cioè quattro oggetti table) nelle quali è possibile inserire una serie di 128 eventi corrispondenti a tempo di attacco, ampiezza, durata (in percentuale tra due tempi d’attacco consecutivi) e frequenza. Apriamo quindi con un doppio click le tabelle “atk”, “amp”, “dur” e “pitch” e inseriamo con il mouse i dati relativi (o osserviamo quelli già inseriti).
Da notare che i tempi d’attacco sono in centesimi di secondo, mentre la partitura dovrebbe specificarli in secondi, che le ampiezze variano tra 0 e 127, mentre per essere udibili dovrebbero arrivare almeno a 10.000 e che le frequenze sono specificate come MIDI-note, mentre dovrebbero essere in Hertz. Vedremo poi come vengono risolte queste discrepanze.
Vediamo ora passo passo il funzionamento del patch.
In alto c’è un bang button che manda il suo bang ad un trigger. Questo trigger “moltiplica” per tre il bang e lo manda a tre diverse destinazioni. La prima destinazione è l’Object s (send) di destra (ricordiamo che la priorità dei messaggi in Max va da destra verso sinistra). Questo send ha come argomento “firstline”; in basso a destra troviamo il corrispondente “r firstline” che invia il bang ricevuto a un trigger che a sua volta attiva il messaggio “clear” che serve a cancellare il precedente contenuto dell’Object Text a cui è collegato. Oltre al messaggio “clear” questo trigger attiva il messaggio “f1 0 4096 10 8 7 6 5 4 3 2 1 cr cr” cioè la funzione della forma d’onda (i due “cr” finali sono due ritorni di carrello che rendono più leggibile il testo) che sarà quindi la prima riga della nostra partitura inserita nell’Object Text.
Osserviamo adesso l’Object pack che si trova nella parte medio-bassa del patch. La sua funzione è quella di assemblare i “note statement” che attiveranno lo strumento che genera la nota con gli opportuni parametri. Questi “note statement” verranno inviati, uno dopo l’altro, all’Object Text.
Torniamo al trigger nella parte alta e vediamo che il secondo “bang” viene inviato dall’Object “s reset” e ricevuto dal corrispettivo Object “r reset” che è collegato ad un subpatch, “timelist”, che stabilisce i punti di start delle note⁴. La funzione di questo bang è di azzerare il punto di start, che sarà quindi associato alla prima nota. Dal subpatch “timelist” viene inviato quindi il punto di start della nota all’Object pack che si incarica di assemblare il “note statement”. L’ultimo “bang” del trigger in alto va all’Object Uzi che sparerà una serie di 128 bang e una serie di 128 numeri.
Abbiamo visto che i numeri escono dall’outlet di destra e sono convogliati in un trigger che li smista poi alle quattro tabelle. La table “pitch”, che come sappiamo contiene i valori di MIDI note, è collegata ad un Object expr che converte le note MIDI in frequenze in hertz. Ognuna di queste frequenze va poi a formare il p5 del “note statement” nell’Object pack. La table “amp” è collegata ad un Object expr che trasforma i valori da 0 a 127 in valori da 0 a 10.000 (p4). La table “dur” è collegata ad un Object che ne divide i valori per 100. Otteniamo così una serie di numeri in virgola mobile compresi tra 0 e 2 che serviranno a moltiplicare il tempo intercorso tra l’attacco di una nota e il successivo (vedi sotto): in questo modo un valore uguale a 1 rappresenta una durata pari allo spazio tra i due attacchi, un valore uguale a 0.5 rappresenta una durata pari alla metà e così via.
Il contenuto della table “atk”, cioè i tempi d’attacco in centesimi di secondo, viene prima trasformato in secondi e poi inviato a due diversi Object. Il primo è un moltiplicatore che calcola il prodotto tra “atk” e “dur” (trasformato come sappiamo): questo prodotto viene inviato all’Object “s time” che manda i valori a due diversi “r time”, uno per il valore di durata della nota (p3) e l’altro per le durate di attacco e rilascio dell’inviluppo (p6 e p7), che corrispondono rispettivamente a un quarto e un terzo della durata totale. Il secondo Object che riceve i valori della tabella “atk” è il già noto “timelist” che calcola i tempi di inizio delle note. Oltre alla serie di numeri l’Uzi spara anche una serie di bang (dall’outlet di sinistra) che attivano il messaggio “i3” (il nome dello strumento Csound) e inviano il “note statement” completo all’Object Text. L’ultimo bang emesso dall’Uzi è il carry bang (outlet centrale) che viene inviato all’Object “r lastline” collegato al messaggio “e” che chiude la partitura.
Facendo click sul bang button in alto e poi aprendo (con un doppio click) l’Object Text possiamo vedere la nostra partitura (ne riportiamo solo una parte):

f1 0 4096 10 8 7 6 5 4 3 2 1
i3 0.000 0.012 8976 261.626 0.003 0.004
i3 0.050 0.015 9685 261.626 0.004 0.005
i3 0.110 0.018 6299 261.626 0.005 0.006
i3 0.180 0.022 6299 261.626 0.005 0.007
i3 0.260 0.022 6299 523.251 0.006 0.007
i3 0.340 0.026 6299 261.626 0.007 0.009
i3 0.430 0.383 9685 261.626 0.096 0.128
i3 1.590 0.033 6299 61.735 0.008 0.011
i3 1.690 0.035 6299 261.626 0.009 0.012
...
...
e

Naturalmente modificando il contenuto delle quattro tabelle “atk”, “amp”, “dur” e “pitch” si otterranno partiture diverse.
Con la finestra Text aperta e in primo piano possiamo salvare il contenuto dell’Object (tramite il menu file, oppure con command-s) con il nome “experiment.sco” e utilizzarlo come partitura per l’orchestra Csound.
La cosa da notare è che essendo Max un sistema totalmente aperto è possibile creare patch che generino orchestre seguendo qualunque criterio possa interessare il compositore.
Vediamo ad esempio una variazione del patch precedente (apri genera-partiture5):

Questo patch genera per ogni nota 5 componenti sinusoidali (notate che la funzione f1 ora è cambiata e contiene solo una sinusoide). Il rapporto armonico/inarmonico delle componenti viene calcolato in base ad una nuova table “distort” che stabilisce appunto la distorsione armonica di ogni nota.
I valori della tabella possono variare fra 0 e 300, e al valore 100 corrisponde un rapporto perfettamente armonico (le frequenze delle 5 componenti sono f, 2f, 3f, 4f, 5f), valori inferiori o superiori creano componenti inarmoniche più vicine o più lontane.
Un patch di questo tipo è ancora comprensibile nel suo insieme, ma siamo al limite: algoritmi più complessi dovrebbero essere divisi in più subpatch collegati fra loro. Il patch funziona praticamente come il precedente, solo che per ogni nota vengono generate 5 componenti.
Vediamo che l’Uzi che produce 128 bang è collegato ad un secondo Uzi che ne produce 5 per ognuno che ne riceve.
Questi 5 bang servono a calcolare le singole componenti: infatti la frequenza viene “intercettata” da un Object expr che, utilizzando il secondo Uzi come indice, la moltiplica per il fattore di distorsione armonica. Anche l’ampiezza viene intercettata e divisa per n (con n = numero della componente).
Lasciamo al lettore, come esercizio, il compito di decifrare tutti i passaggi che sono stati aggiunti in questo patch rispetto al precedente. Le partiture generate da questi patch sono accluse nel CD e si chiamano experiment.sco e experiment5.sco

³ Facendo doppio click sul subpatch si può vedere quali sono le sue componenti.
⁴ Non descriveremo il subpatch, è possibile comunque studiarne il contenuto aprendolo con un doppio click