Category Archives: Compositions

SuperCollider Workshop – Code Examples

Compositions, Research

/*I have been doing  half-day SuperCollider workshops in the past few years. SuperCollider is a code-based audio freeware, and it  is the main program I use for my performance and composition.

Below is my “handouts”  for my workshops. You may copy-past it or download this workshophandouts.txt file and open it with SuperCollider. and you will be able to make some sounds in few minutes.

If you are interested in learning the program, please contact me. */

//

//

//SuperCollider Workshop @ EM2013
//by Joo Won Park (www.joowonpark.net) joowon@joowonpark.net

//SuperCollider is a text-based synthesizer and algorithmic composer.
//SC makes you think in codes and numbers
// Code: “algorithm written in programming language” (from Form & Code by Casey Reas)
// Algorithm: “precise instructions on how to do things” (from Form & Code)
//In other words, SC makes set of instructions to do music/audio related things.

//how to execute things : select/highlight, and then press enter (shift+return), not return
3+6
(3*6)+(2/3)*(4.444432)
10%3
When SC does not understand a line, such as this one, there will be an error message in post window
// when two slash lines are in front of a code, it is considered as comment. execute this line

//Method can be thought as “do something” command. For list of common methods, go to Help->Browse->Common methods.
“Hello”.speak //Mac only
speak(“Hello”)
(3+6).neg
neg(3+6)
(3+6).neg.abs

//SC’s Server needs to be booted in order to execute audio-related codes.
//Boot the Interpreter with command+B or Language->Boot
//Press command+. (period) to stop the sound
{Saw.ar(440,0.5)}.play //Note the syntax.

//use command+D for help files. Double click on the word

//how to use svariables
(
//when executing multiple lines of code, separate them with ;
//grouping codes with () is also very helpful
x=4;
y=8;
x+y
)//you can double click ) or ( to select all the contents inside ()

(x=4; y=8;x+y)
x=4; y=8;x+y

//when using other than a-z as variable, declar it with var
(var words;
words=”double slash at the beginning of the line means comment”;
words.speak
)

(
a={Saw.ar(440)};
a.play
)
//how to make a function {}
//function is a set of instructions that changes value of input x into output y.
//function processes things

//use argument to make an input to the function
y={
arg input;
var distortion;
distortion = input*3;
};
y.value(4);
y.value(20.5);
y.value(5.rand); //execute this code multiple times

(
var appletalk;
appletalk={
arg word;
var talk;
talk = word.speak
};
appletalk.value(“I am an argument”);
)
//note that the following line will not work because argument and var names are local to ()
appletalk.value(“I am out of an argument”)

//this can be fixed using global variables (letters a-z and any var names starting with ~)
z={
arg word;
var talk;
talk = word.speak
};
z.value(“I am an argument”);
z.value(“me too”);

~globalappletalk={
arg word;
var talk;
talk = word.speak
};
~globalappletalk.value(“I am an argument”);
~globalappletalk.value(“me too”);
//one catch with using global var is that you won’t be able to detect syntax (spelling & grammar) errors easily.
~globalappletalkkk.value(“I won’t be executed, but you won’t know why”);

//SynthDef : how to make a function with audio
//use SynthDef (not Synthdef or synthDef) to make an audio-related code with var and arg

SynthDef(“FirstSaw”,{
arg pitch;
var sound,envelope,sound2;
sound = Saw.ar(pitch);
envelope = Line.ar(1,0,2); //make an envelope that changes from 1 to 0 in 2 secondes
sound2 = sound*envelope;
Out.ar(0,sound2)
}).load(s) // make sure to load the synthdef into the server

Synth.new(“FirstSaw”,[\pitch,440]) //make a new synth (an audio event)
Synth(“FirstSaw”,[\pitch,440]) //.new can be omitted
Synth.new(“FirstSaw”,[\pitch,440*2])
Synth.new(“FirstSaw”,[\pitch,69.midicps]) //midi to freq converter

(
var randomizer;
randomizer=60+(12.rand);
Synth.new(“FirstSaw”,[\pitch,randomizer.midicps])
)

//how to change a parameter of a synth in realtime
SynthDef(“LongSaw”,{
arg lforate=3,lfopitch=1,pitch;
var sound,sound2;
sound = SinOsc.ar(lforate,0,lfopitch);
sound2 = Saw.ar(pitch+sound,0.5);
Out.ar(0,sound2)
}).load(s)

a=Synth.new(“LongSaw”,[\pitch,60.midicps,\lforate,1,\lfopitch,10.midicps])
// use .set to change parameters in realtime
a.set(\lforate,3)
a.set(\lforate,5,\lfopitch,10.midicps)
//the following will not work… for now
a.set(\lforate, Line.kr(1,200,0))
a.free //.free deletes the specified synth from the server

//Routine: Making algorithm on how/when to produce sound
//(the bread and butter of sc)
SynthDef(“ForRoutine”,{
arg pitch,vol,dur;
var sound,envelope,sound2;
sound = Saw.ar(pitch);
envelope = Line.ar(1,0,dur);
sound2 = sound*envelope;
Out.ar(0,sound2*vol)
}).load(s)

//here’s a simple randomization of the pitch
Synth.new(“ForRoutine”,[\pitch,60.rand.midicps,\vol,0.5,\dur,2])

//know the difference
2.rand
2.0.rand

//let’s control the range of randomness
(
~randomize=60+(12.rand);
Synth.new(“ForRoutine”,[\pitch,~randomize.midicps,\vol,0.5,\dur,2])
)

//Using a “do loop”, we can repeat the task as fast as the computer can to make a chord
4.do{
~randomize=60+(12.rand);
(“MIDI note “++~randomize++” is chosen”).postln;
//this .postln monitors what note is played
Synth.new(“ForRoutine”,[\pitch,~randomize.midicps,\vol,0.5,\dur,2])
}

//a loop inside a Routine can execute the task with controlled timing

Routine({
4.do{
~randomize=60+(12.rand);
(“MIDI note “++~randomize++” is chosen”).postln;
Synth.new(“ForRoutine”,[\pitch,~randomize.midicps,\vol,0.5,\dur,2]);
1.wait
}
}).play

~sequence1=Routine({
4.do{
~randomize=60+(12.rand);
(“MIDI note “++~randomize++” is chosen”).postln;
Synth.new(“ForRoutine”,[\pitch,~randomize.midicps,\vol,0.5,\dur,0.1+(1.0.rand)]);
0.5.rand.wait
}
})
~sequence1.play
~sequence1.reset //a routine needs to be reset if you want to play the same routine again.

//infinite loop
~sequence2=Routine({
loop{
~randomize=60+(12.rand);
(“MIDI note “++~randomize++” is chosen”).postln; //this .postln monitors what note is played
Synth.new(“ForRoutine”,[\pitch,~randomize.midicps,\vol,0.5.rand,\dur,0.5]);
0.5.rand.wait
}
})
~sequence2.play
~sequence2.stop
~sequence2.reset //a routine needs to be reset if you want to play the same routine again.
//infinite loop2
~sequence3=Routine({
loop{
~randomize=60+(24.rand2);
(“MIDI note “++~randomize++” is chosen”).postln; Synth.new(“ForRoutine2”,[\pitch,~randomize.midicps,\vol,0.5.rand,\dur,0.05]);
0.03.wait
}
})
~sequence3.play
//The above loop will eventually crash the SC in few seconds due to inappropriate memoey allocations (Check Peak CPU of localhost server)
//Use doneAction function in envelopes to prevent it

SynthDef(“ForRoutine2”,{
arg pitch,vol,dur;
var sound,envelope,sound2;
sound = Saw.ar(pitch);
//use doneAction to minimize the CPU usage
envelope = Line.ar(1,0,dur,doneAction:2);
sound2 = sound*envelope;
Out.ar(0,sound2*vol)
}).load(s);

~sequence3=Routine({
loop{
~randomize=60+(24.rand2);
(“MIDI note “++~randomize++” is chosen”).postln;
Synth.new(“ForRoutine2”,[\pitch,~randomize.midicps,\vol,0.5.rand,\dur,0.05]);
0.05.wait
}
})
~sequence3.play

//Arrays : what makes SC a great program
//the bread and butter 2

//array is a list enclosed with []
[0,4,7]
60+[0,4,7]
60+([0,4,7].choose)
Array
SequenceableCollection
Array.series(6,0,2) //whole tone scale

//applying array to make a controlled randomization
SynthDef(“ForRoutine2”,{
arg pitch,vol,dur;
var sound,envelope,sound2;
sound = Saw.ar(pitch);
envelope = XLine.ar(1,0.0001,dur,doneAction:2);
sound2 = sound*envelope;
Out.ar(0,sound2*vol)
}).load(s)

~sequence4=Routine({
loop{
~randomize=60+([0,4,7,11].choose);
(“MIDI note “++~randomize++” is chosen”).postln;
Synth.new(“ForRoutine2”,[\pitch,~randomize.midicps,\vol,0.5.rand,\dur,0.1]);
0.1.wait
}
})
~sequence4.play

//applying array to make a controlled randomization of pitch and rhythm
~sequence5=Routine({
loop{
~randomize=60+([0,4,7,11].choose);
(“MIDI note “++~randomize++” is chosen”).postln; Synth.new(“ForRoutine2”,[\pitch,~randomize.midicps,\vol,[0.5,0.8].choose.rand,\dur,0.1]);
[0.1,0.2,0].choose.wait
}
})
~sequence5.play

//applying array to make a controlled randomization of pitch and rhythm ver2
~pitchset = [0,4,7,11];
~sequence6=Routine({
loop{
~randomize=60+(~pitchset.choose);
(“MIDI note “++~randomize++” is chosen”).postln; Synth.new(“ForRoutine2”,[\pitch,~randomize.midicps,\vol,[0.5,0.8].choose.rand,\dur,0.1]);
[0.1,0.2,0].choose.wait
}
});
~sequence6.play

//change ~pitchset to to play different harmony
~pitchset=[0,3,7,11];
~pitchset=Array.series(6,0,2);
~pitchset=3 //this will give you an error
// Also, synth.set will not work, or will work for only one note because each note triggered with Routine is a separate synth
~pitchset=[3] //make an array with one list instead

//play a melody loop
~pitchset = [0,4,7,11];
~pitchlist = ~pitchset.asList; //convert an array into a “list” that can be interpreted by do loops
~sequence7=Routine({
loop{
~pitchset.do{
arg chosenpitch; //the first argument in a do loop corresponds to the firt value on the list
~randomize=60+chosenpitch;
(“MIDI note “++~randomize++” is chosen”).postln; //this .postln monitors what note is played
Synth.new(“ForRoutine2”,[\pitch,~randomize.midicps,\vol,0.5,\dur,0.1]);
0.1.wait;
}
}
});
~sequence7.play
~pitchset=[0,4,7,11]-2
~pitchset=Array.series(25,0,2)

//Challenge : analyze the following code. run ~sequence7 first
Routine({loop{~pitchset=[[0,4,7,11],[0,4,7,11]-2,[0,4,7,11]-4].choose;4.wait}}).play
//Summary : why use SC?
//SuperCollider makes users explore different modes of expression and composition
//1. customization & precision not easily available to commercial DAW
{SinOsc.ar(Line.kr(0,22000,20.39203),0,0.3)}.play
//2. “If computers could be used to model what we know, then perhaps we could also use them to simulate what we don’t know” (Form+Code by Reas)
//If computers could be used to model what we can play, then perhaps we could also use them to simulate what we can’t play
//3. Powerful DSP

//vanilla
SynthDef(“PulseThing”,{
arg pitch=500,width=0.5, vol=0.8; //you can set initial value of arguments
var sound1;
sound1 = Pulse.ar(pitch,width,vol);
Out.ar(0,sound1)
}).load(s);
Synth(“PulseThing”);

//vanilla + one topping
SynthDef(“PulseThing”,{
arg pitch=500,width=0.5, vol=0.8;
var sound1;
sound1 = Pulse.ar([pitch,pitch*0.5],[width,width*0.5],vol); //array makes a new signal
Out.ar(0,sound1)
}).load(s);
Synth(“PulseThing”);

//vanilla + many toppings
SynthDef(“PulseThing”,{
arg pitch=500,width=0.5, vol=0.8;
var sound1,cluster,mix;

cluster= Array.fill(10,{0.3.rand}).postln; //fill an array with five radom values between 0 and 0.3
sound1 = Pulse.ar(pitch+(pitch*cluster),width*cluster,vol); //this will create a 10 channel audio
mix = Mix(sound1); //mix 10 channel audio into a mono signal

Out.ar(0,mix)
}).load(s);
Synth(“PulseThing”); //note that you need to run the SynthDef again to make a new set of randomized array

//mint
SynthDef(“PulseThing”,{
arg pitch=500,width=0.5, vol=0.8;
var sound1,cluster,mix,filter;

cluster= Array.fill(10,{0.3.rand});
sound1 = Pulse.ar(pitch+(pitch*cluster),width*cluster,vol);
mix = Mix(sound1);

filter = HPF.ar(mix, MouseX.kr(300,10000));
//highpass filter controlled with x-axis of a mouse

Out.ar(0,filter)
}).load(s);
Synth(“PulseThing”);

//Challenge: here’s the above SynthDef in one line.
{HPF.ar(Mix(Pulse.ar(500+(500*(Array.fill(10,{0.3.rand}))),0.5*(Array.fill(10,{0.3.rand})),0.8)), MouseX.kr(300,10000))}.play
//banana split
SynthDef(“Voice”,{
arg pitch=500,width=0.5;
var voice,sound1,cluster,mix,delay;

cluster= Array.fill(10,{0.3.rand2});
voice = AudioIn.ar(1); //get real-time audio
sound1 = PitchShift.ar(voice,0.2,1+cluster); //this will create a 10 channel audio
mix = Mix(sound1*0.3); //mix 10 channel audio into a mono signal
delay = CombC.ar(mix,0.5,0.4,2);

Out.ar(0,delay+voice)
}).load(s);
Synth(“Voice”);

//sundae
~sample1 = Buffer.read(s,”sounds/Fflies.aif”); //load a sample to a buffer
//SC willtry to find the sound in the folder where the actual SC application is located
SynthDef(“Voice”,{
var voice,sound1,cluster,mix,delay;

cluster= Array.fill(10,{0.5.rand2}); //fill an array with five radom values between -0.3 and 0.3

sound1 = PlayBuf.ar(2,~sample1.bufnum,1+cluster); //this will create a 20 channel audio using a sample
mix = Mix(sound1*0.3); //mix 10 channel audio into a mono signal

Out.ar(0,mix)
}).load(s);
//press record button in localhost server to record a sound
Synth(“Voice”);

//Examples:
www.100strangesounds.com

//Final SC Tips
//- count your ()s and {}s. one missing ( can trigger a dramatic whining in the post window
//- spelling is crucial. Synth and synth are different. Have a habit of naming your variable with lower-case letters so it it does not get syntax-colorized with blue.
//- be extra careful in spelling when using a gloabal variable
//- SC documentation is a great textbook.
//For further studies, I recommend to look at the following features
if
In
Out
MIDIResponder
OSCresponder
GUI
Patterns

 

 

Work in Progress : The Hunchback of Notre Dame

Compositions, , , , ,

I’m in charge of the sound and music for The Renegade Company’s upcoming theatre production. The company will reinterpret The Hunchback of Notre Dame in a silent movie style. There will be no dialogues in this nightmarish and grotesque version, and my electronic sounds will fill the space instead.

The director of the company proposed me to make a painful sound to reflect the main character’s suffering.  The play is set in Quasimodo’s dream, and therefore the sound should also convey Quasimodo’s severe hearing damage as well as his emotional state. I imagine that many years of playing the church bell may have caused Quasimodo tinnitus or ringing in the ear.

The most challenging part of this project is that I will not be able to attend some of the shows as I will be 7+ hours away from the theater (a beautiful church in Center City Philadelphia). Despite this geographic challenge, I do not want to make a fixed audio file for this project.  Instead, I want to make an easy-to-operate  software that make unique sounds for each show.  I also decided to focus on the emotional aspect of the characters.

HunchBackProto

The instrument I am building has four emotion sliders: fear, happy, sad, and anger. Each emotion currently has 3-4 different sounds that are controlled by corresponding slider. Also, there are buttons to turn on a sound that simulates tinnitus  and trigger bell sounds.

Below is an example sound of what my current system can do. I improvised for about 6 minutes by combining different emotions as well as triggering tinnitus and bell sounds.

For the actual show, I expect that the sound guy will do the following  tasks:

  1. Press emotion buttons whenever there is a scene or character change. The button will randomly trigger a sound. For example, Quasimodo’s happy sound could be different from Esmeralda’s happy sound.
  2. Increase the slider as the character’s emotion intensifies. For examples, if Quasimodo is little sad, put the slider to 30%. If Quasimodo is extremely sad, crank up the slider to 100%. The change in slider movement will change the “intensity” of the sound. There are many different interpretations of intensity in this software.
  3. Click Tinnitus button. The sound is very long and emotionally draining
  4. Click Bell button according to the play’s cue. The bell sound has an algorithm to play different resonances every each time.

There are many benefits of composing a software instead of recording tracks.

  1. The sound can response more flexibly to the character’s action, especially at improvised sections.
  2. The music sound different every time it is played. They will sound familiar, but the details will be different (think about a jazz pianist interpreting a standard. The pianist would play the same chord progression, but the actual resulting sounds are different every time).
  3. The software is easy enough to be operated by anyone. I shouldn’t have to be there to create sounds.

I’ll be meeting with the director in few days to show my progress. If the director likes the idea, I continue to work on it. I’m also waiting for the response of a percussionist. If he is available, there will be a live percussion accompaniment on top of the electronic part. If he’s unavailable, the sound needs to be a little more exciting.

Please feel free to let me know your thoughts on the sound and performance approach. Does it resemble the sound world of Quasimodo’s nightmare? Do you foresee any technical troubles?