Stdin, stdout and stderr updated, tested.
[Faustine.git] / interpreter / preprocessor / faust-0.9.47mr3 / architecture / dssi.cpp
1 /************************************************************************
2 IMPORTANT NOTE : this file contains two clearly delimited
3 sections : the ARCHITECTURE section (in two parts) and the
4 USER section. Each section is governed by its own copyright
5 and license. Please check individually each section for
6 license and copyright information.
7 *************************************************************************/
8
9 /*******************BEGIN ARCHITECTURE SECTION (part 1/2)****************/
10
11 /************************************************************************
12 FAUST Architecture File
13 Copyright (C) 2011 Michael J. Wilson
14
15 ---------------------------------------------------------------------
16 This Architecture section is free software; you can redistribute
17 it and/or modify it under the terms of the GNU General Public
18 License as published by the Free Software Foundation; either
19 version 3 of the License, or (at your option) any later version.
20
21 This program is distributed in the hope that it will be useful,
22 but WITHOUT ANY WARRANTY; without even the implied warranty of
23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 GNU General Public License for more details.
25
26 You should have received a copy of the GNU General Public License
27 along with this program; If not, see <http://www.gnu.org/licenses/>.
28
29 EXCEPTION : As a special exception, you may create a larger work
30 that contains this FAUST architecture section and distribute that
31 work under terms of your choice, so long as this FAUST
32 architecture section is not modified.
33 ---------------------------------------------------------------------
34
35 ************************************************************************/
36
37 /********************************************************************
38 * dssi.cpp - Polyphonic dssi wrapper for the FAUST language.
39 *
40 * Usage: faust -a dssi.cpp myfaustprog.dsp
41 *
42 * By Michael J. Wilson (mwilson@alumni.caltech.edu)
43 *
44 * Made with reference to:
45 * - vsti-mono.cpp by Julius Smith (http://ccrma.stanford.edu/~jos/)
46 * - ladspa.cpp by GRAME, Centre National de Creation Musicale
47 * - karplong.cpp by Chris Cannam, Steve Harris, Sean Bolton
48 *
49 * Because of the inclusion of code from ladspa.cpp, this architecture
50 * file is also released under the GNU General Public Licenses version
51 * 3. Sections which were taken from ladspa.cpp are clearly marked
52 * below, in order to trace the GPL dependency.
53 * As with faust2pd and vsti-mono.cpp, to obtain MIDI control via
54 * NoteOn/Off, Velocity, and KeyNumber, there must be a button named
55 * "gate" and sliders (or numeric entries) named "gain" and "freq" in
56 * the Faust patch specified in myfaustprog.dsp.
57 *
58 * FAUST
59 * Copyright (C) 2003-2007 GRAME, Centre National de Creation Musicale
60 * http://www.grame.fr/
61 *
62 ********************************************************************/
63
64 #include "dssi.h"
65 #include "ladspa.h"
66
67 #include <math.h>
68 #include <stdlib.h>
69 #include <string.h>
70
71 #include <stack>
72 #include <string>
73 #include <map>
74 #include <vector>
75 #include <list>
76
77 // On Intel set FZ (Flush to Zero) and DAZ (Denormals Are Zero)
78 // flags to avoid costly denormals
79 #ifdef __SSE__
80 #include <xmmintrin.h>
81 #ifdef __SSE2__
82 #define AVOIDDENORMALS _mm_setcsr(_mm_getcsr() | 0x8040)
83 #else
84 #define AVOIDDENORMALS _mm_setcsr(_mm_getcsr() | 0x8000)
85 #endif
86 #else
87 #warning *** dssi.cpp: NO SSE FLAG (denormals may slow things down) ***
88 #define AVOIDDENORMALS
89 #endif
90
91 struct Meta : std::map<const char*, const char*>
92 {
93 void declare (const char* key, const char* value) { (*this)[key]=value; }
94 };
95
96 #define max(x,y) (((x)>(y)) ? (x) : (y))
97 #define min(x,y) (((x)<(y)) ? (x) : (y))
98
99 #define sym(name) xsym(name)
100 #define xsym(name) #name
101
102 inline int lsr (int x, int n) { return int(((unsigned int)x) >> n); }
103 inline int int2pow2 (int x) { int r=0; while ((1<<r)<x) r++; return r; }
104
105 /******************************************************************************
106 *******************************************************************************
107
108 VECTOR INTRINSICS
109
110 *******************************************************************************
111 *******************************************************************************/
112
113 <<includeIntrinsic>>
114
115 //---------------------Abstract User Interface--------------------
116 //
117 // Abstract definition of a User Interface to be passed to the
118 // buildUserInterface method of a Faust Signal Processor
119 //
120 //----------------------------------------------------------------
121 class UI
122 {
123 bool fStopped;
124
125 public:
126 UI() : fStopped(false) {}
127 virtual ~UI() {}
128
129 virtual void addButton(const char* label, float* zone) = 0;
130 virtual void addToggleButton(const char* label, float* zone) = 0;
131 virtual void addCheckButton(const char* label, float* zone) = 0;
132 virtual void addVerticalSlider(const char* label, float* zone, float init, float min, float max, float step) = 0;
133 virtual void addHorizontalSlider(const char* label, float* zone, float init, float min, float max, float step) = 0;
134 virtual void addNumEntry(const char* label, float* zone, float init, float min, float max, float step) = 0;
135
136 // -- passive widgets
137 virtual void addNumDisplay(const char* label, float* zone, int precision) = 0;
138 virtual void addTextDisplay(const char* label, float* zone, char* names[], float min, float max) = 0;
139 virtual void addHorizontalBargraph(const char* label, float* zone, float min, float max) = 0;
140 virtual void addVerticalBargraph(const char* label, float* zone, float min, float max) = 0;
141
142 // -- frames and labels
143 virtual void openFrameBox(const char* label) = 0;
144 virtual void openTabBox(const char* label) = 0;
145 virtual void openHorizontalBox(const char* label) = 0;
146 virtual void openVerticalBox(const char* label) = 0;
147 virtual void closeBox() = 0;
148
149 virtual void show() = 0;
150 virtual void run() = 0;
151
152 void stop() { fStopped = true; }
153 bool stopped() { return fStopped; }
154
155 virtual void declare(float* zone, const char* key, const char* value) {}
156 };
157
158 //------------------Abstract Signal Processor---------------------
159 //
160 // Abstract definition of a Faust Signal Processor
161 //
162 //----------------------------------------------------------------
163 class dsp
164 {
165 protected:
166 int fSamplingFreq;
167 public:
168 dsp() {}
169 virtual ~dsp() {}
170 virtual int getNumInputs() = 0;
171 virtual int getNumOutputs() = 0;
172 virtual void buildUserInterface(UI* interface) = 0;
173 virtual void init(int samplingRate) = 0;
174 virtual void compute(int len, float** inputs, float** outputs)= 0;
175 };
176
177 /********************END ARCHITECTURE SECTION (part 1/2)****************/
178
179 /**************************BEGIN USER SECTION **************************/
180
181 <<includeclass>>
182
183 /***************************END USER SECTION ***************************/
184
185 /*******************BEGIN ARCHITECTURE SECTION (part 2/2)***************/
186
187 ////////////////////////////////////////////////////////////////////////////////
188 // Forward declarations
189 ////////////////////////////////////////////////////////////////////////////////
190 class Plugin;
191 class DescriptorUI;
192 class Voice;
193
194 ////////////////////////////////////////////////////////////////////////////////
195 // Global data
196 ////////////////////////////////////////////////////////////////////////////////
197 // Maximum polyphony, must be at least 1 (TODO make this configurable at compile / runtime?)
198 const int MAX_POLYPHONY = 64;
199 // Descriptor
200 DSSI_Descriptor* g_dssi_descriptor;
201 // Additional data for descriptor:
202 LADSPA_Descriptor* g_ladspa_descriptor;
203 // Program descriptor:
204 DSSI_Program_Descriptor g_program_descriptor;
205
206 // Global data for the descriptor:
207 std::vector<LADSPA_PortDescriptor> g_port_descriptors;
208 std::vector<LADSPA_PortRangeHint> g_port_range_hints;
209 std::vector<const char*> g_port_names;
210 std::string g_name;
211
212 ////////////////////////////////////////////////////////////////////////////////
213 // The enclosed code is from ladspa.cpp
214 // TODO groups of port names
215 static const char* inames[] =
216 {
217 "input00", "input01", "input02", "input03", "input04",
218 "input05", "input06", "input07", "input08", "input09",
219 "input10", "input11", "input12", "input13", "input14",
220 "input15", "input16", "input17", "input18", "input19",
221 "input20", "input21", "input22", "input23", "input24",
222 "input25", "input26", "input27", "input28", "input29",
223 "input30", "input31", "input32", "input33", "input34",
224 "input35", "input36", "input37", "input38", "input39"
225 };
226 static const char* onames[] =
227 {
228 "output00", "output01", "output02", "output03", "output04",
229 "output05", "output06", "output07", "output08", "output09",
230 "output10", "output11", "output12", "output13", "output14",
231 "output15", "output16", "output17", "output18", "output19",
232 "output20", "output21", "output22", "output23", "output24",
233 "output25", "output26", "output27", "output28", "output29",
234 "output30", "output31", "output32", "output33", "output34",
235 "output35", "output36", "output37", "output38", "output39"
236 };
237 // END code from ladspa.cpp
238 ////////////////////////////////////////////////////////////////////////////////
239
240 ////////////////////////////////////////////////////////////////////////////////
241 // Global helper functions
242 ////////////////////////////////////////////////////////////////////////////////
243 char* get_metadata_if_exists(const char* key, const char* default_string)
244 {
245 // TODO probably want to free these somehow. Currently only used for ladspa descriptor
246 Meta meta;
247 mydsp::metadata(&meta);
248 if(meta.find(key) != meta.end())
249 {
250 return strdup(meta[key]);
251 }
252 else
253 {
254 return strdup(default_string);
255 }
256 }
257
258 ////////////////////////////////////////////////////////////////////////////////
259 // The enclosed code is from ladspa.cpp
260 std::string simplify(const std::string& src)
261 {
262 int i=0;
263 int level=2;
264 std::string dst;
265
266 while (src[i] ) {
267
268 switch (level) {
269
270 case 0 :
271 case 1 :
272 case 2 :
273 // Skip the begin of the label "--foo-"
274 // until 3 '-' have been read
275 if (src[i]=='-') { level++; }
276 break;
277
278 case 3 :
279 // copy the content, but skip non alphnum
280 // and content in parenthesis
281 switch (src[i]) {
282 case '(' :
283 case '[' :
284 level++;
285 break;
286
287 case '-' :
288 dst += '-';
289 break;
290
291 default :
292 if (isalnum(src[i])) {
293 dst+= tolower(src[i]);
294 }
295
296 }
297 break;
298
299 default :
300 // here we are inside parenthesis and
301 // we skip the content until we are back to
302 // level 3
303 switch (src[i]) {
304
305 case '(' :
306 case '[' :
307 level++;
308 break;
309
310 case ')' :
311 case ']' :
312 level--;
313 break;
314
315 default :
316 break;
317 }
318 }
319 i++;
320 }
321 return (dst.size() > 0) ? dst :src;
322 }
323 // END code from ladspa.cpp
324 ////////////////////////////////////////////////////////////////////////////////
325
326 ////////////////////////////////////////////////////////////////////////////////
327 // Single voice; use multiple for polyphony
328 ////////////////////////////////////////////////////////////////////////////////
329 class Voice : public UI
330 {
331 public:
332 Voice(int sampleRate);
333 ~Voice();
334
335 // UI methods:
336 // TODO don't hardcode these so hard maybe
337 void setFreq(float val);
338 void setGate(float val);
339 void setGain(float val);
340
341 virtual void addButton(const char* label, float* zone);
342 virtual void addToggleButton(const char* label, float* zone);
343 virtual void addCheckButton(const char* label, float* zone);
344 virtual void addVerticalSlider(const char* label, float* zone, float init, float min, float max, float step);
345 virtual void addHorizontalSlider(const char* label, float* zone, float init, float min, float max, float step);
346 virtual void addNumEntry(const char* label, float* zone, float init, float min, float max, float step);
347
348 virtual void addNumDisplay(const char* label, float* zone, int precision);
349 virtual void addTextDisplay(const char* label, float* zone, char* names[], float min, float max);
350 virtual void addHorizontalBargraph(const char* label, float* zone, float min, float max);
351 virtual void addVerticalBargraph(const char* label, float* zone, float min, float max);
352
353 virtual void openFrameBox(const char* label);
354 virtual void openTabBox(const char* label);
355 virtual void openHorizontalBox(const char* label);
356 virtual void openVerticalBox(const char* label);
357 virtual void closeBox();
358
359 virtual void show();
360 virtual void run();
361
362 // Internal control (to Faust DSP)
363 std::vector<float*> m_controls;
364
365 // TODO maybe don't make this public eventually
366 mydsp* m_mydsp;
367
368 private:
369 // Helpers for UI building:
370 // TODO organize this a bit better later...
371 bool ckAnyMatch(const char* label, const char* indexName, float **zone, float* newZone);
372 bool ckAllMatches(const char* label, float* zone);
373 void addZone(float* zone);
374
375 int m_samplerate;
376
377 float* m_freq_zone;
378 float* m_gate_zone;
379 float* m_gain_zone;
380 };
381
382 ////////////////////////////////////////////////////////////////////////////////
383 // Plugin class to handle DSSI methods:
384 ////////////////////////////////////////////////////////////////////////////////
385 class Plugin : public UI
386 {
387 public:
388 // LADSPA methods:
389 static LADSPA_Handle instantiate(const LADSPA_Descriptor *, unsigned long);
390 static void connectPort(LADSPA_Handle, unsigned long, LADSPA_Data *);
391 static void activate(LADSPA_Handle);
392 static void run(LADSPA_Handle, unsigned long);
393 static void cleanup(LADSPA_Handle);
394
395 // DSSI methods:
396 static const DSSI_Program_Descriptor* getProgram(LADSPA_Handle, unsigned long);
397 static void selectProgram(LADSPA_Handle, unsigned long, unsigned long);
398 static int getMidiController(LADSPA_Handle, unsigned long);
399 static void runSynth(LADSPA_Handle, unsigned long, snd_seq_event_t *, unsigned long);
400
401 // UI methods:
402 // TODO don't hardcode these so hard maybe
403 void setFreq(float val, int voice = 0);
404 void setGate(float val, int voice = 0);
405 void setGain(float val, int voice = 0);
406
407 virtual void addButton(const char* label, float* zone);
408 virtual void addToggleButton(const char* label, float* zone);
409 virtual void addCheckButton(const char* label, float* zone);
410 virtual void addVerticalSlider(const char* label, float* zone, float init, float min, float max, float step);
411 virtual void addHorizontalSlider(const char* label, float* zone, float init, float min, float max, float step);
412 virtual void addNumEntry(const char* label, float* zone, float init, float min, float max, float step);
413
414 virtual void addNumDisplay(const char* label, float* zone, int precision);
415 virtual void addTextDisplay(const char* label, float* zone, char* names[], float min, float max);
416 virtual void addHorizontalBargraph(const char* label, float* zone, float min, float max);
417 virtual void addVerticalBargraph(const char* label, float* zone, float min, float max);
418
419 virtual void openFrameBox(const char* label);
420 virtual void openTabBox(const char* label);
421 virtual void openHorizontalBox(const char* label);
422 virtual void openVerticalBox(const char* label);
423 virtual void closeBox();
424
425 virtual void show();
426 virtual void run();
427
428 private:
429 Plugin(int sampleRate);
430 ~Plugin();
431
432 // Helper methods:
433 void updateControlZones();
434 void runImpl(unsigned long, snd_seq_event_t *, unsigned long);
435 void addSamples(int);
436
437 // Helpers for UI building:
438 // TODO organize this a bit better later...
439 bool ckAnyMatch(const char* label, const char* indexName);
440 bool ckAllMatches(const char* label);
441 void add_control_with_default(float default_value);
442
443 int m_samplerate;
444
445 // Voice allocation memebers (TODO maybe break voice allocator into separate class later)
446 // Note each voice is playing
447 std::vector<int> voice_notes;
448 // Queue of free voices
449 std::list<size_t> voice_free;
450
451 // Voices for polyphony
452 std::vector<Voice*> m_voices;
453
454 // Top-level inputs (from DSSI host)
455 std::vector<float*> m_inputs;
456 // Top-level outputs (to DSSI host)
457 std::vector<float*> m_outputs;
458 // Temp vector for collecting outputs TODO this is an ugly way to do it...
459 std::vector<std::vector<float> > m_temp_outputs;
460 // External control (from DSSI host)
461 std::vector<float*> m_controls;
462
463 // Control default values
464 std::vector<float> m_control_defaults;
465 };
466
467 ////////////////////////////////////////////////////////////////////////////////
468 // UI class to build descriptor, analogous to ladspa.cpp's portCollector
469 ////////////////////////////////////////////////////////////////////////////////
470 const int ICONTROL = LADSPA_PORT_INPUT|LADSPA_PORT_CONTROL;
471 const int OCONTROL = LADSPA_PORT_OUTPUT|LADSPA_PORT_CONTROL;
472
473 class DescriptorUI : public UI
474 {
475 public:
476 DescriptorUI(int ins, int outs);
477
478 virtual void addButton(const char* label, float* zone) {
479 if (!ckAnyMatch(label, "gate"))
480 {
481 addPortDescr(ICONTROL, label, LADSPA_HINT_TOGGLED);
482 }
483 }
484 virtual void addToggleButton(const char* label, float* zone) {
485 addPortDescr(ICONTROL, label, LADSPA_HINT_TOGGLED);
486 }
487 virtual void addCheckButton(const char* label, float* zone) {
488 addPortDescr(ICONTROL, label, LADSPA_HINT_TOGGLED);
489 }
490 virtual void addVerticalSlider(const char* label, float* zone, float init, float min, float max, float step) {
491 if (!ckAllMatches(label))
492 {
493 addPortDescr(ICONTROL, label, LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE, min, max);
494 }
495 }
496 virtual void addHorizontalSlider(const char* label, float* zone, float init, float min, float max, float step) {
497 if (!ckAllMatches(label))
498 {
499 addPortDescr(ICONTROL, label, LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE, min, max);
500 }
501 }
502 virtual void addNumEntry(const char* label, float* zone, float init, float min, float max, float step) {
503 if (!ckAllMatches(label))
504 {
505 addPortDescr(ICONTROL, label, LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE, min, max);
506 }
507 }
508 virtual void addNumDisplay(const char* label, float* zone, int precision) {
509 addPortDescr(OCONTROL, label, 0, -10000, +10000);
510 }
511 virtual void addTextDisplay(const char* label, float* zone, char* names[], float min, float max) {
512 addPortDescr(OCONTROL, label, LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE, min, max);
513 }
514 virtual void addHorizontalBargraph(const char* label, float* zone, float min, float max) {
515 addPortDescr(OCONTROL, label, LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE, min, max);
516 }
517 virtual void addVerticalBargraph(const char* label, float* zone, float min, float max){
518 addPortDescr(OCONTROL, label, LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE, min, max);
519 }
520
521 virtual void openFrameBox(const char* label) { openAnyBox(label); }
522 virtual void openTabBox(const char* label) { openAnyBox(label); }
523 virtual void openHorizontalBox(const char* label) { openAnyBox(label); }
524 virtual void openVerticalBox(const char* label) { openAnyBox(label); }
525
526 virtual void closeBox() { fPrefix.pop(); }
527
528 virtual void show() {}
529 virtual void run() {}
530
531 private:
532 std::stack<std::string> fPrefix;
533
534 void addPortDescr(int type, const char* label, int hint, float min=0.0, float max=0.0);
535
536 void openAnyBox(const char* label);
537
538 bool ckAnyMatch(const char* label, const char* indexName)
539 {
540 // TODO do case-insensitive here...
541 if (strcmp(label,indexName)==0)
542 {
543 // Don't set values in the DescriptorUI
544 // TODO consolidate this later
545 return true;
546 }
547 return false;
548 }
549 bool ckAllMatches(const char* label)
550 {
551 bool result = false;
552 result = result || ckAnyMatch(label,"gain");
553 result = result || ckAnyMatch(label,"gate");
554 result = result || ckAnyMatch(label,"freq");
555 return result;
556 }
557 };
558
559 ////////////////////////////////////////////////////////////////////////////////
560 // DescriptorUI methods
561 ////////////////////////////////////////////////////////////////////////////////
562 DescriptorUI::DescriptorUI(int ins, int outs)
563 {
564 // Note inputs and outputs
565 for (int i = 0; i < ins; i++)
566 {
567 g_port_descriptors.push_back(LADSPA_PORT_INPUT | LADSPA_PORT_AUDIO);
568 LADSPA_PortRangeHint temp;
569 temp.HintDescriptor = 0;
570 temp.LowerBound = 0;
571 temp.UpperBound = 0;
572 g_port_range_hints.push_back(temp);
573 g_port_names.push_back(inames[i]);
574 }
575 for (int j = 0; j < outs; j++)
576 {
577 g_port_descriptors.push_back(LADSPA_PORT_OUTPUT | LADSPA_PORT_AUDIO);
578 LADSPA_PortRangeHint temp;
579 temp.HintDescriptor = 0;
580 temp.LowerBound = 0;
581 temp.UpperBound = 0;
582 g_port_range_hints.push_back(temp);
583 g_port_names.push_back(onames[j]);
584 }
585 }
586
587 void DescriptorUI::addPortDescr(int type, const char* label, int hint, float min, float max)
588 {
589 ////////////////////////////////////////////////////////////////////////////////
590 // The enclosed code is derived from ladspa.cpp
591 std::string fullname = simplify(fPrefix.top() + "-" + label);
592 // TODO for debugging, I'm just using the label for now instead of the full name (since fullname can get long)
593 // char * str = strdup(fullname.c_str());
594 char * str = strdup(label);
595 // END code from ladspa.cpp
596 ////////////////////////////////////////////////////////////////////////////////
597
598 g_port_descriptors.push_back(type);
599 LADSPA_PortRangeHint temp;
600 temp.HintDescriptor = hint;
601 temp.LowerBound = min;
602 temp.UpperBound = max;
603 g_port_range_hints.push_back(temp);
604 g_port_names.push_back(str); // TODO memory leak; need to free
605 }
606
607 void DescriptorUI::openAnyBox(const char* label)
608 {
609 ////////////////////////////////////////////////////////////////////////////////
610 // The enclosed code is from ladspa.cpp
611 if (fPrefix.size() == 0)
612 {
613 // top level label is used as plugin name
614 g_name = label;
615 fPrefix.push(label);
616 }
617 else
618 {
619 std::string s;
620 if (label && label[0])
621 {
622 s = fPrefix.top() + "-" + label;
623 }
624 else
625 {
626 s = fPrefix.top();
627 }
628 fPrefix.push(s);
629 }
630 // END code from ladspa.cpp
631 ////////////////////////////////////////////////////////////////////////////////
632 }
633
634 ////////////////////////////////////////////////////////////////////////////////
635 // Plugin methods
636 ////////////////////////////////////////////////////////////////////////////////
637 Plugin::Plugin(int sampleRate) :
638 m_samplerate(sampleRate)
639 {
640 int i;
641
642 mydsp temp_mydsp;
643
644 for (i = 0; i < MAX_POLYPHONY; i++)
645 {
646 m_voices.push_back(new Voice(m_samplerate));
647
648 // Voice parameters:
649 voice_free.push_back(i);
650 // TODO using -1 to represent nothing; think of a more clear way to do this
651 voice_notes.push_back(-1);
652 }
653 for (i = 0; i < temp_mydsp.getNumInputs(); i++)
654 {
655 m_inputs.push_back(0);
656 }
657 for (i = 0; i < temp_mydsp.getNumOutputs(); i++)
658 {
659 m_outputs.push_back(0);
660 std::vector<float> temp;
661 temp.push_back(0.0);
662 m_temp_outputs.push_back(temp);
663 }
664 }
665
666 Plugin::~Plugin()
667 {
668 size_t i;
669 for (i = 0; i < m_voices.size(); i++)
670 {
671 delete m_voices[i];
672 }
673 }
674
675 LADSPA_Handle Plugin::instantiate(const LADSPA_Descriptor *, unsigned long rate)
676 {
677 Plugin *plugin = new Plugin(rate);
678 size_t i;
679
680 mydsp* temp_mydsp = new mydsp();
681 temp_mydsp->buildUserInterface(plugin);
682 delete temp_mydsp;
683
684 for (i = 0; i < plugin->m_voices.size(); i++)
685 {
686 plugin->m_voices[i]->m_mydsp->buildUserInterface(plugin->m_voices[i]);
687 }
688 return plugin;
689 }
690
691 void Plugin::connectPort(LADSPA_Handle handle, unsigned long port, LADSPA_Data *location)
692 {
693 Plugin *plugin = (Plugin *)handle;
694
695 // Map inputs, then outputs, then controls:
696 if (port < plugin->m_inputs.size())
697 {
698 *(&plugin->m_inputs[port]) = (float *)location;
699 }
700 else if (port < plugin->m_inputs.size() + plugin->m_outputs.size())
701 {
702 *(&plugin->m_outputs[port - plugin->m_inputs.size()]) = (float *)location;
703 }
704 else
705 {
706 plugin->m_controls[port - plugin->m_inputs.size() - plugin->m_outputs.size()] = (float *)location;
707 }
708 }
709
710 void Plugin::activate(LADSPA_Handle handle)
711 {
712 Plugin *plugin = (Plugin *)handle;
713 for (size_t i = 0; i < plugin->m_voices.size(); i++)
714 {
715 plugin->m_voices[i]->m_mydsp->init(plugin->m_samplerate);
716 }
717 }
718
719 void Plugin::run(LADSPA_Handle handle, unsigned long samples)
720 {
721 runSynth(handle, samples, 0, 0);
722 }
723
724 void Plugin::cleanup(LADSPA_Handle handle)
725 {
726 delete (Plugin *)handle;
727 }
728
729 const DSSI_Program_Descriptor* Plugin::getProgram(LADSPA_Handle handle, unsigned long index)
730 {
731 if (index == 0)
732 {
733 return &g_program_descriptor;
734 }
735 else
736 {
737 return NULL;
738 }
739 }
740
741 void Plugin::selectProgram(LADSPA_Handle handle, unsigned long bank, unsigned long program)
742 {
743 Plugin *plugin = (Plugin *)handle;
744 for (size_t i = 0; i < plugin->m_controls.size(); i++)
745 {
746 *(plugin->m_controls[i]) = plugin->m_control_defaults[i];
747 }
748 }
749
750 int Plugin::getMidiController(LADSPA_Handle, unsigned long port)
751 {
752 // TODO this is where we need to map MIDI controllers to ports
753 return DSSI_NONE;
754 }
755
756 void Plugin::updateControlZones()
757 {
758 for (size_t i = 0; i < m_controls.size(); i++)
759 {
760 for (size_t j = 0; j < m_voices.size(); j++)
761 {
762 *(m_voices[j]->m_controls[i]) = *(m_controls[i]);
763 }
764 }
765 }
766
767 void Plugin::runSynth(LADSPA_Handle handle, unsigned long samples, snd_seq_event_t *events, unsigned long eventCount)
768 {
769 Plugin *plugin = (Plugin *)handle;
770 plugin->updateControlZones();
771 plugin->runImpl(samples, events, eventCount);
772 }
773
774 void Plugin::runImpl(unsigned long sampleCount, snd_seq_event_t *events, unsigned long eventCount)
775 {
776 unsigned long pos;
777 unsigned long count;
778 unsigned long eventPos;
779 snd_seq_ev_note_t n;
780
781 size_t voice_index;
782
783 pos = 0;
784 eventPos = 0;
785 while (pos < sampleCount)
786 {
787 while ((eventPos < eventCount) &&
788 (pos >= events[eventPos].time.tick))
789 {
790 switch (events[eventPos].type)
791 {
792 case SND_SEQ_EVENT_NOTEON:
793 n = events[eventPos].data.note;
794 if (n.velocity > 0)
795 {
796 // Look for the next free voice:
797 if (!voice_free.empty())
798 {
799 // Get the index of the first free string and remove it from the list
800 voice_index = voice_free.front();
801 voice_free.pop_front();
802
803 // Play the note on that voice
804 voice_notes[voice_index] = n.note;
805 float freq = 440.0f * powf(2.0f,(((float)n.note)-69.0f)/12.0f);
806 float gain = n.velocity/127.0f;
807 setFreq(freq, voice_index); // Hz - requires Faust control-signal "freq"
808 setGain(gain, voice_index); // 0-1 - requires Faust control-signal "gain"
809 setGate(1.0f, voice_index); // 0 or 1 - requires Faust button-signal "gate"
810 }
811 }
812 break;
813 case SND_SEQ_EVENT_NOTEOFF:
814 for (voice_index = 0; voice_index < voice_notes.size(); voice_index++)
815 {
816 if (voice_notes[voice_index] == events[eventPos].data.note.note)
817 {
818 setGate(0, voice_index);
819 // TODO using -1 to represent nothing; think of a more clear way to do this
820 voice_notes[voice_index] = -1;
821 voice_free.push_back(voice_index);
822 }
823 }
824 break;
825 default:
826 break;
827 }
828 ++eventPos;
829 }
830
831 if ((eventPos < eventCount) && (events[eventPos].time.tick < sampleCount))
832 {
833 count = events[eventPos].time.tick - pos;
834 }
835 else
836 {
837 count = sampleCount - pos;
838 }
839
840 addSamples(count);
841 pos += count;
842 }
843 }
844
845 void Plugin::addSamples(int samples)
846 {
847 size_t i;
848 int j;
849 size_t v;
850
851 // TODO this isn't very efficient right now...
852
853 // Grow temp buffers to appropriate size / zero them:
854 for (i = 0; i < m_temp_outputs.size(); i++)
855 {
856 for (j = 0; j < samples; j++)
857 {
858 if (m_temp_outputs[i].size() < (j+1))
859 {
860 m_temp_outputs[i].push_back(0.0);
861 }
862 else
863 {
864 m_temp_outputs[i][j] = 0.0;
865 }
866 }
867 }
868
869 AVOIDDENORMALS;
870
871 // Add all voices together
872 for (v = 0; v < m_voices.size(); v++)
873 {
874 m_voices[v]->m_mydsp->compute(samples, &m_inputs[0], &m_outputs[0]);
875
876 // Accumulate in temp buffer
877 for (i = 0; i < m_outputs.size(); i++)
878 {
879 for (j = 0; j < samples; j++)
880 {
881 m_temp_outputs[i][j] += m_outputs[i][j];
882 }
883 }
884 }
885
886 // Transfer accumulator to actual outputs
887 for (i = 0; i < m_outputs.size(); i++)
888 {
889 for (j = 0; j < samples; j++)
890 {
891 // TODO find a better way to protect against clipping.
892 m_outputs[i][j] = m_temp_outputs[i][j] / (float)MAX_POLYPHONY;
893 }
894 }
895 }
896
897 void Plugin::setFreq(float val, int voice)
898 {
899 m_voices[voice]->setFreq(val);
900 }
901
902 void Plugin::setGate(float val, int voice)
903 {
904 m_voices[voice]->setGate(val);
905 }
906
907 void Plugin::setGain(float val, int voice)
908 {
909 m_voices[voice]->setGain(val);
910 }
911
912 void Plugin::addButton(const char* label, float* zone)
913 {
914 if (!ckAnyMatch(label, "gate"))
915 {
916 add_control_with_default(0);
917 }
918 }
919
920 void Plugin::addToggleButton(const char* label, float* zone)
921 {
922 add_control_with_default(0);
923 }
924
925 void Plugin::addCheckButton(const char* label, float* zone)
926 {
927 add_control_with_default(0);
928 }
929
930 void Plugin::addVerticalSlider(const char* label, float* zone, float init, float min, float max, float step)
931 {
932 if (!ckAllMatches(label))
933 {
934 add_control_with_default(init);
935 }
936 }
937 void Plugin::addHorizontalSlider(const char* label, float* zone, float init, float min, float max, float step)
938 {
939 if (!ckAllMatches(label))
940 {
941 add_control_with_default(init);
942 }
943 }
944 void Plugin::addNumEntry(const char* label, float* zone, float init, float min, float max, float step)
945 {
946 if (!ckAllMatches(label))
947 {
948 add_control_with_default(init);
949 }
950 }
951
952 void Plugin::addNumDisplay(const char* label, float* zone, int precision)
953 {
954 add_control_with_default(0);
955 }
956 void Plugin::addTextDisplay(const char* label, float* zone, char* names[], float min, float max)
957 {
958 add_control_with_default(0);
959 }
960 void Plugin::addHorizontalBargraph(const char* label, float* zone, float min, float max)
961 {
962 add_control_with_default(min);
963 }
964 void Plugin::addVerticalBargraph(const char* label, float* zone, float min, float max)
965 {
966 add_control_with_default(min);
967 }
968
969 void Plugin::openFrameBox(const char* label)
970 {
971 }
972 void Plugin::openTabBox(const char* label)
973 {
974 }
975 void Plugin::openHorizontalBox(const char* label)
976 {
977 }
978 void Plugin::openVerticalBox(const char* label)
979 {
980 }
981 void Plugin::closeBox()
982 {
983 }
984
985 void Plugin::show()
986 {
987 }
988 void Plugin::run()
989 {
990 }
991
992 bool Plugin::ckAnyMatch(const char* label, const char* indexName)
993 {
994 // TODO do case-insensitive here...
995 if (strcmp(label,indexName)==0)
996 {
997 return true;
998 }
999 return false;
1000 }
1001 bool Plugin::ckAllMatches(const char* label)
1002 {
1003 bool result = false;
1004 result = result || ckAnyMatch(label,"gain");
1005 result = result || ckAnyMatch(label,"gate");
1006 result = result || ckAnyMatch(label,"freq");
1007 return result;
1008 }
1009 void Plugin::add_control_with_default(float default_value)
1010 {
1011 // TODO may need to consider different things for input and output controls...
1012 m_controls.push_back(0);
1013 m_control_defaults.push_back(default_value);
1014 }
1015
1016
1017 ////////////////////////////////////////////////////////////////////////////////
1018 // Voice methods
1019 ////////////////////////////////////////////////////////////////////////////////
1020 Voice::Voice(int sampleRate) :
1021 m_samplerate(sampleRate),
1022 m_freq_zone(0),
1023 m_gate_zone(0),
1024 m_gain_zone(0)
1025 {
1026 m_mydsp = new mydsp();
1027 }
1028
1029 Voice::~Voice()
1030 {
1031 delete m_mydsp;
1032 }
1033
1034 void Voice::setFreq(float val)
1035 {
1036 if (m_freq_zone)
1037 {
1038 *m_freq_zone = val;
1039 }
1040 }
1041
1042 void Voice::setGate(float val)
1043 {
1044 if (m_gate_zone)
1045 {
1046 *m_gate_zone = val;
1047 }
1048 }
1049
1050 void Voice::setGain(float val)
1051 {
1052 if (m_gain_zone)
1053 {
1054 *m_gain_zone = val;
1055 }
1056 }
1057
1058 void Voice::addButton(const char* label, float* zone)
1059 {
1060 if (!ckAnyMatch(label, "gate", &m_gate_zone, zone))
1061 {
1062 addZone(zone);
1063 }
1064 }
1065
1066 void Voice::addToggleButton(const char* label, float* zone)
1067 {
1068 addZone(zone);
1069 }
1070
1071 void Voice::addCheckButton(const char* label, float* zone)
1072 {
1073 addZone(zone);
1074 }
1075
1076 void Voice::addVerticalSlider(const char* label, float* zone, float init, float min, float max, float step)
1077 {
1078 if (!ckAllMatches(label, zone))
1079 {
1080 addZone(zone);
1081 }
1082 }
1083 void Voice::addHorizontalSlider(const char* label, float* zone, float init, float min, float max, float step)
1084 {
1085 if (!ckAllMatches(label, zone))
1086 {
1087 addZone(zone);
1088 }
1089 }
1090 void Voice::addNumEntry(const char* label, float* zone, float init, float min, float max, float step)
1091 {
1092 if (!ckAllMatches(label, zone))
1093 {
1094 addZone(zone);
1095 }
1096 }
1097
1098 void Voice::addNumDisplay(const char* label, float* zone, int precision)
1099 {
1100 addZone(zone);
1101 }
1102 void Voice::addTextDisplay(const char* label, float* zone, char* names[], float min, float max)
1103 {
1104 addZone(zone);
1105 }
1106 void Voice::addHorizontalBargraph(const char* label, float* zone, float min, float max)
1107 {
1108 addZone(zone);
1109 }
1110 void Voice::addVerticalBargraph(const char* label, float* zone, float min, float max)
1111 {
1112 addZone(zone);
1113 }
1114
1115 void Voice::openFrameBox(const char* label)
1116 {
1117 }
1118 void Voice::openTabBox(const char* label)
1119 {
1120 }
1121 void Voice::openHorizontalBox(const char* label)
1122 {
1123 }
1124 void Voice::openVerticalBox(const char* label)
1125 {
1126 }
1127 void Voice::closeBox()
1128 {
1129 }
1130
1131 void Voice::show()
1132 {
1133 }
1134 void Voice::run()
1135 {
1136 }
1137
1138 bool Voice::ckAnyMatch(const char* label, const char* indexName, float **zone, float* newZone)
1139 {
1140 // TODO do case-insensitive here...
1141 if (strcmp(label,indexName)==0)
1142 {
1143 *zone = newZone;
1144 return true;
1145 }
1146 return false;
1147 }
1148 bool Voice::ckAllMatches(const char* label, float* zone)
1149 {
1150 bool result = false;
1151 result = result || ckAnyMatch(label,"gain", &m_gain_zone, zone);
1152 result = result || ckAnyMatch(label,"gate", &m_gate_zone, zone);
1153 result = result || ckAnyMatch(label,"freq", &m_freq_zone, zone);
1154 return result;
1155 }
1156 void Voice::addZone(float* zone)
1157 {
1158 m_controls.push_back(zone);
1159 }
1160
1161
1162 ////////////////////////////////////////////////////////////////////////////////
1163 // Shared object hooks
1164 ////////////////////////////////////////////////////////////////////////////////
1165 extern "C"
1166 {
1167
1168 #ifdef __GNUC__
1169 __attribute__((constructor)) void init(void)
1170 #else
1171 void _init(void)
1172 #endif
1173 {
1174 AVOIDDENORMALS;
1175
1176 if (g_dssi_descriptor == 0)
1177 {
1178 g_ladspa_descriptor = new LADSPA_Descriptor();
1179 g_dssi_descriptor = new DSSI_Descriptor();
1180
1181 mydsp* temp_mydsp = new mydsp();
1182 DescriptorUI* temp_descriptor_ui = new DescriptorUI(temp_mydsp->getNumInputs(), temp_mydsp->getNumOutputs());
1183 temp_mydsp->buildUserInterface(temp_descriptor_ui);
1184
1185 // Fill the descriptors:
1186 // TODO figure out strdup with const strings
1187 g_ladspa_descriptor->UniqueID = 0;
1188 g_ladspa_descriptor->Label = get_metadata_if_exists("name", g_name.c_str());
1189 g_ladspa_descriptor->Properties = LADSPA_PROPERTY_HARD_RT_CAPABLE;
1190 g_ladspa_descriptor->Name = get_metadata_if_exists("name", g_name.c_str());
1191 g_ladspa_descriptor->Maker = get_metadata_if_exists("author", "Maker");
1192 g_ladspa_descriptor->Copyright = get_metadata_if_exists("copyright", "Copyright");
1193 g_ladspa_descriptor->PortCount = g_port_descriptors.size();
1194 g_ladspa_descriptor->PortDescriptors = &g_port_descriptors[0];
1195 g_ladspa_descriptor->PortNames = &g_port_names[0];
1196 g_ladspa_descriptor->PortRangeHints = &g_port_range_hints[0];
1197 g_ladspa_descriptor->ImplementationData = 0;
1198 g_ladspa_descriptor->instantiate = Plugin::instantiate;
1199 g_ladspa_descriptor->connect_port = Plugin::connectPort;
1200 g_ladspa_descriptor->activate = Plugin::activate;
1201 g_ladspa_descriptor->run = Plugin::run;
1202 g_ladspa_descriptor->run_adding = 0;
1203 g_ladspa_descriptor->set_run_adding_gain = 0;
1204 g_ladspa_descriptor->deactivate = 0;
1205 g_ladspa_descriptor->cleanup = Plugin::cleanup;
1206
1207 g_dssi_descriptor->DSSI_API_Version = 1;
1208 g_dssi_descriptor->LADSPA_Plugin = g_ladspa_descriptor;
1209 g_dssi_descriptor->configure = 0;
1210 g_dssi_descriptor->get_program = Plugin::getProgram;
1211 g_dssi_descriptor->select_program = Plugin::selectProgram;
1212 g_dssi_descriptor->get_midi_controller_for_port = Plugin::getMidiController;
1213 g_dssi_descriptor->run_synth = Plugin::runSynth;
1214 g_dssi_descriptor->run_synth_adding = 0;
1215 g_dssi_descriptor->run_multiple_synths = 0;
1216 g_dssi_descriptor->run_multiple_synths_adding = 0;
1217
1218 // Program description (TODO if we eventually support multiple programs we will need to handle this differently)
1219 g_program_descriptor.Bank = 0;
1220 g_program_descriptor.Program = 0;
1221 g_program_descriptor.Name = get_metadata_if_exists("name", g_name.c_str());
1222
1223 delete temp_mydsp;
1224 delete temp_descriptor_ui;
1225 }
1226 }
1227
1228 #ifdef __GNUC__
1229 __attribute__((destructor)) void fini(void)
1230 #else
1231 void _fini()
1232 #endif
1233 {
1234 if (g_ladspa_descriptor)
1235 {
1236 delete g_ladspa_descriptor;
1237 }
1238 if (g_dssi_descriptor)
1239 {
1240 delete g_dssi_descriptor;
1241 }
1242 }
1243
1244 const LADSPA_Descriptor *ladspa_descriptor(unsigned long index)
1245 {
1246 return 0;
1247 }
1248
1249 const DSSI_Descriptor *dssi_descriptor(unsigned long index)
1250 {
1251 if (index == 0)
1252 {
1253 return g_dssi_descriptor;
1254 }
1255 else
1256 {
1257 return NULL;
1258 }
1259 }
1260 }
1261
1262 /********************END ARCHITECTURE SECTION (part 2/2)****************/