Live at the Living Room Concert

I wrote a SuperCollider patch that automatically pans my live synth patching and makes recordings of it. This was the maiden voyage in a concert situation, used in a very small concert on 19 September 2011 at the Fossbox workshop in Wapping.

For this gig, I mostly did chaotic FM modulation. I played around quite a lot with different modes of syncing the oscillators. Sudden major changes (including the silences) are from switching to a hard sync. I haven’t used the syncs much before, so I was never sure what they were going to do.

I’m planning on submitting a copy of this recording with my PhD thesis next week.

Analog Variations

A piece created using an analog synthesiser and using analog
re-processing of recorded materials. The same sounds appear again and
again, each further prepared with analog methods. I wanted to get
back to my roots and do something that used a computer only as a tape
recorder and not as a compositional tool. It’s easier and more
rewarding to get organic sounds out of fiddling knobs than it is
fiddling number generators.

Silicon Valley by Rail

I was home last year for my uncle’s funeral. I don’t have a car or even a drivers license any more, so I rode a lot of trains, especially around the the South Bay Area. Silicon Valley’s trains are diesel, with real bells on them. They sound like something out of time, like our rail infrastructure is from the past even as our gadgets are pushing us into the future.

I recorded the trains and bells with a Xoom recorder. Then, I analysed the spectrum of the bells and used dissonance curves to construct a tuning for FM tones modelled on the bells. I used those tones to construct a drone and then mixed in some processed versions of the train sounds. There’s also a bit of binaural beating in this piece, making it a safe, legal high.

In the process of making this piece, I released a SuperCollider Quark called TuningLib, which has in it a DissonanceCurve class, useful for computing tunings based on timbre.

Live at NOISE=NOISE #19

There’s a series of Noise concerts in the London area called NOISE=NOISE, curated by Ryan Jordan. They’re usually pretty awesome. This was the second one I’ve played in. It was organised about two days before the event, so I threw together my set at the last minute.

In the first part of it, I’m playing my MOTM synthesizer and live sampling that in my SimpleSample SuperCollider patch, controlled by a wireless gamepad. However, one channel seemed to be out on the PA and it seemed like a lot of my SC stuff wasn’t making it out to the PA either. At some point, the joystick gave up the ghost completely, so it switched to being all modular synth.

Some of the frequencies really resonated the hell out of the space. For best results, listen with speakers rather than headphones and turn it up loud.

Blakes 9

I’ve been working on this piece for over a year and it’s time to say it’s done.

The inspiration to start this piece came from two sources. One was that I watched the TV show Blakes 7 and thought it had great incidental music. And the other was that I briefly dated a poet who had a thing for the number 9.

I recorded a loop of synthesized sounds that seemed to go with the sounds on the show, and then I came up with a cutup algorithm that broke it into pieces based on a 9-feeling. But that wasn’t enough, so I added in some glitching. But that wasn’t enough, so I added in another section, and so it grew in an ungainly way, until it filled 80 speakers and was premiered as an N-channel piece at a BEAST concert at the CBSO Centre in Birmingham in June 2009.

Then I spent the summer mixing it down to 2 channels, while trying to prevent it from getting muddy. I won’t lie, it sounds better with more channels, but the stereo version is ok. If you have a subwoofer, it’s even better.

If you happen to have a speaker array of 8 channels or, really, any number of channels and you think you might want to present this piece, please contact me.

Shorts: #29 Raining Up

Commissioned and titled by Autumn Looijen

This piece was created using a MOTM Synthesizer and mixed in Ardour. There were several false starts. I had been doing field recordings of storms and for a while, every artificial sound I made seemed to also sound like weather. The title Autumn chose seems to indicate that I didn’t quite get away from weather-related sounds.

I have started accepting commissions of one minute pieces again, and I’ve dropped the price since the last round. If you’d like to commission me, check out my online shop thing. Order now to beat the holiday rush!

Shorts: #28 Untitled

Commissioned and (un)titled by Cecile Moochnek

I wasn’t looking for a commission when I walked into the Cecile Moochnek Gallery on 4th Street in Berkeley. I was looking to do Christmas shopping. But I got talking to the gallery owner about art and music and she asked me to write her a short piece. This was in December of 2007. I wrote the piece in 2008, but didn’t hear back about a title and got busy with other things. Until today when inquiring about a title for a new commission, I realized this one had never been posted.

I made this piece with a Evenfall MiniModular Synthesizer. This was a all-in-one box modular synthesizer from the 1990′s. It’s a great little synth.

Blake’s 9

This piece has changed significantly since I first posted it and a newer version has since been posted.

I recently watched the entirety of the TV series Blake’s 7. Like all BBC science fiction productions of it’s era, the incidental music and sound effects are outstanding. The background hums, the computer whirrs and the ominous notes create a mood and a sense of place that is alien. After watching several of the episodes, I went home and created a patch on my MOTM synthesizer which seemed to perfectly capture a progression of mood as it might appear in an episode with Avon creeping along with a ray gun, infiltrating a Federation base.

However, as nice as patch was, with it’s 4 minute long loop, it wasn’t a piece. And there wasn’t an obvious way to make it become one. It was too complex and had too much character to mix, but not enough to stand on it’s own. I let it sit for weeks and thought about other things, specifically, a beat generation algorithm that was going nowhere. And then I met a poet who is obsessed with divisions / groups of 9.

I set my beat maker to 9, and then I thought of using it as a an organizational principle for cutting, rather than a way to make cheesy drum loops. I used it to cut my loop to sections and then into grains. Then I played back the grains in groups of 9, to make measures of 9 beats. In order to add some pitch variety, I changed the speed of playback of the grains, with rates of 1, 27/25, 9/7, 7/9, 25/27, a few intervals in a just version of the Bohlen Pierce scale. This scale uses 3′s instead of octaves, so the ratios have multiples of 3 where you would expect powers of two for more traditional scales.

This is a work in progress and may go on to be an installation or gain additional movements or neither or both.

Nice to See You

No More Twist is a new duo of Polly Moller and I. We played this improvised set live on KFJC on 17 July 2008. She was on flute(s) and noisemakers and I played a live sampling application (written in SuperCollider). We were featured to promote the Edgetone New Music Summit. We will be playing there on Wednesday (23 July 2008), where we will be premiering a piece called “Inquisition.” It’s going to have Polly hooked up to a lie detector that I built and I’ll be interpreting her biometric data as she answers questions posed by the audience.

This piece here, however, has text from a long spam email and uses the latest iteration of my SC program SimpleSample.

Joystick Intermezzo

All of my SuperCollider pieces require several silent seconds to clear existing memory, pre-compute data and load joystick drivers. I find it helpful in many circumstances to play short tape pieces as intermezzos while other, longer pieces, get ready to play. This particular one is designed to be used between pieces involving an old fashioned, large joystick. I timed how long it takes to load pieces that involve that joystick and it tends to be around 40 seconds, so this intermezzo is 45 seconds long.

The musical sounds are generated in SuperCollider, using pulse width modulation, constrained to 8 bit resolution, to give it a retro videogame sound. The game sound FX are from Wolfenstein 3d, the first first person shooter, in front of which I wasted many many hours of my youth. Thanks to Eric Bumstead who actually had a copy of it!

Phreaking

I wrote this piece for BrumCon 07. The con was sponsored by our local 2600 group, so I decided to use telephone in-line signaling codes as source materials. I spent a lot of time readin up on phone phreaking, which was just so completely cool. I never did it as a kid because the threats my dad made against me were so dire. But man, it was awesome!

The piece, though, is slightly silly. Well, maybe more than slightly. I doubt I’ll play it again, but I think the logic I used around the drum beats will definitely be refined and reused.

In the spirit of the con, the fugly, un-clean code is below the cut, along with some explanation of what the heck is going on. When I say ugly and unclean, I really, really mean it.

Code

The SuperCollider code requires BBBufferTool.sc (which is a very close relative of BufferTool.sc, so you can use either one). It handles some tricks with Buffers, like granulation.

Some explanation of the code at the bottom . . .

(

	var joystick;

	// drums
	a =  BBBufferTool.open(s, "sounds/SHARP_SN.wav");
	b = 	BBBufferTool.open(s, "sounds/kick2.wav");
	c = 	BBBufferTool.open(s, "sounds/HIHATCLO.wav");
	d =	BBBufferTool.open(s, "sounds/click.au");
	e = 	BBBufferTool.open(s, "sounds/TOM_HI.wav");
	a = [a, b, c, d, e];
	
	// operator	
	b = 	BBBufferTool.open(s, "sounds/pundits/telephone/hangup.aiff");
	c =	BBBufferTool.open(s,"sounds/pundits/telephone/not_completed.aiff");
	d =	BBBufferTool.open(s,"sounds/pundits/telephone/not_in_service.aiff");
	b = [b, c, d];

	SynthDef("teltone", {arg out = 0, freq, dur = 0.2, amp = 0.2, pan = -1;
	
		var sin, env, panner;
		
		sin = SinOsc.ar(freq, mul: amp);
		env = EnvGen.kr(Env.linen(0.01, dur - 0.02, 0.01, 1, 'linear'), doneAction: 2);
		panner = Pan2.ar(sin, pan, env);
		Out.ar(out, panner);
	}).store;
	
	SynthDef("gamey", { arg out, freq, gate = 1, amp, pan;

		var osc, env, filter, panner;

		osc = Pulse.ar(freq, mul:amp);
		env = amp * EnvGen.kr(Env.asr(0.09, 1, 0.1, 1, 'linear'), gate, doneAction: 2);
		osc = osc * env;
		filter = MantissaMask.ar(osc, 8/*, env*/);
		panner = Pan2.ar(filter, pan);
		Out.ar(out, panner);
	}).store;


	SynthDef("funky", { arg out, freq, dur, gate = 1, amp, pan;

		var osc, env, filter, panner, widthline, pitchline;
	
		// a half step down is 50/53
		// and a quarter step is 34/35
		// eigth is 68/ 67

		pitchline = Line.kr((68 / 67), (67 / 68), dur * 3 / 5);
		widthline = Line.kr(0.25, 0.75, dur);

		osc = Pulse.ar(freq * pitchline, widthline);
		env = amp * EnvGen.kr(Env.asr(0.09, 1, 0.1, 1, 'linear'), gate, doneAction: 2);
		osc = osc * env;
		filter = MantissaMask.ar(osc, 8/*, env*/);
		panner = Pan2.ar(filter, pan);
		Out.ar(out, panner);
	}).store;

	
	SynthDef("plainBuf", {arg out = 0, bufnum = 0, gate =1, pan = 0, 
								amp = 0;
	
		// plays a buffer through forwards and at the normal rate
	
		var dur, env, buf, outputAudio;
		dur = BufDur.kr(bufnum) + 1;
		
		// envelope required or the ugens stay around forver
		env = EnvGen.kr(Env.linen(0.0001, (dur - 0.0002), 0.0001, amp), gate, doneAction:2);
		buf = PlayBuf.ar(1, bufnum, BufRateScale.kr(bufnum));
		
		// this Pan2 stuff is a hack because Pan4 is glitchy
		
		outputAudio = Pan2.ar(buf, pan);
		//outputAudio = Pan2.ar(outputAudio.at(0), yPan) ++ Pan2.ar(outputAudio.at(1), yPan);
		
		Out.ar( out, outputAudio * env);
					
	}).store;
	

	SynthDef( "grainBuf", { arg out = 0, bufnum = 0, pan = 0, 
 									amp =1,startFrame = 0, grainDur = 1, rate = 1;
 									
 			var env, speed, player, panner;
 			
 			env = EnvGen.kr(Env.linen(0.001, (grainDur - 0.002), 0.001, amp), doneAction:2);
 			//env = EnvGen.kr(Env.linen(0.0001, (grainDur - 0.0002), 0.0001, 1), doneAction:2);
			speed = rate *  BufRateScale.kr(bufnum);
			player = PlayBuf.ar(1, bufnum, speed, startPos: startFrame);
			panner = Pan2.ar(player, pan, env);
			OffsetOut.ar(out, panner);
	}).store;
	 
	 
	 //HIDDeviceServiceExt.buildDeviceList;
	//HIDDeviceServiceExt.queueDeviceByName('  USB  Joystick  ');
	// Look for the devices that are attached:
	GeneralHID.buildDeviceList;
	// Get the list of devices:
	//g = GeneralHID.deviceList;
	// Check which devices have been found:
	GeneralHID.postDevices;
	// Pick the 6th device and open it and create an instance of it:
	//j = GeneralHID.open( g[6] );
	//j.info;
	
	//j.info.name
	
	
	GeneralHID.deviceList.do({ arg dev, num;
	
		var name;
		
		name = dev.info.name;
		(name.contains("RumblePad")).if ({
		
			j = GeneralHID.open( dev);
		})
		
	});
	
	j.caps;
	
	
	joystick = j;

	// get joystick stuff setup while that goes;
	joystick.spec = IdentityDictionary[
   		// buttons
   		\b1->joystick.slots[1].at(1), \b2->joystick.slots[1].at(2), 
   		\b3->joystick.slots[1].at(3), \b4->joystick.slots[1].at(4), 
   		\b5->joystick.slots[1].at(5), \b6->joystick.slots[1].at(6), 
   		\b7->joystick.slots[1].at(7), \b8->joystick.slots[1].at(8),
   		\b9->joystick.slots[1].at(9), \b10->joystick.slots[1].at(10),    
   		\hat->joystick.slots[3].at(57),
   		// sticks
   		//left
   		\lx->joystick.slots[3].at(48), \ly->joystick.slots[3].at(49),
   		//right
   		\rx-> joystick.slots[3].at(50), \ry->joystick.slots[3].at(53),
  	]; 

	j = joystick;



)		



(

  var coin10p, coin50p, trunk2600, dtmfkey, operator, npa_codes, intl_codes, busy_signal, dial_tone,
  	pay_tone, confirmation_tone, ringback_tone, joystick, steps, dur, flag, drum_accents, cond;
  	 
  	 
  	 
  	 joystick = j;
	GeneralHID.startEventLoop(0.005);

//http://en.wikipedia.org/wiki/Red_box_%28phreaking%29
// In the UK, a 1000 Hz tone for 200 ms represents a 10p coin, 
// and 1000 Hz for 350 ms represents a 50p coin.

	coin10p = [1000, 0.2];
	coin50p = [1000, 0.35];
	trunk2600 = [2600, 0.4];
	pay_tone = [400, 0.125];  // divided by 10 for artistic reasons
	//confirmation_tone = [400, ]
	
	
	// The minimum duration of the tone should be at least 70 msec,
	dtmfkey = IdentityDictionary[
	
		\1-> [697, 1209],
		\2-> [697, 1336],
		\3-> [697, 1477],
		\4-> [770, 1209], 
		\5-> [770, 1336], 
		\6-> [770, 1477], 
		\7-> [852, 1209],
		\8-> [852, 1336], 
		\9-> [852, 1477], 
		\0-> [941, 1336],
		\star-> [941, 1209], 
		\pound-> [941, 1477], 
		\a-> [697, 1633],
		\b-> [770, 1633], 
		\c-> [852, 1633], 
		\d-> [941, 1633]
	];
	
	//Normally, the tone durations are on for 60ms, with 60ms of silence between digits. 
	//The 'KP' and 'KP2' tones are sent for 100ms. 
	// KP2 (ST2 in the R1 standard) was used for dialing internal Bell System telephone numbers.
	
	/*
	Once the far end sends the supervision flash, the user would use the blue box to dial a "Key Pulse" or "KP", the tone that starts a routing digit sequence, followed by either a telephone number or one of the numerous special codes that were used internally by the telephone company, then finished up with a "Start" or "ST" tone. At this point, the far end of the connection would route the call the way you told it, while the users end would think you were still ringing at the original number. KP1 is generally used for domestic dialing where KP2 would be for international calls.
	*/
	
	
	operator = IdentityDictionary[
		\1-> [700, 900],
		\2-> [700, 1100],
		\3-> [900, 1100],
		\4-> [700, 1300], 
		\5-> [900, 1300], 
		\6-> [1100, 1300], 
		\7-> [700, 1500],
		\8-> [900, 1500], 
		\9-> [1100, 1500], 
		\0-> [1300, 1500],
		\11-> [700, 1700],
		\12-> [900, 1700],
		\kp->  [1100, 1700],
		\kp2-> [1300, 1700],
		\st->  [1500, 1700]
	];
	
	npa_codes = [ 
		// a three digit are code (aka a NPA) comes before these codes
		[\1, \0, \0], 
		[\1, \0, \1], 
		[\1, \0, \2], 
		[\1, \0, \3], 
		[\1, \0, \4], 
		[\1, \0, \5], 
		[\1, \0, \6], 
		[\1, \0, \7], 
		[\1, \0, \8], 
		[\1, \0, \9], 
		[\1, \2, \1],
		[\1, \3, \1],
		[\1, \4, \1],
		[\1, \6, \1],
		[\1, \8, \1] // coin refund!
	];
	
	intl_codes = [
	
		[\9, \1, \4, \1, \5, \1], //incoming
		[\2, \1, \2, \1, \5, \1], //incoming
		// senders
		[\9, \1, \4, \1, \8, \2],
		[\2, \1, \2, \1, \8, \3],
		[\4, \1, \2, \1, \8, \4],
		[\4, \0, \7, \1, \8, \5],
		[\5, \1, \0, \1, \8, \6], //oakland!
		[\3, \0, \3, \1, \8, \7],
		[\2, \1, \2, \1, \8, \8]
	];
	
	// The frequencies were initially designed with a ratio of 21/19,
	busy_signal = [ 400, 0.375 ];
	dial_tone = [ 350, 440];
	
	ringback_tone = [ [ [400, 450], 0.4 ], [ \rest, 0.2], [ [400, 450], 0.4 ], [ \rest, 2.0] ];
	
	//In Australia and the UK, the standard ring cadence is 400 ms on, 200 ms off, 400 ms on, 2000 ms off. 


	
	// prepare some buffers, figure out beat sizes

	steps = 30.rrand(38);
	dur = 4 / steps;
	
	{
		b.do({arg bbuf;
			bbuf.beatlength = steps;
			bbuf.calc_grains_dur(dur/4);
		});
	}.fork;
	
	flag = true;
	
	// This piece is five minuts long, so let's pull the plug after 5
	
	Routine.new({ (5 * 60).wait; flag = false; "time's up!".postln; }).play;
	
	
	// ok let's make some sound	
	

	Pseq([
	
		// dial tone
		
		Pbind (

			\instrument, 	\teltone,
			\freq,		dial_tone,
			\dur,		Pseq([2 + 4.0.rand], 1)
		),
		
		// coins
		
		Pbind (
			\instrument, 		\teltone,
			[\freq, \dur],	Prout({
			
								var dur;
								
								(2 + 3.rand).do ({
								
									dur = 0.2.rrand(0.5);
								
									[coin10p, coin50p].choose.yield;
									[\rest, 0.0125].yield;
									pay_tone.yield;
									[\rest, 0.0125].yield;
									//[400, 0.125].yield; // pay tone?
									
									dur = 0.18.rrand(0.3);
									[\rest, dur].yield;
								});
								
								dur = 0.2.rrand(1.1);
								
								[dial_tone, dur].yield;
							})
			
			
			
						//	Prand([coin10p, coin50p, 
						//		[\rest, 0.7],
						//		[\rest, 0.5],
						//		[\rest, 0.6]], 7)
		),
		
		// pause
		
		//Pbind (
		//
		//	\freq,	\rest,
		//	\dur,	Pwhite([0.2, 1], 1)
		//),
		
		// dial
		
		Pbind (

			\instrument, 	\teltone,
			//\dur,		Pfunc({0.1.rrand(0.3)}),
			/*\key,		Pseq([\0, 
							Prand([\0, \1, \2, \3, \4, \5, \6, \7, \8, \9], 7)
							], 7),
			\freq,		Pfunc({ arg evt;
							dtmfkey.at(evt[\key]) }),*/
							
			[\freq, \dur],		Prout ({ arg evt;
			
							var keys, dial, button, dur;
							
							keys = [\0, \1, \2, \3, \4, \5, \6, \7, \8, \9];
							
							evt.dump; evt.array.postln;
							
							button = \0;
							dial = dtmfkey.at(button);
							dur = 0.11.rrand(0.2);
							button.post; dur.post; dial.postln;

							[dial, dur].yield;
							
							dur = 0.05.rrand(0.1);
							[\rest, dur].yield;
							
							7.do({
								
								button = keys.choose;
								dial = dtmfkey.at(button);
								dur = 0.07.rrand(0.2);
								button.post; dur.post; dial.postln;
								
								[dial, dur].yield;

								dur = 0.05.rrand(0.1);
								[\rest, dur].yield;
							});
							
							[\rest, 0.2].yield;
						})
								
			
		),		
		
		// ring back + 2600
		
		Pbind (
			\instrument, 		\teltone,
			[\freq, \dur],	Pseq([
								Pseq(ringback_tone, (2 + 2.rand)),
								trunk2600,
								[\rest, 0.2]
							], 1)
		),
		
		
		// and now the piece
		
		Ptpar([
			//ringing
			0, 	Pbind (
				\instrument, 		\teltone,
				[\freq, \dur],	Pseq(ringback_tone, 95)
				),
			// operator dialing
			1, Pbind (		
				\instrument, 		\teltone,
				[\freq, \dur],	Prout ({
									var button;
									
									/*82.do*/ {flag}.while ({
				
									[operator.at(\kp2), 0.1].yield;
									
									intl_codes.choose.do({ arg key;
									
										[\rest, 0.06].yield;
										[operator.at(key), 0.06].yield;
									});
									
									10.do({
									
										button = 
											[\0, \1, \2, \3, \4, \5, \6, \7, \8, \9].choose;
										
										[\rest, 0.06].yield;
										[operator.at(button), 0.06].yield;
									});
									
									[\rest, 0.06].yield;
									[operator.at(\st), 0.1].yield;
									
									[\rest, 1.82].yield;

									})
								})
				),
			// drum patterns
			
			8, Pseq([ // stick something after the drums
				Pbind(
				\instrument,		\plainBuf,
				//\amp,			0.19,
				//\dur,			Pseq([
				//					Pseq([
				//						Pseq([0.2485], 3), 
				//							0.249], 3),
				//					Pseq([
				//						Pseq([0.2485], 3),
				//						0.271], 1)
				//					], inf),  // * 16 adds up to 4
				[\bufnum, \amp, \dur, \freq],	Prout({
				
			var kick, hat, snare, click, tom, drumpats, currentpat, drums, result, repeats, rest,
				//steps, dur, //have moved outside this Prout
				accents, amp;

			kick = a[1].bufnum;  hat = a[2].bufnum;  snare = a[0].bufnum;  click = a[3].bufnum;  
				tom = a[4].bufnum;
			
			repeats = 8.rrand(10);  // number of times to repeat a pattern before swapping
			
			// what we need is the emergency addition of beats in case a loop is too sparse
			
			joystick.spec.at(\b6).action_({ |val|
				var value;
				value = val.value;
			
				(value == 1).if ({
				
					"adding beats".postln;

					drums = [kick, hat, snare, click, tom].scramble.copyRange(0, 1.rrand(4));
					drums.do({ arg drum;
				
						4.rrand(steps).do({
						
							result = steps.rand;
						
							currentpat = currentpat.add([result, drum]);
						})
					});
				});
			});
			
			// too many!  // drop a beat!
			joystick.spec.at(\b5).action_({ |val|
				var value;
				value = val.value;
			
				(value == 1).if ({
				
					"dropping ".post;
					currentpat.pop.postln;
				
				});
			});

		
			// let's keep the accents around	
			4.rrand(steps /2 ).do ({
				
				drum_accents = drum_accents.add(steps.rand);
			});

			// do the looping thing

			

			/*(80 / repeats).do*/ {flag}.while ({

				//currentpat = drumpats.choose;
				
				drums = [kick, hat, snare, click, tom].scramble.copyRange(0, 1.rrand(4));
				currentpat = [];
				
				drums.do({ arg drum;
				
					4.rrand(steps).do({
					
						result = steps.rand;
						
						currentpat = currentpat.add([result, drum]);
					})
				});
				
				drum_accents.do({ arg ac;
				
					currentpat = [[ac, drums.last]] ++ currentpat;
				});
				
				"new drum pat".postln;
				repeats.do({
				
					//currentpat.postln;
					steps.do ({ arg index;
	
						amp = 0.15;
						result = [];
						rest = \rest;
						drums = [];
						currentpat.do ({ arg val, num;
						
							//val.first
							if (val.first == index, {
								//val.last.postln;
								((drums.includes(val.last)).not). if ({
									drums = drums ++ val.last;
									rest = 440;
								}, { // kill the redundancy
								
									currentpat.removeAt(num);	
								})
							});
							
						});
						
						if ( drum_accents.includes(index), { amp = amp + 0.09; });
						
						[drums, amp, rest].postln;		
						[drums, amp, dur, rest].yield;
					});
				});
			});
			// we're done, so set the flag
			
			flag = false;
			
			})
			
		), // still in the drum Pseq
		Pbind(
		
			\instrument,		\grainBuf,
			\amp,			0.4,
			\rate,			1,
			[\bufnum, \dur, \grainDur, \startFrame, \freq],
							Prout({
								var activebuf;
								
								activebuf = b.choose;
					[activebuf.bufnum, activebuf.dur, activebuf.dur, 0, 440].yield;
							})
		)], 1), //end of drum pseq

		
		
		// busy signal
		
		16, Pbind (

				\instrument, 		\teltone,
				[\freq, \dur],	Pseq ([ Pseq([busy_signal, 
										[\rest, busy_signal.last]],6.rrand(8)),
									Prand([[\rest, 8], [\rest, 16], [\rest, 24]], 1)], 8 )
									
		),
		
		
		// telephone operator voice
		
		56, Pbind (
		
			\instrument,		\grainBuf,
			\amp,			0.4,
			\rate,			1,
			[\bufnum, \dur, \grainDur, \startFrame, \freq],
			
				Prout({
					
					var tick, repeats, accents, substeps, subdur, activebuf, stuttered,
						stutter_probability, overlap, stut, init_func, stutter_steps;
					
					init_func = { arg buf;
					
						// number of times to repeat a pattern before swapping
						repeats = 2.rrand(4);  
						
						// let's keep the accents around
											
						4.rrand(steps /4 ).do ({
				
							accents = accents.add(steps.rand);
						});
					
					
						// ok, now lets' keep the accents off of substeps
						accents = accents * 4;
						//accents = accents ++ drum_accents;
					
						stuttered = 0;
						
						activebuf = b.wrapAt(buf);
						
					};
					
					
					// because there are 4 substeps to a step
					substeps = steps * 4;
					subdur = dur /4;
					
					
					// init
					stuttered = 0;
					tick = 0;
					
					
					stutter_probability = 0.5; // let's try 50%
					overlap = 1.02;  // multiply the duration by
					
					
					// this will become a joystick function:
					
					activebuf = b.choose;
					init_func.value(3.rand);

					joystick.spec.at(\b1).action_({ |val|
						var value;
						value = val.value;
			
						(value == 1).if ({
				
							init_func.value(0)
							
						});
					});

					joystick.spec.at(\b2).action_({ |val|
						var value;
						value = val.value;
			
						(value == 1).if ({
				
							init_func.value(1)
							
						});
					});

					joystick.spec.at(\b3).action_({ |val|
						var value;
						value = val.value;
			
						(value == 1).if ({
				
							init_func.value(2)
							
						});
					});


					joystick.spec.at(\lx).action_({ |val|
					
						var value;
						
						value = val.value;
						
						stutter_probability = value;
						value.postln;
					});
					
					
					stutter_steps = CV.new.sp(2, 0, 5, 1, 'linear');
					
					joystick.spec.at(\rx).action_({ |val|
						var value;
						value = val.value;
						
						stutter_steps.input = value;
						stutter_steps.value.postln;
					});
						


					{flag}.while({
					
						(activebuf.notNil). if ({
							repeats.do({
					
								activebuf.grains.do({arg grain, index;
								
									(accents.includes(index)).if ({ // don't stutter
									
										stuttered = index;
										[grain.bufnum, subdur, subdur * overlap,
											grain.startFrame, 440].yield;
									} , {
									
										// can stutter
										stutter_probability.coin .if ({
										
											// will stutter
											stut = stuttered + stutter_steps.value.rand2;
											[activebuf.grains.wrapAt(stut).bufnum,
												subdur, subdur * overlap,
												activebuf.grains.wrapAt(stut).startFrame,
												440].yield;
										} , {
										
											// won't stutter
											stuttered = index;
											[grain.bufnum, subdur, subdur * overlap,
												grain.startFrame, 440].yield;
										});
									});
									tick = tick + 1;
								});
								
								
								{/*tick < substeps*/ (tick % substeps) != 0}.while({
								
									[0, subdur, subdur, 0, \rest].yield;
									tick = tick +1
								});
								tick = 0;
							});
							
							activebuf = nil;							

						}, {
							stuttered = 0;
							[0, dur, dur, 0, \rest].yield;
						
						});
					});
					
					activebuf = b.choose;
					//[activebuf.bufnum, activebuf.dur, activebuf.dur, 0, 440].yield;
					
				})
		),
		
		// bassline
		
			32, Pbind(	
				\instrument, 		\teltone,
				\amp,			0.18,
				\freq, 			Prout({
									var num, repeats;
									
									num = [\0, \0, \1, \4, \0, \8, \7, \2, \5,
											\0, \6, \4, \4]; 
											
									repeats = 8.rrand(10);
									
									{flag}.while({
									
										num = [
											[\0, \0, \1, \4, \0, \8, \7, \2, \5,
												\0, \6, \4, \4], // my childhood
											// other numbers redacted because they're still current
										].choose;
								
										repeats.do({
										
											num.do({ arg button;
												if (flag, {
												
												  (dtmfkey.at(button) / 8).yield;
												});
											});
										});
									});
								}), 
										
				\dur,			0.5
		)

		], 1 )
	], 1).play;
			
	

)	 
		
	

The very top part loads drum beat sounds and operator sounds. Below that are a bunch of SynthDefs. Many of them are not actually used. (I told you it was ugly.) Then some code related to my joystick. All of that code runs as one block. The variables whose names are single letters, a, b, c, etc are persistent across blocks, but the rest have a local scope.

The next block contains a whole lot of crap about telephone codes. Then we make some decisions about how many beats are going to be in a loop. The Buffers are divided into grains the size of 16th notes. (Which is to say, 4 grains to a beat.) Then comes the timing logic. Pbinds, Pseqs, etc, handle timing really well. So I've got some of them to do the straight telephony-sounding intro. Then, the drums come in. I haphazardly pick some beats which are accented. Those always have drum sounds on them and are hit harder. Then I randomly pick other beats and stick some drum sounds on them also. The rule of loopy dance music is that if you repeat something enough times, it starts to work by the sheer force of the repetition. That's the logic here. So play that a few times. Then switch it up with new drum sounds, but the same accents.

The next interesting thing is the operator voice. It comes in of it's own accord, but future instances of it are triggered with the joystick. The grains of the buffer can be shuffled. The parameters for this are controlled by the sticks on my gamepad. Accented beats are always played at the correct time. This effect would be more striking if the voice accents were actually in synch with the drum accents, but they're not. So the pattern is the same, but will probably be offset in time.

Finally the bassline (which is low sine tones. You won't hear it on your laptop's built-in speakers) is just phone numbers played at slow speed and shifted down by 3 octaves. I took some numbers out of the code above because I don't want folks calling up my friends and family.

The other numbers inside the piece were totally random. This turned out not to be the best idea. To me, it sounded fine, but I'm not a phreaker, so phone number tones are not as meaningful to me. To some folks in the audience, they could totally tell that numbers were not meaningful. Which is really awesome, actually, even though it's not great for this piece.

Every other week, I have to give myself an injection of testosterone. I find it really hard to actually pierce my flesh with a needle. It’s like stabbing myself. At the same time, having testosterone in my body is crucial to my identity.

About a month ago, I used a small digital camera and apple’s photobooth software to film myself from either side, trying to do the shot. The pressure was intense. The shot went terribly wrong. It took me forever to work up the nerve to actually push in the needle and when I did, I didn’t push it in far enough. The testosterone leaked back out of my leg through the puncture.

I created a soundtrack to this disaster using SuperCollider. The sound sources are my voice and de-tuned sine wave generators. The left and the right channels differ by 10 Hz. The sine waves move along a tuning lattice but with so much imprecision that the lattice becomes meaningless. Their timing is out of synch. Finally, a clock ticking sound comes in. How long has this been going on? How long have I been sitting here holding my needle? How long is this going to take me? How many more times will I have to go through with this?

Until the end of my life.

The video is created with Processing.org. Every time a new sound starts, the picture updates, but with a a lot of transparency, so time bleeds together and the images become blurry. I’d hoped that through the repetition of images that I experienced in making this piece, that doing the shot would become demystified and I would exorcise my demons. Did it work? I’ll tell you in two weeks.

Shot (2008)

Commissioned and titled by Josh Fruhlinger. (2007)

Josh gave me the title before I started the piece. Gil Thorp is the name of a surreal American newspaper comic which is supposed to be about high school sports. Josh runs a blog discussing newspaper comics, called the Comics Curmudgeon.

I recorded (British) football from my TV, which included my housemate clapping after a goal. Then, I decided to use white noise, because it’s very similar to crowd sounds. I filtered it a lot to make sort of screetchy sounds. The football announcers didn’t exactly have the accent that I would expect Marty Moon to have, so I kept them in the background. My girlfriend said that it struck her as very Mark Trail-like, so I raised the volume of the background at the end, to make the sports connection clearer.

Bird-like sounds remind me of high school sports, but that’s probably because my high school had a terrible seagull infestation.

I suspect this particular piece might get especially high traffic, so I made a little YouTube video to go with it, but feel free to grab the mp3 if you prefer.

Shorts #27: Gil Thorp (2007)

I used my cell phone to record Nicole clapping inside the cathedral in Breda, the Netherlands. There was an exceptionally long echo on her clap.

I used Audacity to snip out the impulse response from the recording and convolved it several times with the entire recording, using Sound Hack. My cell phone, unsurprisingly emphasizes high frequencies, so the last one I played at half speed to drop it an octave. I mixed these sounds together in Ardour.

The video was some weird cell phone format, which I converted with ffmpegX and then tweaked the speed by writing a little program in Processing. I mixed the whole thing together in iMovie.

That’s seven separate programs, not counting the ones I couldn’t get to work. Obviously, this is an experiment, but I’m looking forward to making more tiny movies.

Also, that sound you hear at the very end of the piece is from my dog barking her head off outside the cathedral. woof woof woof.

If you just want the audio: Clapping (2008)

Shorts: #25 Untitled

Commissioned and (un)titled by Scott Wilson

I talked today about whether or not he wanted to give me a title, and Scott noted that the piece has a “flatuent quality,” but it would be better to resist referencing that in a title.

To make this piece, I recorded myself playing a bovine signaling horn and a didjeridu, both of which I ran through a Sherman filterbank to use as FX. There’s also a little bit of feedback, especially the very last sounds. Processing a didgeridu turns out to be much more straightforward and easy than processing a cow horn. Something to keep in mind.