proxy space examples





preparation of the environment


(

s = Server.local;

s.boot;

p = ProxySpace.push(s);

)


playing and monitoring


// play some output to the hardware busses, this could be any audio rate key.

~out.play;


~out = { SinOsc.ar([400, 408]*0.8, 0, 0.2) };



// replacing the node. the crossfade envelope is created internally.

~out = { SinOsc.ar([443, 600-Rand(0,200)], 0, 0.2) };

~out = { Resonz.ar(Saw.ar(40+[0,0.2], 1), [1200, 1600], 0.1) + SinOsc.ar(60*[1,1.1],0,0.2) };

~out = { Pan2.ar(PinkNoise.ar(0.1), LFClipNoise.kr(2)) };


setting the node controls


~out = { arg rate=2; Pan2.ar(PinkNoise.ar(0.1), LFClipNoise.kr(rate)) };

~out.set(\rate, 30);

~out = { arg rate=2; Pan2.ar(Dust.ar(2000, 0.2), LFClipNoise.kr(rate)) };

~out.set(\rate, 2);


referencing between proxies


~lfo = { LFNoise2.kr(30, 300, 500) };

~out = { SinOsc.ar(~lfo.kr, 0, 0.15)  };

~out = { SinOsc.ar(~lfo.kr * [1, 1.2], 0, 0.1) * Pulse.ar(~lfo.kr * [0.1, 0.125], 0.5) };

~lfo = { LFNoise1.kr(30, 40) + SinOsc.kr(0.1, 0, 200, 500) };

~out = { SinOsc.ar(~lfo.kr * [1, 1.2], 0, 0.1)  };

~lfo = 410;


math


// unary operators

~lfo2 = { SinOsc.kr(0.5, 0, 600, 100)  };

~lfo = ~lfo2.abs;

~lfo2 = { SinOsc.kr(1.3, 0, 600, 100)  };



// binary operators

~lfo3 = { LFTri.kr(0.5, 0, 80, 300) };

~lfo = ~lfo2 + ~lfo3;

~lfo = ~lfo3;

~lfo = (~lfo3 / 50).sin * 200 + 500 * { LFTri.kr(~lfo.kr * 0.0015, 0, 0.1 * ~lfo3.kr / 90, 1) };

~lfo3 = { Mix(~lfo2.kr * [1, 1.2]) };


currentEnvironment.free; // free all node proxies

~out.stop; // free the playback synth.



waking up a network of proxies


// hit cmd-. to stop all nodes

// start again

~out.play; 


feeding back (one buffer size delay)


~out = { SinOsc.ar([220, 330], ~out.ar(2).reverse * LFNoise2.kr(0.5, 4*pi), 0.4) };


// there is no immediacy: hear the buffer size cycle

~out = { Impulse.ar(1 ! 2) + (~out.ar(2) * 0.99) }; 




// supercollider 'differential equations'


~out = { SinOsc.ar(Slope.ar(~out.ar) * MouseX.kr(1000, 18000, 1)) * 0.1 + SinOsc.ar(100, 0, 0.1) };


(

~out = { var z, zz;

z = Slope.ar(~out.ar);

zz = Slope.ar(z);

SinOsc.ar(Rand(300,410), z) *

SinOsc.ar(zz * 410) 

* 0.1 + Decay2.ar(Pan2.ar(Dust.ar(600), MouseX.kr(-1,1)), 0.01, 0.05);

}

)



multiple control


(

~out = { arg freqOffest;

var ctl;

ctl = Control.names(\array).kr(Array.rand(8, 400, 1000));

Pan2.ar(Mix(SinOsc.ar(ctl + freqOffest, 0, 0.1 / 8)), LFNoise0.kr(2))

};

)


~out.setn(\array, Array.exprand(8, 400, 2000));

~out.set(\freqOffest, rrand(300,200));

~out.map(\freqOffest, ~lfo);


// a simpler short form for this is:

(

~out = { arg freqOffest=0, array = #[ 997, 777, 506, 553, 731, 891, 925, 580 ];

Pan2.ar(Mix(SinOsc.ar(array + freqOffest, 0, 0.1 / 8)), LFNoise0.kr(2))

};

)




mixing



~out1 = { SinOsc.ar(600, 0, 0.1) };

~out2 = { SinOsc.ar(500, 0, 0.1) };

~out3 = { SinOsc.ar(400, 0, 0.1) };

~out = ~out2 + ~out1 + ~out3;


~out = ~out1 + ~out2;

~out = ~out1;


// another way is:

~out = { SinOsc.ar(600, 0, 0.1) };

~out.add({ SinOsc.ar(500, 0, 0.1) });

~out.add({ SinOsc.ar(400, 0, 0.1) });


// or with direct access:

~out[1] = { SinOsc.ar(500 * 1.2, 0, 0.1) };

~out[2] = { SinOsc.ar(400 * 1.2, 0, 0.1) };





restoring / erasing


~out.free; // this frees the group, not the play synth x

~out.send; // resends all synths

~out.free; 

~out.send(nil, 1); // this sends at index 1 only 

~out.send;


// removing:

~out.removeLast;

~out.removeAt(0);


// cleaning up, freeing the bus:

~out.clear; // this neutralizes the proxy, and frees its bus



for more on the proxy slots see: jitlib_basic_concepts_03 




garbage collecting


// often there are proxies playing that are not used anymore - this is good,

// because they might be used again at any time. 

// this shows how to free unused proxies, such as ~out1, ~out2.  


~out.play;

~out = { Pan2.ar(SinOsc.ar(~lfo.kr, 0, 0.2), sin(~lfo.kr / 10)) }; // ~lfo is kept, as its parents.

~lfo = { LFNoise2.kr(3, 160, 400) };


p.keysValuesDo { arg key, proxy; [key, proxy.isPlaying].postln };

p.reduce; // all monitoring proxies (in this case ~out) are kept. equivalent: p.reduce(to: [~out]);

p.keysValuesDo { arg key, proxy; [key, proxy.isPlaying].postln };


// to remove everything else:

p.postln;

p.clean; // all monitoring proxies (in this case ~out) are kept.

p.postln;


// after ~out is stopped, it is removed, too:

~out.stop; // stop monitor

p.clean; 

p.postln; // empty space.



execution order



// you can .play .kr or .ar also a name that is not yet used.

// the rate is guessed as far as possible. on this topic see also: [the_lazy_proxy]


~myOut.play; // play some key (audio rate is assumed)


// the rate is determined from the first access: 

// like this ~lfo becomes control rate


~myOut = { SinOsc.ar(~freq.kr * 2, 0, 0.1) }; 

~freq = 900;

~freq = { SinOsc.kr(115, 0, 70, 220) }


~myOut = { SinOsc.ar(~otherFreq.ar * 2, 0, 0.1) };

~otherFreq = { SinOsc.ar(115, 0, 70, 220) };


currentEnvironment.clear; // clear every  proxy in this environment and remove them. (same: p.clear)





setting the xfade time


~out.play;


~out.fadeTime = 4;

~out = { SinOsc.ar(Rand(800, 300.0)*[1,1.1], 0, 0.1) };

~out = { SinOsc.ar(Rand(800, 300.0)*[1,1.1], 0, 0.1) };

~out.fadeTime = 0.01;

~out = { SinOsc.ar(Rand(800, 300.0)*[1,1.1], 0, 0.1) };

~out = { SinOsc.ar(Rand(800, 300.0)*[1,1.1], 0, 0.1) };


~out.free(3);  // release the synths and the group with a given fadeTime without changing proxy time

~out.stop; // stop monitor




setting and mapping arguments



~out.play;


~out = { arg freq=500, ffreq=120; SinOsc.ar(freq*[1,1.1], SinOsc.ar(ffreq, 0, pi), 0.2) };

~out.set(\freq, 400+100.rand2);

~out.set(\freq, 400+100.rand2);

~out.set(\ffreq, 30+20.rand2);

~out.unset(\freq, \ffreq);  // remove the setting

~out.set(\ffreq, 30+10.rand2, \freq, 500 + 200.rand2);



// argument settings and mappings are applied to every new function

~out = { arg freq=100, ffreq=20; SinOsc.ar(freq, SinOsc.ar(SinOsc.ar(ffreq)*ffreq, 0, pi), 0.2) };


// mapping to other proxies

~lfo = { SinOsc.kr(0.3, 0, 80, 100) };

~out.map(\ffreq, ~lfo);


~out = { arg freq=300, ffreq=20; Pulse.ar(freq*[1,1.1]+ SinOsc.ar(ffreq, 0, freq), 0.3, 0.1) };

~out = { arg freq=300, ffreq=20; BPF.ar(LFSaw.ar(ffreq*[1,1.1], 0, 1), freq, 0.2) };


~lfo = { FSinOsc.kr(0.3, 0, 30, 200) + FSinOsc.kr(10, 0, 10) };

~out = { arg freq=300, ffreq=20; SinOsc.ar(freq*[1,1.1], SinOsc.ar(ffreq, 0, pi), 0.1) };



// crossfaded setting and mapping: fadeTime is used

~out.fadeTime = 2;

~out.xset(\freq, 9000);

~out.xset(\freq, rrand(400, 700));


~lfo = { FSinOsc.kr(0.1, 0, 30, 100) };

~lfo2 = { LFClipNoise.kr(3, 100, 200) };

~lfo3 = StreamKrDur(Pseq([Prand([530, 600],1), 700, 400, 800, 500].scramble, inf) / 3, 0.2);


~out.xmap(\ffreq, ~lfo2);

~out.xmap(\ffreq, ~lfo);

~out.xmap(\ffreq, ~lfo3);


// argument rates: just like a synthdef has input 'rates' (like \ir or \tr), a nodeproxy control

// can be given a rate. this rate is used for each function passed into the proxy.


// trigger inputs

~out = { arg trig, dt=1; Decay2.kr(trig, 0.01, dt) * Mix(SinOsc.ar(7000*[1.2, 1.3, 0.2])) }

~out.setRates(\trig, \tr);


// set the group, so the node proxy does not store the new value

~out.group.set(\trig, 0.1, \dt, 0.1); 

~out.group.set(\trig, 0.4, \dt, 0.31);

~out.group.set(\trig, 0.13, \dt, 2);


// lagging controls:

~out.lag(\xfreq, 1); // equivalent to ~out.setRates(\xfreq, 1);

(

~out = { arg trig, dt=1, xfreq=700; 

Decay2.kr(trig, 0.01, dt) * Mix(SinOsc.ar(xfreq*[1.2, 1.3, 0.2])) 

};

)

~out.group.set(\trig, 0.1, \dt, 1, \xfreq, rrand(2000,9000)); 

~out.group.set(\trig, 0.1, \dt, 0.5, \xfreq, rrand(2000,9000)); 

~out.group.set(\trig, 0.1, \dt, 1, \xfreq, rrand(2000,9000)); 


// changing the lag, the synth is reconstructed with the new lag:


~out.lag(\xfreq, 0.01);

~out.group.set(\trig, 0.1, \dt, 1, \xfreq, rrand(2000,9000)); 

~out.group.set(\trig, 0.1, \dt, 1, \xfreq, rrand(2000,9000)); 

~out.group.set(\trig, 0.1, \dt, 1, \xfreq, rrand(2000,9000)); 


// removing the trig rate:

~out.setRates(\trig, nil);


// note that the same works with the i_ and the t_ arguments, just as it does in SynthDef







___________________________________________________________________

other possible inputs



using a synthdef as input



// for a more systematic overview see: [jitlib_fading]


// you have the responsibility for the right number of channels and output rate

// you have to supply an 'out' argument so it can be mapped to the right channel.


~out.play;

~out = SynthDef("w", { arg out=0; Out.ar(out,SinOsc.ar([Rand(430, 600), 600], 0, 0.2)) });

~out = SynthDef("w", { arg out=0; Out.ar(out,SinOsc.ar([Rand(430, 600), 500], 0, 0.2)) });



// if you supply a gate it fades in and out. evaluate this several times

(

~out = SynthDef("w", { arg out=0, gate=1.0; 

Out.ar(out,

SinOsc.ar([Rand(430, 800), Rand(430, 800)], 0, 0.2) * EnvGen.kr(Env.asr(1,1,1), gate, doneAction:2)

) 

});

)


// once the SynthDef is sent, it can be assigned by name. 

// using this method, a gate argument should be 

// provided that releases the synth. (doneAction:2)

// this is very efficient, as the def is on the server already.


// if the synth def is in the synthdesc lib (.store) its gate is detected.


(

SynthDef("staub", { arg out, gate=1; 

Out.ar(out, Ringz.ar(Dust.ar(15), Rand(1, 3) * 3000*[1,1], 0.001) * EnvGen.kr(Env.asr, gate, doneAction:2)) 

}).send(s);

)


~out = \staub;




// if you supply an envelope that frees itself, no bundle is sent to free it

(

~out = SynthDef("w", { arg out, lfo, f0=430;

Out.ar(out,

SinOsc.ar([Rand(f0, 800), Rand(f0, 800)]+lfo, 0, 0.2) * EnvGen.kr(Env.perc(0.01, 0.03), doneAction:2)

) 

});

)


~out.spawn;

~out.spawn([\f0, 5000]);

fork { 5.do { ~out.spawn([\f0, 5000 + 1000.0.rand]); 0.1.wait; } }



// when the synth description in the SynthDescLib is found for the symbol,

// the proxy can determine whether to release or to free the synth.

// so if there is no 'gate' arg provided and the def has a desc, the synth is

// freed and not released. 


(

SynthDef("staub", { arg out; 

Out.ar(out, Ringz.ar(WhiteNoise.ar(0.01), 1000*[1,1], 0.001)) 

}).store; // store the synth def so it is added to the SynthDescLib

)



~out = \staub;

~out = \staub; // watching the synth count shows that the old synth is freed.

~out = 0;  // now out plays continuous stream of zero.

~out = nil; // removes object and stops it.


using patterns


// example


(

SynthDef("who", { arg amp=0.1, freq=440, detune=0, gate=1, out=0, ffreq=800;

var env;

env = Env.asr(0.01, amp, 0.5);

Out.ar(out, Pan2.ar(

Formant.ar(freq + detune, ffreq, 30, EnvGen.kr(env, gate, doneAction:2)), Rand(-1.0, 1.0))

)

}).store;


)


~out.play;



~out = Pbind(\instrument, \who, \freq, [600, 601], \ffreq, 800, \legato, 0.02);





// embed a control node proxy into an event pattern:

// this does not work for indirect assignment as \degree, \midinote, etc., 

// because there is calculations in the event! if needed, these can be done in the SynthDef.


~lfo = { SinOsc.kr(2, 0, 400, 700) };

~out = Pbind(\instrument, \who, \freq, 500, \ffreq, ~lfo, \legato, 0.02);


~lfo = { SinOsc.kr(SinOsc.kr(0.2, Rand(0,pi), 10, 10), 0, 400, 700) };


~lfo = { LFNoise1.kr(5, 1300, 1500) };

~lfo = { MouseX.kr(100, 5500, 1) };


(

~out = Pbind(

\instrument, \who,

\freq, Pseq([500, 380, 300],inf),

\legato, 0.1,

\ffreq, Pseq([~lfo, 100, ~lfo, 100, 300, 550], inf), // use it in a pattern

\dur, Pseq([1, 0.5, 0.75, 0.125]*0.4, inf)

);

)


// note that when you use a proxy within a non-event pattern it gets embedded as an object,

// so this functionality is still standard


// works only with control rate proxies. multichannel control rate proxies cause

// multichannel expansion of the events:


~lfoStereo = { LFNoise1.kr([1, 1], 1300, 1500) }; // 2 channel control rate proxy

~out = Pbind(\instrument, \who, \freq, 1500, \detune, ~lfoStereo, \legato, 0.02);

~lfoStereo = { [MouseX.kr(100, 15500, 1), SinOsc.kr(SinOsc.kr(0.2, 0, 10, 10), 0, 400, 700)] }


// btw: setting the clock will cause the pattern to sync:

p.clock = TempoClock.default;

p.clock.tempo = 2.0;

p.clock.tempo = 1.0



// patterns also crossfade, if an \amp arg is defined in the synthdef:

// (evaluate a couple of times)

~out.fadeTime = 3.0;

(

~out = Pbind(

\instrument, \who,

\freq, Pshuf([500, 380, 200, 510, 390, 300, 300],inf) * rrand(1.0, 2.0),

\legato, 0.1,

\ffreq, Pshuf([~lfo, 100, ~lfo, 100, 300, 550], inf),

\dur, 0.125 * [1, 2, 3, 2/3].choose

);

)



using instruments and players


// pause and resume do not work yet.



// store an instrument

(

Instr(\test, 

{ arg dens=520, ffreq=7000; Ringz.ar(Dust.ar(dens, [1,1]*0.1), ffreq, 0.02) }

);

)


~out = Patch(\test, [10, rrand(5000, 8000)]);

~out.fadeTime = 3;



(

~out = InstrSpawner({ arg freq=1900,env,pan;

Pan2.ar(SinOsc.ar(freq, 0.5pi, 0.3) * EnvGen.kr(env, doneAction: 2), pan)

},[

Prand([1500, 700, 800, 3000] + 170.rand2, inf),

Env.perc(0.002,0.01),

Prand([-1,1],inf)

],0.125)

)


~out.clear;




// does not work (yet).

//~out.set(\dens, 120);

//~out.xset(\dens, 1030); 

//~out.unmap(\ffreq);

//~out.set(\ffreq, 500);



___________________________________________________________________

client side routines


spawning 


~out.play;

~out.awake = false; // allow sound object assignment without immediate sending


// putting an synthdef into the node proxy without playing it right away

// the synthdef has an envelope that frees by itself.

(

~out = SynthDef("a", { arg out=0, freq=800, pmf=1.0, pan;

var env, u;

env = EnvGen.kr(Env.perc(0.001, 0.04, 0.4),doneAction:2); // envelope

u = SinOsc.ar(freq * Rand(0.9, 1.1), SinOsc.ar(pmf, 0, pi), env);

Out.ar(out, Pan2.ar(u, pan))

})

);



// create a task to repeatedly send grains

(

t = Task.new({

loop({

// starts a synth with the current synthdef at index 0

~out.spawn([\pmf, [1, 20, 300].choose, \pan, [0, -1, 1].choose]); 

[0.1, 0.01, 0.25].choose.wait;

})

});

)


t.start;

t.stop;

t.start;


// note: if you want to avoid using interpreter variables (single letter, like "t"),

// you can use Tdef for this. (see Tdef.help)


// set some argument

~out.set(\freq, 300);

~out.set(\freq, 600);

~out.map(\freq, ~lfo);

~lfo = { SinOsc.kr(0.1, 0, 3000, 4000) };

~lfo = { SinOsc.kr(0.1, 0, 600, 700) };

~lfo.add({ Trig.kr(Dust.kr(1), 0.1) * 3000 });

~lfo = 300;


// change the definition while going along

(

~out = SynthDef("a", { arg out, freq=800;

var env;

env = EnvGen.kr(Env.perc(0.01, 0.1, 0.3),doneAction:2);

Out.ar(out, Pulse.ar(freq * Rand([0.9,0.9], 1.1), 0.5, env) )

});

)



t.stop;

~out.awake = true; // don't forget this

//  free all synths in this current ProxySpace

currentEnvironment.clear;





granular synthesis: efficient code


see also [jitlib_efficiency]


~out.play;


(

SynthDef("grain", { arg i_out = 0, pan;

var env;

env = EnvGen.kr(Env.perc(0.001, 0.003, 0.2),doneAction:2);

Out.ar(i_out, Pan2.ar(FSinOsc.ar(Rand(1000,10000)), pan) * env) 

}).send(s);

)


// a target for the grains

~someInput.ar(2);  // initialize to 2 channels audio

~out = ~someInput;


(

t = Task({

loop({

s.sendMsg("/s_new","grain",-1,0,0, 

\i_out, ~someInput.index, // returns the bus index of the proxy

\pan, [1, 1, -1].choose * 0.2

);  

[0.01, 0.02].choose.wait;

})

});

)

t.play;


// different filters;


~out.fadeTime = 1.0;


~out = { BPF.ar(~someInput.ar, MouseX.kr(100, 18000, 1), 0.1) };


~out = { CombL.ar(~someInput.ar * (LFNoise0.ar(2) > 0), 0.2, 0.2, MouseX.kr(0.1, 5, 1)) };


~out = { RLPF.ar(~someInput.ar, LFNoise1.kr(3, 1000, 1040), 0.05) };



t.stop;




//_________


~out.stop;

currentEnvironment.clear;

ProxySpace.pop; // restore original environment




________________________________________________________________________



using multiple proxyspaces

note that this can be done while the server is not running: with p.wakeUp or p.play

the environment can be played back.


// quit server:


s.quit;



// create two proxyspaces without a running server

(

p = ProxySpace(s);

q = ProxySpace(s);


p.use({

~out = { Resonz.ar(~in.ar, ~freq.kr, 0.01) };

~in = { WhiteNoise.ar(0.5) };

~freq = { LFNoise2.kr(1, 1000, 2000) };

});


q.use({

~in = { Dust.ar(20, 0.1) };

~out = { Resonz.ar(~in.ar * 450, ~freq.kr, 0.005) };

~freq = { LFNoise2.kr(1, 400, 2000) };

});

)


// wait for the booted  server

s.boot;


// play the proxy at \out

p.play(\out); 

q.play; // out is the default output



external access



q[\in][1] = { Impulse.ar(2, 0, 0.5) }; // adding a synth at index 1


// equivalent to

q.at(\in).put(1, { Impulse.ar(7, 0, 0.5) });



connecting two spaces (must be on one server)



(

q.use({

~freq =  100 + p[\freq] / 2;

})

)


recording output (see also: [RecNodeProxy])



r = p.record(\out, "proxySpace.aiff");


// start recording

r.unpause;


// pause recording

r.pause;


// stop recording

r.close;






push/pop



// make x the currentEnvironment

p.push; 


~freq = 700;

~freq = 400;

~freq = { p.kr(\freq) + LFNoise1.kr(1, 200, 300) % 400 }; // feedback

~freq = 400;


p.pop; // restore environment



// make y the currentEnvironment

q.push; 


~freq = 1000;

~in = { WhiteNoise.ar(0.01) };


q.pop; // restore environment


q.clear;

p.clear;





______________________________________________________________


some more topics


nodeproxy with numbers as input:


p = ProxySpace.push(s.boot);



~out = { SinOsc.ar(~a.kr * Rand(1, 2), 0, 0.1) };

~out.play;


~a = 900;


// these add up:

~a[0] = 440;

~a[1] = 220;

~a[2] = 20;


~a.fadeTime = 2;


~a[0] = 300; // now there is a crossfade.

~a[1] = { SinOsc.kr(5, 0, 20) }; 

~a[2] = { SinOsc.kr(30, 0, 145) };




// internally a numerical input is approximately replaced by:

// (pseudocode)

SynthDef("name", { arg out, fadeTime;

Out.kr(out,

Control.kr(Array.fill(proxy.numChannels, { the number })) 

* EnvGate.new(fadeTime:fadeTime)

) 

});






Berlin: clubs bars cafes nightlife going out