Time varying sounds

We have been making sounds so far that go on forever until we press a key to stop synthesising (sometimes they faded to silence, but were still running in the background after that!). 

Most of the time, we'll want to make sounds that go on for a limited time, and stop of their own accord. 

Listen to the difference between these two:

{SinOsc.ar(440,0,0.1)}.scope //Sine Oscillator goes on forever

{SinOsc.ar(440,0,Line.kr(0.1,0.0,1.0))}.scope //One second for the sine to disappear entirely

In the second example, I multiplied the sine wave by a line generator that started at 0.1 but went 

to zero over the course of a second.

However, whilst the second sound fades out, both Synths hang around on the synthesis server unless you sent the stop command explicitly.   

Compare (by watching your Synth count on the server graphic, for instance):

{SinOsc.ar(440,0,Line.kr(0.1,0,1,doneAction:2))}.scope //doneAction:2 causes the Synth to be terminated once the line generator gets to the end of its line


In general, we want total control over how parameters of a sound (like volume or frequency) vary over time. 

This is often done by using envelopes. 

 //help files- [Env] [EnvGen]

Env([1,0,1],[1,1]).plot  //This makes an Envelope with three control points, at y positions given by the first array, and separated in x by the values in the second (see the Env help file). The curve drawn out should actually look like a letter envelope!

The .plot gives a quick way of seeing the envelope. We won't need it for synthesis but it helps for you to see some envelope shapes.

//various types of envelope demonstrated:

Env([0,1,0],[1.0,0.5]).plot  //one second 0 to 1 then half a second 1 to 0

Env.linen(0.03,0.5,0.1).plot  //linen has attackTime, sustainTime, releaseTime, level, curve

Env.adsr(0.01, 0.5, 0.5, 0.1, 1.0, 0).plot  //attackTime, decayTime, sustainLevel, releaseTime,

peakLevel, curve

//note that the sustain portion is not shown in time; this particular envelope type deals with variable hold times, and the hold is missed out in the plot

Here's another type of Envelope, good for making percussion sounds:

Env.perc(0.05,0.5,1.0,0).plot //arguments attackTime, releaseTime, level, curve: good for percussive hit envelopes

There are many more types of Envelope to discover and deploy

Let's start using Envelopes for synthesis. We use EnvGen to run the desired Envelope over time.

This is the envelope we'll run:


The following just runs the Envelope: its too slow to hear any sounds (your ears only pick frequencies over 16-20Hz)


This is multiplying a simple sine tone at 440Hz by the envelope over time, to make a limited duration sound


Let's try a slightly more complex example.

I'm going to use an envelope for frequency:


The EnvGen gets plugged into the frequency input of the Saw wave:


Now I'll change the frequency of Saw over 0.5 second and have its amplitude go to zero over 2 seconds:


(A fast frequency sweep is called a chirp in engineering literature, btw).

You can see how the nesting can get more and more complex, and it's now very difficult to read 

the code to see what's going on. This should really be neatened up by writing over a few lines:



EnvGen.kr(Env([10000,20],[0.5])),  //frequency input

EnvGen.kr(Env([0.1,0],[2.0]))      //amplitude input




In SuperCollider you find yourself having to work out what is plugged into what for complex networks,

all written as text. Remember that it may help you if you draw a diagram on paper of the connections. 

I made one subtle difference when I rewrote it: I ran the EnvGen ar control rate (.kr) rather than audio rate (.ar). 

We've tried both .kr or .ar and there's no real difference to our ears (the changes are relatively slow, at least compared to audio oscillator calculations for high frequencies).

We often use .kr when possible, because it means a lower CPU load and ultimately we can run many more

UGens at once. 

Envelopes have a further use of prime importance: they can cause a running collection of UGens to be deallocated once a multiplier envelope has run through its course. 

We'll need this when creating temporary events live. You don't want completed voices hanging around and wasting your CPU when you could be synthesising new voices.

//FM sound





EnvGen.kr(Env([0.5,0.0],[1.0]), doneAction:2)   //doneAction:2 appears again, the deallocation operation




The doneAction argument means that the envelope, on completion, causes its enclosing Synth to be freed.

The only thing that matters is how long the envelope lasts in time: the following also deallocates 

when the envelope ends, though it is controlling frequency rather than amplitude: 


Note how the graphical server status GUI shows no running Synths once this is deallocated. 

We already saw some UGens that can be used like Envelopes, without the two stage 

Env/EnvGen construction. They work in deallocation too - here are examples:

Line //straight line generator

XLine //exponential line generator



There is a remaining thing to explain. I introduced the adsr Env type, and said it could deal with holding open for an unknown time, but did not go further then. 

If you explore the Env help file you'll find references to the releaseNode and loopNode. Let's explain these; they may come in handy later. 

Releasing envelopes

Whilst some envelopes just run through their stages without intervention: 


others will freeze at a certain point, requiring a further instruction to 'release':

a = {EnvGen.ar(Env.asr(0.1,0.1,1.0),doneAction:2)*SinOsc.ar(330)}.play //sound continues

a.release(2.0); //let it finish, taking 2.0 seconds to fade out (it then deallocates, due to the doneAction:2)

//similar, but explicitly using gate argument, which holds the envelope at the releaseNode

a = {arg gate=1; EnvGen.ar(Env.asr(0.1,0.1,0.9),gate,doneAction:2)*SinOsc.ar(330)}.play

a.set(\gate,0) //when gate is set to 0, the envelope can finish, and takes 0.9 seconds to fade out (releaseTime argument to Env.asr set above)

You will normally have a gate argument in these situations; one was missed out above when introducing release just for simplicity of exposition. 

To count the releaseNode number for an arbitrary envelope, imagine that the series of amplitude levels AFTER THE FIRST are indexed; each level and corresponding time gap leading to it is one node


e = Env([0.2,1.0,0.0],[0.1,3.0],0,1); //releaseNode at node 1, which is the pair of 0.0 level in the first array and 3.0 seconds in the second. 

a= {arg gate=1; EnvGen.ar(e,gate,doneAction:2)*SinOsc.ar(550,0,0.1)}.play

a.set(\gate, 0); //takes 3.0 seconds to fade out

Looping envelopes

You can also get an envelope to go into a loop between the releaseNode minus one and the loopNode (the loopNode must be earlier than the releaseNode to be useful). Again, when receiving the release message or explicitly setting gate=0, the envelope transitions to the releaseNode and thence to the close.  

e = Env([0.0,0.0,1.0,0.0],[0.5,1.0,2.0],0,2,0); //releaseNode at 2, loopNode at 0

a= {arg gate=1; EnvGen.ar(e,gate,doneAction:2)*SinOsc.ar(550,0,0.1)}.play

a.set(\gate, 0); //takes 2.0 seconds to fade out

If you set the envelope looping fast enough, you can get interesting control signals and even head towards audio rate waveforms.

e = Env([0.0,1.0,-1.0,0.0],[0.01,0.01,2.0],0,2,0); //releaseNode at 2, loopNode at 0


a= {arg gate=1; EnvGen.ar(e,gate,timeScale:MouseX.kr(0.1,2.0),doneAction:2)}.play

a.set(\gate, 0); //stops immediately since release transition to 0.0 occurs over 2 seconds, too slow to be a pitched oscillation