superdupercollider

Detuning oscillators.

2011-07-20T15:39:00.000-07:00

I'm still not entirely sure how PmonoArtic works, perhaps it will forever remain a mystery, but I do know how the important part of this synth def I came up with works. Well more or less anyway.

(
SynthDef("aSynth",{

 arg lagLev = 0.2, freq= 440, cutoff = 500, gate = 0.5;
 var osc1 = Mix.fill(8, { SinOsc.ar(freq + 10.0.rand, 0, 0.05) });     var filterEnv = EnvGen.ar(Env.adsr(0.02, 0.1, 0.05, 1), gate, doneAction:2);
 var filterOutput = MoogFF.ar(osc1, cutoff * filterEnv, 3.3);    Out.ar(0, filterOutput); 


}).store
)

(
PmonoArtic("aSynth",
 \freq, Pseq([440,330,440,330,550,770,880], inf),
 \legato, Pwrand(#[0.5, 1.0], #[0.1, 0.9], inf),
 \dur, 0.3,
 \cutoff, Pwhite(5000, 10000, inf)



).play
)

This is inspired by something I read on the SC Users list and it's an attempt at a synth that's more analoguesque. It didn't work quite as well as I had anticipated, so I think I'll have to try some more advanced techniques, but I suppose it's a start.

The significant bit is this line:

var osc1 = Mix.fill(8, { SinOsc.ar(freq + 10.0.rand, 0, 0.05) });

Here I'm using the Mix command along with fill to create an array of eight different oscillators all tuned slightly differently, randomly assigned plus or minus 10hz from the frequency passed to the sythdef. It's supposed to give it a vaguely chorus like effect by layering detuned oscillators, which it does a bit, but the effect isn't quite as noticeable as I thought. Increasing the number of oscillators doesn't help much and increasing the frequency that they can change by sounds pretty horrible.

The mix and fill commands are pretty simple to use, by the way.

On it's own you can use Mix.new(array) to mix an array of channels together, or you can use Mix.fill(n, function) to create a whole new array of channels with the function you specify.

I could be wrong, but I think that when you use Mix.fill in a synth def it will only evaluate the function when the synth is loaded, so if you're using random varaibles like I am above, they'll only be random once when it's run.

I've forgotten everything I ever learned about SuperCollider.

2011-07-05T14:36:00.000-07:00

It's been so long I'm not even sure how to spell SuperCollider anymore, I think it's two lls, but that looks wrong.

Several versions of SC have come out since I last used it and of course lots of the quarks and plugins I had from previous versions now no longer work, so I've had to start from scratch with a fresh install. This is probably no bad thing as it means I need to work from the ground up and remind myself how it all works.

I've done this before I think, but now it's time to do again, a SuperCollider Theramin, this time with a phase effect.

{SinOsc.ar(MouseY.kr(1,880),SinOsc.kr(MouseX.kr(0,100)))}.play

I'm still alive.

2011-04-20T13:08:00.000-07:00

I know it's been a very long time since I've updated this blog, but I'm still here and I think it's about time I started looking at Supercollider again. Watch this space.

'Harmoniser' with Tartini

2009-11-30T16:28:00.000-08:00

A little patch I made today following on from the auto chip tune stuff from before. This time a 'harmoniser' type effect made with the same Tartini type resynthesising, using a live input. I've got 'harmoniser' in inverted commas because frankly it isn't very harmonic, but it's a start I suppose. Here's the code.

(
SynthDef("Harm", {|offSet1, offSet2, output, osc1, osc2, mix, pitch1, pitch2, fader|

    var sound = SoundIn.ar;
    var pitch = Tartini.kr(sound)[0];
    var amp = Amplitude.ar(sound);
    pitch = Median.kr(5, pitch); // smooth
    pitch = pitch.min(10000).max(10); // limit
    pitch1 = pitch.cpsmidi.round + 40;
    pitch2 = pitch.cpsmidi.round + 60;
        
        pitch1 = pitch1.midicps;
    pitch2 = pitch2.midicps;        
    
    osc1 = Saw.ar(pitch1, amp * 2); // resynthesise
    osc2 = Pulse.ar(pitch2, 0.2, amp * 2);
    mix = Mix.ar([osc1, osc2]);
    fader = XFade2.ar(sound, mix, -0.5);
    output = FreeVerb.ar(fader, 0.3, 0.1, 0.9); // bit of reverb just to taste
    Out.ar(0, output);
    
    }).memStore;
    
    
)

x = Synth("Harm");

Here Im using Tartini to determine the pitch of the input, then using fairly roundabout method converting it to two lots of midi notes, adding to it to increase the pitch then sending it to some oscillators and finally mixing it back with the original input. If you change the numbers that I've added to the pitches here,

pitch1 = pitch.cpsmidi.round + 40;
pitch2 = pitch.cpsmidi.round + 60;

you should be able to change the 'harmony'.

There may be a better method to shift the synthesised pitches, I'm not sure but this does seem to work.
It sort of sound okay with some guitar or vocal input, but really bad with anything more complex.

Installing bbcut2 in OS X

2009-10-30T15:59:00.000-07:00

I've just upgraded to OS X Snow Leopard and apart from it giving me the ability to take up serpents, drink any deadly thing and not be hurt etc, I also found myself reinstalling SuperCollider from scratch, including all the extensions, quarks and what have you that I had in my previous install.
Everything went smoothly with the exception of bbcut, which took a bit of work. I had the same problem when I installed it the first time round, but I ended up taking such as circuitous route to getting it working that I couldn't remember what I'd done by the time I'd finished. This time I took a more systematic approach and I've isolated the problem.
The latest version of the extension pack provided with the standard SC install includes some, but not all of the Ugens and classes that come with bbcut. If you follow the install instructions that come with bbcut you'll end up with conflicts and the class library won't compile.
To get it to work you'll need to leave out the three ugens in the bbcut2 ugens folder and the machinelistening classes from the bbcut2 classes folder when moving the bbcut folders to your SC directory. These seem to be the source of the conflicts and if you copy over the rest of the files as described in the bbcut2 help file it should all be okay.
If you've already copied these into your SC folder you'll need to make sure you delete the version of the files that come with bbcut and replace the them with the versions that come with the standard SC download, they are different and only the ones from the standard SC download will work. And that's jazz.

I've no idea how this goes on other platforms but I imagine there might be similar problems.

à bientôt.

Wicki - not wiki

2009-10-18T16:34:00.001-07:00

Another soupçon of useful code from the SC-Users list, a Wicki keybord, as used by the Wicki system.
What's the Wicki system? I'm not entirely sure, but it seems to be a way of learning to play music with a type writer style keyboard. There's some background info available here and here.
This bit of code is a class that creates a Wicki keyboard, it is a bit long so I won't reproduce it on this blog, but you can download it here, along with a bit of test code. You can use the keyboard to record and playback sequences of notes, which are stored in an array, probably easier than typing frequencies or midi values directly into patterns and do things like transpose the entire sequence.
As with all SC classes you'll need to put it in the extensions folder and recompile the language before it'll work. The wickiTest file in the zip shows of some of the class methods, but it doesn't mention the startRecording and stopRecording methods. If you want to record an a array of notes you'll need to set it up by doing something like
m.startRecording
and then
m.stopRecording
when you're done.

From Den Haag

2009-10-03T16:59:00.000-07:00

Some great code from tn8, via the SC-Users list, the source code from a piece that she performed at the SC symposium. You can download it here.
It's a fantastic track and it's pretty rare to see the complete source for a song written entirely in SC, so it's worth a look.

Comb Filter Effect

2009-09-17T17:50:00.000-07:00

Another handy snippet of code pulled from the SC-Users list once again. Credit for this goes to Kernal, kernel@audiospillage.com.
The gui should be mostly self explanatory I think, but if you want to use this with other inputs besides the test sound you'll need to set the input bus and send your sound through that.


// parrallel comb filters implemented as effect return

// send the synth defs(
(
SynthDef("ImpulseTest", {|bus = 3|
       
       Out.ar(bus, [Impulse.ar(SinOsc.kr(0.23).range(0.5,23), 0.5)]);
       
}).send(s);
);

(
SynthDef("CombUnit",{|  d1 = 0.001, d2 = 0.001, d3 = 0.001, d4 = 0.001, d5 = 0.001,
                                       t1 = 1, t2 = 1, t3 = 1, t4 = 1, t5 = 1,
                                       f1 = 20000, f2 = 20000, f3 = 20000, f4 = 20000, f5 = 20000,
                                       vol = 1, inBus = 3, outBus = 0|
                                       
       var in, out, c1, c2, c3, c4, c5;

       in = In.ar(inBus, 1);

       c1 = LPF.ar(CombC.ar(in, 1, d1, t1), f1);
       c2 = LPF.ar(CombC.ar(in, 1, d2, t2), f2);
       c3 = LPF.ar(CombC.ar(in, 1, d3, t3), f3);
       c4 = LPF.ar(CombC.ar(in, 1, d4, t4), f4);
       c5 = LPF.ar(CombC.ar(in, 1, d5, t5), f5);
       
       out = (c1 + c2 + c3 + c4 + c5) * 0.2;
       
       Out.ar([outBus, outBus + 1], out * vol);

}).send(s);
);
)



// create the synth
(
       var grp, node, testNode, wComb, testRunning = 0, inputBus = 3;
       
       s.sendMsg("s_new", "CombUnit", node = s.nextNodeID, 1, 1);
       // s.sendMsg("g_new",grp = s.nextNodeID,1,1); // create group @ tail of default node
       
       wComb = SCWindow("C O M A", Rect(100, 300, 720, 220))
               .onClose_({
                       if(testRunning == 1, s.sendMsg("n_free", testNode));
                       s.sendMsg("n_free", node);
               })
               .front;
       
       // input bus
       SCNumberBox(wComb, Rect(10, 10, 30, 20))
               .value_(3)
               .action_({|v|
                       inputBus = v.value;
                       s.sendMsg("n_set", node, "inBus", inputBus);
                       if(testRunning == 0, s.sendMsg("n_set", testNode, "bus", inputBus));
               });
       
       SCStaticText(wComb, Rect(45, 10, 100, 20))
               .string_("Input Bus");
       
       // output bus
       SCNumberBox(wComb, Rect(150, 10, 30, 20))
               .value_(0)
               .action_({|v| s.sendMsg("n_set", node, "outBus", v.value)});
       
       SCStaticText(wComb, Rect(185, 10, 100, 20))
               .string_("Output Bus");
       
       // audio test
       SCButton(wComb, Rect(300, 10, 100, 20))
               .states_([
                       ["Start Test", Color.green, Color.black],
                       ["Stop Test", Color.red, Color.black]
               ])
               .action_({
                       if(testRunning == 0, {
                               s.sendMsg("s_new", "ImpulseTest", testNode = s.nextNodeID, 0, 1, "bus", inputBus);
                               testRunning = 1;
                       },{
                               s.sendMsg("n_free", testNode);
                               testRunning = 0;
                       });
               });
       
       // comb frequencies
       SCStaticText(wComb, Rect(10, 40, 100, 20)).string_("Comb Frequencies");
       5.do{|i|
               var box;
               
               box = SCNumberBox(wComb, Rect(10, 60 + (i * 25), 40, 20))
                       .value_(950);
                       
               SCStaticText(wComb, Rect(55, 60 + (i * 25), 15, 20)).string_("Hz");
               
               SCSlider(wComb, Rect(80, 60 +  (i * 25), 130, 20))
                       .value_(0.5)
                       .action_({|v| var time, freq;
                               freq = [1, 20000, 6].asSpec.map(v.value);
                               time = 1.0 / freq;
                               s.sendMsg("n_set", node, i, time);
                               box.value_(freq.asInteger);
                       })
       };
       
       // resonances
       SCStaticText(wComb, Rect(250, 40, 100, 20)).string_("Resonances");
       5.do{|i|
               var box;
               
               box = SCNumberBox(wComb, Rect(250, 60 + (i * 25), 30, 20))
                       .value_(50);
                       
               SCStaticText(wComb, Rect(285, 60 + (i * 25), 15, 20)).string_("%");
               
               SCSlider(wComb, Rect(300, 60 + (i * 25), 150, 20))
                       .value_(0.5)
                       .action_({|v|
                               s.sendMsg("n_set", node, i+5, [0, 9, 4].asSpec.map(v.value));
                               box.value_(v.value * 100);
                       });
       };
       
       // low pass frequencies
       SCStaticText(wComb, Rect(555, 40, 100, 20)).string_("Low Pass Frequencies");
       5.do{|i|
               var box;
               
               box = SCNumberBox(wComb, Rect(490, 60 + (i * 25), 40, 20)).value_(20000);
               SCStaticText(wComb, Rect(535, 60 + (i * 25), 15, 20)).string_("Hz");
               
               SCSlider(wComb, Rect(555, 60 + (i * 25), 150, 20))
                       .value_(1)
                       .action_({ |v| var freq;
                               freq = [20, 20000, \exp].asSpec.map(v.value);
                               s.sendMsg("n_set", node, i+10, freq);
                               box.value_(freq);
                       });
       };
       
       // volume control
       SCStaticText(wComb, Rect(10, 190, 70, 20)).string_("Volume");
       SCSlider(wComb, Rect(80, 190, 625, 20))
               .value_(1)
               .action_({|v| s.sendMsg("n_set", node, "vol", [0, 1, 4].asSpec.map(v.value))});
)

More 140 character SuperCollider Tweets

2009-08-21T14:58:00.000-07:00

Even SuperCollidists aren't immune to the memetic allure of Twitter, there's been a whole load of 140 character SuperCollider programmes appearing both on Twitter and on the SC Users list. Thankfully someone has been kind enough to collect them all up and put them on this page here, at the SC Wiki. Smashing.

Here's a couple of my favorites,

from Fredrik Olofsson

{RHPF.ar(GbmanN.ar([2300,1150]),LFSaw.ar(Pulse.ar(4,[1,2]/8,1,LFPulse.ar(1/8)/5+1))+2)}.play

And from the Venerable Dan

{LocalOut.ar(a=DynKlank.ar(`[LocalIn.ar.clip2(LFPulse.kr([1,2,1/8]).sum/2)**100*100],Impulse.ar(10)));HPF.ar(a).clip2!2}.play//#supercollider

Recreating the THX sound

2009-08-09T14:45:00.000-07:00

In a similar vein to the recreation of the rave hoover here's another reverse engineer and recreation of a famous sound, the tooth shattering TXH Deep Note. You can read the full story on EarSlap, but here's the final code.

//inverting init sort, louder bass, final volume envelope, some little tweaks

(

{

var numVoices = 30;

var fundamentals = ({rrand(200.0, 400.0)}!numVoices).sort.reverse;

var finalPitches = (numVoices.collect({|nv| (nv/(numVoices/6)).round * 12; }) + 14.5).midicps;

var outerEnv = EnvGen.kr(Env([0, 0.1, 1], [8, 4], [2, 4]));

var ampEnvelope = EnvGen.kr(Env([0, 1, 1, 0], [3, 21, 3], [2, 0, -4]), doneAction: 2);



var snd = Mix

({|numTone|



    var initRandomFreq = fundamentals[numTone] + LFNoise2.kr(0.5, 6 * (numVoices - (numTone + 1)));

    var destinationFreq = finalPitches[numTone] + LFNoise2.kr(0.1, (numTone / 3));

    var sweepEnv =

        EnvGen.kr(

            Env([0, rrand(0.1, 0.2), 1], [rrand(5.5, 6), rrand(8.5, 9)],

                [rrand(2.0, 3.0), rrand(4.0, 5.0)]));

    var freq = ((1 - sweepEnv) * initRandomFreq) + (sweepEnv * destinationFreq);



    Pan2.ar

    (

        BLowPass.ar(Saw.ar(freq), freq * 6, 0.6),

        rrand(-0.5, 0.5),

        (1 - (1/(numTone + 1))) * 1.5

    ) / numVoices

}!numVoices);



Limiter.ar(BLowPass.ar(snd, 2000 + (outerEnv * 18000), 0.5, (2 + outerEnv) * ampEnvelope));

}.play;

)

Apparently the original took 20,000 lines of C code! This is a tad more efficient and sounds very close to the original.

Auto chiptunes with Moog

2009-07-25T17:45:00.000-07:00

Wow, it's been a while since I've posted, but It's been a busy month.
Here's an update to Dan's auto chiptune thing that I modified in my last post. This time I decided to mate it with my Moog synthdef in an attempt to create a pitch tracking interface for my synth. Surprisingly it works pretty well.

(
SynthDef("chiptune", { |oscType =0, oscType2 = 1, pan = 0, level = 0.5, cutoff = 500, gain = 3.3, attack = 0.1, decay = 0.1, sust = 0.7, rel = 0.2, attackf = 0.1, decayf = 0.1, sustf = 0.9, relf = 0.2, gate = 1, freq =440, lagLev = 0.2|
    var son, pitch, amp, wibble, oscArray, oscArray2, ampEnv, filterEnv, osc1, osc2, fade, filter;
    son = SoundIn.ar;
    pitch = Tartini.kr(son)[0];
    amp = Amplitude.ar(son);
    pitch = Median.kr(5, pitch); // smooth
    pitch = pitch.min(10000).max(10); // limit
    pitch = pitch.cpsmidi.round.midicps; // coerce
    
    oscArray = [Saw.ar(Lag.kr(pitch, lagLev)), SinOsc.ar(Lag.kr(pitch, lagLev)), Pulse.ar(Lag.kr(pitch, lagLev))];
    oscArray2 = [Saw.ar(Lag.kr(pitch, lagLev)), SinOsc.ar(Lag.kr(pitch, lagLev)), Pulse.ar(Lag.kr(pitch, lagLev))];
    ampEnv = EnvGen.ar(Env.adsr(attack, decay, sust, rel), gate, doneAction:2);
    filterEnv = EnvGen.ar(Env.adsr(attackf, decayf, sustf, relf), gate, doneAction:2);
     osc1 = Select.ar(oscType, oscArray);
     osc2 = Select.ar(oscType2, oscArray2);
    fade = Pan2.ar(XFade2.ar(osc1, osc2, pan , level * ampEnv, 0));
    filter = MoogFF.ar(fade, cutoff * filterEnv, gain);   
     wibble = FreeVerb.ar(filter, 0.3, 0.1, 0.9); // bit of reverb just to taste
    Out.ar(0, wibble.dup);
}).memStore;
)

Auto Chiptune

2009-07-05T16:39:00.000-07:00

A while ago now Dan posted some auto chip tune generating code on his blog, I've been meaning to write about this for ages, but I've only just got round to it. It takes any MP3 file and converts it to chiptune like sounds by using Tartini to follow the pitch and then re synthesising with a pulse wave. Here's the original code as taken from his blog.

s.boot;
(
SynthDef("help_mp3_01", { |bufnum = 0|
    var son, pitch, amp, wibble;
    son = DiskIn.ar(2, bufnum).mean;
    pitch = Tartini.kr(son)[0];
    amp = Amplitude.ar(son);
    pitch = Median.kr(5, pitch); // smooth
    pitch = pitch.min(10000).max(10); // limit
    pitch = pitch.cpsmidi.round.midicps; // coerce
    wibble = Pulse.ar(pitch, 0.2, amp * 2); // resynthesise
    wibble = FreeVerb.ar(wibble, 0.3, 0.1, 0.9); // bit of reverb just to taste
    Out.ar(0, wibble.dup);
}).memStore;
)

// Now let's create the MP3 object and cue it into a Buffer.
m = MP3("../mp3s/Gimme A Pig Foot And A Bottle Of Beer.mp3");   
m.start;
b = Buffer.cueSoundFile(s, m.fifo, 0, 2);
// Off we go:
x = Synth("help_mp3_01", [\bufnum, b.bufnum], addAction:\addToTail);

// Please remember to tidy up after yourself:
x.free;
b.close; b.free;
m.finish;

Just for the hell of it I decided to adapt it to use live audio input and give it three different oscillators to choose from. Here's my version, you can change the oscillator with the \oscType parameter.

(
SynthDef("chiptune", { |oscType = 0|
    var son, pitch, amp, wibble, oscArray;
    son = SoundIn.ar;
    pitch = Tartini.kr(son)[0];
    amp = Amplitude.ar(son);
    pitch = Median.kr(5, pitch); // smooth
    pitch = pitch.min(10000).max(10); // limit
    pitch = pitch.cpsmidi.round.midicps; // coerce
    oscArray = [Pulse.ar(pitch, 0.2, amp * 2), SinOsc.ar(pitch, 0, amp * 2), Saw.ar(pitch, amp * 2)];
    wibble = Select.ar(oscType, oscArray); // resynthesise
    wibble = FreeVerb.ar(wibble, 0.3, 0.1, 0.9); // bit of reverb just to taste
    Out.ar(0, wibble.dup);
}).memStore;
)


// Off we go:
x = Synth("chiptune", [\oscType, 1], addAction:\addToTail);

// Please remember to tidy up after yourself:
x.free;

sounds pretty good with guitar.

SuperCollider 3.3.1 is out - Safari 4 fix.

2009-06-25T17:03:00.001-07:00

SuperCollider 3.3.1 is out now and it works with Safari 4! I don't know about you but that's a weight off my mind.

A Generative Looper.

2009-06-18T15:16:00.000-07:00

What's a generative looper? It's a type of cartilaginous fish, but it's also a interesting new project from Arthur Carabot, via the SC Users list. Here's the source and here's an intructional video.
I can't get it to work at the moment but maybe it's just me.

More Dominator Deconstruction.

2009-06-16T16:25:00.000-07:00

Another attempt at the rave hoover sound, this time from Wouter Snoei on the SC-Users list, probably the best so far and based on further research into the Alpha Juno 2. Here's the code,

(
SynthDef( "hoover", { |freq = 220, amp = 0.1, lgu = 0.1, lgd = 1, gate = 1|
var pwm, mix, env;

freq = freq.cpsmidi.lag(lgu,lgd).midicps;
freq = SinOsc.kr( { 2.9 rrand: 3.1 }!3, {2pi.rand}!3 ).exprange( 0.995, 1.005 ) * freq;
pwm = SinOsc.kr( {2.0 rrand: 4.0}!3 ).range(0.125,0.875);

// the saw/pulses
mix = (LFSaw.ar( freq * [0.25,0.5,1], 1 ).range(0,1)
               * (1 - LFPulse.ar(freq * [0.5,1,2], 0, pwm))).sum * 0.1;

// the bass
mix = mix + LFPar.ar( freq * 0.25, 0, 0.1 );

// eq for extra sharpness
mix = BPeakEQ.ar( mix, 6000, 1, 3 );
mix = BPeakEQ.ar( mix, 3500, 1, 6 );

// kind of chorus
mix = mix + CombC.ar( mix.dup, 1/200,
                       SinOsc.kr( 3, [0.5pi, 1.5pi] ).range(1/300,1/200),
               0.0 ) * 0.5;

env = EnvGen.kr( Env.asr, gate );

Out.ar( 0, mix * env * amp );
}).store;
)

(
p = Pmono(\hoover,
               \dur, Pseq([0.25,0.5,7, 0.25]* 0.24, inf),
               \lgu, 0.15,
               \lgd, Pseq([ 0.1, 0.1, 1.5, 0.25], inf ),
               \midinote, Pseq([20, 67, 62, 20] , inf)).play;
)
p.stop;

(
p = Pmono(\hoover, \dur, 0.24,
       \lgu, 0.2,
       \lgd, Pseq([1,1,2,0.5,2,2,2,2], inf ),
        \midinote, Pseq([55, 40, 67, 55, 40, 55, 53, 52], inf)).play;
)
p.stop;

Wouter's come up with a more accurate version of the pulse width modulation, certainly more accurate than my complete guess work and it sounds great.

Here's a little line of code taken from Wouter's post that may offer a bit of an explaination of what's going on with the modulation.

{ LFSaw.ar( 200, 1 ).range(0,1) * (1-LFPulse.ar( 400, 0, 2/3 )) }.plot;

If you run it you should get this plot,

You can see the waveform is a sort of flattened saw wave, this might explain why Dan had trouble identifying what it was.

Deconstructing the Dominator

2009-06-14T16:30:00.001-07:00

Dan's got a post over on his blog about reverse engineering the "hoover sound' found in the old school rave classic Dominator by Human Resource. He took a pretty technical approach and did various forms of analysis to come up with something that sound pretty good.
I thought I'd have a go myself, but I decided to take a more direct approach and look it up. I found this wikipedia article about it, it turns out that Human Resource were using a Roland Alpha Juno 2 to create that sound, a mid 80's digital/analogue hybrid synth. There's a good explanation of it's features here, importantly though, it does have a chorus unit built in, which Dan did identify as being the key feature of the sound.

Here's my re-construction attempt, I did start out to try and recreate the functions of an Alpha Juno 2, but in the end I mostly just improvised.

(
SynthDef(\aj2, {
arg freq = 440, gate = 1, lagLev = 0.01, predelay=0.01, speed=0.05, depth=0.01, ph_diff=0.5;
 var width1, width2, width3, osc1, osc2, osc3, filterOut, mix, sig, modulators, numDelays = 8, lfo; 
 width1 = SinOsc.ar(4, 0, 0.8, 0.2).abs;
 width2 = SinOsc.ar(6, 0, 0.8, 0.2).abs;
 width3 = SinOsc.ar(2, 0, 0.8, 0.2).abs;
 lfo = SinOsc.kr(5, 0, 5);
 osc1 = Pulse.ar(Lag.kr(freq + lfo), width1);
 osc2 = Pulse.ar(Lag.kr((freq/2) + lfo), 0.5);
 osc3 = Pulse.ar(Lag.kr((freq*2) + lfo), width3);
 mix = Mix.new([osc1, osc2, osc3]);
 modulators = Array.fill(numDelays, {arg i;
          SinOsc.kr(speed * rrand(0.94, 1.06), ph_diff * i, depth, predelay);}); 
    sig = DelayC.ar(mix, 0.5, modulators);  
    sig = sig.sum; 
    Out.ar(0, sig.dup)
}).store
)

p = Pmono(\aj2, \dur, 0.24, \midinote, Pseq([40, 67, 64, 62, 62, 62, 62, 62], inf)).play;

I've got three pulse width modulated square wave oscillators here, modulated with low frequency SinOscs and some vibrato added with another low frequency SinOsc. These are put through a chorus efect taken from the ixi-audio.com tutorial, featured here before.

My patch is mostly based on random guesswork and a little bit of research, but it sounds okay, though probably not as good as Dan's scientific attempt.

2 channel bitcrusher

2009-06-08T13:35:00.000-07:00

A small update to my bitcrusher plugin, duplicating the bitchrushed output for 'stereo'. The old version had only 1 channel output, which was to be expected as the input was only 1 channel, but this meant that in Garageband at least the signal was just one channel of a 2 channel track. In effect that the signal was panned all the way to the left with no way of centering it, duplicating the output works round this.




( var name, func, specs, componentType, componentSubtype, builder;

name = "Decimator"; // name of your plugin
func =  {
     | sampleRate,  bitRate|
     
     var decOut, in;
    
    in = AudioIn.ar([1]);  //Input from AU  host
    
    decOut = Decimator.ar(in, sampleRate , bitRate).dup;
    

    Out.ar([0,1], decOut);//Output to AU host
};

specs =  #[ 
    [0, 20000 , \Linear, 10000,\Hertz ] ,
    [0, 16 , \Linear, 8,\Indexed ] 
];    
    
    


componentType = \aufx;
    
    

componentSubtype = \DECI; 


builder = AudioUnitBuilder.new(name, componentSubtype,func, specs, componentType);




builder.makeInstall; 

)

Hadron

2009-05-31T17:20:00.000-07:00

Anonther intersting new quark,Hadron is a graphical patching environment for use in SC. Looks a bit like it may cover some of the same ground as TeaTracks, featured here previously, but I haven't used it yet. There is a very handy instructional video, which is allways nice.

Simple Phaser effect.

2009-05-19T16:45:00.000-07:00

Another guitar effect, but also suitable for other things, a simple phaser. This example was adapted from the truly fantastic ixi-audio SuperCollider tutorial.

(
SynthDef(\phaser, { arg out=0, in=0; 

    var input,dsig, mixed;
    input = SoundIn.ar(in, 1);
    
    dsig = AllpassL.ar(input, 4, SinOsc.ar(2, 0, 0.005, 0.005), 0);
    mixed = input + dsig;
    Out.ar([out, out+1], mixed);
}).load(s);
)

a = Synth(\phaser, addAction:\addToTail)

Very similar to flange, but with a shorter delay time and no feedback, it's got a more otherworldly sound.

Creating plugins with SuperCollider AU

2009-05-12T15:56:00.000-07:00

SuperColliderAU is an AudioUnit wrapper that allows you to embed a SuperCollider server in a AU host and either control it through SClang or package it up as a stand alone plugin.
It is of course OS X only being based around Apples AU API and there are some limitations to what you can do with it. According to the SourceForge page activity on this project seems to have stalled a bit, but it's pretty usuable in it's current state. It is possible to create effects units, but instruments with midi support don't seem to work very well. I've strugled to get anything to happen with Garage Band as a host at least, but that could just be me.
To install it you'll need to follow the instructions provided on the readme, it's very simple, just adding the main class and the server to the relevant directories, then recompile the lang and you're ready to go.
I decided to use it to create a bitcrushing plugin, making use of the Decimator Ugen, featured here before. The code is really simple, here it is.




( var name, func, specs, componentType, componentSubtype, builder;

name = "Decimator"; // name of your plugin
func =  {
     | sampleRate,  bitRate|
     
     var decOut, in;
    
    in = AudioIn.ar([1]);  //Input from AU  host
    
    decOut = Decimator.ar(in, sampleRate , bitRate);
    

    Out.ar(0, decOut);//Output to AU host
};

specs =  #[ 
    [0, 20000 , \Linear, 10000,\Hertz ] ,
    [0, 16 , \Linear, 8,\Indexed ] 
];    
    
    


componentType = \aufx;
    
    

componentSubtype = \DECI; 


builder = AudioUnitBuilder.new(name, componentSubtype,func, specs, componentType);




builder.makeInstall; 

)

There's a function, this is the code that the server will execute when it's embeded in the AU host, there's an array of specs that described the units, range and presets for the GUI control and a builder command that takes the relevant arguments and packages up the plugin.
The function is a very simple effect patch that takes the audio in from the AU host, decimates it and sends it to the output. The help file is a bit vague about this, but I assume that the relevant audio bus used for input from the AU host is 1, and that it needs to be sent out through 0, this is what seems to work anyway.
After that there's the control spec array, this is slightly different from the standard SC spec, but it is explained in the help file fairly well. It contains the range of values, the type and the default setting. In this case I've st up two suitable sliders to control the bit rate and sample rate, I selected index as the type for the bit rate as this gives an integer.
The builder command takes the name of the plugin, a component subtype, basically a unique identifier for the plugin, the function to be used, the spec and the component type, in this case an audio effect unit.
All being well, when this could runs it should create a plugin in the SuperCollider_f/scaudk folder, which can then be loaded into your AU host.

Here's the final product ready rolled.
It you want to gove it a try it should be fairly self explanatory, but I can't guarantee compatabilty with all AU hosts.

Guitar effects

2009-05-09T15:37:00.000-07:00

I've concentrated mostly on synthesis so far with my SuperCollider experiments, but today for a change I've been trying out some audio prosessing with a live input, my guitar.

To get a Mic or line input in SC you have several options, but using a SoundIn Ugen seems to be the easiest. SoundIn is a wrapper for the standard In Ugen, but it makes thigs easier by offsetting the bus index so that the first audio input is always 0. Setting up audio in in SuperCollider can be a bit of a chore, so check the help file if you can't fathom how input works.

Let's start with distortion, there's loads of ways of doing this,

{SoundIn.ar(0).fold2(0.3)}.play

using fold2 works well, as does clip

{SoundIn.ar(0).clip2(0.3)}.play

and there's also the obviously titled distort

{SoundIn.ar(0).distort}.play

The effect of this sems to be fairly subtle though. Making better use of it is this SynthDef, which comes from the Pfx help file, last used with my drum machine.

SynthDef(\distort, { arg out=0, pregain=40, amp=0.2, gate=1;

var env;

env = Linen.kr(gate, 0.05, 1, 0.1, 2);

XOut.ar(out, env, (SoundIn.ar(out, 2) * pregain).distort * amp);

}, [\ir, 0.1, 0.1, 0]).store;

You'll need to use a line like this to set the synth up.

a = Synth(\distort, addAction:\addToTail)

and if you're feeling like Alec Empire you can't beat a bit of bitcrushing for uttlerly insane fuzz.

{Decimator.ar(SoundIn.ar(0), 10000, 1)}.play

FreeVerb is an excellent choice for reverb,

{FreeVerb.ar(SoundIn.ar(0).distort)}.play

but something like flange is more difficult. This example is taken from the ixi-audio tutorial from ixi-audio.com, very slightly adapted to fit my audio input busses.

A flange effect adds a continually varying delayed signal to the original creating a phasing effect. The AllpassL in this case is the delay, with the LFpar UGen controlling the delay time, which is then mixed with the original input.

*/



(
SynthDef(\flanger, { arg out=0, in=0, delay=0.1, depth=0.08, rate=0.06, fdbk=0.0, decay=0.0; 

    var input, maxdelay, maxrate, dsig, mixed, local;
    maxdelay = 0.013;
    maxrate = 10.0;
    input = SoundIn.ar(in, 1);
    local = LocalIn.ar(1);
    dsig = AllpassL.ar( // the delay (you could use AllpassC (put 0 in decay))
        input + (local * fdbk),
        maxdelay * 2,
        LFPar.kr( // very similar to SinOsc (try to replace it) - Even use LFTri
            rate * maxrate,
            0,
            depth * maxdelay,
            delay * maxdelay),
        decay);
    mixed = input + dsig;
    LocalOut.ar(mixed);
    Out.ar([out, out+1], mixed);
}).load(s);
)

After evaluating that SynthDef you'll need to set up an instance of the synth and set the audio in like this,

a = Synth(\flanger, [\in, 0], addAction:\addToTail)

you can then set the various parameters of the effect like this.

a.set(\delay, 0.04)
a.set(\depth, 0.04)
a.set(\rate, 0.01)
a.set(\fdbk, 0.08)
a.set(\decay, 0.01)

.

Crushing the Bits for Fun and Profit

2009-05-02T17:25:00.000-07:00

Bitcrushing, reducing the sample and bit rate of audio for effect was invented by audio pioneer Bit Crusher in the early 80's and is pretty easy to implement in SuperCollider.
There are a few ways of doing it, but probably the easiest is to use the ladspa plugins that are part of the Standard SC plugin pack.
There don't seem to be any help docs with these plugins, but they aren't too hard to work out.
For now I'm using Decimator, which looks a bit like this,

Decimator.ar(in, rate, bits, mul, add )

It takes audio in, and the new sample rate and bit depths you want to use, as well as the standard mul and add args.

Here's my faithful drum machine yet again, this time with some bitcrushing.

(
SynthDef(\drums, {|out = 0, bassLevel = 0 , snareLevel = 0, hatLevel = 0, tomLevel = 0, pan1 = -1, pan2 = -1, pan3 = 1, pan4 = 1|

    var  env1, env2, env3, env4, bass, snare, hat, tom, bassOut, snareOut, hatOut, tomOut, mixer; 
    env1 = EnvGen.kr(Env.perc(0.001, 0.2, 1, -4), 1, doneAction:2);
    env2 = EnvGen.kr(Env.perc(0.001, 0.5, 1, -1), 1, doneAction:2);
    env3 = EnvGen.kr(Env.perc(0.002, 0.3, 1, -2), 1, doneAction:2);
    env4 = EnvGen.kr(Env.perc(0.001, 0.1, 1, -5), 1, doneAction:2);    
    bass = SinOsc.ar(80) + Crackle.ar(1, 0.5);
    bassOut = Pan2.ar(bass*env1, pan1, bassLevel);
    
    snare = SinOsc.ar(120) - WhiteNoise.ar(0.5, 0.5);
    snareOut = Pan2.ar(snare*env4, pan2, snareLevel);    
    
    hat = Klank.ar(`[ [ 6563, 9875 ],
               [ 0.6, 0.5 ],
               [ 0.002, 0.003] ], PinkNoise.ar(1));    
    hatOut = Pan2.ar(hat*env3, pan2, hatLevel);    
    
    tom =  SinOsc.ar(440); 
    tomOut = Pan2.ar(tom*env4, pan4, tomLevel);    
    
    mixer = Mix.new([bassOut, snareOut, hatOut, tomOut]); 
    
    
    Out.ar(out, mixer);
    
    }).store
    
    )
           
    

    (
        SynthDef("bitcrush", { arg out;      
    var audio, efx, f;
        
    audio = In.ar(20,2);
    efx=  Decimator.ar(audio, SinOsc.ar(0.05, 0, 9000, 1000).abs, 1);    
    Out.ar(out, efx);
}).memStore;               
          )
      
     (          
     a = Synth.after(1, "bitcrush");     
      )    
          
          
          (
               
               
  

    a = Pseq  ([1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0]);
    b = Pseq  ([0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0]);
    c = Pseq  ([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0]);
    d = Pseq  ([0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1]);    
    e = Pwhite (0.14, 0.16, inf);
    
    p = Pbind(
       \instrument, \drums,
       \out, [20],
      \dur, e,
       \bassLevel,  Pseq ([a], inf), 
       \snareLevel, Pseq ([b], inf),
       \hatLevel,   Pseq ([c], inf),       
       \tomLevel,   Pseq ([d], inf)
                             
                       ).play;
                       
     
            )

This uses the same method that I used previously to add an effect to a pattern, sending the output of the pattern to the bitcrusher through a bus, and making sure the order of execution is correct the with Synth.after method.
I'm using a sin oscillator to modulate the sample rate, varying it between 1000 and 10000 and using a .abs method to make sure it doesn't go negative, because negative sample rates don't work.
At lower bit rates and depths it's got a very 8-bit sound not unlike the ZX Spectrum beeper.
Buzzy.

Daily Coding

2009-04-30T14:42:00.000-07:00

In interesting experiment from Fredrik Olofsson, a daily coding challenge. He's been creating new SuperCollider code every day in April, all based around the same synthdef, battling Marcus Fjellström who has been doing the same thing on his blog here.

Dedication.

Tea Tracks

2009-04-29T10:38:00.000-07:00

TeaTracks is a multitrack sequencer for Supercollider designed by Jan Trutzschler. If like me you're wondering how a sequencer actually slots into SuperCollider, fear not, because Dan has displayed the will of the warrior and created this intro video hosted here on archive.org .
Smashing.

DX-7 and Optimisation

2009-04-24T08:58:00.000-07:00

A couple of things -

Discovered via Fredrik Olofsson's blog, stefan kersten's FM7 plugin. Presumably inspired by the DX-7, it's a Ugen with a bank of 6 phase modulated oscillators. Looks like fun, and if I can fathom the help file I think I'm going to do someting with it.

Also, discovered via SC Users, this handy page about optimisation.
Speedy.

Pattern FX with Pfx

2009-04-16T15:31:00.000-07:00

It's time to bring out my drum machine again. I've done effects with it before, but this is a new method, slightly more intuitive as you don't need to mess about with busses, it's all handled by the patterns.

(
SynthDef(\drums, {|out = 0, bassLevel = 0 , snareLevel = 0, hatLevel = 0, tomLevel = 0, pan1 = -1, pan2 = -1, pan3 = 1, pan4 = 1|

    var  env1, env2, env3, env4, bass, snare, hat, tom, bassOut, snareOut, hatOut, tomOut, mixer; 
    env1 = EnvGen.kr(Env.perc(0.001, 0.2, 1, -4), 1, doneAction:2);
    env2 = EnvGen.kr(Env.perc(0.001, 0.5, 1, -1), 1, doneAction:2);
    env3 = EnvGen.kr(Env.perc(0.002, 0.3, 1, -2), 1, doneAction:2);
    env4 = EnvGen.kr(Env.perc(0.001, 0.1, 1, -5), 1, doneAction:2);    
    bass = SinOsc.ar(80) + Crackle.ar(1, 0.5);
    bassOut = Pan2.ar(bass*env1, pan1, bassLevel);
    
    snare = SinOsc.ar(120) - WhiteNoise.ar(0.5, 0.5);
    snareOut = Pan2.ar(snare*env4, pan2, snareLevel);    
    
    hat = Klank.ar(`[ [ 6563, 9875 ],
               [ 0.6, 0.5 ],
               [ 0.002, 0.003] ], PinkNoise.ar(1));    
    hatOut = Pan2.ar(hat*env3, pan2, hatLevel);    
    
    tom =  SinOsc.ar(440); 
    tomOut = Pan2.ar(tom*env4, pan4, tomLevel);    
    
    mixer = Mix.new([bassOut, snareOut, hatOut, tomOut]); 
    
    
    Out.ar(out, mixer);
    
    }).store
    
    )

Pfx, or at least it's near relation Pfxb, is currently being debated on the SC Users list so some people might be having problems with it. It seems to work fine for me with OS X, but I think it's a pretty new feature so you might need the latest SuperCollider release candidate if you want to give it a try.

This code is very closely adapted from the Pfx help file, all I've really done is bodge my drum machine sythdef onto it, but it works very well.

(
SynthDef(\echo, { arg out=0, maxdtime=0.2, dtime=0.2, decay=2, gate=1;
var env, in;
env = Linen.kr(gate, 0.05, 1, 0.1, 2);
in = In.ar(out, 2);
XOut.ar(out, env, CombL.ar(in * env, maxdtime, dtime, decay, 1, in));
}, [\ir, \ir, 0.1, 0.1, 0]).store;

SynthDef(\distort, { arg out=0, pregain=40, amp=0.2, gate=1;
var env;
env = Linen.kr(gate, 0.05, 1, 0.1, 2);
XOut.ar(out, env, (In.ar(out, 2) * pregain).distort * amp);
}, [\ir, 0.1, 0.1, 0]).store;

SynthDef(\wah, { arg out=0, gate=1;
var env, in;
env = Linen.kr(gate, 0.05, 1, 0.4, 2);
in = In.ar(out, 2);
XOut.ar(out, env, RLPF.ar(in, LinExp.kr(LFNoise1.kr(0.3), -1, 1, 200,
8000), 0.1).softclip * 0.8);
}, [\ir, 0]).store;
)


(
               
               
  

    a = Pseq  ([1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0]);
    b = Pseq  ([0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0]);
    c = Pseq  ([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0]);
    d = Pseq  ([0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1]);    
    e = Pwhite (0.14, 0.16, inf);
    
    p = Pbind(
       \instrument, \drums,
      \dur, e,
       \bassLevel,  Pseq ([a], inf), 
       \snareLevel, Pseq ([b], inf),
       \hatLevel,   Pseq ([c], inf),       
       \tomLevel,   Pseq ([d], inf)
                             
                       );
                       
     
     q = Pfx(p, \echo, \dtime, 0.02, \decay, 0.1);     
            
    r = Pfx(q, \distort, \pregain, 20, \amp, 0.25);
    
     o = Pfx(r, \wah).play;
                        )

Pfx takes a pattern and the name of the effect synthdef as arguemnts, then the names and the arguments you'd usually pass to the synthdef to control it. Pfx then takes the patern you've specified and plays it through the effect you've given it.

As shown in the above code, you can easily nest Pfx patterns to layer on more effects. I've got my original drum machine pattern defined as normal then I've passed it to a Pfx named q, then passed that new pattern on to r and then o, so I end up with my initially defined pattern passed through three effects.

Sounds dubesque.

Moog miditest

2009-04-08T17:18:00.000-07:00

More work on my Moogy synth, nothing too spectacular, once again I've made use of .miditest from Dewdrop_lib. I've just invoked the miditest method and added control specs for all the parameters. This is the 'lfo' amplitude modulation version of my synth, the oscType sliders let you select from the 12 possible combinations of saw, sin and pulse waves with trinagle, sin or pulse wave amplitude modulation.

( 
 SynthDef("Moog",{

arg oscType =0, oscType2 = 0, pan = 0, level = 0.5, cutoff = 500, gain = 3.3, attack = 0.1, decay = 0.1, sust = 0.7, rel = 0.2, attackf = 0.1, decayf = 0.1, sustf = 0.9, relf = 0.2, gate = 1, freq =440, lfo1Rate = 12, lfo2Rate =4, lfo3Rate = 6;

var lfo1 = Lag2.kr(LFSaw.kr(lfo1Rate), 0.1);
var lfo2 = Lag2.kr(LFTri.kr(lfo2Rate), 0.1);
var lfo3 = SinOsc.kr(lfo3Rate);

var oscArray = [Saw.ar(freq), SinOsc.ar(freq), Pulse.ar(freq),Saw.ar(freq, lfo1), SinOsc.ar(freq,0, lfo1), Pulse.ar(freq, 0.5,lfo1), Saw.ar(freq,lfo2), SinOsc.ar(freq, 0,lfo2), Pulse.ar(freq, 0.5,lfo2), Saw.ar(freq, lfo3), SinOsc.ar(freq,0, lfo3), Pulse.ar(freq, 0.5, lfo3)];
var oscArray2 = [Saw.ar(freq), SinOsc.ar(freq), Pulse.ar(freq),Saw.ar(freq, lfo1), SinOsc.ar(freq,0, lfo1), Pulse.ar(freq, 0.5,lfo1), Saw.ar(freq,lfo2), SinOsc.ar(freq, 0,lfo2), Pulse.ar(freq,0.5,lfo2), Saw.ar(freq, lfo3), SinOsc.ar(freq,0, lfo3), Pulse.ar(freq, 0.5, lfo3)];

var ampEnv = EnvGen.ar(Env.adsr(attack, decay, sust, rel), gate, doneAction:2);
var filterEnv = EnvGen.ar(Env.adsr(attackf, decayf, sustf, relf), gate, doneAction:2);
var osc1 = Select.ar(oscType, oscArray);
var osc2 = Select.ar(oscType2, oscArray2);
var fade = Pan2.ar(XFade2.ar(osc1, osc2, pan , level * ampEnv, 0));
var filter = MoogFF.ar(fade, cutoff * filterEnv, gain);
Out.ar(0,filter)

}).miditest(nil, [[0, 11, \linear, 1, 0, 1], [0, 11, \linear, 1, 0, 1], [-1, 1, \linear, 0.1, 0, 0.1], [0, 4, \linear, 0.1, 1, 0.1], [0, 10000, \linear, 0.1, 5000, 0.1],[0, 4, \linear, 0.1, 1, 0.1],[0, 4, \linear, 0.1, 1, 0.1],[0, 4, \linear, 0.1, 1, 0.1],[0, 4, \linear, 0.1, 1, 0.1],[0, 4, \linear, 0.1, 1, 0.1],[0, 4, \linear, 0.1, 1, 0.1],[0, 4, \linear, 0.1, 1, 0.1],[0, 4, \linear, 0.1, 1, 0.1],[0, 4, \linear, 0.1, 1, 0.1],nil, nil, [0, 50, \linear, 0.1, 1, 0.1],[0, 50, \linear, 0.1, 1, 0.1], [0, 50, \linear, 0.1, 1, 0.1]])
)

By the way, I use MidiKeyswith OS X to play midi notes with an ordinary alphanumeric keyboard. Very handy and SuperCollider recognises it without any trouble.
This appears to be a Windows substitute but I've no idea what it's like and it might be a pain in the arse to get working. If you're running linux you're on your own.

Complex envelopes.

2009-04-03T17:02:00.000-07:00

I posted a phase modulation synth a while ago, but here's another one, this time using the PMOsc ugen and some custom defined envelopes.

(
SynthDef("phase", { |freq = 440, modfreq = 600,
index = 3, modphase = 2, gate = 1|
var env1 = EnvGen.kr(Env.new([0.2,0.6,0.6,0.8,0.01, 0.2, 0.1, 0.01],[0.1,0.3,0.1,0.2], 'linear', 3, 6));

var pmosc = PMOsc.ar(freq,modfreq, index , modphase);
var out = MoogFF.ar(pmosc, 5000 * env1, 0.1);
Out.ar(0, Pan2.ar(out * EnvGen.kr(Env.new([0.1,0.5,0.3,0.6,0.7,0.8,0.7,0],[0.02,0.03,0.04,0.02,0.04,0.1,0.1],'linear', 2, 1), gate, doneAction:2)))
}).miditest(nil, [nil, [0, 100, \linear, 0, 2], [0, 20, \linear, 0, 2],
[0, 4, \linear, 0, 2], nil]);

)

Defining new envelopes is reasonably easy, the help file explains most of it very well, but the release node and looping function took me a while to work out.

When you create a new envelope with Env.new you can give it a release node, this is the value of the envelope that will be held until the note is released. If you've got a envelope handyly defined like this (the first array is the list if output values, the second is the time it takes to transition to the next one)

Env.new([1,2,3,4,5] , [1,2,3,4]. 'linear', 5]
the note will be held at the first value on the list, '5' in this case, until it's released.
If you define a loop node like this

Env.new([1,2,3,4,5] , [1,2,3,4]. 'linear', 5, 1]

When the note is held it will loop through the nodes starting at the loop node and ending at the node before the release node untill the note is realsed. So in this case when the note is held, the values put out by the envelope will loop through the values '1, 2, 3, 4' as long as the note is held and then transition to '5'when it's released. I think.

And that's jazz.

Using BBCut and a Simple Drum Machine

2009-04-01T15:47:00.001-07:00

I've had this code for ages but I forgot about it.
It's my simple drum machine again, but this time put through BBCut, the beat slicing library. I've got to admit, it doesn't sound too good yet, but the principle's there.

Also it's yet another experiment with formatting, I'll find a something that works one day.

s.boot

(
SynthDef(\drums, {|out = 0, bassLevel = 0, 
snareLevel = 0, hatLevel = 0, tomLevel = 0,
 pan1 = 0, pan2 = 0, pan3 = 0, pan4 = 0|

    var  env1, env2, env3, bass, snare, hat, tom, bassOut, snareOut,
    hatOut, tomOut, mixer; 
    env1 = EnvGen.kr(Env.perc(0.001, 0.2, 1, -4), 1, doneAction:2);
    env2 = EnvGen.kr(Env.perc(0.002, 0.3, 1, -2), 1, doneAction:2);
    env3 = EnvGen.kr(Env.perc(0.001, 0.1, 1, -5), 1, doneAction:2);    
    bass = SinOsc.ar(80) + Crackle.ar(1, 0.5);
    bassOut = Pan2.ar(bass*env1, pan1, bassLevel);
    
    snare = SinOsc.ar(40) - WhiteNoise.ar(0.5, 0.5);
    snareOut = Pan2.ar(snare*env1, pan2, snareLevel);    
    
    hat = Klank.ar(`[ [ 6563, 9875 ],
               [ 0.61, 0.55046827363918 ],
               [ 0.0024, 0.0036 ] ], PinkNoise.ar(1));    
    hatOut = Pan2.ar(hat*env2, pan2, hatLevel);    
    
    tom =  SinOsc.ar(440); 
    tomOut = Pan2.ar(tom*env3, pan4, tomLevel);    
    
    mixer = (bassOut + snareOut) + (hatOut + tomOut); 
    
    
    Out.ar(out, mixer);
    
    }).store
    
    )
    
TempoClock.default.tempo_(3);

(
var buf, clock, bbcutgroup;
~synthbus = Bus.audio(s,2);
~synthgroup= Group.head(Node.basicNew(s,1));

    a = Pseq  ([1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0]);
    b = Pseq  ([0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0]);
    c = Pseq  ([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0]);
    d = Pseq  ([0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1]);    

p = Pbind(
       \instrument, \drums,
       \dur, 0.2,
       \bassLevel,  Pseq ([a], inf), 
       \snareLevel, Pseq ([b], inf),
       \hatLevel,   Pseq ([c], inf),       
       \tomLevel,   Pseq ([d], inf),
       \group, ~synthgroup,
       \out, ~synthbus
).play;

clock= ExternalClock(TempoClock.default);

bbcutgroup= Group.after(~synthgroup);

Routine.run({
buf= BBCutBuffer.alloc(s,44100,2);
s.sync; //this forces a wait for the Buffer to be allocated
BBCut2(CutGroup(CutStream1(~synthbus.index, buf, 0.75, 0.01, 0.5,
-4),bbcutgroup, numChannels:2), SQPusher1.new).play(clock);
});
clock.play;
)
~synthbus.free;

The code is not to hard to follow I hope, it's adapted from the BBcut help file with help from Dan once again. The only tough bits are the groups and nodes stuff, which to be honest I don't fully understand myself. Maybe I'll post about them in more detail if I ever fathom it.

A one liner from the SC users list.

2009-03-30T15:02:00.000-07:00

Lifted directly from the SC Users List a lovely one liner.

// server samplerate should be 44100

{Splay.ar(Ringz.ar(Impulse.ar([2, 1, 4], [0.1, 0.11, 0.12]), [0.1,
0.1, 0.5])) * EnvGen.kr(Env([1, 1, 0], [120, 10]), doneAction: 2)}.play

--
This work is licensed under the Creative Commons Attribution-Share
Alike 3.0 Germany License. To view a copy of this license, visit http://creativecommons.org/licenses/by-sa/3.0/de/
or send a letter to Creative Commons, 171 Second Street, Suite 300,
San Francisco, California, 94105, USA.

Tasty.

Stolen From MCLD

2009-03-27T16:50:00.000-07:00

Dan Stowel AKA MCLD, legendary SuperCollidist, has brought honour to his family and started twittering about SuperCollider,

Posting very short snippets of code such as this.

{t=HPZ1.kr(LFNoise0.kr(4));{Pulse.ar((t*10000+0.0001).lag(0, 0.1))}.dup+(SinOsc.ar([220, 330])*Integrator.kr(t))*0.1}.play;//

Nice,

He also drank a jar of coffee and took some E, now he's totally Wired! i.e. he's in Wired Magazine.

Nicer.

The heterodyne is a lie

2009-03-21T17:24:00.000-07:00

I knew there was something not quite right with my 'more accurate Theremin' code.

It does work, but not for the reason that I thought it did. Here's the original code,

(
{
var mouse = MouseX.kr(100000,110000,1);

BPF.ar((SinOsc.ar(100000) * SinOsc.ar(mouse)), mouse - 100000, 0.2);

}.scope

)

I should have known, 100Khz is waaaay above the maximum frequency that can be produced by a standard sampling rate of 40-some thousand hz, according to Nyquist-Shannon sampling theorem.

Simply put, aliasing causes the code to output the sound, the rest is erm , complicated.

A better explanation can be found on the SC user list where I asked about it.

Qapla!

Midievalism - Midi control

2009-03-20T17:23:00.000-07:00

James Harkins' Dewdrop_lib , has an armada of wonderful surprises for the budding SuperCollidist, including several classes for dealing with midi stuff.

This is part of the official extensions package, but you'll still need to install the quark and recompile the language for it to work.

A useful method is .miditest, which you can append to any synthdef and automatically create a simple midi interface and a gui to control it. It's very simple to use and the help file is easy to understand.

Here's an example of a simple phase modulating synth I made. The synth itself is pretty simple, I'm just using sin oscillators to modulate the phase of another SinOsc.

(
SynthDef("phase", { |freq = 440, pm1f = 2,
pm2f = 2, pm3f = 2, gate = 1|

var out =
SinOsc.ar(freq, SinOsc.ar(pm1f, SinOsc.ar(2, SinOsc.ar(pm2f,
SinOsc.ar(pm3f))))*2pi);
Out.ar(0, Pan2.ar(out * EnvGen.kr(Env.adsr, gate, doneAction:2)))
}).miditest(nil, [nil, [0, 50, \linear, 0, 2], [0, 50, \linear, 0, 2],
[0, 50, \linear, 0, 2], nil]);

)

To make miditest work correctly you'll need to supply it control specs for each of the parameters of your synth in the second argument. If any of your paremeters don't need to be controlled by the gui, putting nil as the argument will cause it to be left out.

Some Birthday Code

2009-03-19T17:37:00.000-07:00

It's was my birthday recently and I was lucky enough to get this birthday code from my old friend and Finchley's premier SuperCollidist, Dan.

I was going to post the code on here, but it's pretty long and I can't get it to format nicely at the moment, so you'll have to make do with the .scd file in the link above.

Happy Birthday to me.

Lag in the Time of Cholera.

2009-03-12T15:58:00.000-07:00

I updated my Moog synth to use low frequency oscillators to modulate the amplitude a while ago , finding a new use for the Lag Ugen in the process.

Here's the relevant bit,

var lfo1 = Lag2.kr(LFSaw.kr(lfo1Rate), 0.1);
var lfo2 = Lag2.kr(LFTri.kr(lfo2Rate), 0.1);
var lfo3 = Lag2.kr(SinOsc.kr(lfo3Rate), 0.1);

When I put it onto my oscillator array the lfo modulates the multipler of the Ugens.

Why the Lag?

Without it it sounds pretty bad, the sudden changes in amplitude cause a nasty clicking sound. Lag smoothes out the waveform so that the change is more gradual and sounds much better.

The Joy of Frequecy Modulation

2009-03-10T18:04:00.000-07:00

Here's a simple frequency modulating synth def I came up with,

(
   SynthDef(\efemer, {|freq = 240, modlev1 = 100, modlev2 = 100,
carlev = 1, pulsewidth = 0.5, mod1osctype = 1, 
mod2osctype = 2 , carosctype = 2, sinphase = 0|
   
       var mod1array = [Saw.ar(freq, modlev1), Pulse.ar(freq, pulsewidth, modlev1), 
SinOsc.ar(freq, sinphase, modlev1)];
       
       var mod1 = Select.ar(mod1osctype, mod1array); 
       
       var mod2array = [Saw.ar(freq + mod1, modlev2), 
Pulse.ar(freq + mod1, pulsewidth, modlev2),
SinOsc.ar(freq + mod1, sinphase, modlev2)];  
       
       var mod2 = Select.ar(mod2osctype, mod2array);
       
       var cararray = [Saw.ar(freq + mod2, carlev), 
Pulse.ar(freq + mod2, pulsewidth, carlev), 
SinOsc.ar(freq = mod2, 1, carlev)];
       
       var car = Select.ar(carosctype, cararray);
       var env = EnvGen.ar( Env.perc(0.11, 1), doneAction: 2);        
       
       Out.ar(0, Pan2.ar(car * env))
       }).store
       )    
       
       
       (
Pbind(\instrument, "efemer", 
   \mod1osctype, Pseq([0,1,2], inf), 
   \freq, Pseq([220,330,440,550], inf), 
   \dur, 0.3
   ).play
   )

I think it need's some work.

A More Accurate Theremin (possibly)

2009-03-07T15:55:00.000-08:00

One of the weird things about the Theremin is the way it creates sound. Rather than generating sound directly from a voltage controlled oscillator like later analogue synths, it creates sound via the heterodyne principle. Why I have no idea, but it does. Before I go any further I sould point out that I learned everything I know about signal processing from Wikipedia, so my explanations here might be a bit garbled.

In a Theremin there are two high frequency oscilators, one at a fixed frequency and one at a frequency controlled by the movement of the players hand. These two signals are multiplied by each other, which gives two new frequecies, one at the sum of the original two and one at the diffrence between them. The difference of these two is the audio signal that is output, so

120000hz * 115000 = 235000hz and 5000hz.

I think.

So just for the hell of it I decided to try doing this in SuperCollider and surprise, it works!

(
{
var mouse = MouseX.kr(100000,110000,1);

BPF.ar((SinOsc.ar(100000) * SinOsc.ar(mouse)), mouse - 100000, 0.2);

}.scope

)

I've put it through a band pass filter that follows the audio frequency in an attempt to filter out what I can only assume are sidebands or aliasing or something. It doesn't quite work completely, but it's better than nothing.

The Ondes Martenot used heterodyning too so I did the same thing with my simple version of it.

(
{

var mouse = MouseX.kr(100000,110000,1);

w = SCWindow.new("I catch keystrokes");
w.front;

FreeVerb.ar(BPF.ar((SinOsc.ar(100000, 0, KeyState.kr(36, 0, MouseY.kr(1,0)) ) * SinOsc.ar(mouse)), mouse - 100000, 0.2), 0.5, 0.3);

}.freqscope

)

And that's Jazz.

Adding LFO modulation

2009-03-04T16:56:00.000-08:00

Another addition to my Moog style synth, LFO amplitude modulation.

Here's the code,

(
SynthDef("Moog",{

arg oscType =0, oscType2 = 0, pan = 0, level = 0.5, cutoff = 500, gain = 3.3,
attack = 0.1, decay = 0.1, sust = 0.7, rel = 0.2, attackf = 0.1, decayf = 0.1,
sustf = 0.9, relf = 0.2, gate = 1, freq =440, lagLev = 0.2, lfo1Rate = 12,
lfo2Rate =4, lfo3Rate = 6;

var lfo1 = Lag2.kr(LFSaw.kr(lfo1Rate), 0.1);
var lfo2 = Lag2.kr(LFTri.kr(lfo2Rate), 0.1);
var lfo3 = Lag2.kr(SinOsc.kr(lfo3Rate), 0.1);

var oscArray = [Saw.ar(Lag.kr(freq, lagLev)), SinOsc.ar(Lag.kr(freq, lagLev)),
Pulse.ar(Lag.kr(freq, lagLev)),Saw.ar(Lag.kr(freq, lagLev), lfo1),
SinOsc.ar(Lag.kr(freq, lagLev),0, lfo1), Pulse.ar(Lag.kr(freq, lagLev), lfo1),
Saw.ar(Lag.kr(freq, lagLev),lfo2), SinOsc.ar(Lag.kr(freq, lagLev), 0,lfo2),
Pulse.ar(Lag.kr(freq, lagLev), lfo2), Saw.ar(Lag.kr(freq, lagLev), lfo3),
SinOsc.ar(Lag.kr(freq, lagLev), 0, lfo3), Pulse.ar(Lag.kr(freq, lagLev), 0, lfo3)];

var oscArray2 = [Saw.ar(Lag.kr(freq, lagLev)), SinOsc.ar(Lag.kr(freq, lagLev)),
Pulse.ar(Lag.kr(freq, lagLev)),Saw.ar(Lag.kr(freq, lagLev), lfo1),
SinOsc.ar(Lag.kr(freq, lagLev),0, lfo1), Pulse.ar(Lag.kr(freq, lagLev), lfo1),
Saw.ar(Lag.kr(freq, lagLev),lfo2), SinOsc.ar(Lag.kr(freq, lagLev), 0,lfo2),
Pulse.ar(Lag.kr(freq, lagLev), lfo2), Saw.ar(Lag.kr(freq, lagLev), lfo3),
SinOsc.ar(Lag.kr(freq, lagLev), 0, lfo3), Pulse.ar(Lag.kr(freq, lagLev), 0, lfo3)];

var ampEnv = EnvGen.ar(Env.adsr(attack, decay, sust, rel), gate, doneAction:2);
var filterEnv = EnvGen.ar(Env.adsr(attackf, decayf, sustf, relf), gate, doneAction:2);
var osc1 = Select.ar(oscType, oscArray);
var osc2 = Select.ar(oscType2, oscArray2);
var fade = Pan2.ar(XFade2.ar(osc1, osc2, pan , level * ampEnv, 0));
var filter = MoogFF.ar(fade, cutoff * filterEnv, gain);
Out.ar(0,filter)

}).store
)







And here's a download link

I'll talk a bit more about this later.

Hail Atlantis.

A Simple Ondes Martenot

2009-03-02T17:33:00.001-08:00

The Ondes Martenot is a very early electronic synthesiser created in the late 1920's by Maurice Martenot. It's generates sound in a similar way to the Theremin, but is much more sophisticated, having several waveforms and filters.

The unique thing about the Ondes Martenot is it's control method. Like many later monophonic synths it's got a piano style keyboard, but it also has a unique finger ring controller. This is a ring connected to a pice of wire worn on the players right index finger, as the ring moves back and forth it alters the pitch of the synth.

Whether the player is using the keyboard or the ring controller, the sounds themselves are triggered by a an experession key, a small glass button to the left of the keyboard. This is an analogue control, the more the button is pressed down the greater the amplitude.

Here's a YouTube Video of one being played, which should make things clearer.

You've probably seen a simple Theremin implemented in SuperCollider several times, it's a classic bit of code, the audio equivalent of 'Hello World', here it is again in all it's glory.

{SinOsc.ar(MouseX.kr(20,20000))}.play

To extend this a little bit I decided to create a simple Ondes Martenot style synth, using a key on the keyboard as an expression key. Sadly this is only a binary control, it's either on or off, unlike the orginal, instead I've used the mouse y position to control the level, with the key just acting as a switch.

Here's the code.

( 
w = SCWindow.new("I catch keystrokes");w.front;  
{ FreeVerb.ar(SinOsc.ar(MouseX.kr(20, 20000, 1), 0,
KeyState.kr(36, 0, MouseY.kr(1,0))),
0.5, 0.3, 0.1) }.play; 
)

This firstly creates a standard window, as the title suggests, to catch keystrokes. I got this idea from the help file on keyboard input, it serves no purpose other than as a safe place to direct keyboard input to.

A keyState ugen provides the extra control input to the SinOsc. A KeyState takes 3 arguments, the key number it is to respond to, the output when the key is not pressed and the output when it is. As you can see Im using this to control the amplitude of a SinOsc, when key 36 (the enter key) is pressed it outputs the mouse y value as the multiplier for the osc.

Using the a key to trigger the sound gives a bit more expressive power than the standard Theremin, plus it's great for doing impressions of the Clangers.

Another try with the 303 code.

2009-03-01T13:14:00.000-08:00

It's been pointed out that blogger's formatting has mangled some of the code here. This is an attempt to rectify that.

If anyone has any trouble copy and pasting this please let me know.

(

s = Server.internal;

SynthDef("sc303", { arg out=0, freq=440, wave=0, ctf=100, res=0.2,

sus=0, dec=1.0, env=1000, gate=0, vol=0.2;

var filEnv, volEnv, waves;

// can't use adsr with exp curve???

//volEnv = EnvGen.ar(Env.adsr(1, 0, 1, dec, vol, 'exp'), In.kr(bus));

volEnv = EnvGen.ar(Env.new([10e-10, 1, 1, 10e-10], [0.01, sus, dec], 'exp'), gate);

filEnv = EnvGen.ar(Env.new([10e-10, 1, 10e-10], [0.01, dec], 'exp'), gate);

waves = [Saw.ar(freq, volEnv), Pulse.ar(freq, 0.5, volEnv)];

Out.ar(out, RLPF.ar( Select.ar(wave, waves), ctf + (filEnv * env), res).dup * vol);

}).send(s);

)

s.sendMsg("s_new", "sc303", 3000, 0, 0);

s.sendMsg("n_set", 3000, 'gate', 1, 'freq', 220);

s.sendMsg("n_set", 3000, 'gate', 0);

s.sendMsg("n_set", 3000, 'dec', 1);

s.sendMsg("n_free", ~node)

// make GUI!

(

~bpm = 140;

~step = 0;

// set default note ons

~defaultNoteOns = Array.fill(16,1);

// this is the note on array that will be used in the sequencer routine

~noteOns = ~defaultNoteOns;

// set root

~root = 36;

// set default pitches

~defaultPitches = [ 0, 12, 0, 0, -12, 0, 0, 0, -12, 0, 12, 0, 3, -5, 2, 0 ];

// this is the pitch array that will be used in the sequencer routine

~pitches = ~defaultPitches;

~tStepLED = Array.new; // the step indicator LEDs as an array

~sNoteOn = Array.new; // the note-on sliders as an array

~tNoteOn = Array.new; // the note-on value boxes as an array

~sPitch = Array.new; // the pitch sliders as an array

~tPitch = Array.new; // the pitch value boxes as an array

w = SCWindow("SC-303", Rect(128, 64, 510, 320));

w.view.background = Color.white;

w.front;

~layoutLeft = SCCompositeView(w, Rect(0, 0, 400, 320)); // make the left pane of the window

~layoutLeft.decorator = FlowLayout(~layoutLeft.bounds); // auto-arrange the elements

~layoutRight = SCCompositeView(w, Rect(400, 0, 400, 120));

~layoutRight.decorator = FlowLayout(~layoutRight.bounds);

// make transport controls

// Tempo

SCStaticText(~layoutRight, Rect(0,0, 45, 14)).string_("BPM: ");

~tBpm = SCNumberBox(~layoutRight, Rect(0,0, 45, 14))

.string_(~bpm)

.action_({ arg item;

~bpm = item.value;

~sBpm.value_((~bpm-40)/200);

});

~layoutRight.decorator.nextLine;

~sBpm = SCSlider(~layoutRight, Rect(0,0, 100, 20))

.background_(Color.new(0.8,0.8,0.8))

.value_((~bpm-40)/200)

.action_({ arg sldr;

~bpm = ((sldr.value)*200) + 40;

~tBpm.string_(~bpm);

});

~layoutRight.decorator.nextLine;

// Reset

SCButton(~layoutRight, Rect(0,0,45,20))

.states_([["|<"]])

.action_({ arg item;

~tStepLED[~step].background_(Color.new(0.6,0,0));

~step = 0;

~tStepLED[0].background_(Color.new(1,0,0));

});

// Play/Pause

SCButton(~layoutRight, Rect(0,0,45,20))

.states_([[">"],["||"]])

.action_({ arg item;

if( item.value == 0, {

~seqr.stop;

},{

~seqr.reset;

~seqr.play;

});

~layoutRight.decorator.nextLine;

// Root note

SCStaticText(~layoutRight, Rect(0,0, 45, 14)).string_("Root: ");

~tRoot = SCStaticText(~layoutRight, Rect(0,0, 45, 14)).string_(~root);

~layoutRight.decorator.nextLine;

SCSlider(~layoutRight, Rect(0,0, 100, 20))

.background_(Color.new(0.8,0.8,0.8))

.value_((~root-24)/36)

.step_(1/48)

.action_({ arg sldr;

~root = ((sldr.value)*36) + 24;

~tRoot.string_(~root);

});

// make synth control labels

SCStaticText(~layoutLeft, Rect(0,0, 45, 14)).string_("Wave");

SCStaticText(~layoutLeft, Rect(0,0, 80, 14)).string_("Cutoff");

SCStaticText(~layoutLeft, Rect(0,0, 80, 14)).string_("Resonance");

SCStaticText(~layoutLeft, Rect(0,0, 80, 14)).string_("Decay");

SCStaticText(~layoutLeft, Rect(0,0, 80, 14)).string_("Envelope");

~layoutLeft.decorator.nextLine;

// make the synth controls

// wave-type

SCButton(~layoutLeft, Rect(0,0,45,20))

.states_([["Saw"],["Square"]])

.action_({ arg item;

s.sendMsg("n_set", ~node, 'wave', item.value);

});

// cut-off frequency

SCSlider(~layoutLeft, Rect(0,0, 80, 20))

.background_(Color.new(0.8,0.8,0.8))

.action_({ arg sldr;

s.sendMsg("n_set", ~node, 'ctf', ((sldr.value)*(10000-100))+100); // modify synth param

});

// resonance amt

SCSlider(~layoutLeft, Rect(0,0, 80, 20))

.background_(Color.new(0.8,0.8,0.8))

.action_({ arg sldr;

s.sendMsg("n_set", ~node, 'res', (1-sldr.value)*(0.97)+0.03); // modify synth param

});

// decay amt

SCSlider(~layoutLeft, Rect(0,0, 80, 20))

.background_(Color.new(0.8,0.8,0.8))

.action_({ arg sldr;

s.sendMsg("n_set", ~node, 'dec', (sldr.value)*2); // modify synth param

});

// envelope amt

SCSlider(~layoutLeft, Rect(0,0, 80, 20))

.background_(Color.new(0.8,0.8,0.8))

.action_({ arg sldr;

s.sendMsg("n_set", ~node, 'env', (sldr.value)*10000); // modify synth param

});

~layoutLeft.decorator.nextLine;

// make step LEDs

16.do({ arg i;

~tStepLED = ~tStepLED.add(

SCStaticText(~layoutLeft, Rect(0,0,20,12))

.background_(Color.new(0.6,0,0))

.stringColor_(Color.white)

.string_(i+1)

);

});

~tStepLED[~step].background_(Color.new(1,0,0));

~layoutLeft.decorator.nextLine;

// make the note-on sliders

16.do({ arg i;

~sNoteOn = ~sNoteOn.add(

SCSlider(~layoutLeft, Rect(0,0,20,60)) // position doesn't matter; width, height do

.background_(Color.new(0,0,0.7)) // color the slider

.step_(0.1) // values are stepped by 0.1

.value_(~noteOns[i]) // assign it its value from the note on array

.action_({ arg sldr; // when the slider is moved...

~noteOns[i] = sldr.value; // ... update note-on array

~tNoteOn[i].string = sldr.value; // ... update its value box

// ...change color of value box

~tNoteOn[i].background = Color.new((1-~noteOns[i]),1,(1-~noteOns[i]));

})

);

});

~layoutLeft.decorator.nextLine;

// make the note-on value boxes

16.do({ arg i;

~tNoteOn = ~tNoteOn.add(

SCStaticText(~layoutLeft, Rect(0,0,20,20))

.background_(Color.new((1-~noteOns[i]),1,(1-~noteOns[i])))

.string_(~sNoteOn[i].value)

.align_(0)

.action_({ arg text;

text.string.postln;

})

);

});

~layoutLeft.decorator.nextLine;

// make the pitch sliders

16.do({ arg i;

~sPitch = ~sPitch.add(

SCSlider(~layoutLeft, Rect(0,0,20,120))

.value_((~pitches[i]+12)/24)

.step_(1/24)

.background_(Color.new(0.8,0.8,0.8))

.action_({ arg item;

~pitches[i] = ((item.value * 24)-12);

~tPitch[i].string = ((item.value * 24)-12);

})

);

});

~layoutLeft.decorator.nextLine;

// make the pitch value boxes

16.do({ arg i;

~tPitch = ~tPitch.add(

SCStaticText(~layoutLeft, Rect(0,0,20,20))

.background_(Color.white)

.string_(~pitches[i].value)

.align_(0)

);

});

/*~tempButt = SCButton(w, Rect(0,0,60,60))

.states_([

["0", Color.red, Color.black]

]);*/

)

// do other stuff

(

~node = s.nextNodeID;

// start the synth

s.sendMsg("s_new", "sc303", ~node, 1, 1);

// make the step sequencer

~seqr = Routine.new({

loop({

// turn on LED

{~tStepLED[~step].background_(Color.new(1,0,0)); /*(~step.asString + "on").postln;*/}.defer;

if(~noteOns[~step].coin, {

// play note!

// this is out of sync

// s.sendMsg("n_set", ~node, 'gate', 1, 'freq', (~pitches[~step]+~root).midicps);

// (7.5/~bpm).wait;

// s.sendMsg("n_set", ~node, 'gate', 0);

// (7.5/~bpm).wait;

// buffer playback on server (adds start/stop delay, but better inter-note timing)

s.sendBundle(s.latency, ["n_set", ~node, 'gate', 1, 'freq', (~pitches[~step]+~root).midicps]);

(7.5/~bpm).wait;

s.sendBundle(s.latency, ["n_set", ~node, 'gate', 0]);

(7.5/~bpm).wait;

},{

// it's a rest

(15/~bpm).wait;

});

// turn off LED

{~tStepLED[(~step-1)%16].background_(Color.new(0.6,0,0)); /*(((~step-1)%16).asString + "off").postln;*/}.defer;

~step = (~step + 1)%16;

});

)

~seqr.play;

~seqr.stop;

~seqr.reset;

~pitches

303 Emulator

2009-02-28T16:54:00.001-08:00

Found in the depths of the SC Users list archive, a very nice 303 emulator created by SuperCollidist extraordinaire Lance J. Putnam.

To run this you'll need to evaluate the two sections separately, then send the sequncer routine a play message, like this.

~seqr.play;

This is a fairly large chunk of code so here's an .rtf version.

(
s = Server.internal;

SynthDef("sc303", { arg out=0, freq=440, wave=0, ctf=100, res=0.2,
sus=0, dec=1.0, env=1000, gate=0, vol=0.2;
var filEnv, volEnv, waves;

// can't use adsr with exp curve???
//volEnv = EnvGen.ar(Env.adsr(1, 0, 1, dec, vol, 'exp'), In.kr(bus));
volEnv = EnvGen.ar(Env.new([10e-10, 1, 1, 10e-10], [0.01, sus, dec], 'exp'), gate);
filEnv = EnvGen.ar(Env.new([10e-10, 1, 10e-10], [0.01, dec], 'exp'), gate);

waves = [Saw.ar(freq, volEnv), Pulse.ar(freq, 0.5, volEnv)];

Out.ar(out, RLPF.ar( Select.ar(wave, waves), ctf + (filEnv * env), res).dup * vol);
}).send(s);

)

/*
s.sendMsg("s_new", "sc303", 3000, 0, 0);
s.sendMsg("n_set", 3000, 'gate', 1, 'freq', 220);
s.sendMsg("n_set", 3000, 'gate', 0);
s.sendMsg("n_set", 3000, 'dec', 1);

s.sendMsg("n_free", ~node)
*/

// make GUI!
(
~bpm = 140;
~step = 0;
// set default note ons
~defaultNoteOns = Array.fill(16,1);
// this is the note on array that will be used in the sequencer routine
~noteOns = ~defaultNoteOns;

// set root
~root = 36;

// set default pitches
~defaultPitches = [ 0, 12, 0, 0, -12, 0, 0, 0, -12, 0, 12, 0, 3, -5, 2, 0 ];
// this is the pitch array that will be used in the sequencer routine
~pitches = ~defaultPitches;

~tStepLED = Array.new; // the step indicator LEDs as an array
~sNoteOn = Array.new; // the note-on sliders as an array
~tNoteOn = Array.new; // the note-on value boxes as an array
~sPitch = Array.new; // the pitch sliders as an array
~tPitch = Array.new; // the pitch value boxes as an array

w = SCWindow("SC-303", Rect(128, 64, 510, 320));
w.view.background = Color.white;
w.front;

~layoutLeft = SCCompositeView(w, Rect(0, 0, 400, 320)); // make the left pane of the window
~layoutLeft.decorator = FlowLayout(~layoutLeft.bounds); // auto-arrange the elements
~layoutRight = SCCompositeView(w, Rect(400, 0, 400, 120));
~layoutRight.decorator = FlowLayout(~layoutRight.bounds);

// make transport controls

// Tempo
SCStaticText(~layoutRight, Rect(0,0, 45, 14)).string_("BPM: ");
~tBpm = SCNumberBox(~layoutRight, Rect(0,0, 45, 14))
.string_(~bpm)
.action_({ arg item;
~bpm = item.value;
~sBpm.value_((~bpm-40)/200);
});

~layoutRight.decorator.nextLine;
~sBpm = SCSlider(~layoutRight, Rect(0,0, 100, 20))
.background_(Color.new(0.8,0.8,0.8))
.value_((~bpm-40)/200)
.action_({ arg sldr;
~bpm = ((sldr.value)*200) + 40;
~tBpm.string_(~bpm);
});

~layoutRight.decorator.nextLine;

// Reset
SCButton(~layoutRight, Rect(0,0,45,20))
.states_([["|<"]]) .action_({ arg item; ~tStepLED[~step].background_(Color.new(0.6,0,0)); ~step = 0; ~tStepLED[0].background_(Color.new(1,0,0)); }); // Play/Pause SCButton(~layoutRight, Rect(0,0,45,20)) .states_([[">"],["||"]])
.action_({ arg item;
if( item.value == 0, {
~seqr.stop;
},{
~seqr.reset;
~seqr.play;
});
});

~layoutRight.decorator.nextLine;

// Root note
SCStaticText(~layoutRight, Rect(0,0, 45, 14)).string_("Root: ");
~tRoot = SCStaticText(~layoutRight, Rect(0,0, 45, 14)).string_(~root);
~layoutRight.decorator.nextLine;
SCSlider(~layoutRight, Rect(0,0, 100, 20))
.background_(Color.new(0.8,0.8,0.8))
.value_((~root-24)/36)
.step_(1/48)
.action_({ arg sldr;
~root = ((sldr.value)*36) + 24;
~tRoot.string_(~root);
});

// make synth control labels
SCStaticText(~layoutLeft, Rect(0,0, 45, 14)).string_("Wave");
SCStaticText(~layoutLeft, Rect(0,0, 80, 14)).string_("Cutoff");
SCStaticText(~layoutLeft, Rect(0,0, 80, 14)).string_("Resonance");
SCStaticText(~layoutLeft, Rect(0,0, 80, 14)).string_("Decay");
SCStaticText(~layoutLeft, Rect(0,0, 80, 14)).string_("Envelope");
~layoutLeft.decorator.nextLine;

// make the synth controls
// wave-type
SCButton(~layoutLeft, Rect(0,0,45,20))
.states_([["Saw"],["Square"]])
.action_({ arg item;
s.sendMsg("n_set", ~node, 'wave', item.value);
});
// cut-off frequency
SCSlider(~layoutLeft, Rect(0,0, 80, 20))
.background_(Color.new(0.8,0.8,0.8))
.action_({ arg sldr;
s.sendMsg("n_set", ~node, 'ctf', ((sldr.value)*(10000-100))+100); // modify synth param
});

// resonance amt
SCSlider(~layoutLeft, Rect(0,0, 80, 20))
.background_(Color.new(0.8,0.8,0.8))
.action_({ arg sldr;
s.sendMsg("n_set", ~node, 'res', (1-sldr.value)*(0.97)+0.03); // modify synth param
});

// decay amt
SCSlider(~layoutLeft, Rect(0,0, 80, 20))
.background_(Color.new(0.8,0.8,0.8))
.action_({ arg sldr;
s.sendMsg("n_set", ~node, 'dec', (sldr.value)*2); // modify synth param
});

// envelope amt
SCSlider(~layoutLeft, Rect(0,0, 80, 20))
.background_(Color.new(0.8,0.8,0.8))
.action_({ arg sldr;
s.sendMsg("n_set", ~node, 'env', (sldr.value)*10000); // modify synth param
});

~layoutLeft.decorator.nextLine;

// make step LEDs
16.do({ arg i;
~tStepLED = ~tStepLED.add(
SCStaticText(~layoutLeft, Rect(0,0,20,12))
.background_(Color.new(0.6,0,0))
.stringColor_(Color.white)
.string_(i+1)
);
});
~tStepLED[~step].background_(Color.new(1,0,0));
~layoutLeft.decorator.nextLine;

// make the note-on sliders
16.do({ arg i;
~sNoteOn = ~sNoteOn.add(
SCSlider(~layoutLeft, Rect(0,0,20,60)) // position doesn't matter; width, height do
.background_(Color.new(0,0,0.7)) // color the slider
.step_(0.1) // values are stepped by 0.1
.value_(~noteOns[i]) // assign it its value from the note on array
.action_({ arg sldr; // when the slider is moved...
~noteOns[i] = sldr.value; // ... update note-on array
~tNoteOn[i].string = sldr.value; // ... update its value box
// ...change color of value box
~tNoteOn[i].background = Color.new((1-~noteOns[i]),1,(1-~noteOns[i]));
})
);
});
~layoutLeft.decorator.nextLine;

// make the note-on value boxes
16.do({ arg i;
~tNoteOn = ~tNoteOn.add(
SCStaticText(~layoutLeft, Rect(0,0,20,20))
.background_(Color.new((1-~noteOns[i]),1,(1-~noteOns[i])))
.string_(~sNoteOn[i].value)
.align_(0)
.action_({ arg text;
text.string.postln;
})
);
});
~layoutLeft.decorator.nextLine;

// make the pitch sliders
16.do({ arg i;
~sPitch = ~sPitch.add(
SCSlider(~layoutLeft, Rect(0,0,20,120))
.value_((~pitches[i]+12)/24)
.step_(1/24)
.background_(Color.new(0.8,0.8,0.8))
.action_({ arg item;
~pitches[i] = ((item.value * 24)-12);
~tPitch[i].string = ((item.value * 24)-12);
})
);
});
~layoutLeft.decorator.nextLine;

// make the pitch value boxes
16.do({ arg i;
~tPitch = ~tPitch.add(
SCStaticText(~layoutLeft, Rect(0,0,20,20))
.background_(Color.white)
.string_(~pitches[i].value)
.align_(0)
);
});
/*~tempButt = SCButton(w, Rect(0,0,60,60))
.states_([
["0", Color.red, Color.black]
]);*/

)

// do other stuff

(
~node = s.nextNodeID;

// start the synth
s.sendMsg("s_new", "sc303", ~node, 1, 1);

// make the step sequencer
~seqr = Routine.new({
loop({

// turn on LED
{~tStepLED[~step].background_(Color.new(1,0,0)); /*(~step.asString + "on").postln;*/}.defer;

if(~noteOns[~step].coin, {
// play note!
// this is out of sync
// s.sendMsg("n_set", ~node, 'gate', 1, 'freq', (~pitches[~step]+~root).midicps);
// (7.5/~bpm).wait;
// s.sendMsg("n_set", ~node, 'gate', 0);
// (7.5/~bpm).wait;

// buffer playback on server (adds start/stop delay, but better inter-note timing)
s.sendBundle(s.latency, ["n_set", ~node, 'gate', 1, 'freq', (~pitches[~step]+~root).midicps]);
(7.5/~bpm).wait;
s.sendBundle(s.latency, ["n_set", ~node, 'gate', 0]);
(7.5/~bpm).wait;
},{
// it's a rest
(15/~bpm).wait;
});

// turn off LED
{~tStepLED[(~step-1)%16].background_(Color.new(0.6,0,0)); /*(((~step-1)%16).asString + "off").postln;*/}.defer;

~step = (~step + 1)%16;

});
});
)

~seqr.play;
~seqr.stop;
~seqr.reset;

I'm going to go into this in more detail and possibly add to it or adapt it later...

Auto Gui

2009-02-26T16:26:00.000-08:00

Hidden away in the GUI Overview help file this little gem,

Automatic GUI

You can get a quick simple automatic interface for a Synth with SynthDesc : makeWindow.

(
s.waitForBoot({
SynthDef("test", { arg out, freq=330, amp=0.6;
Out.ar(out, SinOsc.ar(freq,0,amp))
}).store;

SynthDescLib.global.at(\test).makeWindow;
});
)

An auto GUI creator.
I haven't really read around it much yet, but it seems to work pretty well.

I decided to mate it with the wonderful Atari2600 Ugen from Fredrik Olofsson.

(
SynthDef(\atari2600, {|out= 0, gate= 1, tone0= 5, tone1= 8, freq0= 10, freq1= 20, rate= 1, amp= 1, pan= 0|
var e, z;
e= EnvGen.kr(Env.asr(0.01, amp, 0.05), gate, doneAction:2);
z= Atari2600.ar(tone0, tone1, freq0, freq1, 15, 15, rate);
Out.ar(out, Pan2.ar(z*e, pan));
}).store
)

SynthDescLib.global.at(\atari2600).makeWindow;

And I got a handy widget for exploring a new Ugen.

Gooey

2009-02-24T16:38:00.000-08:00

And now a bit more explanation of what I'm doing with my Moog GUI.

There are a few different ways of creating GUIs and controlling synths in SuperCollider, for now I've gone with a simple approach using Pattern Proxies and the standard Slider class, but I might try something different as I add features.

Here's some of my GUI code again,

(
var window = Window.new("Moog",Rect(400, 400, 140, 100)).front;
var cutoffSlider, cutoffRef, resgainSlider;

~cutoffRef = PatternProxy();

cutoffSlider = Slider.new(window,Rect(10, 25, 100, 20));
cutoffSlider.action_{
var val;
val = (10000*(cutoffSlider.value));
val.postln;
~cutoffRef.source_(val);
};

StaticText.new(window,Rect(10, 5, 100, 20))
.string_("Cutoff")
.action_{|v| };

)
This is the bit that creates the window and the filter cutoff slider.

The first thing I've done is create a window, the parameters passed to it are the title, the initial position it appears in on the screen and the size of the window itself.

Then I've created a Pattern Proxy, this is the thing that allows me to control my synth with both a GUI and a pattern.

A Pattern Proxy is an object that can be placed in in a pattern and be changed whilst the pattern is playing. In this case I'm using a GUI to change the value of the Pattern Proxy as the pattern plays. I've set it as a global variable with a ~ so I can use it outside of the function it's created in.

I then create a slider that controls the value of the Pattern Proxy. It's instantiated with the name of the window it is to appear in and values setting it's size and position in the window.

The action_ method controls the action the slider performs when it's moved. In this case it takes the value of the slider object and multiplies it by 10000. Slider values move between 0 and 1, so to turn it into something usable by the synth I need to change the range. For simple linear values multiplying the output works fine, but for more complex stuff you can use a ControlSpec.

I then set the modified value to be the source of the Pattern Proxy, the object it takes it's values from.

After that there's a static text box, created in a similar way to the slider, as a label.

To actually make use of the Pattern Proxy, I need a pattern, so here it is again.

(
Pmono("Moog",
\freq, Pseq([440, 550, 660, 770, 660, 880], inf),
\dur, 0.2,
\oscType, Pseq([1,0,1,0,1], inf),
\oscType2, Pseq([0,0,2,2,1], inf),
\cutoff, (~cutoffRef),
\gain, (~resgainRef)

).play
)

All I've done is drop in the proxies as I would do with any other pattern streams.

This time I've used a Pmono, which creates only one instance of the synth on ther server and feeds it all the values in turn, instead of creating new ones with each note. This sounds a tad more like a an authentic Moog, plus I need to use a mono pattern with my new version of the synth that features portamento.

Shazam.

Portamento

2009-02-23T17:27:00.000-08:00

Before I do anymore GUI stuff a quick addition to my Moog synth itself, portamento!

Also known as slide or glissando, it's a nice feature of many analogue synths, here's the wiki page on it if you're not sure what I'm talking about.

I've been wanting to add this to my synth since I created it but I thought it might be difficult, but after putting my faith in the hand of providence and searching the SuperCollider user mailing list, I found simple that portamento is in fact dead easy.

Here's my revised SynthDef

(
SynthDef("Moog",{

arg oscType =0, oscType2 = 1, pan = 0, level = 0.5, cutoff = 500, gain = 3.3, attack = 0.1, decay = 0.1, sust = 0.7, rel = 0.2, attackf = 0.1, decayf = 0.1, sustf = 0.9, relf = 0.2, gate = 1, freq =440, lagLev = 0.2;

var oscArray = [Saw.ar(Lag.kr(freq, lagLev)), SinOsc.ar(Lag.kr(freq, lagLev)), Pulse.ar(Lag.kr(freq, lagLev))];
var oscArray2 = [Saw.ar(Lag.kr(freq, lagLev)), SinOsc.ar(Lag.kr(freq, lagLev)), Pulse.ar(Lag.kr(freq, lagLev))];
var ampEnv = EnvGen.ar(Env.adsr(attack, decay, sust, rel), gate, doneAction:2);
var filterEnv = EnvGen.ar(Env.adsr(attackf, decayf, sustf, relf), gate, doneAction:2);
var osc1 = Select.ar(oscType, oscArray);
var osc2 = Select.ar(oscType2, oscArray2);
var fade = Pan2.ar(XFade2.ar(osc1, osc2, pan , level * ampEnv, 0));
var filter = MoogFF.ar(fade, cutoff * filterEnv, gain);
Out.ar(0,filter)

}).store
)

All I've done here is encapsulated each of my frequency arguments for the oscillators in a lag Ugen. The slide time, or the time it takes for the pitch of each note to move from it's original value to the new note is set by the lagLev argument, in seconds.

To make this work you'll need to use a Pmono pattern, it won't work if a new synth is created with each note as it would be with a Pbind pattern.

And that's Jazz.

A simple GUI

2009-02-22T16:32:00.000-08:00

Controlling a synth with text isn't always intuitive, so I've decided to start working towards creating a GUI for my little Moogesque synth.

To begin with I've created a very simple interface with two sliders that allow me to control the filter cutoff frequency and the resonance gain.

Here's the Moog synthdef again.

(
SynthDef("Moog",{

arg oscType =0, oscType2 = 1, pan = 0, level = 0.5, cutoff = 500, gain = 3.3, attack = 0.1, decay = 0.1, sust = 0.7, rel = 0.2, attackf = 0.1, decayf = 0.1, sustf = 0.9, relf = 0.2, gate = 1, freq =440;

var oscArray = [Saw.ar(freq ), SinOsc.ar(freq), Pulse.ar(freq)];
var oscArray2 = [Saw.ar(freq), SinOsc.ar(freq), Pulse.ar(freq)];
var ampEnv = EnvGen.ar(Env.adsr(attack, decay, sust, rel), gate, doneAction:2);
var filterEnv = EnvGen.ar(Env.adsr(attackf, decayf, sustf, relf), gate, doneAction:2);
var osc1 = Select.ar(oscType, oscArray);
var osc2 = Select.ar(oscType2, oscArray2);
var fade = Pan2.ar(XFade2.ar(osc1, osc2, pan , level * ampEnv, 0));
var filter = MoogFF.ar(fade, cutoff * filterEnv, gain);
Out.ar(0,filter)

}).store
)

I've added a panner to it to center the sound, but other than that it's the same for now.

This is my GUI code.

It should be cross platform but I've only tried it on OS X.

(
var window = Window.new("",Rect(400, 400, 140, 100)).front;
var cutoffSlider, cutoffRef, resgainSlider;

~resgainRef = PatternProxy(3);
~cutoffRef = PatternProxy(440);

cutoffSlider = Slider.new(window,Rect(10, 25, 100, 20));
cutoffSlider.action_{
var val;
val = (10000*(cutoffSlider.value));
val.postln;
~cutoffRef.source_(val);
};

StaticText.new(window,Rect(10, 5, 100, 20))
.string_("Cutoff")
.action_{|v| };

resgainSlider = Slider.new(window,Rect(10, 65, 100, 20));
resgainSlider.action_{
var val;
val = (4*(resgainSlider.value));
val.postln;
~resgainRef.source_(val);
};

StaticText.new(window,Rect(10, 45, 100, 20))
.string_("Resonance Gain")
.action_{|v| };
)

and here's a pattern incorporating the GUI elements I've created.

(
Pmono("Moog",
\freq, Pseq([440, 550, 660, 770, 660, 880], inf),
\dur, 0.2,
\oscType, Pseq([1,0,1,0,1], inf),
\oscType2, Pseq([0,0,2,2,1], inf),
\cutoff, (~cutoffRef),
\gain, (~resgainRef)

).play
)

This time I've used a Pmono for a more authentic sound, but more on that later...

A Filter and Even More Drum Machine

2009-02-17T16:54:00.000-08:00

Pulled from the ever informative SuperCollider Users Mailing List is this fine little example of an interesting low pass filter courtesy of nonprivate, aka DJ Cylob.

this is kind of nice,

here's the normal sort of lpf:

(
{
var f;
f = FSinOsc.kr(1, 0, 24, 84).midicps;
RLPF.ar(Saw.ar(70,0.2), f, 0.3)
}.play
)

but with this combo of lpf and mid eq, the bass disappears as the resonance increases, which is a bit more like a real filter.

(
{
var f;
f = FSinOsc.kr(1, 0, 24, 84).midicps;

MidEQ.ar(
LPF.ar(Saw.ar(70,0.2), f),
f,

0.5, 18, 0.6
)

}.play
)
"

Inspired by this I decided to see if I could use it on my drum machine and at the same learn how to send the output of a pattern through an effect.

Here's the code I came up with, adapted from the Pbind help file which covers this very topic.

(
SynthDef(\drums, {|out = 0, bassLevel = 0 , snareLevel = 0, hatLevel = 0, tomLevel = 0, pan1 = 0, pan2 = 0, pan3 = 0, pan4 = 0|

var env1, env2, env3, env4, bass, snare, hat, tom, bassOut, snareOut, hatOut, tomOut, mixer;
env1 = EnvGen.kr(Env.perc(0.001, 0.2, 1, -4), 1, doneAction:2);
env2 = EnvGen.kr(Env.perc(0.001, 0.5, 1, -1), 1, doneAction:2);
env3 = EnvGen.kr(Env.perc(0.002, 0.3, 1, -2), 1, doneAction:2);
env4 = EnvGen.kr(Env.perc(0.001, 0.1, 1, -5), 1, doneAction:2);
bass = SinOsc.ar(80) + Crackle.ar(1, 0.5);
bassOut = Pan2.ar(bass*env1, pan1, bassLevel);

snare = SinOsc.ar(120) - WhiteNoise.ar(0.5, 0.5);
snareOut = Pan2.ar(snare*env4, pan2, snareLevel);

hat = Klank.ar(`[ [ 6563, 9875 ],
[ 0.6, 0.5 ],
[ 0.002, 0.003] ], PinkNoise.ar(1));
hatOut = Pan2.ar(hat*env3, pan2, hatLevel);

tom = SinOsc.ar(440);
tomOut = Pan2.ar(tom*env4, pan4, tomLevel);

mixer = Mix.new([bassOut, snareOut, hatOut, tomOut]);

Out.ar(out, mixer);

}).store

)

(
SynthDef("lpfandmideq", { arg out;
var audio, efx, f;
f = SinOsc.kr(3, 0, 24, 84).midicps;
audio = In.ar(20,2);
efx= MidEQ.ar(
LPF.ar(audio, f),
f,

0.5, 18, 0.6
);

Out.ar(out, efx);
}).memStore;
)

(
a = Synth.after(1, "lpfandmideq");
)

(

a = Pseq ([1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0]);
b = Pseq ([0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0]);
c = Pseq ([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0]);
d = Pseq ([0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1]);
e = Pwhite (0.14, 0.16, inf);

p = Pbind(
\instrument, \drums,
\out, 20,
\dur, e,
\bassLevel, Pseq ([a], inf),
\snareLevel, Pseq ([b], inf),
\hatLevel, Pseq ([c], inf),
\tomLevel, Pseq ([d], inf)

).play;

)

To make this work you will need to make sure that you evaluate each section in brackets separately, apart from that it's pretty striaghtforward really.

In setting up the effect synth I needed to make sure that I set the input bus and the number of channels, this needs two beacuse the drum machine is a two channel synth

audio = In.ar(20,2);

then create an instance of this synth

(
a = Synth.after(1, "lpfandmideq");
)

and finally set the output of my pattern to the same bus that I set as the input of my effect.

\out, 20,

and that's Jazz.

Surprisingly easy really and it doesn't sound too bad.

More drum machine

2009-02-11T15:43:00.000-08:00

I've been fiddling with my maliciously inept drum machine a bit more and using a couple of the enormous selection of pattern classes I've added some new features.

A lot of real drum machines both hardware and software have a 'swing' or 'shuffle' which add a bit of syncopation though I suspect most of them do it in a more sophisticated way than what I've done here.

e = Pwhite (0.14, 0.16);

\dur, e,

I've used a Pwhite pattern to randomly select the \dur interval.

The Pwhite pattern randomly generates values from a range provided by the first two parameters and repeats this a number of times set by the third value entered, with inf being the default. Sticking this into my drum sequence means that the interval between each drum sound will be random, givning it a possibly more 'organic' feel. Or maybe just making it sound wonky.

I've seen some software synths that let the user generate random patterns, I've done something similar using a Pwrand.

f = Pwrand ([0, 1], [75, 25].normalizeSum, inf);

\bassLevel, Pseq ([f], inf),

A Pwrand pattern generates random numbers from a list with a weighted probability. The above line generates a pattern with a 25% chance of each step having a drum sound and a 75% chance of being silent.

Pwrand takes two arrays as arguments, the first one being the list of numbers to select randomly from, the second one being a list of probabilities, which should add up to one. Passing the second array a .normaliseSum message neatly side steps my poor mental arithmetic and automatically normalises the array elements to sum to one. Being able to weight the results makes the resulting pattern sound more rhythmic, without long silences or rolls that an unweighted probability would lead to.

Here's the full pattern with these two bits added.

(

a = Pseq ([1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0]);
b = Pseq ([0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0]);
c = Pseq ([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0]);
d = Pseq ([0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1]);
e = Pwhite (0.14, 0.16);
f = Pwrand ([0, 1], [75, 25].normalizeSum, inf);

p = Pbind(
\instrument, \drums,
\dur, e,
\bassLevel, Pseq ([f], inf),
\snareLevel, Pseq ([b], inf),
\hatLevel, Pseq ([f], inf),
\tomLevel, Pseq ([d], inf)

).play;

)

Simple Drum Machine

2009-02-10T15:53:00.000-08:00

After shamelessly flashing my Moog synth, I think it's time to reveal another SuperCollider creation. A very simple drum machine, made up of two parts. A SynthDef, defining my drums and a pattern template to play them.

Here's the SynthDef

bass = SinOsc.ar(80) + Crackle.ar(1, 0.5);
bassOut = Pan2.ar(bass*env1, pan1, bassLevel);

snare = SinOsc.ar(120) - WhiteNoise.ar(0.5, 0.5);
snareOut = Pan2.ar(snare*env4, pan2, snareLevel);

hat = Klank.ar(`[ [ 6563, 9875 ],
[ 0.6, 0.5 ],
[ 0.002, 0.003] ], PinkNoise.ar(1));
hatOut = Pan2.ar(hat*env3, pan2, hatLevel);

tom = SinOsc.ar(440);
tomOut = Pan2.ar(tom*env4, pan4, tomLevel);

mixer = Mix.new([bassOut, snareOut, hatOut, tomOut]);

Out.ar(out, mixer);

}).store

)

I have four sound sources, four envelopes and four panners.

I have to admit that the drum sounds are a bit crappy and need some more work, they've got a certain Casio feel to them, and not in a good way, but they do the job.

After some experimentation I've discovered that pretty much anything sounds something like a drum if you put it through a percussive envelope, but so far the best results seem to come from some sort of noise source and/or a SinOsc.

The bass drum is a fairly low frequency sine with a bit of crackle added to it at a low level.

The snare is a sine with some white noise subtracted from it, I don't fully understand this yet, but subtracting a white noise source from the sine sounded better than adding it.

A wild guess lead me to the klank UGen in creating the hat( I think it might be a felt one) and the tom is just a simple SinOsc.

All these sound sources are controlled with percussive envelopes, each with slightly varying attack and release times.

These are then passed to a two channel panner, which apart from allowing me to control the level of the sound also allows me to change the position of the sound between two channels.

Here's the pattern I use to control it.

(

a = Pseq ([1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0]);
b = Pseq ([0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0]);
c = Pseq ([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0]);
d = Pseq ([0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1]);

p = Pbind(
\instrument, \drums,
\dur, 0.12,
\bassLevel, Pseq ([a], inf),
\snareLevel, Pseq ([b], inf),
\hatLevel, Pseq ([c], inf),
\tomLevel, Pseq ([d], inf)

).play;

)

The args passed to my SynthDef include levels for each of the drums. Sequencing these using a pattern seemed like the easiest way of triggering them. Each value of the pattern can be set at either 0 for no drum or >0 to trigger a drum sound. This might not be the most efficient way of doing things but it does work.

I still don't understand exactly how it works, but the /dur argument sets the tempo, I think each event is timed as a fraction of the default clock setting of 1, but I could be wrong.

You can do all kinds of great things with patterns, above I'm nesting them rather than defining them directly which will allow me to more easily create complex drum sequences. If I want to compose a song I can define more patterns and sequence them with the main pattern.

(

a = Pseq ([1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0]);
b = Pseq ([0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0]);
c = Pseq ([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0]);
d = Pseq ([0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1]);
e = Pseq ([0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1]);

p = Pbind(
\instrument, \drums,
\dur, 0.12,
\bassLevel, Pseq ([a], inf),
\snareLevel, Pseq ([b, e], inf),
\hatLevel, Pseq ([c], inf),
\tomLevel, Pseq ([d], inf)

).play;

)

Like that.

Moooog

2009-02-09T15:18:00.000-08:00

Last post I showed of my wonderfully entertaining Moog style synth. This time I'm going to go into some of it in more detail.

Envelopes have troubled me for a while and mental images of stationary have not helped me understand what they do. After much study I have learned they are in fact structures that control a particular aspect of a sound over time, usually the amplitude or volume, but also filters and effects.

I use two in this synth, one to control the amplitude of the oscillators and one to control the filter.

(
SynthDef("Moog",{

arg oscType =0, oscType2 = 1, pan = 0, level = 0.5, cutoff = 500, gain = 3.3, attack = 0.1, decay = 0.1, sust = 0.7, rel = 0.2, attackf = 0.1, decayf = 0.1, sustf = 0.9, relf = 0.2, gate = 1, freq =440;

var oscArray = [Saw.ar(freq ), SinOsc.ar(freq), Pulse.ar(freq)];
var oscArray2 = [Saw.ar(freq), SinOsc.ar(freq), Pulse.ar(freq)];
var ampEnv = EnvGen.ar(Env.adsr(attack, decay, sust, rel), gate, doneAction:2);
var filterEnv = EnvGen.ar(Env.adsr(attackf, decayf, sustf, relf), gate, doneAction:2);
var osc1 = Select.ar(oscType, oscArray);
var osc2 = Select.ar(oscType2, oscArray2);
var fade = XFade2.ar(osc1, osc2, pan , level * ampEnv);
var filter = MoogFF.ar(fade, cutoff * filterEnv, gain);
Out.ar(0,filter)

}).store
)

This here is the SynthDef. I've created two arrays of oscillators which are selected by the arg osc type being passed to the Select ugen.

The envelopes are created by these two lines,

var ampEnv = EnvGen.ar(Env.adsr(attack, decay, sust, rel), gate, doneAction:2);
var filterEnv = EnvGen.ar(Env.adsr(attackf, decayf, sustf, relf), gate, doneAction:2);

I create a new envelope generator object and pass it an adsr (attack, decay, sustain release) evelope specification. The variables attack, decay, sustain and release contain the time in seconds.

var fade = XFade2.ar(osc1, osc2, pan , level * ampEnv);
var filter = MoogFF.ar(fade, cutoff * filterEnv, gain);

Here I times the output of the evnvelopes by the level of the cross fade and the cuttoff frequency of the moog filter giving me a output which is changed over time by the envelope.

Moog Thing

2009-02-07T14:36:00.000-08:00

This is a blog about SuperCollider.

Whilst supercollider isn't my first language, I'm not a hugely experienced programmer, so this is going to be very much from a newbies perspective.

Lets start at the beginning.

This is the first real SuperCollider program that I managed to get working, very closely aided by my mate Dan who is very good at Supercollider indeed.

(
SynthDef("Moog",{

arg oscType =0, oscType2 = 1, pan = 0, level = 0.5, cutoff = 500, gain = 3.3, attack = 0.1, decay = 0.1, sust = 0.7, rel = 0.2, attackf = 0.1, decayf = 0.1, sustf = 0.9, relf = 0.2, gate = 1, freq =440;

var oscArray = [Saw.ar(freq ), SinOsc.ar(freq), Pulse.ar(freq)];
var oscArray2 = [Saw.ar(freq), SinOsc.ar(freq), Pulse.ar(freq)];
var ampEnv = EnvGen.ar(Env.adsr(attack, decay, sust, rel), gate, doneAction:2);
var filterEnv = EnvGen.ar(Env.adsr(attackf, decayf, sustf, relf), gate, doneAction:2);
var osc1 = Select.ar(oscType, oscArray);
var osc2 = Select.ar(oscType2, oscArray2);
var fade = XFade2.ar(osc1, osc2, pan , level * ampEnv);
var filter = MoogFF.ar(fade, cutoff * filterEnv, gain);
Out.ar(0,filter)

}).store
)

it's a synth. A simple Moog inspired thing, with two oscillators, which can be either saw, sin or square/pulse waves and a mixer to mix them. It's also got a filter and two envelopes, one controlling the filter and one controlling the amplitude.

here's a pattern to play it with.

(
Pbind(
\instrument, "Moog",
\freq, Pseq([440, 550, 660, 770, 660, 330, 880], inf),
\dur, Pseq([0.2, 0.4, 0.1, 0.2, 0.2], inf),
\oscType, Pseq([0,0,0,0,0], inf),
\oscType2, Pseq([0,0,2,2,1], inf),
\cutoff, Pseq([100,599,1000,20,800], inf),
\pan, Pseq([1], inf)

).play
)

I'll go into more details of it's workings later...