_vdof_ @mbuoninfante - Tumblr Blog

Isoneph - Rooibos (single release)

I’m really happy to share the video of the single from an EP I've been working on last year, which is now finally seeing the light, thanks to the Z-Axis label.

Thanks again to @tristanmcguire for coming up with this really nice piece of work!

#z-axis #dub #downtempo #london #brixton #salerno #ardour #linux #ubuntustudio #trip hop

ozachou

Computational Drawing CXIV

vdof - in vacuo

In 2021 I released a new album as vdof where I got back to one of my initial love, electric bass. It’s the result of few years experimenting with ambient and drone music but, at same time a return to my roots (beats and bass).

https://vdof.bandcamp.com/album/in-vacuo

#experimental #ambient #liveelectronics #bass

vdof - pulse setup

I just recently released two albums I have been working on in the last months, raw material and for the present, and I decided to document the making of them (the theory and the research part apply to both works, but the technical details described below apply to for the present only).

Both these works are born from the need to reconnect with sound and explore its pure characteristics, free from musical structures, scores, visual feedback and any other sensory input other than hearing.

When working on them I tried to take the distance from my usual setup which includes laptop (mainly running ChucK and Pure Data) and few hardware sequencers/synths, that I usually control and heavily process in the digital domain (a sort of augmentation one could say).

In this case instead I wanted to play a single instrument, something simpler in its structure, something I had to learn how to play, something unfamiliar at first.

Also, I didn’t want to use the computer (as in a standard laptop), not even to record the work.

Thus, I ended up focusing on two phenomena: feedback and modulation.

I started working on a ChucK script I then ran on Raspberry Pi 3 and at the same time I bought a small second-hand Soundcraft mixer (before I had everything going straight into the audio interface).

In ChucK I implemented a unit generator based on a particular modulation technique, a pulse generator. I then used this as a main module in a slightly more complex unit generator which uses two pulse generators in an fm fashion, with also a feedback component in it.

I mapped a MIDI controller and began playing with this new sound generator.

On the mixer side, I started experimenting with some basic no input techniques which involved a Lexicon MPX550 multi effect.

I then combined the work done in ChucK with the analog experiments conducted with the mixer and ended up with a system that looked like this:

Raspberry Pi 3 running ChucK

Novation ZeRO SL MkII MIDI controller

Soundcraft Spirit Folio lite mixer

Lexicon MPX550

Tascam DR-05 portable recorder

I spent several days playing with the system, trying to understand its strengths and weaknesses, changing approaches, working on the mappings (what controls what and how), exploring new gestures, etc. .

In doing so I realized I wanted something a bit more homogenic as I felt as if I had two separate instruments in front of me (the Rasp Pi and the mixer itself), therefore I added another feedback component to the system, looping the main output from the mixer back to the RaspPi (which already used internal feedback).

This kind of closed the circle. Now all the parts in the system played an equal role in the overall architecture, and also an unstable component was added, allowing the instrument to surprise me with ever evolving textures as well as piercing sounds.

I had to revisit once again what I learned so far. A new approach was required, because now the player and the instrument had the same importance.

It was like the instrument had its own will that the player must respect and listen to, instead of trying to impose his/her own one.

I feel pretty satisfied with the system now. There are still things I want to add/change, and I hope I’ll do that as soon as possible.

Probably I will also spend few words about the artistic decisions behind these works, since they played quite an important role, but for now I’ll share few diagrams showing what described above.

The next step would be that of releasing the ChucK code as well.

#vdof #improv #chuck #drone #raspberrypi #sonic art #ambient #sound art #feedback

r_cycle - creative coding with Launchpad and Pure Data

I’m really happy to announce that few weeks ago r_cycle, a project I’ve been working on in the last months, has been officially announced. It’s an open source “middleware” written in Pure Data Vanilla, a library for creative coding with Launchpad. More info here. A big thanks goes to Paul Mansell, Tristan McGuire, Jerome Meunier, Dave Hodder and Peter Kirn. Also, a huge thanks goes to all the open source communities, especially the Pure Data one.

#puredata #opensource #launchpad #electronicmusic #creativecoding #livecoding

really happy to share the last sonic artifact I've been working on in the last months.

a slow journey, an attempt to focus on sound matter devoid of any particular emotional aspect.

thanks to all the open source communities!

https://is.gd/uvWmPt

#drone #improv #ChucK #opensource #liveelectronics

Novation ZeRO SLMkII - Pure Data Ctrl

A Pure Data patch that allows to easily receive MIDI messages from the ZeRO SLMkII MIDI controller, and also to control encoders, buttons and screens from the patch.

Spoiler alert, with the encoders is possible to use whatever range from 1 to N!!!!!

https://github.com/mariobuoninfante/ZeRO_SLMkII_Pd

MonoSynth in ChucK - pt 9

Parte 9

SCOPO

Aggiungere una sezione filtri al sintetizzatore.

PREREQUISITI

Per poter utilizzare questo programma serve avere un controller MIDI connesso al computer, o una virtual MIDI keyboard. Questo va connesso (o aperto nel caso di una tastiera virtuale), prima di far partire il programma.

Conoscenza base del protocollo MIDI (https://it.wikipedia.org/wiki/Musical_Instrument_Digital_Interface - http://www.nyu.edu/classes/bello/FMT_files/8_MIDIcomms.pdf – https://www.nyu.edu/classes/bello/FMT_files/9_MIDI_code.pdf).

Conoscenza base dei filtri classici (https://en.wikipedia.org/wiki/Audio_filter).

ANALISI DEL PROGRAMMA

In questo programma viene implementata una sezione filtri che include:

filtro passa basso

filtro passa banda

filtro passa alto

In ChucK questi corrispondono ai seguenti UGens1:

LPF

BPF

HPF

I quali hanno I seguenti metodi:

.freq() - per impostare il cutoff

.Q() - per impostare la risonanza

.set() - per impostare cutoff e risonanza contemporaneamente

// loop infinito while( true ) { // avanza ad ogni messaggio MIDI ricevuto m_in => now; while( m_in.recv( msg_in ) ) { if( msg_in.data1 == ( NOTE_ON + MIDI_CHANNEL ) && msg_in.data3 != 0 ) { msg_in.data2 => midi_note; set_oscils( midi_note ); // seleziona la wavetable in base alla nota ricevuta e l'oscillatore selezionato Std.mtof( midi_note ) => fr; // conversione da MIDI a Freq in Hz line.target( fr ); // assegnare la frequenza a 'line' che controlla la freq dell'oscillatore msg_in.data2 => last_note; set_cutoff( raw_cutoff ); msg_in.data3 * divided_by_127 => float amplitude; m_env.target( amplitude ); env.duration( attack_time ); env.keyOn(1); } // controlla che il messaggio MIDI sia un NOTE OFF o un NOTE ON con velocity 0 // in entrambi i casi la nota MIDI deve combaciare con l'ultima suonata (playedNote) else if( ( msg_in.data1 == ( NOTE_ON + MIDI_CHANNEL ) && msg_in.data3 == 0 && msg_in.data2 == last_note ) || ( msg_in.data1 == ( NOTE_OFF + MIDI_CHANNEL ) && msg_in.data2 == last_note ) ) { env.duration( release_time ); env.keyOff(1); } // portamento else if( msg_in.data1 == ( CTRL_CHANGE+MIDI_CHANNEL ) && msg_in.data2 == knobs[0] ) { set_interp( msg_in.data3 ) => freq_interpolation; line.time( freq_interpolation ); } // seleziona la forma d'onda else if( msg_in.data1 == ( CTRL_CHANGE+MIDI_CHANNEL ) && msg_in.data2 == knobs[1] ) { msg_in.data3 * 4 => int x; x / 128 => selected_oscil; if( selected_oscil != previous_oscil ) { set_oscils( midi_note ); // seleziona la wavetable in base alla nota ricevuta e l'oscillatore selezionato <<< "waveform: " + waveform_name[ selected_oscil ] >>>; selected_oscil => previous_oscil; } } // seleziona il filtro else if( msg_in.data1 == ( CTRL_CHANGE+MIDI_CHANNEL ) && msg_in.data2 == knobs[2] ) { ( ( msg_in.data3 / 128. ) * 3 ) $ int => filter_id; // chiama 'select_filter()' solo quando 'filter_id' cambia valore if( filter_id != previous_filter_id ) { select_filter( filter_id ); filter_id => previous_filter_id; } } // cutoff else if( msg_in.data1 == ( CTRL_CHANGE+MIDI_CHANNEL ) && msg_in.data2 == knobs[3] ) { msg_in.data3 * divided_by_127 => raw_cutoff; set_cutoff( raw_cutoff ); <<< "CUTOFF: " + cutoff >>>; } // Q - resonance else if( msg_in.data1 == ( CTRL_CHANGE+MIDI_CHANNEL ) && msg_in.data2 == knobs[4] ) { set_Q( msg_in.data3 * divided_by_127 ); <<< "filter Q: " + Q >>>; } } }

#chuck #computermusic #electronicmusic

a hacker’s guide

Interesting article about hacking, creative coding and other cool things here (scroll down till the bottom to see a pop up dialog appear): https://novationmusic.com/keys/sl-mkiii Proud to be there together with some amazing people... talking about Pd (among other things)

#puredata #pd #creativecoding #novation #computermusic

MonoSynth in ChucK - pt.8

Parte 8

SCOPO

Implementazione dei 4 oscillatori classici (limitati in banda):

sine

square

triangle

sawtooth

Utilizzo di array di UGen e perfezionamento dell'algoritmo di gestione degli oscillatori.

PREREQUISITI

Conoscenza base del protocollo MIDI (https://it.wikipedia.org/wiki/Musical_Instrument_Digital_Interface - http://www.nyu.edu/classes/bello/FMT_files/8_MIDIcomms.pdf - https://www.nyu.edu/classes/bello/FMT_files/9_MIDI_code.pdf)

Conoscenza base della sintesi additiva e della serie di Fourier

ANALISI DEL PROGRAMMA

Questo programma non differisce troppo da quello presentato nel precedente tutorial.

All’oscillatore a forma d’onda quadra sono stati affiancati quelli: sinusoidale, triangolare e a dente di sega.

// loop infinito while( true ) { // avanza ad ogni messaggio MIDI ricevuto m_in => now; while( m_in.recv( msg_in ) ) { if( msg_in.data1 == ( NOTE_ON + MIDI_CHANNEL ) && msg_in.data3 != 0 ) { // resetta il volume prima di generare una nuova nota per evitare 'glitch' env.duration( 3::ms ); env.keyOff(1); 3::ms => now; msg_in.data2 => midi_note; set_oscils( midi_note ); // seleziona la wavetable in base alla nota ricevuta e l’oscillatore selezionato Std.mtof( midi_note ) => fr; // conversione da MIDI a Freq in Hz line.target( fr ); // assegnare la frequenza a 'line' che controlla la freq dell'oscillatore msg_in.data2 => last_note; msg_in.data3 * divided_by_127 => float amplitude; env.gain( amplitude ); env.duration( attack_time ); env.keyOn(1); } // controlla che il messaggio MIDI sia un NOTE OFF o un NOTE ON con velocity 0 // in entrambi i casi la nota MIDI deve combaciare con l'ultima suonata (playedNote) else if( ( msg_in.data1 == ( NOTE_ON + MIDI_CHANNEL ) && msg_in.data3 == 0 && msg_in.data2 == last_note ) || ( msg_in.data1 == ( NOTE_OFF + MIDI_CHANNEL ) && msg_in.data2 == last_note ) ) { env.duration( release_time ); env.keyOff(1); } // portamento else if( msg_in.data1 == ( CTRL_CHANGE+MIDI_CHANNEL ) && msg_in.data2 == knobs[0] ) { set_interp( msg_in.data3 ) => freq_interpolation; line.time( freq_interpolation ); } // seleziona la forma d'onda else if( msg_in.data1 == ( CTRL_CHANGE+MIDI_CHANNEL ) && msg_in.data2 == knobs[1] ) { msg_in.data3 * 4 => int x; x / 128 => selected_oscil; if( selected_oscil != previous_oscil ) { set_oscils( midi_note ); // seleziona la wavetable in base alla nota ricevuta e l'oscillatore selezionato <<< "waveform: " + waveform_name[ selected_oscil ] >>>; selected_oscil => previous_oscil; } } } }

function void init_oscils() { /* Inizializza l'array di Gen10 'oscils'. Il primo elemento dell'array e' una sinusoide, a seguire si ha onda quadra, triangolare e dente di sega, le quali utilizzano 4 Gen10 ognuna. */ float coefficients[0]; // coefficienti degli UGen Gen10 // onda sinusoidale - oscils[0] coefficients.size(1); 1 => coefficients[0]; oscils[0].coefs( coefficients ); // onda quadra - formula: y = sum[(1/k)*sin(2PI*f*k*t)]; con k=1,3,5,7,9,... // quadra: 14 parziali - oscils[1] for( 1 => int c; c < 15; c++ ) { ( ( c * 2 ) - 1 ) => int odd; // solo numeri dispari coefficients.size( odd ); // ridimensiona l'array 1. / odd => float amp; // 1/n amp => coefficients[ odd-1 ]; } oscils[1].coefs( coefficients ); // quadra: 7 parziali - oscils[2] for( 1 => int c; c < 8; c++ ) { ( ( c * 2 ) - 1 ) => int odd; coefficients.size( odd ); 1. / odd => float amp; amp => coefficients[ odd-1 ]; } oscils[2].coefs( coefficients ); // quadra: 3 parziali - oscils[3] for( 1 => int c; c < 4; c++ ) { ( ( c * 2 ) - 1 ) => int odd; coefficients.size( odd ); 1. / odd => float amp; amp => coefficients[ odd-1 ]; } oscils[3].coefs( coefficients ); // quadra: 1 parziale - sinusoide - oscils[4] for( 1 => int c; c < 2; c++ ) { ( ( c * 2 ) - 1 ) => int odd; coefficients.size( odd ); 1. / odd => float amp; amp => coefficients[ odd-1 ]; } oscils[4].coefs( coefficients ); // onda triangolare - formula: y = sum[(1/k^2)*sin(2PI*f*k*t + theta)]; con k=1,3,5,7,9,... e theta=0,180,0,180 in gradi // triangolare: 14 parziali - oscils[5] for( 1 => int c; c < 15; c++ ) { float theta; /* theta=0 quando c e' dispari, theta=180 quando c e' pari. La fase viene espressa attraverso l'ampiezza. Ampiezza positiva quando theta=0, ampiezza negativa quando theta=180, cioe' si ha la fase inversa. */ if( ( c % 2 ) == 1 ) { 1 => theta; } else { -1 => theta; } ( ( c * 2 ) - 1 ) => int odd; // solo numeri dispari coefficients.size( odd ); // ridimensiona l'array theta * ( 1. / ( odd * odd ) ) => float amp; // 1/(n^2) * theta amp => coefficients[ odd-1 ]; } oscils[5].coefs( coefficients ); // triangolare: 7 parziali - oscils[6] for( 1 => int c; c < 8; c++ ) { float theta; /* theta=0 quando c e' dispari, theta=180 quando c e' pari. La fase viene espressa attraverso l'ampiezza. Ampiezza positiva quando theta=0, ampiezza negativa quando theta=180, cioe' si ha la fase inversa. */ if( ( c % 2 ) == 1 ) { 1 => theta; } else { -1 => theta; } ( ( c * 2 ) - 1 ) => int odd; // solo numeri dispari coefficients.size( odd ); // ridimensiona l'array theta * ( 1. / ( odd * odd ) ) => float amp; // 1/(n^2) * theta amp => coefficients[ odd-1 ]; } oscils[6].coefs( coefficients ); // triangolare: 3 parziali - oscils[7] for( 1 => int c; c < 4; c++ ) { float theta; /* theta=0 quando c e' dispari, theta=180 quando c e' pari. La fase viene espressa attraverso l'ampiezza. Ampiezza positiva quando theta=0, ampiezza negativa quando theta=180, cioe' si ha la fase inversa. */ if( ( c % 2 ) == 1 ) { 1 => theta; } else { -1 => theta; } ( ( c * 2 ) - 1 ) => int odd; // solo numeri dispari coefficients.size( odd ); // ridimensiona l'array theta * ( 1. / ( odd * odd ) ) => float amp; // 1/(n^2) * theta amp => coefficients[ odd-1 ]; } oscils[7].coefs( coefficients ); // triangolare: 1 parziale - sinusoide - oscils[8] for( 1 => int c; c < 2; c++ ) { float theta; /* theta=0 quando c e' dispari, theta=180 quando c e' pari. La fase viene espressa attraverso l'ampiezza. Ampiezza positiva quando theta=0, ampiezza negativa quando theta=180, cioe' si ha la fase inversa. */ if( ( c % 2 ) == 1 ) { 1 => theta; } else { -1 => theta; } ( ( c * 2 ) - 1 ) => int odd; // solo numeri dispari coefficients.size( odd ); // ridimensiona l'array theta * ( 1. / ( odd * odd ) ) => float amp; // 1/(n^2) * theta amp => coefficients[ odd-1 ]; } oscils[8].coefs( coefficients ); // onda a dente di sega - formula: y = sum[(1/k)*sin(2PI*f*k*t)]; con k=1,2,3,4,5,... // dente di sega: 14 parziali - oscils[9] for( 1 => int c; c < 15; c++ ) { coefficients.size( c ); // ridimensiona l'array ( 1. / c ) => float amp; // 1/n amp => coefficients[ c-1 ]; } oscils[9].coefs( coefficients ); // dente di sega: 7 parziali - oscils[10] for( 1 => int c; c < 8; c++ ) { coefficients.size( c ); // ridimensiona l'array ( 1. / c ) => float amp; // 1/n amp => coefficients[ c-1 ]; } oscils[10].coefs( coefficients ); // dente di sega: 3 parziali - oscils[11] for( 1 => int c; c < 4; c++ ) { coefficients.size( c ); // ridimensiona l'array ( 1. / c ) => float amp; // 1/n amp => coefficients[ c-1 ]; } oscils[11].coefs( coefficients ); // dente di sega: 1 parziale - sinusoide - oscils[12] for( 1 => int c; c < 2; c++ ) { coefficients.size( c ); // ridimensiona l'array ( 1. / c ) => float amp; // 1/n amp => coefficients[ c-1 ]; } oscils[12].coefs( coefficients ); }

function void set_oscils( int x ) { /* Seleziona l'UGen Gen10 in base alla nota ricevuta. I diversi Gen10 hanno un diverso numero di armoniche, piu' e' alta la nota selezionata meno armoniche si avranno per evitare problemi di aliasing */ 0 => int pointer; // utilizzato come puntatore per l'array 'oscils' // quando l'oscillatore selezionato NON e' sinusoidale if( selected_oscil > 0 ) { ( ( selected_oscil - 1 ) * 4 ) + 1 => pointer; if( x <= 70 && oscils[ pointer ].isConnectedTo( env ) == 0 ) { for( 0 => int c; c < oscils.size(); c++ ) { if( c == pointer ) { phasor => oscils[c] => env; } else { phasor =< oscils[c] =< env; } } } else if( x > 70 && x <= 90 && oscils[ pointer + 1 ].isConnectedTo( env ) == 0 ) { for( 0 => int c; c < oscils.size(); c++ ) { if( c == ( pointer + 1 ) ) { phasor => oscils[c] => env; } else { phasor =< oscils[c] =< env; } } } else if( x > 90 && x <= 108 && oscils[ pointer + 2 ].isConnectedTo( env ) == 0 ) { for( 0 => int c; c < oscils.size(); c++ ) { if( c == ( pointer + 2 ) ) { phasor => oscils[c] => env; } else { phasor =< oscils[c] =< env; } } } else if( x > 108 && x <= 127 && oscils[ pointer + 3 ].isConnectedTo( env ) == 0 ) { for( 0 => int c; c < oscils.size(); c++ ) { if( c == ( pointer + 3 ) ) { phasor => oscils[c] => env; } else { phasor =< oscils[c] =< env; } } } } // quando l'oscillatore selezionato e' sinusoidale else if( selected_oscil == 0 ) { if( oscils[ pointer ].isConnectedTo( env ) == 0 ) { for( 0 => int c; c < oscils.size(); c++ ) { if( c == pointer ) { phasor => oscils[c] => env; } else { phasor =< oscils[c] =< env; } } } } }

/*-----------------------INFO------------------------- PREMI "Add Shred" per lanciare il programma e "Remove Shred" per term_inarlo. "Replace Shred" serve a far ripartire il programma. ----------------------------------------------------*/ // RTcMix Lookup table: https://en.wikipedia.org/wiki/Real-time_Cmix Gen10 oscils[13]; Phasor phasor; // utilizzato per controllare le look-up table contentute in 'oscils' 0 => int selected_oscil; // oscillatore selezionato (0. sine, 1. square, 2. tri, 3. sawtooth) -1 => int previous_oscil; // variabile utilizzata nel ciclo while ["SINE", "SQUARE", "TRIANGLE", "SAWTOOTH"] @=> string waveform_name[]; Step step => Envelope line => phasor; Envelope env => Gain master => dac; step.next(1); // imposta il valore di 'step' su 1 phasor.sync(0); init_oscils(); // inizializza gli UGen Gen10 // connessioni MIDI MidiIn m_in; // crea un input MIDI MidiMsg msg_in; // crea un contenitore per i messaggi MIDI ricevuti /* seleziona la porta MIDI che corrisponde al controller in uso (CTRL+2 per controllare le porte MIDI) */ "Launchkey MK2 25 MIDI 1" => string device_name; m_in.open( device_name ); // variabili 144 => int NOTE_ON; 128 => int NOTE_OFF; 176 => int CTRL_CHANGE; 0 => int MIDI_CHANNEL; // canale MIDI - range da 0 a 15 float fr; float amp; int midi_note; int last_note; 0.007874016 => float divided_by_127; 0.05 => float freq_interpolation; // in secondi [21,22,23,24,25,26,27,28] @=> int knobs[]; // control change corrispondenti agli 8 potenziometri presenti sul controller 0.1 => amp; master.gain( amp ); // impostare l'ampiezza del Gain 'master' 10::ms => dur attack_time; // tempo di attacco 500::ms => dur release_time; // tempo di rilascio line.time( freq_interpolation ); // imposta il tempo di interpolatione della frequenza dell'oscillatore <<< "Basic Mono Synth with Sine, Square, Triangle and Sawtooth oscillators" >>>; <<< "waveform: " + waveform_name[ selected_oscil ] >>>; // loop infinito while( true ) { // avanza ad ogni messaggio MIDI ricevuto m_in => now; while( m_in.recv( msg_in ) ) { if( msg_in.data1 == ( NOTE_ON + MIDI_CHANNEL ) && msg_in.data3 != 0 ) { // resetta il volume prima di generare una nuova nota per evitare 'glitch' env.duration( 3::ms ); env.keyOff(1); 3::ms => now; msg_in.data2 => midi_note; set_oscils( midi_note ); // seleziona la wavetable in base alla nota ricevuta e l'oscillatore selezionato Std.mtof( midi_note ) => fr; // conversione da MIDI a Freq in Hz line.target( fr ); // assegnare la frequenza a 'line' che controlla la freq dell'oscillatore msg_in.data2 => last_note; msg_in.data3 * divided_by_127 => float amplitude; env.gain( amplitude ); env.duration( attack_time ); env.keyOn(1); } // controlla che il messaggio MIDI sia un NOTE OFF o un NOTE ON con velocity 0 // in entrambi i casi la nota MIDI deve combaciare con l'ultima suonata (playedNote) else if( ( msg_in.data1 == ( NOTE_ON + MIDI_CHANNEL ) && msg_in.data3 == 0 && msg_in.data2 == last_note ) || ( msg_in.data1 == ( NOTE_OFF + MIDI_CHANNEL ) && msg_in.data2 == last_note ) ) { env.duration( release_time ); env.keyOff(1); } // portamento else if( msg_in.data1 == ( CTRL_CHANGE+MIDI_CHANNEL ) && msg_in.data2 == knobs[0] ) { set_interp( msg_in.data3 ) => freq_interpolation; line.time( freq_interpolation ); } // seleziona la forma d'onda else if( msg_in.data1 == ( CTRL_CHANGE+MIDI_CHANNEL ) && msg_in.data2 == knobs[1] ) { msg_in.data3 * 4 => int x; x / 128 => selected_oscil; if( selected_oscil != previous_oscil ) { set_oscils( midi_note ); // seleziona la wavetable in base alla nota ricevuta e l'oscillatore selezionato <<< "waveform: " + waveform_name[ selected_oscil ] >>>; selected_oscil => previous_oscil; } } } } // -------------FUNZIONI-------------- function float set_interp( float x ) { x * divided_by_127 => x; // scala in un range da 0 a 1 x * x * x => x; // rendi la funzione esponenziale ( x * 0.997 ) + 0.003 => x; // scala in un range da 3 a 1000 millisecondi <<< "Freq Interpolation: " + x + " sec" >>>; return x; } function void set_oscils( int x ) { /* Seleziona l'UGen Gen10 in base alla nota ricevuta. I diversi Gen10 hanno un diverso numero di armoniche, piu' e' alta la nota selezionata meno armoniche si avranno per evitare problemi di aliasing */ 0 => int pointer; // utilizzato come puntatore per l'array 'oscils' // quando l'oscillatore selezionato NON e' sinusoidale if( selected_oscil > 0 ) { ( ( selected_oscil - 1 ) * 4 ) + 1 => pointer; if( x <= 70 && oscils[ pointer ].isConnectedTo( env ) == 0 ) { for( 0 => int c; c < oscils.size(); c++ ) { if( c == pointer ) { phasor => oscils[c] => env; } else { phasor =< oscils[c] =< env; } } } else if( x > 70 && x <= 90 && oscils[ pointer + 1 ].isConnectedTo( env ) == 0 ) { for( 0 => int c; c < oscils.size(); c++ ) { if( c == ( pointer + 1 ) ) { phasor => oscils[c] => env; } else { phasor =< oscils[c] =< env; } } } else if( x > 90 && x <= 108 && oscils[ pointer + 2 ].isConnectedTo( env ) == 0 ) { for( 0 => int c; c < oscils.size(); c++ ) { if( c == ( pointer + 2 ) ) { phasor => oscils[c] => env; } else { phasor =< oscils[c] =< env; } } } else if( x > 108 && x <= 127 && oscils[ pointer + 3 ].isConnectedTo( env ) == 0 ) { for( 0 => int c; c < oscils.size(); c++ ) { if( c == ( pointer + 3 ) ) { phasor => oscils[c] => env; } else { phasor =< oscils[c] =< env; } } } } // quando l'oscillatore selezionato e' sinusoidale else if( selected_oscil == 0 ) { if( oscils[ pointer ].isConnectedTo( env ) == 0 ) { for( 0 => int c; c < oscils.size(); c++ ) { if( c == pointer ) { phasor => oscils[c] => env; } else { phasor =< oscils[c] =< env; } } } } } function void init_oscils() { /* Inizializza l'array di Gen10 'oscils'. Il primo elemento dell'array e' una sinusoide, a seguire si ha onda quadra, triangolare e dente di sega, le quali utilizzano 4 Gen10 ognuna. */ float coefficients[0]; // coefficienti degli UGen Gen10 // onda sinusoidale - oscils[0] coefficients.size(1); 1 => coefficients[0]; oscils[0].coefs( coefficients ); // onda quadra - formula: y = sum[(1/k)*sin(2PI*f*k*t)]; con k=1,3,5,7,9,... // quadra: 14 parziali - oscils[1] for( 1 => int c; c < 15; c++ ) { ( ( c * 2 ) - 1 ) => int odd; // solo numeri dispari coefficients.size( odd ); // ridimensiona l'array 1. / odd => float amp; // 1/n amp => coefficients[ odd-1 ]; } oscils[1].coefs( coefficients ); // quadra: 7 parziali - oscils[2] for( 1 => int c; c < 8; c++ ) { ( ( c * 2 ) - 1 ) => int odd; coefficients.size( odd ); 1. / odd => float amp; amp => coefficients[ odd-1 ]; } oscils[2].coefs( coefficients ); // quadra: 3 parziali - oscils[3] for( 1 => int c; c < 4; c++ ) { ( ( c * 2 ) - 1 ) => int odd; coefficients.size( odd ); 1. / odd => float amp; amp => coefficients[ odd-1 ]; } oscils[3].coefs( coefficients ); // quadra: 1 parziale - sinusoide - oscils[4] for( 1 => int c; c < 2; c++ ) { ( ( c * 2 ) - 1 ) => int odd; coefficients.size( odd ); 1. / odd => float amp; amp => coefficients[ odd-1 ]; } oscils[4].coefs( coefficients ); // onda triangolare - formula: y = sum[(1/k^2)*sin(2PI*f*k*t + theta)]; con k=1,3,5,7,9,... e theta=0,180,0,180 in gradi // triangolare: 14 parziali - oscils[5] for( 1 => int c; c < 15; c++ ) { float theta; /* theta=0 quando c e' dispari, theta=180 quando c e' pari. La fase viene espressa attraverso l'ampiezza. Ampiezza positiva quando theta=0, ampiezza negativa quando theta=180, cioe' si ha la fase inversa. */ if( ( c % 2 ) == 1 ) { 1 => theta; } else { -1 => theta; } ( ( c * 2 ) - 1 ) => int odd; // solo numeri dispari coefficients.size( odd ); // ridimensiona l'array theta * ( 1. / ( odd * odd ) ) => float amp; // 1/(n^2) * theta amp => coefficients[ odd-1 ]; } oscils[5].coefs( coefficients ); // triangolare: 7 parziali - oscils[6] for( 1 => int c; c < 8; c++ ) { float theta; /* theta=0 quando c e' dispari, theta=180 quando c e' pari. La fase viene espressa attraverso l'ampiezza. Ampiezza positiva quando theta=0, ampiezza negativa quando theta=180, cioe' si ha la fase inversa. */ if( ( c % 2 ) == 1 ) { 1 => theta; } else { -1 => theta; } ( ( c * 2 ) - 1 ) => int odd; // solo numeri dispari coefficients.size( odd ); // ridimensiona l'array theta * ( 1. / ( odd * odd ) ) => float amp; // 1/(n^2) * theta amp => coefficients[ odd-1 ]; } oscils[6].coefs( coefficients ); // triangolare: 3 parziali - oscils[7] for( 1 => int c; c < 4; c++ ) { float theta; /* theta=0 quando c e' dispari, theta=180 quando c e' pari. La fase viene espressa attraverso l'ampiezza. Ampiezza positiva quando theta=0, ampiezza negativa quando theta=180, cioe' si ha la fase inversa. */ if( ( c % 2 ) == 1 ) { 1 => theta; } else { -1 => theta; } ( ( c * 2 ) - 1 ) => int odd; // solo numeri dispari coefficients.size( odd ); // ridimensiona l'array theta * ( 1. / ( odd * odd ) ) => float amp; // 1/(n^2) * theta amp => coefficients[ odd-1 ]; } oscils[7].coefs( coefficients ); // triangolare: 1 parziale - sinusoide - oscils[8] for( 1 => int c; c < 2; c++ ) { float theta; /* theta=0 quando c e' dispari, theta=180 quando c e' pari. La fase viene espressa attraverso l'ampiezza. Ampiezza positiva quando theta=0, ampiezza negativa quando theta=180, cioe' si ha la fase inversa. */ if( ( c % 2 ) == 1 ) { 1 => theta; } else { -1 => theta; } ( ( c * 2 ) - 1 ) => int odd; // solo numeri dispari coefficients.size( odd ); // ridimensiona l'array theta * ( 1. / ( odd * odd ) ) => float amp; // 1/(n^2) * theta amp => coefficients[ odd-1 ]; } oscils[8].coefs( coefficients ); // onda a dente di sega - formula: y = sum[(1/k)*sin(2PI*f*k*t)]; con k=1,2,3,4,5,... // dente di sega: 14 parziali - oscils[9] for( 1 => int c; c < 15; c++ ) { coefficients.size( c ); // ridimensiona l'array ( 1. / c ) => float amp; // 1/n amp => coefficients[ c-1 ]; } oscils[9].coefs( coefficients ); // dente di sega: 7 parziali - oscils[10] for( 1 => int c; c < 8; c++ ) { coefficients.size( c ); // ridimensiona l'array ( 1. / c ) => float amp; // 1/n amp => coefficients[ c-1 ]; } oscils[10].coefs( coefficients ); // dente di sega: 3 parziali - oscils[11] for( 1 => int c; c < 4; c++ ) { coefficients.size( c ); // ridimensiona l'array ( 1. / c ) => float amp; // 1/n amp => coefficients[ c-1 ]; } oscils[11].coefs( coefficients ); // dente di sega: 1 parziale - sinusoide - oscils[12] for( 1 => int c; c < 2; c++ ) { coefficients.size( c ); // ridimensiona l'array ( 1. / c ) => float amp; // 1/n amp => coefficients[ c-1 ]; } oscils[12].coefs( coefficients ); } // _FUNZIONI

#chuck #computermusic #electronicmusic

ChucK repo

Finally decided to create a repo containing some (hopefully useful) ChucK code https://github.com/mariobuoninfante/ChucK_various

#chuck #computermusic #electronicmusic

MonoSynth in ChucK - pt.7

Parte 7

SCOPO

Utilizzo di lookup table come generatore d’onda quadra limitata in banda al posto di un oscillatore sinusoidale.

Utilizzo della struttura di controllo “for”.

PREREQUISITI

Conoscenza base del protocollo MIDI (https://it.wikipedia.org/wiki/Musical_Instrument_Digital_Interface - http://www.nyu.edu/classes/bello/FMT_files/8_MIDIcomms.pdf - https://www.nyu.edu/classes/bello/FMT_files/9_MIDI_code.pdf)

Conoscenza base della sintesi additiva e della serie di Fourier

LOOKUP TABLE E PHASOR

Nei precedenti tutorial sono stati affrontate principalmente problematiche riguardanti il controllo delle varie componenti base di un sintetizzatore (implementazione di una tastiera MIDI, controllo in frequenza di un oscillatore, portamento, etc.). Questo tutorial invece, sara’ incentrato sull’implementazione di un oscillatore ad onda quadra limitato in banda e si iniziera’ ad affrontare la parte riguardante il timbro dello strumento.

Generalmente I sintetizzatori hardware hanno una sezione chiamata VCO (voltage controlled oscillators - se analogici) o DCO (digital controlled oscillators - se digitali), la quale include vari oscillatori con forme d’onda differenti tra loro.

Le forme d’onde classiche molto spesso implementate nei synth hardware e software sono: sinusoidale, quadra, triangolare e dente di sega.

function void setSquareWave(int x) { // seleziona l'UGen Gen10 in base alla nota ricevuta. // I diversi Gen10 hanno un diverso numero di armoniche, // piu' e' alta la nota selezionata meno armoniche si avranno // per evitare problemi di aliasing if(x <= 70 && square_1.isConnectedTo(env) == 0) { phasor => square_1 => env; phasor =< square_2 =< env; phasor =< square_3 =< env; phasor =< square_4 =< env; <<< "SQUARE 1" >>>; } else if(x > 70 && x <= 90 && square_2.isConnectedTo(env) == 0) { phasor =< square_1 =< env; phasor => square_2 => env; phasor =< square_3 =< env; phasor =< square_4 =< env; <<< "SQUARE 2" >>>; } else if(x > 90 && x <= 108 && square_3.isConnectedTo(env) == 0) { phasor =< square_1 =< env; phasor =< square_2 =< env; phasor => square_3 => env; phasor =< square_4 =< env; <<< "SQUARE 3" >>>; } else if(x > 108 && x <= 127 && square_4.isConnectedTo(env) == 0) { phasor =< square_1 =< env; phasor =< square_2 =< env; phasor =< square_3 =< env; phasor => square_4 => env; <<< "SQUARE 4" >>>; } } function void initSquareWave() { // crea 4 diverse lookup table, con contenuti armonici different. // onda quadra - formula: y = sum[(1/k)*sin(2PI*f*k*t)]; con k=1,3,5,7,9,... // square_1: 14 parziali for(1=>int c; c<15; c++) { ((c * 2) - 1) => int odd; // solo numeri dispari coefficients.size(odd); // ridimensiona l'array 1. / odd => float amp; // 1/n amp => coefficients[odd-1]; } square_1.coefs(coefficients); // square_2: 7 parziali for(1=>int c; c<8; c++) { ((c * 2) - 1) => int odd; coefficients.size(odd); 1. / odd => float amp; amp => coefficients[odd-1]; } square_2.coefs(coefficients); // square_3: 3 parziali for(1=>int c; c<4; c++) { ((c * 2) - 1) => int odd; coefficients.size(odd); 1. / odd => float amp; amp => coefficients[odd-1]; } square_3.coefs(coefficients); // square_4: 1 parziale - sinusoide for(1=>int c; c<2; c++) { ((c * 2) - 1) => int odd; coefficients.size(odd); 1. / odd => float amp; amp => coefficients[odd-1]; } square_4.coefs(coefficients); }

#chuck #computermusic #electronicmusic

MonoSynth in ChucK - pt.6

Parte 6

SCOPO

Aggiungere il portamento al programma precedente

Utilizzo di funzioni, array e di messaggi MIDI control change.

PREREQUISITI

Conoscenza base del protocollo MIDI (https://it.wikipedia.org/wiki/Musical_Instrument_Digital_Interface - http://www.nyu.edu/classes/bello/FMT_files/8_MIDIcomms.pdf - https://www.nyu.edu/classes/bello/FMT_files/9_MIDI_code.pdf)

ANALISI DEL PROGRAMMA

In questo esempio viene implementato un altro modulo presente in molti sintetizzatori commerciali, il portamento, che permette di effettuare un glissando tra note successive.

Di solito, quando due note differenti vengono generate in successione (ie C4 e dopo F#4), la frequenza dell’oscillatore cambia immediatamente. Con l’utilizzo del portamento e’ possibile rendere questo passaggio graduale. Al cambiare della nota, la frequenza dell’oscillatore non passa immediatamente dal punto A (frequenza della prima nota) al punto B (frequenza della seconda nota), ma “impiega del tempo” la cui durata corrisponde al valore del portamento.

#chuck #computermusic #electronicmusic

MonoSynth in ChucK - pt.5

Parte 5

SCOPO

Migliorare il programma illustrato nella parte 4.

Utilizzo di un device MIDI (controller, keyboard, virtual keyboard, etc.) per controllare un oscillatore sinusoidale.

Utilizzo della struttura di controllo if/else e if/else if.

PREREQUISITI

Per poter utilizzare questo programma serve avere un controller MIDI connesso al computer, o una virtual MIDI keyboard. Bisogna connettere (o aprire nel caso di una tastiera virtuale) il controller prima di far partire il programma.

Conoscenza base del protocollo MIDI (https://it.wikipedia.org/wiki/Musical_Instrument_Digital_Interface - http://www.nyu.edu/classes/bello/FMT_files/8_MIDIcomms.pdf - https://www.nyu.edu/classes/bello/FMT_files/9_MIDI_code.pdf)

ANALISI DEL PROGRAMMA

Nella parte 4 si e’ realizzato un semplice programma che permette di controllare un oscillatore sinusoidale ed il suo inviluppo via MIDI.

Con l’intento di offrire una gentile introduzione all’argomento, non sono state fatte una serie di considerazioni importanti riguardo la gestione di messaggi MIDI, infatti il precedente programma, nonostante perfettamente funzionante, non considera alcuni possibili situazioni in cui l’utente si puo’ trovare e che possono causare comportamenti indesiderati.

while(true) { // quando un (qualsiasi) messaggio MIDI viene ricevuto // avanza nel programma mIn => now; while(mIn.recv(msgIn)) { // stampa sulla console il messaggio MIDI raw <<< "Raw MIDI msg: " + msgIn.data1, msgIn.data2, msgIn.data3 >>>; // controlla che il messaggio MIDI sia un NOTE ON con velocity maggiore di 0 if(msgIn.data1 == (NOTE_ON + MIDI_CHANNEL) && msgIn.data3 != 0) { // prendere il MIDI byte 2 (nel caso di messaggi NOTE ON/OFF e' il pitch) // ed assegnarlo alla variabile di tipo int "midiNote" msgIn.data2 => midiNote; Std.mtof(midiNote) => fr; // conversione da MIDI a Freq in Hz sine.freq(fr); // assegnare la frequenza all'oscillatore msgIn.data2 => lastNote; // impostare il tempo impegato dall'inviluppo per // passare da 0 a 1 (da minimo a massimo) env.duration(attackTime); // triggerare l'inviluppo per farlo passare da OFF a ON env.keyOn(1); <<< "KEY PRESSED" >>>; } // controlla che il messaggio MIDI sia un NOTE OFF o un NOTE ON con velocity 0 // in entrambi i casi la nota MIDI deve combaciare con l'ultima suonata (playedNote) else if( (msgIn.data1 == (NOTE_ON + MIDI_CHANNEL) && msgIn.data3 == 0 && msgIn.data2 == lastNote) || (msgIn.data1 == (NOTE_OFF + MIDI_CHANNEL) && msgIn.data2 == lastNote) ) { // impostare il tempo impegato dall'inviluppo per // passare da 1 a 0 (da massimo a minimo) env.duration(releaseTime); // triggerare l'inviluppo per farlo passare da ON a OFF env.keyOff(1); <<< "KEY RELEASED" >>>; } } }

#chuck #computermusic #electronicmusic

MonoSynth in ChucK - pt.4

Parte 4

SCOPO

Utilizzo di un device MIDI (controller, keyboard, virtual keyboard, etc.) per controllare un oscillatore sinusoidale.

Utilizzo della struttura di controllo if/else.

PREREQUISITI

Conoscenza base del protocollo MIDI (https://it.wikipedia.org/wiki/Musical_Instrument_Digital_Interface - http://www.nyu.edu/classes/bello/FMT_files/8_MIDIcomms.pdf - https://www.nyu.edu/classes/bello/FMT_files/9_MIDI_code.pdf)

ANALISI DEL PROGRAMMA

Anche in questa quarta parte, il programma inizia con la dichiarazione degli UGen, seguita pero’ da due oggetti nuovi: MidiIn e MidiMsg.

//oscillatore sinusoidale collegato ad un inviluppo SinOsc sine => Envelope env => dac; //connessioni MIDI MidiIn mIn; MidiMsg msgIn;

MidiIn rappresenta la porta MIDI utilizzata da ChucK (rappresenta il controller), mentre MidiMsg puo’ essere considerato come un contenitore in cui vengono contenuti I messaggi generati dal device MIDI.

#chuck #computermusic #electronicmusic

MonoSynth in ChucK - pt.3

Parte 3

SCOPO

Aggiunta di un inviluppo alla catena audio utilizzata fino ad ora.

ANALISI DEL PROGRAMMA

Come di consueto il programma inizia con la dichiarazione degli UGen e delle variabili utilizzate:

// oscillatore sinusoidale collegato ad un inviluppo SinOsc sine => Envelope env => dac; // variabili float fr; float amp; int midiNote; dur t;

In questo caso si ha un oscillatore sinusoidale collegato ad un UGen Envelope la cui uscita e’ collegata al dac.

Envelope e’ un generatore di inviluppo (Wikipedia - Generatore di inviluppo) di tipo AR, cioe’ ha solo due “stati”, attack e release. In pratica si possono impostare indipendentemente il tempo di attacco (tempo che intercorre tra volume 0 e volume massimo) e di rilascio (tempo che intercorre tra volume massimo e volume 0) che influenzaranno il segnale generato dall’oscillatore sinusoidale (env controlla il volume dell’oscillatore).

#chuck #computermusic #electronicmusic

MonoSynth in ChucK - pt.2

Parte 2

SCOPO

Utilizzo di variabili al posto di valori hard coded (https://it.wikipedia.org/wiki/Codifica_fissa), conversione da note MIDI a frequenze in Hertz e generazione di valori random da utilizzare come frequenza per un oscillatore sinusoidale.

ANALISI DEL PROGRAMMA

Questo programma, come il precedente, utilizza un oscillatore sinusoidale controllato in frequenza ed ampiezza, quindi come prima cosa si dichiara un UGen del tipo SinOsc, di nome sine, collegato (=>) ad un dac (scheda audio del computer):

//oscillatore sinusoidale SinOsc sine => dac;

Di seguito viene introdotta un’importante novita’, i valori numerici utilizzati per impostare la frequenza e l’ampiezza dell’oscillatore sinusoidale, come per altri scopi, qui vengono assegnati a delle variabili.

//variabili float fr; float amp; int midiNote; dur t; //assegnare valori alle variabili ("valore => nome della variabile") 0.2 => amp; 500::ms => t;

Una variabile non e’ altro che un contenitore di informazioni (dati) che possiede un nome specifico e unico.

In ChucK le variabili possono essere di tipo:

int: numero intero (ie 1,-35, 9999)

float: numero in virgola mobile (ie 456.789, -23.45, .5, 0.678903)

time: tempo in ChucK (ie now+5::second, 34567::samp)

dur: durata in ChucK (ie 50::week, 34::day,1.567::hour, 567::minute, 1::second, 23::ms, 48000::samp)

complex: numero complesso in forma rettangolare (ie #(2.3, 4), #(5, -1.235) )

polar: numero complesso in forma polare (ie %(2, 0.5*pi), %(45, -1.2*pi) )

string: stringa di testo (ie “monophonic synth”, “I’m a string”, “foo”)

#chuck #computermusic #electronicmusic

Trending Blogs

Recently Viewed Blogs

_vdof_