View source for FaustWorkshop2014

== Day 1 ==

Optional textbook to go further: http://www.amazon.com/Physical-Audio-Signal-Processing-Instruments/dp/0974560723

==== Simple Gain Controller ====

<pre style="white-space: pre-wrap; 
white-space: -moz-pre-wrap; 
white-space: -pre-wrap; 
white-space: -o-pre-wrap; 
word-wrap: break-word;">
import("filter.lib");

process = *(hslider("gain",0.5,0,1,0.01)) : smooth(0.999);
</pre>

==== Simple Sine Oscillator Synthesizer ====

<pre style="white-space: pre-wrap; 
white-space: -moz-pre-wrap; 
white-space: -pre-wrap; 
white-space: -o-pre-wrap; 
word-wrap: break-word;">
import("music.lib");
import("filter.lib");

g = hslider("myParameter",0,0,1,0.01);
freq = hslider("frequency",440,50,1000,0.1);

myOsc(frequency,gain) = osc(frequency)*(smoothGain) 
with{
        // the smooth(0.999) function interpolates the different values of gain so that it doesn't click
	smoothGain = gain : smooth(0.999);
};

process = myOsc(freq,g) ;
</pre>

==== Working with Signals ====

<code>
process = _ <: _,_,_,_ :> _;
</code>

is the same as:

<code>
process = _ <: _+_+_+_;
</code>

==== Simple Panner ====

<pre style="white-space: pre-wrap; 
white-space: -moz-pre-wrap; 
white-space: -pre-wrap; 
white-space: -o-pre-wrap; 
word-wrap: break-word;">
import("filter.lib");

// the metadata "[style:knob]" turns the horizontal slider into a knob
pan = hslider("pan [style:knob]",0.5,0,1,0.01) : smooth(0.999);

process = _ <: *(pan),*(1-pan);
</pre>

==== Additive Synthesizer ====

<pre style="white-space: pre-wrap; 
white-space: -moz-pre-wrap; 
white-space: -pre-wrap; 
white-space: -o-pre-wrap; 
word-wrap: break-word;">
import("music.lib");
import("effect.lib");

gain = hslider("gain",0,0,1,0.01) : smooth(0.999);
freq = hslider("freq",440,50,1000,0.1) : smooth(0.999);
// the smooth function can be used as a simple envelope generator for gate
gate = button("gate") : smooth(0.999);

process = osc(freq),osc(freq*2),osc(freq*3) :> *(gain)*gate <: _,_;
</pre>

The last line of the code can be replaced by:

<code>
process = par(i,3,osc(freq*(i+1))) :> *(gain)*gate <: _,_;
</code>

or

<code>
process = sum(i,3,osc(freq*(i+1))) : *(gain)*gate <: _,_;
</code>

= Day 2 =

=== Wave Shape Synthesis ===

<pre style="white-space: pre-wrap; 
white-space: -moz-pre-wrap; 
white-space: -pre-wrap; 
white-space: -o-pre-wrap; 
word-wrap: break-word;">
saw1(freq) // Sawtooth wave 
lf_imptrain(freq) // Impulse train
lf_squarewave(freq) // Square wave
</pre>

=== Tremolo and Ring Modulation ===

<pre style="white-space: pre-wrap; 
white-space: -moz-pre-wrap; 
white-space: -pre-wrap; 
white-space: -o-pre-wrap; 
word-wrap: break-word;">
import("filter.lib");

freq = hslider("freq",2,1,500,0.01);
gain = hslider("gain",1,0,1,0.01) : smooth(0.999);
depth = hslider("depth",0,0,1,0.01) : smooth(0.999);

ringMod = *(1-(depth*osc(freq)/2 + 0.5));

process = ringMod*gain <: _,_;
</pre>

=== Stereo Ring Modulator ===

<pre style="white-space: pre-wrap; 
white-space: -moz-pre-wrap; 
white-space: -pre-wrap; 
white-space: -o-pre-wrap; 
word-wrap: break-word;">
import("filter.lib");

freq = hslider("freq",2,1,500,0.01);
gain = hslider("gain",1,0,1,0.01) : smooth(0.999);
depth = hslider("depth",0,0,1,0.01) : smooth(0.999);

pan = 1-(depth*osc(freq)/2 + 0.5);
stereoRingMod = _ <: *(pan),*(1-pan); 

process = stereoRingMod : *(gain), *(gain);
</pre>

=== Delay ===

One sample delay:

<code>
_';
</code>

N samples delay:

<code>
_@N;
</code>

Fractional delay:

<code>
fdelay1(MaxDelayLength, delayLength)
</code>

=== The Simplest Lowpass/Highpass Filter ===

<pre style="white-space: pre-wrap; 
white-space: -moz-pre-wrap; 
white-space: -pre-wrap; 
white-space: -o-pre-wrap; 
word-wrap: break-word;">
import("filter.lib");
import("music.lib");

b1 = hslider("feedforward",0,-1,1,0.01) : smooth(0.999);
filter = _ <: _+(_' : *(b1)) : *(0.5); 
process = noise : filter;
</pre>

=== Feedforward Comb Filter ===

<pre style="white-space: pre-wrap; 
white-space: -moz-pre-wrap; 
white-space: -pre-wrap; 
white-space: -o-pre-wrap; 
word-wrap: break-word;">
import("filter.lib");
import("music.lib");

b = hslider("feedforward",0,-1,1,0.01) : smooth(0.999);
del = hslider("del",1,1,100,1);
filter = _ <: _+(_@del : *(b)) : *(0.5);
process = noise : filter;
</pre>

=== Flanger ===

<pre style="white-space: pre-wrap; 
white-space: -moz-pre-wrap; 
white-space: -pre-wrap; 
white-space: -o-pre-wrap; 
word-wrap: break-word;">
import("music.lib");
import("filter.lib");

flangeDelay = hslider("flangeDelay",0.05,0.001,1,0.001)*SR*0.001;
depth = hslider("depth",0.5,-1,1,0.01) : smooth(0.999);
speed = hslider("speed",0.5,0.1,20,0.01);
gain = hslider("gain",0.8,0,1,0.01) : smooth(0.999);

myFlanger = _ <: _,fdelay1(1024,delayLength)*depth : + : *(0.5)
with{
	delayLength = flangeDelay*(1 + osc(speed))/2;
};

process = myFlanger*gain;
</pre>

= Day 3 =

=== Flanger with Advanced Interface ===

This interface is in no way better than the previous one. It just demonstrates what elements can be used to improve a simple Faust UI.

<pre style="white-space: pre-wrap; 
white-space: -moz-pre-wrap; 
white-space: -pre-wrap; 
white-space: -o-pre-wrap; 
word-wrap: break-word;">
import("music.lib");
import("filter.lib");
 
flangeDelay = hslider("[0]Flange Delay [tooltip: This is the flanger delay] [unit: ms] [style: knob]",0.05,0.001,1,0.001)*SR*0.001;
depth = hslider("[1]Depth",0.5,-1,1,0.01) : smooth(0.999);
speed = hslider("[2]Speed",0.5,0.1,20,0.01);
gain = hslider("[3]Gain",0.8,0,1,0.01) : smooth(0.999);

myFlanger = _ <: _,fdelay1(1024,delayLength)*depth : + : *(0.5)
with{
	delayLength = flangeDelay*(1 + osc(speed))/2;
};

process = vgroup("My Flanger",hgroup("[1]Flanger Parameters",myFlanger)*hgroup("[0]Gain",gain));
</pre>

=== Echo ===

<pre style="white-space: pre-wrap; 
white-space: -moz-pre-wrap; 
white-space: -pre-wrap; 
white-space: -o-pre-wrap; 
word-wrap: break-word;">
import("music.lib");
import("filter.lib");
delayDuration = hslider("duration",1,0.01,1,0.01); // in seconds
feedback = hslider("feedback",0,0,0.99,0.01) : smooth(0.999);
delayLength = SR*delayDuration;
process = (+ : fdelay(SR,delayLength)) ~ *(feedback);
</pre>

=== Feedback Comb Filter ===

https://ccrma.stanford.edu/~jos/pasp/Feedback_Comb_Filters.html

<pre style="white-space: pre-wrap; 
white-space: -moz-pre-wrap; 
white-space: -pre-wrap; 
white-space: -o-pre-wrap; 
word-wrap: break-word;">
import("music.lib");
import("filter.lib");
delayLength = hslider("delayLength",1,0,1000,1); // in samples
feedback = hslider("feedback",0,0,0.99,0.01) : smooth(0.999);
process = (+ : fdelay(1024,delayLength)) ~ *(-feedback);
</pre>

=== Karplus Strong  ===

A simple string physical model. An average filter is used to attenuate high frequencies faster than low frequencies. 

<pre style="white-space: pre-wrap; 
white-space: -moz-pre-wrap; 
white-space: -pre-wrap; 
white-space: -o-pre-wrap; 
word-wrap: break-word;">
import("filter.lib");
import("music.lib");

freq = hslider("freq",440,50,1000,0.1);
feedback = hslider("feedback",0,0,0.999,0.001);

string = + ~ (fdelay(1024,delayLength) : *(feedback) : filter)
with{
	delayLength = SR/freq;
	filter = _ <: (_+_')/2;
};

impulse = button("gate") <: _,_' : - : >(0);

process = impulse : string;
</pre>