transit authority

// SC Bus exercise 1: building some sends

// CMD + ENTER / CTRL + ENTER from here to run the code
(
// create a Dictionary of synths:
~synths = Dictionary.new;

// create a Dictionary of audio busses:
~busses = Dictionary.new;
~busses[\mainOut] = Bus.audio(server: Server.default, numChannels: 2);
~busses[\delaySend] = Bus.audio(server: Server.default, numChannels: 2);
~busses[\reverbSend] = Bus.audio(server: Server.default, numChannels: 2);

// alias our Server:
s = Server.default;

// make a Routine, so that we can sync changes to the Server
Routine{

	// define our source sound:
	SynthDef("source", {
		var snd = LPF.ar(Saw.ar(\hz.kr(330)), (\hz.kr(330)*8).clip(20,20000));
		snd = snd * LagUD.ar(Impulse.ar(2), 0, 2);

		Out.ar(\outMain.kr, (snd * \levelMain.kr(1)).dup); // .dup = send stereo signal
		Out.ar(\outSend1.kr, (snd * \levelSend1.kr(0)).dup);
		Out.ar(\outSend2.kr, (snd * \levelSend2.kr(0)).dup);
	}).add;

	// define our delay:
	SynthDef("delay", {
		Out.ar(\out.kr, CombC.ar(In.ar(\in.kr, 2),1.0,0.2,3.2));
	}).add;

	// define our reverb:
	SynthDef("reverb", {
		var sig = In.ar(\in.kr, 2);
		Out.ar(\out.kr, FreeVerb2.ar(sig[0], sig[1], 1.0, 0.7, 0.2, 1.5));
	}).add;

	// define our main output:
	SynthDef("main", {
		Out.ar(\out.kr, In.ar(\in.kr, 2));
	}).add;

	// we sync the Server here so that the common SynthDefs above
	//   are present on the Server when requested below
	s.sync;

	// build our source and pass it arguments:
	~synths[\source] = Synth.new("source", [
		\outMain, ~busses[\mainOut], // connecting to the mainOut bus
		\outSend1, ~busses[\delaySend], // connecting to the delaySend bus
		\outSend2, ~busses[\reverbSend] // connecting to the reverbSend bus
	]);

	// build our delay AFTER our source
	//   and pass it arguments:
	~synths[\delay] = Synth.after(~synths[\source], "delay", [
		\in, ~busses[\delaySend], // input = the delaySend bus
		\out, ~busses[\mainOut] // output = the mainOut bus
	]);

	// build our reverb AFTER our delay
	//   and pass it arguments:
	~synths[\reverb] = Synth.after(~synths[\delay], "reverb", [
		\in, ~busses[\reverbSend], // input = the reverbSend bus
		\out, ~busses[\mainOut] // output = the mainOut bus
	]);

	// build our main output AFTER our reverb
	//   and pass it arguments:
	~synths[\main] = Synth.after(~synths[\reverb], "main", [
		\in, ~busses[\mainOut], // input = the mainOut bus
		\out, 0 // output = the default output device
	]);
}.play;
)

// SC Bus exercise 2
// busses in a class with panning and commands

FXBusDemo {

	var <synths;
	var <busses;
	var <g;

	*new {
		^super.new.init();
	}

	init {
		var s = Server.default;
		synths = Dictionary.new;
		busses = Dictionary.new;

		Routine {
			// in this demo, source bus is mono / FX are stereo:
			busses[\source] = Bus.audio(s, 1);
			busses[\main_out] = Bus.audio(s, 2);
			busses[\reverb_send] = Bus.audio(s, 2);
			busses[\delay_send] = Bus.audio(s, 2);

			// define our patch synths, to control stereo field:
			SynthDef.new(\patch_pan, {
				Out.ar(\out.kr, Pan2.ar(In.ar(\in.kr), \pan.kr(0), \level.kr(1)));
			}).send(s);

			SynthDef.new(\patch_main, {
				Out.ar(\out.kr, In.ar(\in.kr, 2) * \level.kr(1));
			}).send(s);

			// define our main synth:
			SynthDef.new(\sourceBlip, {
				var snd = LPF.ar(Saw.ar(\hz.kr(330)), (\hz.kr(330)*8).clip(20,20000));
				snd = snd * LagUD.ar(Impulse.ar(2), 0, 2);
				Out.ar(\out.kr, snd * \level.kr(0.5));
			}).send(s);

			// we'll sync here so that the common SynthDefs above
			//   are present on the Server when requested:
			s.sync;

			// add a group to order our synths / nodes:
			g = Group.new(s);

			// instantiate our main synth:
			synths[\source] = Synth.new(\sourceBlip,
				target:g, addAction:\addToHead, args:[
					\out, busses[\source]
			]);

			synths[\dry] = Synth.new(\patch_pan,
				target:synths[\source], addAction:\addAfter, args:[
					\in, busses[\source],
					\out, busses[\main_out],
					\level, 1.0
			]);

			synths[\delay_send] = Synth.new(\patch_pan,
				target:synths[\source], addAction:\addAfter, args:[
					\in, busses[\source],
					\out, busses[\delay_send],
					\level, 0.0
			]);

			synths[\reverb_send] = Synth.new(\patch_pan,
				target:synths[\source], addAction:\addAfter, args:[
					\in, busses[\source],
					\out, busses[\reverb_send],
					\level, 0.0
			]);

			synths[\delay] = SynthDef.new(\delay, {
				arg in, out, level=1;
				Out.ar(out, DelayC.ar(In.ar(in, 2), 1.0, 0.2, level));
			}).play(target:synths[\delay_send], addAction:\addAfter, args:[
				\in, busses[\delay_send], \out, busses[\main_out]
			]);

			synths[\reverb] = SynthDef.new(\reverb, {
				arg in, out, level=1;
				Out.ar(out, FreeVerb.ar(In.ar(in, 2), 1.0, 0.9, 0.1, level));
			}).play(target:synths[\reverb_send], addAction:\addAfter, args:[
				\in, busses[\reverb_send], \out, busses[\main_out]
			]);

			synths[\main_out] = Synth.new(\patch_main,
				target:g, addAction:\addToTail, args: [
					\in, busses[\main_out], \out, 0
			]);

		}.play;
	}

	setLevel { arg key, val;
		synths[key].set(\level, val);
	}

	setPan { arg key, val;
		synths[key].set(\pan, val);
	}

	setHz { arg val;
		synths[\source].set(\hz, val);
	}

	// IMPORTANT: free Server resources and nodes when done!
	free {
		g.free;
		busses.do({arg bus; bus.free;});
	}

}

// SC Bus exercise 3
// adding an isolator

FXBusDemo {

	var <synths;
	var <busses;
	var <g;

	// NEW: add an optional 'hz' argument to control
	//   the pitch of the synth at instantiation:
	*new {
		arg hz = 330;
		^super.new.init(hz);
	}

	init {
		// NEW: add an optional 'hz' argument to control
		//   the pitch of the synth at instantiation:
		arg hz = 330;
		var s = Server.default;
		synths = Dictionary.new;
		busses = Dictionary.new;

		Routine {
			// in this demo, source bus is mono / FX are stereo:
			busses[\source] = Bus.audio(s, 1);
			busses[\main_out] = Bus.audio(s, 2);
			busses[\reverb_send] = Bus.audio(s, 2);
			busses[\delay_send] = Bus.audio(s, 2);

			// define our patch synths, to control stereo field:
			SynthDef.new(\patch_pan, {
				Out.ar(\out.kr, Pan2.ar(In.ar(\in.kr), \pan.kr(0), \level.kr(1)));
			}).send(s);

			// NEW: build an isolator into our main output:
			SynthDef.new(\patch_main, {
				var src = In.ar(\in.kr, 2);
				var fc1 = \fc1.kr(600);
				var fc2 = \fc2.kr(1800);

				var ampLo = \ampLo.kr(1);
				var ampMid = \ampMid.kr(1);
				var ampHi = \ampHi.kr(1);

				var lo = LPF.ar(LPF.ar(src, fc1), fc1) * ampLo;
				var mid = HPF.ar(HPF.ar(LPF.ar(LPF.ar(src, fc2), fc2), fc1), fc1) * ampMid;
				var hi = HPF.ar(HPF.ar(src, fc2), fc2) * ampHi;

				var mix = lo + mid + hi;

				Out.ar(\out.kr, mix * \level.kr(1));
			}).send(s);

			// define our main synth:
			SynthDef.new(\sourceBlip, {
				var snd = LPF.ar(Saw.ar(\hz.kr(hz)), (\hz.kr(hz)*8).clip(20,20000));
				snd = snd * LagUD.ar(Impulse.ar(2), 0, 2);
				Out.ar(\out.kr, snd * \level.kr(0.5));
			}).send(s);

			// we'll sync here so that the common SynthDefs above
			//   are present on the Server when requested:
			s.sync;

			// add a group to order our synths / nodes:
			g = Group.new(s);

			// instantiate our main synth:
			synths[\source] = Synth.new(\sourceBlip,
				target:g, addAction:\addToHead, args:[
					\out, busses[\source]
			]);

			synths[\dry] = Synth.new(\patch_pan,
				target:synths[\source], addAction:\addAfter, args:[
					\in, busses[\source],
					\out, busses[\main_out],
					\level, 1.0
			]);

			synths[\delay_send] = Synth.new(\patch_pan,
				target:synths[\source], addAction:\addAfter, args:[
					\in, busses[\source],
					\out, busses[\delay_send],
					\level, 0.0
			]);

			synths[\reverb_send] = Synth.new(\patch_pan,
				target:synths[\source], addAction:\addAfter, args:[
					\in, busses[\source],
					\out, busses[\reverb_send],
					\level, 0.0
			]);

			synths[\delay] = SynthDef.new(\delay, {
				arg in, out, level=1;
				Out.ar(out, DelayC.ar(In.ar(in, 2), 1.0, 0.2, level));
			}).play(target:synths[\delay_send], addAction:\addAfter, args:[
				\in, busses[\delay_send], \out, busses[\main_out]
			]);

			synths[\reverb] = SynthDef.new(\reverb, {
				arg in, out, level=1;
				Out.ar(out, FreeVerb.ar(In.ar(in, 2), 1.0, 0.9, 0.1, level));
			}).play(target:synths[\reverb_send], addAction:\addAfter, args:[
				\in, busses[\reverb_send], \out, busses[\main_out]
			]);

			synths[\main_out] = Synth.new(\patch_main,
				target:g, addAction:\addToTail, args: [
					\in, busses[\main_out], \out, 0
			]);

		}.play;
	}

	setLevel { arg key, val;
		synths[key].set(\level, val);
	}

	setPan { arg key, val;
		synths[key].set(\pan, val);
	}

	setHz { arg val;
		synths[\source].set(\hz, val);
	}

	// NEW: add controls for our main_out synth:
	setMain { arg key, val;
		synths[\main_out].set(key, val);
	}

	// IMPORTANT: free Server resources and nodes when done!
	free {
		g.free;
		busses.do({arg bus; bus.free;});
	}

}

Engine_FXBusDemo : CroneEngine {
// All norns engines follow the 'Engine_MySynthName' convention above

	// NEW: select a variable to invoke FXBusDemo with
	var kernel;

	*new { arg context, doneCallback;
		^super.new(context, doneCallback);
	}

	alloc { // allocate memory to the following:

		// NEW: since FXBusDemo is now a supercollider Class,
		//   we can just construct an instance of it
		kernel = FXBusDemo.new();

		// NEW: build an 'engine.set_level(synth,val)' command
		this.addCommand(\set_level, "sf", { arg msg;
			var voiceKey = msg[1].asSymbol;
			var freq = msg[2].asFloat;
			kernel.setLevel(voiceKey,freq);
		});

		// NEW: build an 'engine.set_pan(synth,val)' command
		this.addCommand(\set_pan, "sf", { arg msg;
			var voiceKey = msg[1].asSymbol;
			var freq = msg[2].asFloat;
			kernel.setPan(voiceKey,freq);
		});

		// NEW: build an 'engine.set_hz(val)' command
		this.addCommand(\set_hz, "f", { arg msg;
			var freq = msg[1].asFloat;
			kernel.setHz(freq);
		});

		// NEW: build an 'engine.set_main(key,val)' command
		this.addCommand(\set_main, "sf", { arg msg;
			var key = msg[1].asSymbol;
			var val = msg[2].asFloat;
			kernel.setMain(key,val);
		});

	} // alloc


	// NEW: when the script releases the engine,
	//   free Server resources and nodes!
	// IMPORTANT
	free {
		kernel.free;
	} // free


} // CroneEngine

// SC Bus exercise 4: polls
// sending brightness + amplitude analysis to Lua

FXBusDemo {

	var <synths;
	var <busses;
	var <g;

	*new {
		^super.new.init();
	}

	init {
		var s = Server.default;
		synths = Dictionary.new;
		busses = Dictionary.new;

		Routine {
			busses[\source] = Bus.audio(s, 1);
			busses[\main_out] = Bus.audio(s, 2);
			busses[\reverb_send] = Bus.audio(s, 2);
			busses[\delay_send] = Bus.audio(s, 2);

			// NEW: add an analysis audio bus:
			busses[\analysis] = Bus.audio(s, 2);
			// NEW: define control Busses for our Lua polls
			busses[\brightness] = Bus.control(s);
			busses[\amp] = Bus.control(s);

			SynthDef.new(\patch_pan, {
				Out.ar(\out.kr, Pan2.ar(In.ar(\in.kr), \pan.kr(0), \level.kr(1)));
			}).send(s);

			SynthDef.new(\patch_main, {
				var src = In.ar(\in.kr, 2);
				var fc1 = \fc1.kr(600);
				var fc2 = \fc2.kr(1800);

				var ampLo = \ampLo.kr(1);
				var ampMid = \ampMid.kr(1);
				var ampHi = \ampHi.kr(1);

				var lo = LPF.ar(LPF.ar(src, fc1), fc1) * ampLo;
				var mid = HPF.ar(HPF.ar(LPF.ar(LPF.ar(src, fc2), fc2), fc1), fc1) * ampMid;
				var hi = HPF.ar(HPF.ar(src, fc2), fc2) * ampHi;

				var mix = lo + mid + hi;

				Out.ar(\out.kr, mix * \level.kr(1));
			}).send(s);

			// define our source synth:
			SynthDef.new(\sourceBlip, {
				var snd = LPF.ar(Saw.ar(\hz.kr(330)), \fchz.kr(800).clip(20,20000));
				snd = snd * LagUD.ar(Impulse.ar(0.3), 0, 10);
				Out.ar(\out.kr, snd * \level.kr(0.5));
			}).send(s);

			// we're syncing here so that the SynthDefs above
			//   is present on the Server when requested
			s.sync;

			// add a group to order our synths / nodes:
			g = Group.new(s);

			// instantiate our main synth:
			synths[\source] = Synth.new(\sourceBlip,
				target:g, addAction:\addToHead, args:[
					\out, busses[\source]
			]);

			synths[\dry] = Synth.new(\patch_pan,
				target:synths[\source], addAction:\addAfter, args:[
					\in, busses[\source],
					\out, busses[\main_out],
					\level, 1.0
			]);

			synths[\delay_send] = Synth.new(\patch_pan,
				target:synths[\source], addAction:\addAfter, args:[
					\in, busses[\source],
					\out, busses[\delay_send],
					\level, 0.0
			]);

			synths[\reverb_send] = Synth.new(\patch_pan,
				target:synths[\source], addAction:\addAfter, args:[
					\in, busses[\source],
					\out, busses[\reverb_send],
					\level, 0.0
			]);

			synths[\delay] = SynthDef.new(\delay, {
				arg in, out, dtime=0.2, level=1;
				Out.ar(out, DelayC.ar(In.ar(in, 2), 1.0, dtime, level));
			}).play(target:synths[\delay_send], addAction:\addAfter, args:[
				\in, busses[\delay_send], \out, busses[\main_out]
			]);

			synths[\reverb] = SynthDef.new(\reverb, {
				arg in, out, level=1;
				Out.ar(out, FreeVerb.ar(In.ar(in, 2), 1.0, 0.9, 0.1, level));
			}).play(target:synths[\reverb_send], addAction:\addAfter, args:[
				\in, busses[\reverb_send], \out, busses[\main_out]
			]);

			synths[\main_out] = Synth.new(\patch_main,
				target:g, addAction:\addToTail, args: [
					// NEW: send main out to analysis bus
					\in, busses[\main_out], \out, busses[\analysis]
			]);

			// NEW: build a brightness tracker
			synths[\brightness] = SynthDef.new(\brightnessTracker, {
				arg in, out, brightOut, ampOut;
				var src = In.ar(in, 2);
				var mixed = Mix.new([src[0],src[1]]);
				var amp = Amplitude.kr(mixed);
				var chain = FFT(LocalBuf(2048), mixed);
				var brightness = SpecCentroid.kr(chain);
				// send the output out:
				Out.ar(out, src);
				// send the brightness to a control bus:
				Out.kr(brightOut, brightness);
				// send the amp to a control bus:
				Out.kr(ampOut, amp);
			}).play(target:g, addAction:\addToTail, args: [
				\in, busses[\analysis],
				\out, 0,
				\brightOut, busses[\brightness].index,
				\ampOut, busses[\amp].index
			]);

		}.play;
	}

	setLevel { arg key, val;
		synths[key].set(\level, val);
	}

	setPan { arg key, val;
		synths[key].set(\pan, val);
	}

	// NEW: add controls for our source synth voice
	setSynth { arg key, val;
		synths[\source].set(key, val);
	}
	// NEW: add control for our delay time
	setDelayTime{ arg val;
		synths[\delay].set(\dtime, val.min(1));
	}

	setMain { arg key, val;
		synths[\main_out].set(key, val);
	}

	// IMPORTANT: free Server resources and nodes when done!
	free {
		g.free;
		busses.do({arg bus; bus.free;});
	}

}

Engine_FXBusDemo : CroneEngine {
// All norns engines follow the 'Engine_MySynthName' convention above

	var kernel;

	*new { arg context, doneCallback;
		^super.new(context, doneCallback);
	}

	alloc { // allocate memory to the following:

		kernel = FXBusDemo.new(Crone.server);

		this.addCommand(\set_level, "sf", { arg msg;
			var voiceKey = msg[1].asSymbol;
			var val = msg[2].asFloat;
			kernel.setLevel(voiceKey,val);
		});

		this.addCommand(\set_pan, "sf", { arg msg;
			var voiceKey = msg[1].asSymbol;
			var val = msg[2].asFloat;
			kernel.setPan(voiceKey,val);
		});

		// NEW: add control over synth
		this.addCommand(\set_synth, "sf", { arg msg;
			var attribute = msg[1].asSymbol;
			var val = msg[2].asFloat;
			kernel.setSynth(attribute,val);
		});

		// NEW: add control over delay time
		this.addCommand(\set_delay_time, "f", { arg msg;
			var val = msg[1].asFloat;
			kernel.setDelayTime(val);
		});

		this.addCommand(\set_main, "sf", { arg msg;
			var key = msg[1].asSymbol;
			var val = msg[2].asFloat;
			kernel.setMain(key,val);
		});

		// NEW: add brightness poll
		this.addPoll(\brightness_poll, {
			var spectral = kernel.busses[\brightness].getSynchronous;
			spectral
		});

		// NEW: add amp poll
		this.addPoll(\amp_poll, {
			var amp = kernel.busses[\amp].getSynchronous;
			amp
		});

	} // alloc

	// IMPORTANT
	free {
		kernel.free;
	} // free


} // CroneEngine