Refactoring of class process in faustexp.ml.
[Faustine.git] / interpretor / faust-0.9.47mr3 / architecture / music.lib
1 /************************************************************************
2 ************************************************************************
3 FAUST library file
4 Copyright (C) 2003-2011 GRAME, Centre National de Creation Musicale
5 ---------------------------------------------------------------------
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU Lesser General Public License as
8 published by the Free Software Foundation; either version 2.1 of the
9 License, or (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU Lesser General Public License for more details.
15
16 You should have received a copy of the GNU Lesser General Public
17 License along with the GNU C Library; if not, write to the Free
18 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
19 02111-1307 USA.
20 ************************************************************************
21 ************************************************************************/
22
23 declare name "Music Library";
24 declare author "GRAME";
25 declare copyright "GRAME";
26 declare version "1.0";
27 declare license "LGPL";
28
29 import("math.lib");
30
31 //-----------------------------------------------
32 // DELAY LINE
33 //-----------------------------------------------
34 frac(n) = n-int(n);
35 index(n) = &(n-1) ~ +(1); // n = 2**i
36 //delay(n,d,x) = rwtable(n, 0.0, index(n), x, (index(n)-int(d)) & (n-1));
37 delay(n,d,x) = x@(int(d)&(n-1));
38 fdelay(n,d,x) = delay(n,int(d),x)*(1 - frac(d)) + delay(n,int(d)+1,x)*frac(d);
39
40
41 delay1s(d) = delay(65536,d);
42 delay2s(d) = delay(131072,d);
43 delay5s(d) = delay(262144,d);
44 delay10s(d) = delay(524288,d);
45 delay21s(d) = delay(1048576,d);
46 delay43s(d) = delay(2097152,d);
47
48 fdelay1s(d) = fdelay(65536,d);
49 fdelay2s(d) = fdelay(131072,d);
50 fdelay5s(d) = fdelay(262144,d);
51 fdelay10s(d) = fdelay(524288,d);
52 fdelay21s(d) = fdelay(1048576,d);
53 fdelay43s(d) = fdelay(2097152,d);
54
55 millisec = SR/1000.0;
56
57 time1s = hslider("time", 0, 0, 1000, 0.1)*millisec;
58 time2s = hslider("time", 0, 0, 2000, 0.1)*millisec;
59 time5s = hslider("time", 0, 0, 5000, 0.1)*millisec;
60 time10s = hslider("time", 0, 0, 10000, 0.1)*millisec;
61 time21s = hslider("time", 0, 0, 21000, 0.1)*millisec;
62 time43s = hslider("time", 0, 0, 43000, 0.1)*millisec;
63
64
65 echo1s = vgroup("echo 1000", +~(delay(65536, int(hslider("millisecond", 0, 0, 1000, 0.10)*millisec)-1) * (hslider("feedback", 0, 0, 100, 0.1)/100.0)));
66 echo2s = vgroup("echo 2000", +~(delay(131072, int(hslider("millisecond", 0, 0, 2000, 0.25)*millisec)-1) * (hslider("feedback", 0, 0, 100, 0.1)/100.0)));
67 echo5s = vgroup("echo 5000", +~(delay(262144, int(hslider("millisecond", 0, 0, 5000, 0.50)*millisec)-1) * (hslider("feedback", 0, 0, 100, 0.1)/100.0)));
68 echo10s = vgroup("echo 10000", +~(delay(524288, int(hslider("millisecond", 0, 0, 10000, 1.00)*millisec)-1) * (hslider("feedback", 0, 0, 100, 0.1)/100.0)));
69 echo21s = vgroup("echo 21000", +~(delay(1048576, int(hslider("millisecond", 0, 0, 21000, 1.00)*millisec)-1) * (hslider("feedback", 0, 0, 100, 0.1)/100.0)));
70 echo43s = vgroup("echo 43000", +~(delay(2097152, int(hslider("millisecond", 0, 0, 43000, 1.00)*millisec)-1) * (hslider("feedback", 0, 0, 100, 0.1)/100.0)));
71
72
73 //--------------------------sdelay(N,it,dt)----------------------------
74 // s(mooth)delay : a mono delay that doesn't click and doesn't
75 // transpose when the delay time is changed. It takes 4 input signals
76 // and produces a delayed output signal
77 //
78 // USAGE : ... : sdelay(N,it,dt) : ...
79 //
80 // Where :
81 // <N> = maximal delay in samples (must be a constant power of 2, for example 65536)
82 // <it> = interpolation time (in samples) for example 1024
83 // <dt> = delay time (in samples)
84 // < > = input signal we want to delay
85 //--------------------------------------------------------------------------
86
87 sdelay(N, it, dt) = ctrl(it,dt),_ : ddi(N)
88
89 with {
90
91 //---------------------------ddi(N,i,d0,d1)-------------------------------
92 // DDI (Double Delay with Interpolation) : the input signal is sent to two
93 // delay lines. The outputs of these delay lines are crossfaded with
94 // an interpolation stage. By acting on this interpolation value one
95 // can move smoothly from one delay to another. When <i> is 0 we can
96 // freely change the delay time <d1> of line 1, when it is 1 we can freely change
97 // the delay time <d0> of line 0.
98 //
99 // <N> = maximal delay in samples (must be a power of 2, for example 65536)
100 // <i> = interpolation value between 0 and 1 used to crossfade the outputs of the
101 // two delay lines (0.0: first delay line, 1.0: second delay line)
102 // <d0> = delay time of delay line 0 in samples between 0 and <N>-1
103 // <d1> = delay time of delay line 1 in samples between 0 and <N>-1
104 // < > = the input signal we want to delay
105 //-------------------------------------------------------------------------
106 ddi(N, i, d0, d1) = _ <: delay(N,d0), delay(N,d1) : interpolate(i);
107
108
109 //----------------------------ctrl(it,dt)------------------------------------
110 // Control logic for a Double Delay with Interpolation according to two
111 //
112 // USAGE : ctrl(it,dt)
113 // where :
114 // <it> an interpolation time (in samples, for example 256)
115 // <dt> a delay time (in samples)
116 //
117 // ctrl produces 3 outputs : an interpolation value <i> and two delay
118 // times <d0> and <d1>. These signals are used to control a ddi (Double Delay with Interpolation).
119 // The principle is to detect changes in the input delay time dt, then to
120 // change the delay time of the delay line currently unused and then by a
121 // smooth crossfade to remove the first delay line and activate the second one.
122 //
123 // The control logic has an internal state controlled by 4 elements
124 // <v> : the interpolation variation (0, 1/it, -1/it)
125 // <i> : the interpolation value (between 0 and 1)
126 // <d0>: the delay time of line 0
127 // <d1>: the delay time of line 1
128 //
129 // Please note that the last stage (!,_,_,_) cut <v> because it is only
130 // used internally.
131 //-------------------------------------------------------------------------
132 ctrl(it, dt) = \(v,ip,d0,d1).( (nv, nip, nd0, nd1)
133 with {
134
135 // interpolation variation
136 nv = if (v!=0.0, // if variation we are interpolating
137 if( (ip>0.0) & (ip<1.0), v , 0), // should we continue or not ?
138 if ((ip==0.0) & (dt!=d0), 1.0/it, // if true xfade from dl0 to dl1
139 if ((ip==1.0) & (dt!=d1), -1.0/it, // if true xfade from dl1 to dl0
140 0))); // nothing to change
141 // interpolation value
142 nip = ip+nv : min(1.0) : max(0.0);
143
144 // update delay time of line 0 if needed
145 nd0 = if ((ip >= 1.0) & (d1!=dt), dt, d0);
146
147 // update delay time of line 0 if needed
148 nd1 = if ((ip <= 0.0) & (d0!=dt), dt, d1);
149
150 } ) ~ (_,_,_,_) : (!,_,_,_);
151 };
152
153
154
155
156 //-----------------------------------------------
157 // Tempo, beats and pulses
158 //-----------------------------------------------
159
160 tempo(t) = (60*SR)/t; // tempo(t) -> samples
161
162 period(p) = %(int(p))~+(1); // signal en dent de scie de periode p
163 pulse(t) = period(t)==0; // pulse (10000...) de periode p
164 pulsen(n,t) = period(t)<n; // pulse (1110000...) de taille n et de periode p
165 beat(t) = pulse(tempo(t)); // pulse au tempo t
166
167
168
169 //-----------------------------------------------
170 // conversions between db and linear values
171 //-----------------------------------------------
172
173 db2linear(x) = pow(10, x/20.0);
174 linear2db(x) = 20*log10(x);
175
176
177
178
179
180 //===============================================
181 // Random and Noise generators
182 //===============================================
183
184
185 //-----------------------------------------------
186 // noise : Noise generator
187 //-----------------------------------------------
188
189 random = +(12345) ~ *(1103515245);
190 RANDMAX = 2147483647.0;
191
192 noise = random / RANDMAX;
193
194
195 //-----------------------------------------------
196 // Generates multiple decorrelated random numbers
197 // in parallel. Expects n>0.
198 //-----------------------------------------------
199
200 multirandom(n) = randomize(n) ~_
201 with {
202 randomize (1) = +(12345) : *(1103515245);
203 randomize (n) = randomize(1) <: randomize(n-1),_;
204 };
205
206
207 //-----------------------------------------------
208 // Generates multiple decorrelated noises
209 // in parallel. Expects n>0.
210 //-----------------------------------------------
211
212 multinoise(n) = multirandom(n) : par(i,n,/(RANDMAX))
213 with {
214 RANDMAX = 2147483647.0;
215 };
216
217
218 //------------------------------------------------
219
220 noises(N,i) = multinoise(N) : selector(i,N);
221
222
223 //-----------------------------------------------
224 // osc(freq) : Sinusoidal Oscillator
225 //-----------------------------------------------
226
227 tablesize = 1 << 16;
228 samplingfreq = SR;
229
230 time = (+(1)~_ ) - 1; // 0,1,2,3,...
231 sinwaveform = float(time)*(2.0*PI)/float(tablesize) : sin;
232
233 decimal(x) = x - floor(x);
234 phase(freq) = freq/float(samplingfreq) : (+ : decimal) ~ _ : *(float(tablesize));
235 osc(freq) = rdtable(tablesize, sinwaveform, int(phase(freq)) );
236 osci(freq) = s1 + d * (s2 - s1)
237 with {
238 i = int(phase(freq));
239 d = decimal(phase(freq));
240 s1 = rdtable(tablesize+1,sinwaveform,i);
241 s2 = rdtable(tablesize+1,sinwaveform,i+1);};
242
243
244 //-----------------------------------------------
245 // ADSR envelop
246 //-----------------------------------------------
247
248 // a,d,s,r = attack (#samples), decay (sec), sustain (percentage), release (sec)
249 // t = trigger signal
250
251 adsr(a,d,s,r,t) = env ~ (_,_) : (!,_) // the 2 'state' signals are fed back
252 with {
253 env (p2,y) =
254 (t>0) & (p2|(y>=1)), // p2 = decay-sustain phase
255 (y + p1*u - (p2&(y>s))*v*y - p3*w*y) // y = envelop signal
256 *((p3==0)|(y>=eps)) // cut off tails to prevent denormals
257 with {
258 p1 = (p2==0) & (t>0) & (y<1); // p1 = attack phase
259 p3 = (t<=0) & (y>0); // p3 = release phase
260 // #samples in attack, decay, release, must be >0
261 na = SR*a+(a==0.0); nd = SR*d+(d==0.0); nr = SR*r+(r==0.0);
262 // correct zero sustain level
263 z = s+(s==0.0)*db2linear(-60);
264 // attack, decay and (-60dB) release rates
265 u = 1/na; v = 1-pow(z, 1/nd); w = 1-1/pow(z*db2linear(60), 1/nr);
266 // values below this threshold are considered zero in the release phase
267 eps = db2linear(-120);
268 };
269 };
270
271
272 //-----------------------------------------------
273 // Spatialisation
274 //-----------------------------------------------
275
276 panner(c) = _ <: *(1-c), *(c);
277
278 bus2 = _,_;
279 bus3 = _,_,_;
280 bus4 = _,_,_,_;
281 bus5 = _,_,_,_,_;
282 bus6 = _,_,_,_,_,_;
283 bus7 = _,_,_,_,_,_,_;
284 bus8 = _,_,_,_,_,_,_,_;
285
286 gain2(g) = *(g),*(g);
287 gain3(g) = *(g),*(g),*(g);
288 gain4(g) = *(g),*(g),*(g),*(g);
289 gain5(g) = *(g),*(g),*(g),*(g),*(g);
290 gain6(g) = *(g),*(g),*(g),*(g),*(g),*(g);
291 gain7(g) = *(g),*(g),*(g),*(g),*(g),*(g),*(g);
292 gain8(g) = *(g),*(g),*(g),*(g),*(g),*(g),*(g),*(g);
293
294
295 //------------------------------------------------------
296 //
297 // GMEM SPAT
298 // n-outputs spatializer
299 // implementation of L. Pottier
300 //
301 //------------------------------------------------------
302 //
303 // n = number of outputs
304 // r = rotation (between 0 et 1)
305 // d = distance of the source (between 0 et 1)
306 //
307 //------------------------------------------------------
308 spat(n,a,d) = _ <: par(i, n, *( scaler(i, n, a, d) : smooth(0.9999) ))
309 with {
310 scaler(i,n,a,d) = (d/2.0+0.5)
311 * sqrt( max(0.0, 1.0 - abs(fmod(a+0.5+float(n-i)/n, 1.0) - 0.5) * n * d) );
312 smooth(c) = *(1-c) : +~*(c);
313 };
314
315
316
317 //--------------- Second Order Generic Transfert Function -------------------------
318 // TF2(b0,b1,b2,a1,a2)
319 //
320 //---------------------------------------------------------------------------------
321
322 TF2(b0,b1,b2,a1,a2) = sub ~ conv2(a1,a2) : conv3(b0,b1,b2)
323 with {
324 conv3(k0,k1,k2,x) = k0*x + k1*x' + k2*x'';
325 conv2(k0,k1,x) = k0*x + k1*x';
326 sub(x,y) = y-x;
327 };
328
329
330 /*************************** Break Point Functions ***************************
331
332 bpf is an environment (a group of related definitions) tha can be used to
333 create break-point functions. It contains three functions :
334 - start(x,y) to start a break-point function
335 - end(x,y) to end a break-point function
336 - point(x,y) to add intermediate points to a break-point function
337
338 A minimal break-point function must contain at least a start and an end point :
339
340 f = bpf.start(x0,y0) : bpf.end(x1,y1);
341
342 A more involved break-point function can contains any number of intermediate
343 points
344
345 f = bpf.start(x0,y0) : bpf.point(x1,y1) : bpf.point(x2,y2) : bpf.end(x3,y3);
346
347 In any case the x_{i} must be in increasing order (for all i, x_{i} < x_{i+1})
348
349 For example the following definition :
350
351 f = bpf.start(x0,y0) : ... : bpf.point(xi,yi) : ... : bpf.end(xn,yn);
352
353 implements a break-point function f such that :
354
355 f(x) = y_{0} when x < x_{0}
356 f(x) = y_{n} when x > x_{n}
357 f(x) = y_{i} + (y_{i+1}-y_{i})*(x-x_{i})/(x_{i+1}-x_{i}) when x_{i} <= x and x < x_{i+1}
358
359 ******************************************************************************/
360
361 bpf = environment
362 {
363 // Start a break-point function
364 start(x0,y0) = \(x).(x0,y0,x,y0);
365
366 // Add a break-point
367 point(x1,y1) = \(x0,y0,x,y).(x1, y1, x , if (x < x0, y, if (x < x1, y0 + (x-x0)*(y1-y0)/(x1-x0), y1)));
368
369 // End a break-point function
370 end (x1,y1) = \(x0,y0,x,y).(if (x < x0, y, if (x < x1, y0 + (x-x0)*(y1-y0)/(x1-x0), y1)));
371
372 // definition of if
373 if (c,t,e) = select2(c,e,t);
374 };
375
376
377