cyfaust 0.1.0__cp311-cp311-macosx_15_0_arm64.whl

cyfaust/resources/libraries/examples/old/rewriting/fold.dsp

@@ -0,0 +1,61 @@
+
+// How to emulate Faust's seq, par, sum.
+// x(k) is assumed to yield the kth signal.
+
+xseq(1,x)	= x(0);
+xseq(n,x)	= xseq(n-1,x) : x(n-1);
+
+xpar(1,x)	= x(0);
+xpar(n,x)	= xpar(n-1,x) , x(n-1);
+
+xsum(1,x)	= x(0);
+xsum(n,x)	= xsum(n-1,x) + x(n-1);
+
+// These are all very similar. Abstracting
+// on the binary "accumulator" function, we
+// get the familiar fold(-left) function:
+
+fold(1,f,x)	= x(0);
+fold(n,f,x)	= f(fold(n-1,f,x),x(n-1));
+
+// Now seq, par, sum can be defined as:
+
+fseq(n)		= fold(n,\(x,y).(x:y));
+fpar(n)		= fold(n,\(x,y).(x,y));
+fsum(n)		= fold(n,+);
+fprod(n)	= fold(n,*);
+
+// Often it is more convenient to specify
+// parameters as a Faust tuple. We can match
+// against the (x,xs) pattern to decompose
+// these.
+
+vfold(f,(x,xs))	= f(x,vfold(f,xs));
+vfold(f,x)	= x;
+
+// Tuple version of seq, par, sum:
+
+vseq		= vfold(\(x,y).(x:y));
+vpar		= vfold(\(x,y).(x,y));
+vsum		= vfold(+);
+vprod		= vfold(*);
+
+// Examples:
+
+import("music.lib");
+f0		= 440;
+a(0)		= 1;
+a(1)		= 0.5;
+a(2)		= 0.3;
+h(i)		= a(i)*osc((i+1)*f0);
+
+// sums
+//process		= xsum(3,h);
+//process	= fsum(3,h);
+//process	= vsum((h(0),h(1),h(2)));
+
+reverse (x:y)	= reverse(y):reverse(x);
+reverse(x)	= x;
+
+// sequences from tuples (parallel -> serial)
+process	= vseq((sin,cos,tan)), vprod((2,3,4,5));

cyfaust/resources/libraries/examples/old/rewriting/mesh.dsp

@@ -0,0 +1,43 @@
+
+/* Layout of a systolic array:
+
+        x1        xm
+        ↓         ↓
+   y1 → □ → ... → □ → y1'
+        ↓         ↓
+       ...       ...
+        ↓         ↓
+   yn → □ → ... → □ → yn'
+        ↓         ↓
+        x1'       xm'
+
+  g(m,f)   : y,x1,...,xm -> x1',...,xm',y'
+  constructs a single row of size m.
+
+  h(n,m,f) : y1,...,yn,x1,...,xm -> x1',...,xm',yn',...,y1'
+  constructs an array of size nxm.
+
+  f is the function computed by each cell, which must take
+  exactly two inputs and yield exactly two outputs. */
+
+g(1,f)		= f;
+g(m,f)		= (f, r(m-1)) : (_, g(m-1,f));
+
+h(1,m,f)	= g(m,f);
+h(n,m,f)	= (r(n+m) <:
+		   (!,r(n-1),s(m), (_,s(n-1),r(m) : g(m,f)))) :
+                  (h(n-1,m,f), _);
+
+// route n inputs
+r(1)		= _;
+r(n)		= _,r(n-1);
+
+// skip n inputs
+s(1)		= !;
+s(n)		= !,s(n-1);
+
+// sample cell function
+f		= + <: _,_;
+
+//process		= g(3,f);
+process		= h(2,3,f);

cyfaust/resources/libraries/examples/old/rewriting/mesh.pd

@@ -0,0 +1,37 @@
+#N canvas 678 191 450 300 10;
+#X floatatom 79 41 5 0 0 0 - x1 -;
+#X floatatom 154 42 5 0 0 0 - x2 -;
+#X floatatom 228 43 5 0 0 0 - x3 -;
+#X floatatom 42 122 5 0 0 0 - y2 -;
+#X floatatom 42 98 5 0 0 0 - y1 -;
+#X obj 114 112 mesh~;
+#X obj 356 218 tgl 15 0 sample empty empty 17 7 0 10 -262144 -1 -1
+0 1;
+#X msg 356 243 \; pd dsp \$1;
+#X obj 373 111 tgl 15 0 empty empty empty 17 7 0 10 -262144 -1 -1 0
+1;
+#X msg 373 136 \; val \$1;
+#X obj 79 18 tgl 15 0 x1 val empty 17 7 0 10 -262144 -1 -1 0 1;
+#X obj 154 19 tgl 15 0 x2 val empty 17 7 0 10 -262144 -1 -1 0 1;
+#X obj 228 21 tgl 15 0 x3 val empty 17 7 0 10 -262144 -1 -1 0 1;
+#X obj 21 97 tgl 15 0 y1 val empty 17 7 0 10 -262144 -1 -1 0 1;
+#X obj 21 121 tgl 15 0 y2 val empty 17 7 0 10 -262144 -1 -1 0 1;
+#X obj 216 180 sample;
+#X obj 279 88 sample;
+#X obj 280 129 sample;
+#X obj 141 180 sample;
+#X obj 71 180 sample;
+#X obj 356 192 loadbang;
+#X connect 0 0 5 3;
+#X connect 1 0 5 4;
+#X connect 2 0 5 5;
+#X connect 3 0 5 2;
+#X connect 4 0 5 1;
+#X connect 5 1 19 0;
+#X connect 5 2 18 0;
+#X connect 5 3 15 0;
+#X connect 5 4 17 0;
+#X connect 5 5 16 0;
+#X connect 6 0 7 0;
+#X connect 8 0 9 0;
+#X connect 20 0 6 0;

cyfaust/resources/libraries/examples/old/rewriting/sample.pd

@@ -0,0 +1,12 @@
+#N canvas 337 294 450 300 10;
+#X obj 112 62 metro 100;
+#X floatatom 3 18 5 0 0 0 - - -;
+#X obj 112 35 tgl 15 0 empty sample empty 17 7 0 10 -262144 -1 -1 1
+1;
+#X obj 55 62 inlet~;
+#X obj 56 104 snapshot~;
+#X connect 0 0 4 0;
+#X connect 2 0 0 0;
+#X connect 3 0 4 0;
+#X connect 4 0 1 0;
+#X coords 0 -1 1 1 65 35 1 0 0;

cyfaust/resources/libraries/examples/old/rewriting/serial.dsp

@@ -0,0 +1,7 @@
+
+// sequences from tuples (parallel -> serial)
+
+serial((x,y))	= serial(x) : serial(y);
+serial(x)	= x;
+
+process		= serial((sin,cos,tan));

cyfaust/resources/libraries/examples/old/rewriting/sum.dsp

@@ -0,0 +1,55 @@
+
+// How to emulate Faust's seq, par, sum.
+// x(k) is assumed to yield the kth signal.
+
+xseq(1,x)	= x(0);
+xseq(n,x)	= xseq(n-1,x) : x(n-1);
+
+xpar(1,x)	= x(0);
+xpar(n,x)	= xpar(n-1,x) , x(n-1);
+
+xsum(1,x)	= x(0);
+xsum(n,x)	= xsum(n-1,x) + x(n-1);
+
+// These are all very similar. Abstracting
+// on the binary "accumulator" function, we
+// get the familiar fold(-left) function:
+
+fold(1,f,x)	= x(0);
+fold(n,f,x)	= f(fold(n-1,f,x),x(n-1));
+
+// Now seq, par, sum can be defined as:
+
+fseq(n)		= fold(n,\(x,y).(x:y));
+fpar(n)		= fold(n,\(x,y).(x,y));
+fsum(n)		= fold(n,+);
+
+// Often it is more convenient to specify
+// parameters as a Faust tuple. We can match
+// against the (x,y) pattern to decompose
+// these.
+
+vfold(f,(x,y))	= f(vfold(f,x),y);
+vfold(f,x)	= x;
+
+// Tuple version of seq, par, sum:
+
+vseq		= vfold(\(x,y).(x:y));
+vpar		= vfold(\(x,y).(x,y));
+vsum		= vfold(+);
+
+// Example: sum of sinusoids.
+
+import("music.lib");
+
+f0		= 440;
+a(0)		= 1;
+a(1)		= 0.5;
+a(2)		= 0.3;
+h(i)		= a(i)*osc((i+1)*f0);
+
+v		= hslider("vol", 0.3, 0, 1, 0.01);
+
+process		= v*fsum(3,h);
+//process	= v*xsum(3,h);
+//process	= v*vsum((h(0),h(1),h(2)));

cyfaust/resources/libraries/examples/old/rewriting/test.pd

@@ -0,0 +1,48 @@
+#N canvas 363 282 562 379 10;
+#X obj 38 65 fact~;
+#X obj 67 111 snapshot~;
+#X floatatom 67 141 10 0 0 0 - - -;
+#X obj 85 65 bng 15 250 50 0 empty empty empty 17 7 0 10 -262144 -1
+-1;
+#X obj 199 29 phasor~ 1;
+#X obj 156 84 serial~;
+#X obj 200 112 snapshot~;
+#X floatatom 200 142 7 0 0 0 - - -;
+#X obj 218 84 metro 100;
+#X obj 218 53 tgl 15 0 empty empty empty 17 7 0 10 -262144 -1 -1 0
+1;
+#X obj 320 27 loadbang;
+#X msg 320 55 \; pd dsp 1;
+#X obj 171 229 sum~;
+#X obj 196 294 dac~;
+#X obj 195 261 *~ 0;
+#X obj 218 230 tgl 15 0 empty empty empty 17 7 0 10 -262144 -1 -1 0
+1;
+#N canvas 0 0 450 300 (subpatch) 0;
+#X array scope 1920 float 2;
+#X coords 0 1 1920 -1 200 140 1;
+#X restore 271 200 graph;
+#X obj 69 262 tabwrite~ scope;
+#X obj 69 229 metro 40;
+#X obj 69 206 tgl 15 0 empty empty empty 17 7 0 10 -262144 -1 -1 0
+1;
+#X msg 171 203 vol \$1;
+#X obj 174 178 hsl 64 15 0 1 0 0 empty empty empty -2 -8 0 10 -262144
+-1 -1 0 1;
+#X connect 0 1 1 0;
+#X connect 1 0 2 0;
+#X connect 3 0 1 0;
+#X connect 4 0 5 1;
+#X connect 5 1 6 0;
+#X connect 6 0 7 0;
+#X connect 8 0 6 0;
+#X connect 9 0 8 0;
+#X connect 10 0 11 0;
+#X connect 12 1 14 0;
+#X connect 12 1 17 0;
+#X connect 14 0 13 0;
+#X connect 15 0 14 1;
+#X connect 18 0 17 0;
+#X connect 19 0 18 0;
+#X connect 20 0 12 0;
+#X connect 21 0 20 0;

cyfaust/resources/libraries/examples/phasing/flanger.dsp

@@ -0,0 +1,8 @@
+declare name "flanger";
+declare version "0.0";
+declare author "JOS, revised by RM";
+declare description "Flanger effect application.";
+
+import("stdfaust.lib");
+
+process = dm.flanger_demo;

cyfaust/resources/libraries/examples/phasing/phaser.dsp

@@ -0,0 +1,8 @@
+declare name "phaser";
+declare version "0.0";
+declare author "JOS, revised by RM";
+declare description "Phaser demo application.";
+
+import("stdfaust.lib");
+
+process = dm.phaser2_demo;

cyfaust/resources/libraries/examples/phasing/phaserFlangerLab.dsp

@@ -0,0 +1,12 @@
+declare name "phaserFlangerLab";
+
+import("stdfaust.lib");
+
+fx_stack = 
+ vgroup("[1]", dm.sawtooth_demo) <:
+ vgroup("[2]", dm.flanger_demo) : 
+ vgroup("[3]", dm.phaser2_demo);
+
+level_viewer(x,y) = attach(x, vgroup("[4]", dm.spectral_level_demo(x+y))),y;
+
+process = fx_stack : level_viewer;

cyfaust/resources/libraries/examples/physicalModeling/brass.dsp

@@ -0,0 +1,8 @@
+declare name "Brass";
+declare description "Simple brass instrument physical model with physical parameters.";
+declare license "MIT";
+declare copyright "(c)Romain Michon, CCRMA (Stanford University), GRAME";
+
+import("stdfaust.lib");
+
+process = pm.brass_ui <: _,_;

cyfaust/resources/libraries/examples/physicalModeling/brassMIDI.dsp

@@ -0,0 +1,8 @@
+declare name "BrassMIDI";
+declare description "Simple MIDI-controllable brass instrument physical model with physical parameters.";
+declare license "MIT";
+declare copyright "(c)Romain Michon, CCRMA (Stanford University), GRAME";
+
+import("stdfaust.lib");
+
+process = pm.brass_ui_MIDI <: _,_;

cyfaust/resources/libraries/examples/physicalModeling/churchBell.dsp

@@ -0,0 +1,8 @@
+declare name "ChurchBell";
+declare description "Generic church bell physical model.";
+declare license "MIT";
+declare copyright "(c)Romain Michon, CCRMA (Stanford University), GRAME";
+
+import("stdfaust.lib");
+
+process = pm.churchBell_ui <: _,_;

cyfaust/resources/libraries/examples/physicalModeling/clarinet.dsp

@@ -0,0 +1,8 @@
+declare name "Clarinet";
+declare description "Simple clarinet physical model with physical parameters.";
+declare license "MIT";
+declare copyright "(c)Romain Michon, CCRMA (Stanford University), GRAME";
+
+import("stdfaust.lib");
+
+process = pm.clarinet_ui <: _,_;

cyfaust/resources/libraries/examples/physicalModeling/clarinetMIDI.dsp

@@ -0,0 +1,8 @@
+declare name "ClarinetMIDI";
+declare description "Simple MIDI-controllable clarinet physical model with physical parameters.";
+declare license "MIT";
+declare copyright "(c)Romain Michon, CCRMA (Stanford University), GRAME";
+
+import("stdfaust.lib");
+
+process = pm.clarinet_ui_MIDI <: _,_;

cyfaust/resources/libraries/examples/physicalModeling/djembeMIDI.dsp

@@ -0,0 +1,8 @@
+declare name "DjembeMIDI";
+declare description "Simple MIDI-controllable djembe physical model.";
+declare license "MIT";
+declare copyright "(c)Romain Michon, CCRMA (Stanford University), GRAME";
+
+import("stdfaust.lib");
+
+process = pm.djembe_ui_MIDI <: _,_;

cyfaust/resources/libraries/examples/physicalModeling/elecGuitarMIDI.dsp

@@ -0,0 +1,10 @@
+declare name "ElecGuitarMidi";
+declare description "Simple electric guitar model without effect chain.";
+declare license "MIT";
+declare copyright "(c)Romain Michon, CCRMA (Stanford University), GRAME";
+
+import("stdfaust.lib");
+
+// TODO: We could potentially add an audio effect chain here
+
+process = pm.elecGuitar_ui_MIDI <: _,_;

cyfaust/resources/libraries/examples/physicalModeling/englishBell.dsp

@@ -0,0 +1,8 @@
+declare name "EnglishChurchBell";
+declare description "English church bell physical model.";
+declare license "MIT";
+declare copyright "(c)Romain Michon, CCRMA (Stanford University), GRAME";
+
+import("stdfaust.lib");
+
+process = pm.englishBell_ui <: _,_;

cyfaust/resources/libraries/examples/physicalModeling/faust-stk/NLFeks.dsp

@@ -0,0 +1,91 @@
+declare name "NLFeks";
+declare author "Julius Smith and Romain Michon";
+declare version "1.0";
+declare license "STK-4.3";
+declare copyright "Julius Smith";
+declare reference "http://ccrma.stanford.edu/~jos/pasp/vegf.html";
+// -> Virtual\_Electric\_Guitars\_Faust.html";
+
+import("instruments.lib");
+
+//==================== GUI SPECIFICATION ================
+
+// standard MIDI voice parameters:
+// NOTE: The labels MUST be "freq", "gain", and "gate" for faust2pd
+freq = nentry("freq", 440, 20, 7040, 1);  // Hz
+gain = nentry("gain", 1, 0, 10, 0.01);    // 0 to 1
+gate = button("gate");                    // 0 or 1
+
+// Additional parameters (MIDI "controllers"):
+
+// Pick angle in [0,0.9]:
+pickangle = 0.9 * hslider("pick_angle",0,0,0.9,0.1);
+
+// Normalized pick-position in [0,0.5]:
+beta = hslider("pick_position [midi: ctrl 0x81]", 0.13, 0.02, 0.5, 0.01);
+       // MIDI Control 0x81 often "highpass filter frequency"
+
+// String decay time in seconds:
+t60 = hslider("decaytime_T60", 4, 0, 10, 0.01);  // -60db decay time (sec)
+
+// Normalized brightness in [0,1]:
+B = hslider("brightness [midi:ctrl 0x74]", 0.5, 0, 1, 0.01);// 0-1
+    // MIDI Controller 0x74 is often "brightness" 
+    // (or VCF lowpass cutoff freq)
+
+// Dynamic level specified as dB level desired at Nyquist limit:
+L = hslider("dynamic_level", -10, -60, 0, 1) : ba.db2linear;
+// Note: A lively clavier is obtained by tying L to gain (MIDI velocity).
+
+//Nonlinear filter parameters
+typeModulation = nentry("v:Nonlinear Filter/typeMod",0,0,4,1);
+nonLinearity = hslider("Nonlinearity",0,0,1,0.01) : si.smoo;
+frequencyMod = hslider("freqMod",220,20,1000,0.1) : si.smoo;
+
+//==================== SIGNAL PROCESSING ================
+
+//----------------------- noiseburst -------------------------
+// White noise burst (adapted from Faust's karplus.dsp example)
+// Requires music.lib (for noise)
+noiseburst(gate,P) = no.noise : *(gate : trigger(P))
+with {
+  diffgtz(x) = (x-x') > 0;
+  decay(n,x) = x - (x>0)/n;
+  release(n) = + ~ decay(n);
+  trigger(n) = diffgtz : release(n) : > (0.0);
+};
+
+nlfOrder = 6;
+P = ma.SR/freq ; // fundamental period in samples
+Pmax = 4096; // maximum P (for delay-line allocation)
+
+ppdel = beta*P; // pick position delay
+pickposfilter = fi.ffcombfilter(Pmax,ppdel,-1); 
+
+excitation = noiseburst(gate,P) : *(gain); // defined in route.lib
+
+rho = pow(0.001,1.0/(freq*t60)); // multiplies loop-gain
+
+// Original EKS damping filter:
+b1 = 0.5*B; b0 = 1.0-b1; // S and 1-S
+dampingfilter1(x) = rho * ((b0 * x) + (b1 * x'));
+
+// Linear phase FIR3 damping filter:
+h0 = (1.0 + B)/2; h1 = (1.0 - B)/4;
+dampingfilter2(x) = rho * (h0 * x' + h1*(x+x''));
+
+loopfilter = dampingfilter2; // or dampingfilter1
+
+filtered_excitation = excitation : si.smooth(pickangle) 
+		    : pickposfilter;// : levelfilter(L,freq);
+
+//nonlinear allpass filter (nonLinearModulator is declared in instruments.lib)
+NLFM =  nonLinearModulator(nonLinearity,1,freq,typeModulation,frequencyMod,nlfOrder);
+
+//declared in instruments.lib
+stereo = stereoizer(P);
+
+stringloop = (+ : de.fdelay4(Pmax, P-2)) ~ (loopfilter : NLFM);
+
+process = filtered_excitation : stringloop : stereo : instrReverb;
+

cyfaust/resources/libraries/examples/physicalModeling/faust-stk/NLFfm.dsp

@@ -0,0 +1,70 @@
+declare name "NLFfm";
+declare description "FM synthesizer implemented with a nonlinear passive allpass filter";
+declare author "Romain Michon";
+declare copyright "Romain Michon (rmichon@ccrma.stanford.edu)";
+declare version "1.0";
+
+import("instruments.lib");
+
+//==================== GUI SPECIFICATION ================
+
+freq = nentry("h:Basic_Parameters/freq [1][unit:Hz] [tooltip:Tone frequency]",440,20,20000,1);
+gain = nentry("h:Basic_Parameters/gain [1][tooltip:Gain (value between 0 and 1)]",0.8,0,1,0.01); 
+gate = button("h:Basic_Parameters/gate [1][tooltip:noteOn = 1, noteOff = 0]");
+
+typeModulation = nentry("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Modulation_Type 
+[2][tooltip: 0=theta is modulated by the incoming signal; 1=theta is modulated by the averaged incoming signal;
+2=theta is modulated by the squared incoming signal; 3=theta is modulated by a sine wave of frequency freqMod;
+4=theta is modulated by a sine wave of frequency freq;]",0,0,4,1);
+nonLinearity = hslider("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Nonlinearity 
+[2][tooltip:Nonlinearity factor (value between 0 and 1)]",0,0,1,0.01);
+frequencyMod = hslider("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Modulation_Frequency 
+[2][unit:Hz][tooltip:Frequency of the sine wave for the modulation of theta (works if Modulation Type=3)]",220,20,1000,0.1);
+nonLinAttack = hslider("h:Physical_and_Nonlinearity/v:Nonlinear_Filter_Parameters/Nonlinearity_Attack
+[2][unit:s][Attack duration of the nonlinearity]",0.1,0,2,0.01);
+
+vibratoFreq = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Freq 
+[3][unit:Hz]",5,1,15,0.1);
+vibratoGain = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Gain
+[3][tooltip:A value between 0 and 1]",0.1,0,1,0.01);
+vibratoAttack = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Attack 
+[3][unit:s][tooltip:Vibrato attack duration]",0.5,0,2,0.01);
+vibratoRelease = hslider("h:Envelopes_and_Vibrato/v:Vibrato_Parameters/Vibrato_Release 
+[3][unit:s][tooltip:Vibrato release duration]",0.01,0,2,0.01);
+
+envelopeAttack = hslider("h:Envelopes_and_Vibrato/v:Envelope_Parameters/Envelope_Attack 
+[4][unit:s][tooltip:Envelope attack duration]",0.05,0,2,0.01);
+envelopeDecay = hslider("h:Envelopes_and_Vibrato/v:Envelope_Parameters/Envelope_Decay 
+[4][unit:s][tooltip:Envelope decay duration]",0.05,0,2,0.01);
+envelopeRelease = hslider("h:Envelopes_and_Vibrato/v:Envelope_Parameters/Envelope_Release 
+[4][unit:s][tooltip:Envelope release duration]",0.05,0,2,0.01);
+
+//----------------------- Nonlinear filter ----------------------------
+//nonlinearities are created by the nonlinear passive allpass ladder filter declared in miscfilter.lib
+
+//nonlinear filter order
+nlfOrder = 3; 
+
+//attack - sustain - release envelope for nonlinearity (declared in instruments.lib)
+envelopeMod = en.asr(nonLinAttack,1,envelopeRelease,gate);
+
+//nonLinearModultor is declared in instruments.lib, it adapts allpassnn from miscfilter.lib 
+//for using it with waveguide instruments
+NLFM =  nonLinearModulator((nonLinearity : si.smoo),envelopeMod,freq,
+     typeModulation,(frequencyMod : si.smoo),nlfOrder);
+
+//----------------------- Algorithm implementation ----------------------------
+
+//stereoizer is declared in instruments.lib and implement a stereo spacialisation in function of 
+//the frequency period in number of samples 
+stereo = stereoizer(ma.SR/freq);
+
+//vibrato gain is controlled by envVibrato (declared in instruments.lib)
+vibrato = os.osc(vibratoFreq)*vibratoGain*envVibrato(0.1*2*vibratoAttack,0.9*2*vibratoAttack,100,vibratoRelease,gate);
+
+//output gain is controlled by an adsr envelope
+envelope = en.adsr(envelopeAttack,envelopeDecay,0.9,envelopeRelease,gate)*gain;
+breath = envelope + envelope*vibrato;
+
+process = os.osc(freq)*breath : NLFM : stereo : instrReverb;
+

cyfaust/resources/libraries/examples/physicalModeling/faust-stk/README

@@ -0,0 +1,125 @@
+FAUST SYNTHESIS TOOLKIT: A SET OF LINEAR AND NONLINEAR PHYSICAL MODELS FOR FAUST
+      			 
+CIEREC, EA 3068				Center for Computer Research in Music and Acoustics
+Université Jean Monnet		 and	(CCRMA) Stanford University
+F-42023, Saint-Etienne, France	 	Palo Alto, CA 94305, USA
+			      
+			 
+
+1/ What is it?
+--------------
+
+The FAUST Synthesis ToolKit is a set virtual musical instruments written in the FAUST 
+programming language and based on waveguide algorithms and modal synthesis. Most of them
+were inspired by instruments implemented in the Synthesis ToolKit and the program SynthBuilder.
+
+The STK is developed since 1996 by P. R. Cook and G. P. Scavone. It is a set of open 
+source audio signal processing and algorithmic synthesis classes written in the C++ programming
+language that can be used in the development of music synthesis and audio processing
+software (https://ccrma.stanford.edu/software/stk/).
+
+On the other hand, SynthBuilder was a program used at Stanford's CCRMA (Center for Computer Research 
+in Music and Acoustics) in the nineties to implement physical models of musical instruments. Most
+of its algorithms use the waveguide synthesis technique but some of them are also based on modal synthesis.
+
+Our attention has partly been focused on the pedagogical aspect of the implemented objects. Indeed, 
+we tried to make the FAUST code of each objects as optimized and as expressive as possible.
+
+Some of the instruments in the (FAUST-STK) use nonlinear allpass filters to create interesting and 
+new behaviors. Also, most of them can be used with gesture following datas (see the /gesture-following folder
+for some examples).
+
+2/ Which instruments?
+---------------------
+
+WIND INSTRUMENTS
+
+     - A simple clarinet (clarinet.dsp),
+     - A clarinet with a tone hole model (blowHole.dsp),
+     - A flute (flutestk.dsp),
+     - A pan-flute (flute.dsp),
+     - A brass instrument that can be used as a trumpet, a trombon, a french horn, etc. (brass.dsp),
+     - A simple saxophone (saxophony.dsp),
+     - A bottle where it is possible to blow threw the neck to make sound (blowBotle.dsp).
+
+STRING INSTRUMENTS
+
+     - An acoustic finger bass (bass.dsp),
+     - A bowed string instrument that can be used as a cello, a violin, etc. (bowed.dsp),
+     - A simple sitar (sitar.dsp),
+     - A nonlinear extended Karplus-Strong (NLFeks.dsp).  
+
+KEYBOARDS INSTRUMENTS
+
+     - A piano that uses commuted waveguide synthesis (piano.dsp),
+     - An harpsichord (harpro.dsp).
+
+PERCUSSION INSTRUMENTS
+
+     - A tibetan bowl (tibetanBowl.dsp),
+     - A wooden bare (uniBar.dsp),
+     - An iron bare (tunedBar.dsp),
+     - A glass bare (glassHarmonica.dsp),
+     - A set of percussion instruments that use modal synthesis (modalBar.dsp). 
+
+OTHER  
+
+     - A voice synthesizer (voiceForm.dsp),
+     - A FM synthesizer that uses an nonlinear allpass filter (NLFfm.dsp).
+
+3/ Organisation of the distribution and remarks
+-----------------------------------------------
+
+Most of the instruments implemented in the FAUST-STK use functions declared in instruments.lib so
+this file is required for compilation. Also, a few instruments use datas that are stored in external
+C++ functions (.h).
+
+The "pd-patches" folder contains examples of use of the FAUST-STK instruments in PureData (faust2pd
+needs to be install on your computer to use these examples). 
+
+The FAUST-STK instruments are all monophonic. If you wish to make them polyphonic, we recommend you
+to compile them for PureData and to use faust2pd ("make pdpoly2" or "make pdpoly4" or "make pdpoly6" or
+"make pdpoly8" where 2, 4, 6 and 8 are the number of voices). For more informations about that, 
+you can look at the examples in the pd-patches/ folder. 
+
+You can find in the gesture-following/ folder an improved version of bowed.dsp that uses gesture following
+datas in PureData (first, type "make" in a terminal and then open playMe.pd). This work has been done with
+the help of E. Maestre (MTG, Barcelona).
+
+The instruments from the Faust-STK have been tested with the OSC support for FAUST implemented with some
+of the architecture files (jackqt, jackgtk, etc.).
+
+3/ How to compile?
+------------------
+
+In order to compile the instruments, the latest FAUST repository must be installed on your computer as well 
+as all the required dependencies for the FAUST architecture you wish to use. 
+
+Run any of the faust compilation script with one of the .dsp file contained in this directory. For example:
+
+faust2caqt *
+
+will compile all the objects as Core Audio Qt applications...
+
+4/ Acknowledgments
+------------------
+
+This work has been carried out in the frame of the ASTREE project (Analyse et Synthèse Temps REEl), 
+supported by the Agence Nationale de Recherche (ANR-08-CORD-003) at Stanford's CCRMA (Center for 
+Computer Research in Music and Acoustics).
+
+Special thanks to J.O. Smith, Y. Orlarey, E. Maestre, S. Letz and L. Pottier for their support and help.
+
+Thanks also to my colleagues from the CCRMA team for all their suggestions and good ideas.
+
+5/ Questions and suggestions
+----------------------------
+
+About FAUST-STK: rmichon@ccrma.stanford.edu or rmnmichon@gmail.com
+
+About FAUST: https://lists.sourceforge.net/lists/listinfo/faudiostream-users  
+
+
+
+
+Romain Michon