projects / Faustine.git / blob
? search:


d2181d133f879c8657dabf0bc5ca681c79d2c36b
[Faustine.git] / interpretor / faust-0.9.47mr3 / architecture / plot.cpp
1 /************************************************************************
2
3 IMPORTANT NOTE : this file contains two clearly delimited sections :
4 the ARCHITECTURE section (in two parts) and the USER section. Each section
5 is governed by its own copyright and license. Please check individually
6 each section for license and copyright information.
7 *************************************************************************/
8
9 /*******************BEGIN ARCHITECTURE SECTION (part 1/2)****************/
10
11 /************************************************************************
12 FAUST Architecture File
13 Copyright (C) 2003-2011 GRAME, Centre National de Creation Musicale
14 ---------------------------------------------------------------------
15 This Architecture section is free software; you can redistribute it
16 and/or modify it under the terms of the GNU General Public License
17 as published by the Free Software Foundation; either version 3 of
18 the License, or (at your option) any later version.
19
20 This program is distributed in the hope that it will be useful,
21 but WITHOUT ANY WARRANTY; without even the implied warranty of
22 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 GNU General Public License for more details.
24
25 You should have received a copy of the GNU General Public License
26 along with this program; If not, see <http://www.gnu.org/licenses/>.
27
28 EXCEPTION : As a special exception, you may create a larger work
29 that contains this FAUST architecture section and distribute
30 that work under terms of your choice, so long as this FAUST
31 architecture section is not modified.
32
33
34 ************************************************************************
35 ************************************************************************/
36
37
38 #include <stdlib.h>
39 #include <stdio.h>
40 #include <string.h>
41 #include <limits.h>
42 #include <math.h>
43 #include <errno.h>
44 #include <time.h>
45 #include <ctype.h>
46
47 #include <vector>
48 #include <stack>
49 #include <string>
50 #include <map>
51 #include <iostream>
52
53 // g++ -O3 -lm -lsndfile myfx.cpp
54
55 using namespace std;
56
57 struct Meta : map<const char*, const char*>
58 {
59 void declare (const char* key, const char* value) { (*this)[key]=value; }
60 };
61
62 //-------------------------------------------------------------------
63 // Generic min and max using c++ inline
64 //-------------------------------------------------------------------
65
66 inline int max (unsigned int a, unsigned int b) { return (a>b) ? a : b; }
67 inline int max (int a, int b) { return (a>b) ? a : b; }
68
69 inline long max (long a, long b) { return (a>b) ? a : b; }
70 inline long max (int a, long b) { return (a>b) ? a : b; }
71 inline long max (long a, int b) { return (a>b) ? a : b; }
72
73 inline float max (float a, float b) { return (a>b) ? a : b; }
74 inline float max (int a, float b) { return (a>b) ? a : b; }
75 inline float max (float a, int b) { return (a>b) ? a : b; }
76 inline float max (long a, float b) { return (a>b) ? a : b; }
77 inline float max (float a, long b) { return (a>b) ? a : b; }
78
79 inline double max (double a, double b) { return (a>b) ? a : b; }
80 inline double max (int a, double b) { return (a>b) ? a : b; }
81 inline double max (double a, int b) { return (a>b) ? a : b; }
82 inline double max (long a, double b) { return (a>b) ? a : b; }
83 inline double max (double a, long b) { return (a>b) ? a : b; }
84 inline double max (float a, double b) { return (a>b) ? a : b; }
85 inline double max (double a, float b) { return (a>b) ? a : b; }
86
87
88 inline int min (int a, int b) { return (a<b) ? a : b; }
89
90 inline long min (long a, long b) { return (a<b) ? a : b; }
91 inline long min (int a, long b) { return (a<b) ? a : b; }
92 inline long min (long a, int b) { return (a<b) ? a : b; }
93
94 inline float min (float a, float b) { return (a<b) ? a : b; }
95 inline float min (int a, float b) { return (a<b) ? a : b; }
96 inline float min (float a, int b) { return (a<b) ? a : b; }
97 inline float min (long a, float b) { return (a<b) ? a : b; }
98 inline float min (float a, long b) { return (a<b) ? a : b; }
99
100 inline double min (double a, double b) { return (a<b) ? a : b; }
101 inline double min (int a, double b) { return (a<b) ? a : b; }
102 inline double min (double a, int b) { return (a<b) ? a : b; }
103 inline double min (long a, double b) { return (a<b) ? a : b; }
104 inline double min (double a, long b) { return (a<b) ? a : b; }
105 inline double min (float a, double b) { return (a<b) ? a : b; }
106 inline double min (double a, float b) { return (a<b) ? a : b; }
107
108
109
110 inline int lsr (int x, int n) { return int(((unsigned int)x) >> n); }
111
112 template<typename T> T abs (T a) { return (a<T(0)) ? -a : a; }
113
114
115 /******************************************************************************
116 *******************************************************************************
117
118 VECTOR INTRINSICS
119
120 *******************************************************************************
121 *******************************************************************************/
122
123 //inline void *aligned_calloc(size_t nmemb, size_t size) { return (void*)((unsigned)(calloc((nmemb*size)+15,sizeof(char)))+15 & 0xfffffff0); }
124 //inline void *aligned_calloc(size_t nmemb, size_t size) { return (void*)((size_t)(calloc((nmemb*size)+15,sizeof(char)))+15 & ~15); }
125
126 <<includeIntrinsic>>
127
128
129
130
131 /******************************************************************************
132 *******************************************************************************
133
134 USER INTERFACE
135
136 *******************************************************************************
137 *******************************************************************************/
138
139 class UI
140 {
141 bool fStopped;
142 public:
143
144 UI() : fStopped(false) {}
145 virtual ~UI() {}
146
147 // -- active widgets
148
149 virtual void addButton(const char* label, float* zone) = 0;
150 virtual void addToggleButton(const char* label, float* zone) = 0;
151 virtual void addCheckButton(const char* label, float* zone) = 0;
152 virtual void addVerticalSlider(const char* label, float* zone, float init, float min, float max, float step) = 0;
153 virtual void addHorizontalSlider(const char* label, float* zone, float init, float min, float max, float step) = 0;
154 virtual void addNumEntry(const char* label, float* zone, float init, float min, float max, float step) = 0;
155
156 // -- passive widgets
157
158 virtual void addNumDisplay(const char* label, float* zone, int precision) = 0;
159 virtual void addTextDisplay(const char* label, float* zone, char* names[], float min, float max) = 0;
160 virtual void addHorizontalBargraph(const char* label, float* zone, float min, float max) = 0;
161 virtual void addVerticalBargraph(const char* label, float* zone, float min, float max) = 0;
162
163 // -- frames and labels
164
165 virtual void openFrameBox(const char* label) = 0;
166 virtual void openTabBox(const char* label) = 0;
167 virtual void openHorizontalBox(const char* label) = 0;
168 virtual void openVerticalBox(const char* label) = 0;
169 virtual void closeBox() = 0;
170
171 virtual void show() = 0;
172 virtual void run() = 0;
173
174 void stop() { fStopped = true; }
175 bool stopped() { return fStopped; }
176
177 virtual void declare(float* zone, const char* key, const char* value) {}
178 };
179
180 struct param {
181 float* fZone; float fMin; float fMax;
182 param(float* z, float init, float a, float b) : fZone(z), fMin(a), fMax(b) { *z = init; }
183 };
184
185
186 class CMDUI : public UI
187 {
188 int fArgc;
189 char** fArgv;
190 vector<char*> fFiles;
191 stack<string> fPrefix;
192 map<string, param> fKeyParam;
193
194 void openAnyBox(const char* label)
195 {
196 string prefix;
197
198 if (label && label[0]) {
199 prefix = fPrefix.top() + "-" + label;
200 } else {
201 prefix = fPrefix.top();
202 }
203 fPrefix.push(prefix);
204 }
205
206 string simplify(const string& src)
207 {
208 int i=0;
209 int level=0;
210 string dst;
211
212 while (src[i] ) {
213
214 switch (level) {
215
216 case 0 :
217 case 1 :
218 case 2 :
219 // Skip the begin of the label "--foo-"
220 // until 3 '-' have been read
221 if (src[i]=='-') { level++; }
222 break;
223
224 case 3 :
225 // copy the content, but skip non alphnum
226 // and content in parenthesis
227 switch (src[i]) {
228 case '(' :
229 case '[' :
230 level++;
231 break;
232
233 case '-' :
234 dst += '-';
235 break;
236
237 default :
238 if (isalnum(src[i])) {
239 dst+= tolower(src[i]);
240 }
241
242 }
243 break;
244
245 default :
246 // here we are inside parenthesis and
247 // we skip the content until we are back to
248 // level 3
249 switch (src[i]) {
250
251 case '(' :
252 case '[' :
253 level++;
254 break;
255
256 case ')' :
257 case ']' :
258 level--;
259 break;
260
261 default :
262 break;
263 }
264
265 }
266 i++;
267 }
268 return dst;
269 }
270
271
272 public:
273
274 CMDUI(int argc, char *argv[]) : UI(), fArgc(argc), fArgv(argv) { fPrefix.push("-"); }
275 virtual ~CMDUI() {}
276
277
278 void addOption(const char* label, float* zone, float init, float min, float max)
279 {
280 string fullname = "-" + simplify(fPrefix.top() + "-" + label);
281 fKeyParam.insert(make_pair(fullname, param(zone, init, min, max)));
282 }
283
284
285 virtual void addButton(const char* label, float* zone)
286 {
287 addOption(label,zone,0,0,1);
288 }
289
290 virtual void addToggleButton(const char* label, float* zone)
291 {
292 addOption(label,zone,0,0,1);
293 }
294
295 virtual void addCheckButton(const char* label, float* zone)
296 {
297 addOption(label,zone,0,0,1);
298 }
299
300 virtual void addVerticalSlider(const char* label, float* zone, float init, float min, float max, float step)
301 {
302 addOption(label,zone,init,min,max);
303 }
304
305 virtual void addHorizontalSlider(const char* label, float* zone, float init, float min, float max, float step)
306 {
307 addOption(label,zone,init,min,max);
308 }
309
310 virtual void addNumEntry(const char* label, float* zone, float init, float min, float max, float step)
311 {
312 addOption(label,zone,init,min,max);
313 }
314
315 // -- passive widgets
316
317 virtual void addNumDisplay(const char* label, float* zone, int precision) {}
318 virtual void addTextDisplay(const char* label, float* zone, char* names[], float min, float max) {}
319 virtual void addHorizontalBargraph(const char* label, float* zone, float min, float max) {}
320 virtual void addVerticalBargraph(const char* label, float* zone, float min, float max) {}
321
322 virtual void openFrameBox(const char* label) { openAnyBox(label); }
323 virtual void openTabBox(const char* label) { openAnyBox(label); }
324 virtual void openHorizontalBox(const char* label) { openAnyBox(label); }
325 virtual void openVerticalBox(const char* label) { openAnyBox(label); }
326
327 virtual void closeBox() { fPrefix.pop(); }
328
329 virtual void show() {}
330 virtual void run() {}
331
332 void printhelp()
333 {
334 map<string, param>::iterator i;
335 cout << fArgc << "\n";
336 cout << fArgv[0] << " option list : ";
337 for (i = fKeyParam.begin(); i != fKeyParam.end(); i++) {
338 cout << "[ " << i->first << " " << i->second.fMin << ".." << i->second.fMax <<" ] ";
339 }
340 cout << " infile outfile\n";
341 }
342
343 void process_command()
344 {
345 map<string, param>::iterator p;
346 for (int i = 1; i < fArgc; i++) {
347 if (fArgv[i][0] == '-') {
348 if ( (strcmp(fArgv[i], "-help") == 0)
349 || (strcmp(fArgv[i], "-h") == 0)
350 || (strcmp(fArgv[i], "--help") == 0) ) {
351 printhelp();
352 exit(1);
353 }
354 p = fKeyParam.find(fArgv[i]);
355 if (p == fKeyParam.end()) {
356 cout << fArgv[0] << " : unrecognized option " << fArgv[i] << "\n";
357 printhelp();
358 exit(1);
359 }
360 char* end;
361 *(p->second.fZone) = float(strtod(fArgv[i+1], &end));
362 i++;
363 } else {
364 fFiles.push_back(fArgv[i]);
365 }
366 }
367 }
368
369 int files() { return fFiles.size(); }
370 char* file (int n) { return fFiles[n]; }
371
372 };
373
374 //----------------------------------------------------------------
375 // d�inition du processeur de signal
376 //----------------------------------------------------------------
377
378 class dsp {
379 protected:
380 int fSamplingFreq;
381 public:
382 dsp() {}
383 virtual ~dsp() {}
384
385 virtual int getNumInputs() = 0;
386 virtual int getNumOutputs() = 0;
387 virtual void buildUserInterface(UI* interface) = 0;
388 virtual void init(int samplingRate) = 0;
389 virtual void compute(int len, float** inputs, float** outputs) = 0;
390 virtual void conclude() {}
391 };
392
393 /********************END ARCHITECTURE SECTION (part 1/2)****************/
394
395 /**************************BEGIN USER SECTION **************************/
396
397 <<includeclass>>
398
399 /***************************END USER SECTION ***************************/
400
401 /*******************BEGIN ARCHITECTURE SECTION (part 2/2)***************/
402
403 mydsp DSP;
404
405
406 class channels
407 {
408 int fNumFrames;
409 int fNumChannels;
410 float* fBuffers[256];
411
412 public:
413
414 channels(int nframes, int nchannels)
415 {
416 fNumFrames = nframes;
417 fNumChannels = nchannels;
418
419 // allocate audio channels
420 for (int i = 0; i < fNumChannels; i++) {
421 fBuffers[i] = (float*) calloc (fNumFrames, sizeof(float));
422 }
423 }
424
425 ~channels()
426 {
427 // free separate input channels
428 for (int i = 0; i < fNumChannels; i++) {
429 // free(fBuffers[i]);
430 }
431 }
432
433 float** buffers() { return fBuffers; }
434 };
435
436
437
438 #define kFrames 512
439
440 int main(int argc, char *argv[] )
441 {
442 float fnbsamples;
443
444
445 CMDUI* interface = new CMDUI(argc, argv);
446 DSP.buildUserInterface(interface);
447 interface->addOption("-n", &fnbsamples, 16, 0.0, 100000000.0);
448
449 if (DSP.getNumInputs() > 0) {
450 fprintf(stderr, "no inputs allowed\n");
451 exit(1);
452 }
453
454 // init signal processor and the user interface values
455 DSP.init(44100);
456
457 // modifie the UI valuez according to the command line options
458 interface->process_command();
459
460 int nouts = DSP.getNumOutputs();
461 channels chan (kFrames, nouts);
462
463 int nbsamples = int(fnbsamples);
464 while (nbsamples > kFrames) {
465 DSP.compute(kFrames, 0, chan.buffers());
466 for (int i = 0; i < kFrames; i++) {
467 for (int c = 0; c < nouts; c++) {
468 printf("%8f\t", chan.buffers()[c][i]);
469 }
470 cout << endl;
471 }
472 nbsamples -= kFrames;
473 }
474
475 DSP.compute(nbsamples, 0, chan.buffers());
476 for (int i = 0; i < nbsamples; i++) {
477 for (int c = 0; c < nouts; c++) {
478 printf("%8f\t", chan.buffers()[c][i]);
479 }
480 cout << endl;
481 }
482 return 0;
483 }
484 /********************END ARCHITECTURE SECTION (part 2/2)****************/
485
486
An OCaml-based interpreter for Faust and its vector extension