projects / Faustine.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
New Faustine tested by sin.dsp and fft.dsp.
[Faustine.git] / interpretor / faust-0.9.47mr3 / architecture / ladspa.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 #include <math.h>
38 #include <stdlib.h>
39 #include <string.h>
40 #include <stdio.h>
41
42 #include <stack>
43 #include <string>
44 #include <iostream>
45 #include <map>
46
47 #include "ladspa.h"
48 #include "gui/GUI.h"
49 #include "misc.h"
50 #include "audio/dsp.h"
51
52 // On Intel set FZ (Flush to Zero) and DAZ (Denormals Are Zero)
53 // flags to avoid costly denormals
54 #ifdef __SSE__
55 #include <xmmintrin.h>
56 #ifdef __SSE2__
57 #define AVOIDDENORMALS _mm_setcsr(_mm_getcsr() | 0x8040)
58 #else
59 #define AVOIDDENORMALS _mm_setcsr(_mm_getcsr() | 0x8000)
60 #endif
61 #else
62 #warning *** ladspa.cpp: NO SSE FLAG (denormals may slow things down) ***
63 #define AVOIDDENORMALS
64 #endif
65
66 #define sym(name) xsym(name)
67 #define xsym(name) #name
68
69 /******************************************************************************
70 *******************************************************************************
71
72 VECTOR INTRINSICS
73
74 *******************************************************************************
75 *******************************************************************************/
76
77 <<includeIntrinsic>>
78
79 /********************END ARCHITECTURE SECTION (part 1/2)****************/
80
81 /**************************BEGIN USER SECTION **************************/
82
83 <<includeclass>>
84
85 /***************************END USER SECTION ***************************/
86
87 /*******************BEGIN ARCHITECTURE SECTION (part 2/2)***************/
88
89 //-----------------------------------portCollector--------------------------------------
90 //
91 // portCollector is passed to the buildUserInterface method of a dsp object
92 // in order to build a description of its inputs, outputs and control ports.
93 // This description is used to fill a LADSPA_Descriptor
94 //
95 //--------------------------------------------------------------------------------------
96
97 //--------------------------------useful constants--------------------------------------
98
99 #define MAXPORT 1024
100 static const int ICONTROL = LADSPA_PORT_INPUT|LADSPA_PORT_CONTROL;
101 static const int OCONTROL = LADSPA_PORT_OUTPUT|LADSPA_PORT_CONTROL;
102 static const int RANGE = LADSPA_PORT_INPUT|LADSPA_PORT_CONTROL;
103
104 static const char* inames[] = {
105 "input00", "input01", "input02", "input03", "input04",
106 "input05", "input06", "input07", "input08", "input09",
107 "input10", "input11", "input12", "input13", "input14",
108 "input15", "input16", "input17", "input18", "input19",
109 "input20", "input21", "input22", "input23", "input24",
110 "input25", "input26", "input27", "input28", "input29",
111 "input30", "input31", "input32", "input33", "input34",
112 "input35", "input36", "input37", "input38", "input39"
113 };
114
115 static const char* onames[] = {
116 "output00", "output01", "output02", "output03", "output04",
117 "output05", "output06", "output07", "output08", "output09",
118 "output10", "output11", "output12", "output13", "output14",
119 "output15", "output16", "output17", "output18", "output19",
120 "output20", "output21", "output22", "output23", "output24",
121 "output25", "output26", "output27", "output28", "output29",
122 "output30", "output31", "output32", "output33", "output34",
123 "output35", "output36", "output37", "output38", "output39"
124 };
125
126 class portCollector : public UI
127 {
128 private:
129
130 //--------------------------------------------------------------------------------------
131
132 const int fInsCount; // number of audio input ports
133 const int fOutsCount; // number of audio output ports
134 int fCtrlCount; // number of control ports
135
136 LADSPA_PortDescriptor fPortDescs[MAXPORT]; // table of port descriptors to be used in a LADSPA_Descriptor
137 const char* fPortNames[MAXPORT]; // table of port names to be used in a LADSPA_Descriptor
138 LADSPA_PortRangeHint fPortHints[MAXPORT]; // table of port hints to be used in a LADSPA_Descriptor
139
140 string fPluginName; // toplevel prefix used as plugin name
141 stack<string> fPrefix; // current prefix for controls name
142
143
144 //--------------------------------------------------------------------------------------
145 string simplify(const string& src)
146 {
147 int i=0;
148 int level=2;
149 string dst;
150
151 while (src[i] ) {
152
153 switch (level) {
154
155 case 0 :
156 case 1 :
157 case 2 :
158 // Skip the begin of the label "--foo-"
159 // until 3 '-' have been read
160 if (src[i]=='-') { level++; }
161 break;
162
163 case 3 :
164 // copy the content, but skip non alphnum
165 // and content in parenthesis
166 switch (src[i]) {
167 case '(' :
168 case '[' :
169 level++;
170 break;
171
172 case '-' :
173 dst += '-';
174 break;
175
176 default :
177 if (isalnum(src[i])) {
178 dst+= tolower(src[i]);
179 }
180
181 }
182 break;
183
184 default :
185 // here we are inside parenthesis and
186 // we skip the content until we are back to
187 // level 3
188 switch (src[i]) {
189
190 case '(' :
191 case '[' :
192 level++;
193 break;
194
195 case ')' :
196 case ']' :
197 level--;
198 break;
199
200 default :
201 break;
202 }
203
204 }
205 i++;
206 }
207 return (dst.size() > 0) ? dst :src;
208 }
209
210 void addPortDescr(int type, const char* label, int hint, float min=0.0, float max=0.0)
211 {
212 string fullname = simplify(fPrefix.top() + "-" + label);
213 char * str = strdup(fullname.c_str());
214
215 fPortDescs[fInsCount + fOutsCount + fCtrlCount] = type;
216 fPortNames[fInsCount + fOutsCount + fCtrlCount] = str;
217 fPortHints[fInsCount + fOutsCount + fCtrlCount].HintDescriptor = hint;
218 fPortHints[fInsCount + fOutsCount + fCtrlCount].LowerBound = min;
219 fPortHints[fInsCount + fOutsCount + fCtrlCount].UpperBound = max;
220 fCtrlCount++;
221 }
222
223 void openAnyBox(const char* label)
224 {
225 if (fPrefix.size() == 0) {
226 // top level label is used as plugin name
227 fPluginName = label;
228 fPrefix.push(label);
229
230 } else {
231 string s;
232 if (label && label[0]) {
233 s = fPrefix.top() + "-" + label;
234 } else {
235 s = fPrefix.top();
236 }
237 fPrefix.push(s);
238 }
239 }
240
241 public:
242
243 //--------------------------------Collect the audio ports-------------------------------
244
245 portCollector(int ins, int outs) : UI(), fInsCount(ins), fOutsCount(outs), fCtrlCount(0)
246 {
247 for (int i = 0; i < ins; i++) {
248 fPortDescs[i] = LADSPA_PORT_INPUT | LADSPA_PORT_AUDIO;
249 fPortNames[i] = inames[i];
250 fPortHints[i].HintDescriptor = 0;
251 }
252 for (int j = 0; j < outs; j++) {
253 fPortDescs[ins + j] = LADSPA_PORT_OUTPUT | LADSPA_PORT_AUDIO;
254 fPortNames[ins + j] = onames[j];
255 fPortHints[ins + j].HintDescriptor = 0;
256 }
257 };
258
259 virtual ~portCollector() {}
260
261 //------------------------------Collect the control ports-------------------------------
262
263 virtual void addButton(const char* label, float* zone) {
264 addPortDescr(ICONTROL, label, LADSPA_HINT_TOGGLED);
265 }
266
267 virtual void addToggleButton(const char* label, float* zone) {
268 addPortDescr(ICONTROL, label, LADSPA_HINT_TOGGLED);
269 }
270
271 virtual void addCheckButton(const char* label, float* zone) {
272 addPortDescr(ICONTROL, label, LADSPA_HINT_TOGGLED);
273 }
274
275 virtual void addVerticalSlider(const char* label, float* zone, float init, float min, float max, float step) {
276 addPortDescr(ICONTROL, label, LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE, min, max);
277 }
278
279 virtual void addHorizontalSlider(const char* label, float* zone, float init, float min, float max, float step) {
280 addPortDescr(ICONTROL, label, LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE, min, max);
281 }
282
283 virtual void addNumEntry(const char* label, float* zone, float init, float min, float max, float step) {
284 addPortDescr(ICONTROL, label, LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE, min, max);
285 }
286
287 // -- passive widgets
288
289 virtual void addNumDisplay(const char* label, float* zone, int precision) {
290 addPortDescr(OCONTROL, label, 0, -10000, +10000);
291 }
292 virtual void addTextDisplay(const char* label, float* zone, const char* names[], float min, float max) {
293 addPortDescr(OCONTROL, label, LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE, min, max);
294 }
295 virtual void addHorizontalBargraph(const char* label, float* zone, float min, float max) {
296 addPortDescr(OCONTROL, label, LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE, min, max);
297 }
298 virtual void addVerticalBargraph(const char* label, float* zone, float min, float max){
299 addPortDescr(OCONTROL, label, LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE, min, max);
300 }
301
302 virtual void openFrameBox(const char* label) { openAnyBox(label); }
303 virtual void openTabBox(const char* label) { openAnyBox(label); }
304 virtual void openHorizontalBox(const char* label) { openAnyBox(label); }
305 virtual void openVerticalBox(const char* label) { openAnyBox(label); }
306
307 virtual void closeBox() { fPrefix.pop(); }
308
309 virtual void show() {}
310 virtual void run() {}
311
312 //---------------------------------Fill the LADSPA descriptor---------------------------
313
314 // generate an ID from a plugin name
315 int makeID (const char* s) {
316 int h = 0;
317 for (int i = 0; s[i]; i++) {
318 h = (h << 3) + (s[i] & 7);
319 }
320 return 1+h%1000;
321 }
322
323 // fill a ladspa descriptor with the information collected on ports
324 void fillPortDescription (LADSPA_Descriptor * descriptor) {
325 const char* name = sym(mydsp);
326 descriptor->PortCount = fCtrlCount+fInsCount+fOutsCount;
327 descriptor->PortDescriptors = fPortDescs;
328 descriptor->PortNames = fPortNames;
329 descriptor->PortRangeHints = fPortHints;
330
331 descriptor->Label = strdup(name);
332 descriptor->UniqueID = makeID(name);
333 // descriptor->Label = strdup(fPluginName.c_str());
334 // descriptor->UniqueID = makeID(fPluginName.c_str());
335 descriptor->Properties = LADSPA_PROPERTY_HARD_RT_CAPABLE;
336 descriptor->Name = name;
337 // descriptor->Name = strdup(fPluginName.c_str());
338 descriptor->Maker = "undefined";
339 descriptor->Copyright = "undefined";
340 }
341 };
342
343 //--------------------------------------portData----------------------------------------
344 //
345 // portData : a user interface used to associate the data buffers and the ports
346 //
347 //--------------------------------------------------------------------------------------
348
349 class portData : public UI
350 {
351
352 private:
353
354 //--------------------------------------------------------------------------------------
355
356 const int fInsCount; // number of audio input ports
357 const int fOutsCount; // number of audio output ports
358 int fCtrlCount; // number of control ports
359
360 float* fPortZone[MAXPORT]; //
361 float* fPortData[MAXPORT];
362
363 //--------------------------------------------------------------------------------------
364
365 void addZone(float* zone)
366 {
367 fPortZone[fInsCount + fOutsCount + fCtrlCount] = zone;
368 fCtrlCount++;
369 }
370
371 public:
372
373 //--------------------------------Collect the audio ports-------------------------------
374
375 portData(int ins, int outs) : UI(), fInsCount(ins), fOutsCount(outs), fCtrlCount(0) {};
376 virtual ~portData() {}
377
378 //------------------------------Collect the control zones-------------------------------
379
380 virtual void addButton(const char* label, float* zone) { addZone(zone); }
381 virtual void addToggleButton(const char* label, float* zone) { addZone(zone); }
382 virtual void addCheckButton(const char* label, float* zone) { addZone(zone); }
383
384 virtual void addVerticalSlider(const char* label, float* zone, float init, float min, float max, float step) { addZone(zone); }
385 virtual void addHorizontalSlider(const char* label, float* zone, float init, float min, float max, float step) { addZone(zone); }
386 virtual void addNumEntry(const char* label, float* zone, float init, float min, float max, float step) { addZone(zone); }
387
388 // -- passive widgets
389
390 virtual void addNumDisplay(const char* label, float* zone, int precision) { addZone(zone); }
391 virtual void addTextDisplay(const char* label, float* zone, const char* names[], float min, float max) { addZone(zone); }
392 virtual void addHorizontalBargraph(const char* label, float* zone, float min, float max) { addZone(zone); }
393 virtual void addVerticalBargraph(const char* label, float* zone, float min, float max) { addZone(zone); }
394
395 virtual void openFrameBox(const char* label) { }
396 virtual void openTabBox(const char* label) { }
397 virtual void openHorizontalBox(const char* label) { }
398 virtual void openVerticalBox(const char* label) { }
399 virtual void closeBox() { }
400
401 virtual void show() {}
402 virtual void run() {}
403
404 //---------------------------------interaction with LADSPA------------------------------
405
406 void setPortData (unsigned long port, LADSPA_Data* data) {
407 fPortData[port] = data;
408 }
409
410 void updateCtrlZones() {
411 for (int i = fInsCount+fOutsCount; i < fInsCount+fOutsCount+fCtrlCount; i++) *fPortZone[i] = *fPortData[i];
412 }
413
414 float** getInputs() {
415 return &fPortData[0];
416 }
417
418 float** getOutputs() {
419 return &fPortData[fInsCount];
420 }
421 };
422
423 //--------------------------------Faust-LADSPA plugin-----------------------------------
424 //
425 // Plugin structure, callbacks and LADSPA_descriptor(i) entry point
426 //
427 //--------------------------------------------------------------------------------------
428
429 LADSPA_Descriptor* gDescriptor = 0;
430
431 struct PLUGIN
432 {
433 unsigned long fSampleRate;
434 portData* fPortData;
435 dsp* fDsp;
436
437 PLUGIN(unsigned long r, portData* d, dsp* p) : fSampleRate(r), fPortData(d), fDsp(p) {}
438 };
439
440 LADSPA_Handle instantiate_method (const struct _LADSPA_Descriptor * Descriptor, unsigned long SampleRate)
441 {
442 dsp* p = new mydsp();
443 portData* d = new portData(p->getNumInputs(), p->getNumOutputs());
444
445 p->buildUserInterface(d);
446 return new PLUGIN (SampleRate, d, p);
447 }
448
449 void connect_method (LADSPA_Handle Instance, unsigned long Port, LADSPA_Data * DataLocation)
450 {
451 PLUGIN* p = (PLUGIN*) Instance;
452 p->fPortData->setPortData(Port, DataLocation);
453 }
454
455 void activate_method (LADSPA_Handle Instance)
456 {
457 PLUGIN* p = (PLUGIN*) Instance;
458 p->fDsp->init(p->fSampleRate);
459 }
460
461 void run_method (LADSPA_Handle Instance, unsigned long SampleCount)
462 {
463 PLUGIN* p = (PLUGIN*) Instance;
464 p->fPortData->updateCtrlZones();
465 AVOIDDENORMALS;
466 p->fDsp->compute(SampleCount, p->fPortData->getInputs(), p->fPortData->getOutputs());
467 }
468
469 void deactivate_method (LADSPA_Handle Instance)
470 {}
471
472 void cleanup_method (LADSPA_Handle Instance)
473 {
474 PLUGIN* p = (PLUGIN*) Instance;
475 delete p->fPortData;
476 delete p->fDsp;
477 delete p;
478 }
479
480 //--------------------------------------------------------------------------------------
481
482 void init_descriptor(LADSPA_Descriptor* descriptor)
483 {
484 descriptor->UniqueID = 123456;
485 descriptor->Label = "none";
486 descriptor->Properties = LADSPA_PROPERTY_HARD_RT_CAPABLE;
487 descriptor->Name = "none";
488 descriptor->Maker = "Yann Orlarey";
489 descriptor->Copyright = "GPL";
490
491 descriptor->ImplementationData = 0;
492
493 // description des methods
494 descriptor->instantiate = instantiate_method;
495 descriptor->connect_port = connect_method;
496 descriptor->activate = activate_method;
497 descriptor->run = run_method;
498 descriptor->run_adding = 0;
499 descriptor->set_run_adding_gain = 0;
500 descriptor->deactivate = deactivate_method;
501 descriptor->cleanup = cleanup_method;
502 }
503
504 //--------------------------------------------------------------------------------------
505
506 const LADSPA_Descriptor * ladspa_descriptor(unsigned long Index)
507 {
508 if (Index == 0) {
509 if (gDescriptor == 0)
510 {
511 // allocate temporaries dsp and portCollector to build the plugin description
512 mydsp* p = new mydsp();
513 if (p) {
514 portCollector* c=new portCollector(p->getNumInputs(), p->getNumOutputs());
515 p->buildUserInterface(c);
516 gDescriptor = new LADSPA_Descriptor;
517 init_descriptor(gDescriptor);
518 c->fillPortDescription(gDescriptor);
519 delete p;
520 } else {
521 printf("Memory Error : unable to allocate the dsp object\n");
522 }
523 }
524 return gDescriptor;
525 } else {
526 return NULL;
527 }
528 }
529
530 /********************END ARCHITECTURE SECTION (part 2/2)****************/
531
532
An OCaml-based interpreter for Faust and its vector extension