1 /*
2 dahdsr.so.c - A LADSPA plugin to generate DAHDSR envelopes
3 Gate and (re)trigger
4
5 Copyright (C) 2004 Mike Rawes
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21
22 #include <stdlib.h>
23 #include <ladspa.h>
24 #include "common.h"
25 #include "gettext.h"
26
27 #ifdef ENABLE_NLS
28 #include <locale.h>
29 #define G_(s) gettext(s)
30 #else
31 #define G_(s) (s)
32 #endif
33 #define G_NOP(s) s
34
35 /* 3 Variants, id = 2021, 2022 and _2038_
36 #define DAHDSR_BASE_ID 2021
37 */
38 #define DAHDSR_VARIANT_COUNT 3
39
40 #define DAHDSR_GATE 0
41 #define DAHDSR_TRIGGER 1
42 #define DAHDSR_DELAY 2
43 #define DAHDSR_ATTACK 3
44 #define DAHDSR_HOLD 4
45 #define DAHDSR_DECAY 5
46 #define DAHDSR_SUSTAIN 6
47 #define DAHDSR_RELEASE 7
48 #define DAHDSR_OUTPUT 8
49
50 LADSPA_Descriptor ** dahdsr_descriptors = 0;
51
52 typedef enum
53 {
54 IDLE,
55 DELAY,
56 ATTACK,
57 HOLD,
58 DECAY,
59 SUSTAIN,
60 RELEASE
61 } DAHDSRState;
62
63 typedef struct
64 {
65 LADSPA_Data * gate;
66 LADSPA_Data * trigger;
67 LADSPA_Data * delay;
68 LADSPA_Data * attack;
69 LADSPA_Data * hold;
70 LADSPA_Data * decay;
71 LADSPA_Data * sustain;
72 LADSPA_Data * release;
73 LADSPA_Data * output;
74 LADSPA_Data srate;
75 LADSPA_Data inv_srate;
76 LADSPA_Data last_gate;
77 LADSPA_Data last_trigger;
78 LADSPA_Data from_level;
79 LADSPA_Data level;
80 DAHDSRState state;
81 unsigned long samples;
82 } Dahdsr;
83
84 const LADSPA_Descriptor *
ladspa_descriptor(unsigned long index)85 ladspa_descriptor (unsigned long index)
86 {
87 if (index < DAHDSR_VARIANT_COUNT)
88 return dahdsr_descriptors[index];
89
90 return 0;
91 }
92
93 void
cleanupDahdsr(LADSPA_Handle instance)94 cleanupDahdsr (LADSPA_Handle instance)
95 {
96 free (instance);
97 }
98
99 void
connectPortDahdsr(LADSPA_Handle instance,unsigned long port,LADSPA_Data * data)100 connectPortDahdsr (LADSPA_Handle instance,
101 unsigned long port,
102 LADSPA_Data * data)
103 {
104 Dahdsr * plugin = (Dahdsr *)instance;
105
106 switch (port)
107 {
108 case DAHDSR_GATE:
109 plugin->gate = data;
110 break;
111 case DAHDSR_TRIGGER:
112 plugin->trigger = data;
113 break;
114 case DAHDSR_DELAY:
115 plugin->delay = data;
116 break;
117 case DAHDSR_ATTACK:
118 plugin->attack = data;
119 break;
120 case DAHDSR_HOLD:
121 plugin->hold = data;
122 break;
123 case DAHDSR_DECAY:
124 plugin->decay = data;
125 break;
126 case DAHDSR_SUSTAIN:
127 plugin->sustain = data;
128 break;
129 case DAHDSR_RELEASE:
130 plugin->release = data;
131 break;
132 case DAHDSR_OUTPUT:
133 plugin->output = data;
134 break;
135 }
136 }
137
138 LADSPA_Handle
instantiateDahdsr(const LADSPA_Descriptor * descriptor,unsigned long sample_rate)139 instantiateDahdsr (const LADSPA_Descriptor * descriptor,
140 unsigned long sample_rate)
141 {
142 Dahdsr * plugin = (Dahdsr *) malloc (sizeof (Dahdsr));
143
144 plugin->srate = (LADSPA_Data) sample_rate;
145 plugin->inv_srate = 1.0f / plugin->srate;
146
147 return (LADSPA_Handle) plugin;
148 }
149
150 void
activateDahdsr(LADSPA_Handle instance)151 activateDahdsr (LADSPA_Handle instance)
152 {
153 Dahdsr * plugin = (Dahdsr *) instance;
154
155 plugin->last_gate = 0.0f;
156 plugin->last_trigger = 0.0f;
157 plugin->from_level = 0.0f;
158 plugin->level = 0.0f;
159 plugin->state = IDLE;
160 plugin->samples = 0;
161 }
162
163 void
runDahdsr_Audio(LADSPA_Handle instance,unsigned long sample_count)164 runDahdsr_Audio (LADSPA_Handle instance,
165 unsigned long sample_count)
166 {
167 Dahdsr * plugin = (Dahdsr *) instance;
168
169 /* Gate */
170 LADSPA_Data * gate = plugin->gate;
171
172 /* Trigger */
173 LADSPA_Data * trigger = plugin->trigger;
174
175 /* Delay Time (s) */
176 LADSPA_Data * delay = plugin->delay;
177
178 /* Attack Time (s) */
179 LADSPA_Data * attack = plugin->attack;
180
181 /* Hold Time (s) */
182 LADSPA_Data * hold = plugin->hold;
183
184 /* Decay Time (s) */
185 LADSPA_Data * decay = plugin->decay;
186
187 /* Sustain Level */
188 LADSPA_Data * sustain = plugin->sustain;
189
190 /* Release Time (s) */
191 LADSPA_Data * release = plugin->release;
192
193 /* Envelope Out */
194 LADSPA_Data * output = plugin->output;
195
196 /* Instance Data */
197 LADSPA_Data srate = plugin->srate;
198 LADSPA_Data inv_srate = plugin->inv_srate;
199 LADSPA_Data last_gate = plugin->last_gate;
200 LADSPA_Data last_trigger = plugin->last_trigger;
201 LADSPA_Data from_level = plugin->from_level;
202 LADSPA_Data level = plugin->level;
203 DAHDSRState state = plugin->state;
204 unsigned long samples = plugin->samples;
205
206 LADSPA_Data gat, trg, del, att, hld, dec, sus, rel;
207 LADSPA_Data elapsed;
208 unsigned long s;
209
210 for (s = 0; s < sample_count; s++)
211 {
212 /* Convert times into rates */
213 del = delay[s] > 0.0f ? inv_srate / delay[s] : srate;
214 att = attack[s] > 0.0f ? inv_srate / attack[s] : srate;
215 hld = hold[s] > 0.0f ? inv_srate / hold[s] : srate;
216 dec = decay[s] > 0.0f ? inv_srate / decay[s] : srate;
217 rel = release[s] > 0.0f ? inv_srate / release[s] : srate;
218
219 gat = gate[s];
220 trg = trigger[s];
221 sus = f_clip (sustain[s], 0.0f, 1.0f);
222
223 /* Initialise delay phase if gate is opened and was closed, or
224 we received a trigger */
225 if ((trg > 0.0f && !(last_trigger > 0.0f)) ||
226 (gat > 0.0f && !(last_gate > 0.0f)))
227 {
228 if (del < srate)
229 {
230 state = DELAY;
231 }
232 else if (att < srate)
233 {
234 state = ATTACK;
235 }
236 else
237 {
238 state = hld < srate ? HOLD
239 : (dec < srate ? DECAY
240 : (gat > 0.0f ? SUSTAIN
241 : (rel < srate ? RELEASE
242 : IDLE)));
243 level = 1.0f;
244 }
245 samples = 0;
246 }
247
248 /* Release if gate was open and now closed */
249 if (state != IDLE && state != RELEASE &&
250 last_gate > 0.0f && !(gat > 0.0f))
251 {
252 state = rel < srate ? RELEASE : IDLE;
253 samples = 0;
254 }
255
256 if (samples == 0)
257 from_level = level;
258
259 /* Calculate level of envelope from current state */
260 switch (state)
261 {
262 case IDLE:
263 level = 0;
264 break;
265 case DELAY:
266 samples++;
267 elapsed = (LADSPA_Data) samples * del;
268 if (elapsed > 1.0f)
269 {
270 state = att < srate ? ATTACK
271 : (hld < srate ? HOLD
272 : (dec < srate ? DECAY
273 : (gat > 0.0f ? SUSTAIN
274 : (rel < srate ? RELEASE
275 : IDLE))));
276 samples = 0;
277 }
278 break;
279 case ATTACK:
280 samples++;
281 elapsed = (LADSPA_Data) samples * att;
282 if (elapsed > 1.0f)
283 {
284 state = hld < srate ? HOLD
285 : (dec < srate ? DECAY
286 : (gat > 0.0f ? SUSTAIN
287 : (rel < srate ? RELEASE
288 : IDLE)));
289 level = 1.0f;
290 samples = 0;
291 } else {
292 level = from_level + elapsed * (1.0f - from_level);
293 }
294 break;
295 case HOLD:
296 samples++;
297 elapsed = (LADSPA_Data) samples * hld;
298 if (elapsed > 1.0f)
299 {
300 state = dec < srate ? DECAY
301 : (gat > 0.0f ? SUSTAIN
302 : (rel < srate ? RELEASE
303 : IDLE));
304 samples = 0;
305 }
306 break;
307 case DECAY:
308 samples++;
309 elapsed = (LADSPA_Data) samples * dec;
310 if (elapsed > 1.0f)
311 {
312 state = gat > 0.0f ? SUSTAIN
313 : (rel < srate ? RELEASE
314 : IDLE);
315 level = sus;
316 samples = 0;
317 }
318 else
319 {
320 level = from_level + elapsed * (sus - from_level);
321 }
322 break;
323 case SUSTAIN:
324 level = sus;
325 break;
326 case RELEASE:
327 samples++;
328 elapsed = (LADSPA_Data) samples * rel;
329 if (elapsed > 1.0f)
330 {
331 state = IDLE;
332 level = 0.0f;
333 samples = 0;
334 }
335 else
336 {
337 level = from_level - elapsed * from_level;
338 }
339 break;
340 default:
341 /* Should never happen */
342 level = 0.0f;
343 }
344
345 output[s] = level;
346
347 last_gate = gate[s];
348 last_trigger = trigger[s];
349 }
350
351 plugin->last_gate = last_gate;
352 plugin->last_trigger = last_trigger;
353 plugin->from_level = from_level;
354 plugin->level = level;
355 plugin->state = state;
356 plugin->samples = samples;
357 }
358
359 void
runDahdsr_Control(LADSPA_Handle instance,unsigned long sample_count)360 runDahdsr_Control (LADSPA_Handle instance,
361 unsigned long sample_count)
362 {
363 Dahdsr * plugin = (Dahdsr *) instance;
364
365 /* Gate */
366 LADSPA_Data * gate = plugin->gate;
367
368 /* Trigger */
369 LADSPA_Data * trigger = plugin->trigger;
370
371 /* Delay Time (s) */
372 LADSPA_Data delay = * (plugin->delay);
373
374 /* Attack Time (s) */
375 LADSPA_Data attack = * (plugin->attack);
376
377 /* Hold Time (s) */
378 LADSPA_Data hold = * (plugin->hold);
379
380 /* Decay Time (s) */
381 LADSPA_Data decay = * (plugin->decay);
382
383 /* Sustain Level */
384 LADSPA_Data sustain = * (plugin->sustain);
385
386 /* Release Time (s) */
387 LADSPA_Data release = * (plugin->release);
388
389 /* Envelope Out */
390 LADSPA_Data * output = plugin->output;
391
392 /* Instance Data */
393 LADSPA_Data srate = plugin->srate;
394 LADSPA_Data inv_srate = plugin->inv_srate;
395 LADSPA_Data last_gate = plugin->last_gate;
396 LADSPA_Data last_trigger = plugin->last_trigger;
397 LADSPA_Data from_level = plugin->from_level;
398 LADSPA_Data level = plugin->level;
399 DAHDSRState state = plugin->state;
400 unsigned long samples = plugin->samples;
401
402 LADSPA_Data gat, trg, del, att, hld, dec, sus, rel;
403 LADSPA_Data elapsed;
404 unsigned long s;
405
406 /* Convert times into rates */
407 del = delay > 0.0f ? inv_srate / delay : srate;
408 att = attack > 0.0f ? inv_srate / attack : srate;
409 hld = hold > 0.0f ? inv_srate / hold : srate;
410 dec = decay > 0.0f ? inv_srate / decay : srate;
411 rel = release > 0.0f ? inv_srate / release : srate;
412
413 sus = f_clip (sustain, 0.0f, 1.0f);
414
415 for (s = 0; s < sample_count; s++)
416 {
417 gat = gate[s];
418 trg = trigger[s];
419
420 /* Initialise delay phase if gate is opened and was closed, or
421 we received a trigger */
422 if ((trg > 0.0f && !(last_trigger > 0.0f)) ||
423 (gat > 0.0f && !(last_gate > 0.0f)))
424 {
425 if (del < srate)
426 {
427 state = DELAY;
428 }
429 else if (att < srate)
430 {
431 state = ATTACK;
432 }
433 else
434 {
435 state = hld < srate ? HOLD
436 : (dec < srate ? DECAY
437 : (gat > 0.0f ? SUSTAIN
438 : (rel < srate ? RELEASE
439 : IDLE)));
440 level = 1.0f;
441 }
442 samples = 0;
443 }
444
445 /* Release if gate was open and now closed */
446 if (state != IDLE && state != RELEASE &&
447 last_gate > 0.0f && !(gat > 0.0f))
448 {
449 state = rel < srate ? RELEASE : IDLE;
450 samples = 0;
451 }
452
453 if (samples == 0)
454 from_level = level;
455
456 /* Calculate level of envelope from current state */
457 switch (state)
458 {
459 case IDLE:
460 level = 0;
461 break;
462 case DELAY:
463 samples++;
464 elapsed = (LADSPA_Data) samples * del;
465 if (elapsed > 1.0f)
466 {
467 state = att < srate ? ATTACK
468 : (hld < srate ? HOLD
469 : (dec < srate ? DECAY
470 : (gat > 0.0f ? SUSTAIN
471 : (rel < srate ? RELEASE
472 : IDLE))));
473 samples = 0;
474 }
475 break;
476 case ATTACK:
477 samples++;
478 elapsed = (LADSPA_Data) samples * att;
479 if (elapsed > 1.0f)
480 {
481 state = hld < srate ? HOLD
482 : (dec < srate ? DECAY
483 : (gat > 0.0f ? SUSTAIN
484 : (rel < srate ? RELEASE
485 : IDLE)));
486 level = 1.0f;
487 samples = 0;
488 } else {
489 level = from_level + elapsed * (1.0f - from_level);
490 }
491 break;
492 case HOLD:
493 samples++;
494 elapsed = (LADSPA_Data) samples * hld;
495 if (elapsed > 1.0f)
496 {
497 state = dec < srate ? DECAY
498 : (gat > 0.0f ? SUSTAIN
499 : (rel < srate ? RELEASE
500 : IDLE));
501 samples = 0;
502 }
503 break;
504 case DECAY:
505 samples++;
506 elapsed = (LADSPA_Data) samples * dec;
507 if (elapsed > 1.0f)
508 {
509 state = gat > 0.0f ? SUSTAIN
510 : (rel < srate ? RELEASE
511 : IDLE);
512 level = sus;
513 samples = 0;
514 }
515 else
516 {
517 level = from_level + elapsed * (sus - from_level);
518 }
519 break;
520 case SUSTAIN:
521 level = sus;
522 break;
523 case RELEASE:
524 samples++;
525 elapsed = (LADSPA_Data) samples * rel;
526 if (elapsed > 1.0f)
527 {
528 state = IDLE;
529 level = 0.0f;
530 samples = 0;
531 }
532 else
533 {
534 level = from_level - elapsed * from_level;
535 }
536 break;
537 default:
538 /* Should never happen */
539 level = 0.0f;
540 }
541
542 output[s] = level;
543
544 last_gate = gat;
545 last_trigger = trg;
546 }
547
548 plugin->last_gate = last_gate;
549 plugin->last_trigger = last_trigger;
550 plugin->from_level = from_level;
551 plugin->level = level;
552 plugin->state = state;
553 plugin->samples = samples;
554 }
555
556 void
runDahdsr_CGT_Control(LADSPA_Handle instance,unsigned long sample_count)557 runDahdsr_CGT_Control (LADSPA_Handle instance,
558 unsigned long sample_count)
559 {
560 Dahdsr * plugin = (Dahdsr *) instance;
561
562 /* Gate */
563 LADSPA_Data gate = * (plugin->gate);
564
565 /* Trigger */
566 LADSPA_Data trigger = * (plugin->trigger);
567
568 /* Delay Time (s) */
569 LADSPA_Data delay = * (plugin->delay);
570
571 /* Attack Time (s) */
572 LADSPA_Data attack = * (plugin->attack);
573
574 /* Hold Time (s) */
575 LADSPA_Data hold = * (plugin->hold);
576
577 /* Decay Time (s) */
578 LADSPA_Data decay = * (plugin->decay);
579
580 /* Sustain Level */
581 LADSPA_Data sustain = * (plugin->sustain);
582
583 /* Release Time (s) */
584 LADSPA_Data release = * (plugin->release);
585
586 /* Envelope Out */
587 LADSPA_Data * output = plugin->output;
588
589 /* Instance Data */
590 LADSPA_Data srate = plugin->srate;
591 LADSPA_Data inv_srate = plugin->inv_srate;
592 LADSPA_Data last_gate = plugin->last_gate;
593 LADSPA_Data last_trigger = plugin->last_trigger;
594 LADSPA_Data from_level = plugin->from_level;
595 LADSPA_Data level = plugin->level;
596 DAHDSRState state = plugin->state;
597 unsigned long samples = plugin->samples;
598
599 LADSPA_Data gat, trg, del, att, hld, dec, sus, rel;
600 LADSPA_Data elapsed;
601 unsigned long s;
602
603 /* Convert times into rates */
604 del = delay > 0.0f ? inv_srate / delay : srate;
605 att = attack > 0.0f ? inv_srate / attack : srate;
606 hld = hold > 0.0f ? inv_srate / hold : srate;
607 dec = decay > 0.0f ? inv_srate / decay : srate;
608 rel = release > 0.0f ? inv_srate / release : srate;
609
610 gat = gate;
611 trg = trigger;
612 sus = f_clip (sustain, 0.0f, 1.0f);
613
614 /* Initialise delay phase if gate is opened and was closed, or
615 we received a trigger */
616 if ((trg > 0.0f && !(last_trigger > 0.0f)) ||
617 (gat > 0.0f && !(last_gate > 0.0f)))
618 {
619 if (del < srate)
620 {
621 state = DELAY;
622 }
623 else if (att < srate)
624 {
625 state = ATTACK;
626 }
627 else
628 {
629 state = hld < srate ? HOLD
630 : (dec < srate ? DECAY
631 : (gat > 0.0f ? SUSTAIN
632 : (rel < srate ? RELEASE
633 : IDLE)));
634 level = 1.0f;
635 }
636 samples = 0;
637 }
638
639 /* Release if gate was open and now closed */
640 if (state != IDLE && state != RELEASE &&
641 last_gate > 0.0f && !(gat > 0.0f))
642 {
643 state = rel < srate ? RELEASE : IDLE;
644 samples = 0;
645 }
646
647 for (s = 0; s < sample_count; s++)
648 {
649 if (samples == 0)
650 from_level = level;
651
652 /* Calculate level of envelope from current state */
653 switch (state)
654 {
655 case IDLE:
656 level = 0;
657 break;
658 case DELAY:
659 samples++;
660 elapsed = (LADSPA_Data) samples * del;
661 if (elapsed > 1.0f)
662 {
663 state = att < srate ? ATTACK
664 : (hld < srate ? HOLD
665 : (dec < srate ? DECAY
666 : (gat > 0.0f ? SUSTAIN
667 : (rel < srate ? RELEASE
668 : IDLE))));
669 samples = 0;
670 }
671 break;
672 case ATTACK:
673 samples++;
674 elapsed = (LADSPA_Data) samples * att;
675 if (elapsed > 1.0f)
676 {
677 state = hld < srate ? HOLD
678 : (dec < srate ? DECAY
679 : (gat > 0.0f ? SUSTAIN
680 : (rel < srate ? RELEASE
681 : IDLE)));
682 level = 1.0f;
683 samples = 0;
684 } else {
685 level = from_level + elapsed * (1.0f - from_level);
686 }
687 break;
688 case HOLD:
689 samples++;
690 elapsed = (LADSPA_Data) samples * hld;
691 if (elapsed > 1.0f)
692 {
693 state = dec < srate ? DECAY
694 : (gat > 0.0f ? SUSTAIN
695 : (rel < srate ? RELEASE
696 : IDLE));
697 samples = 0;
698 }
699 break;
700 case DECAY:
701 samples++;
702 elapsed = (LADSPA_Data) samples * dec;
703 if (elapsed > 1.0f)
704 {
705 state = gat > 0.0f ? SUSTAIN
706 : (rel < srate ? RELEASE
707 : IDLE);
708 level = sus;
709 samples = 0;
710 }
711 else
712 {
713 level = from_level + elapsed * (sus - from_level);
714 }
715 break;
716 case SUSTAIN:
717 level = sus;
718 break;
719 case RELEASE:
720 samples++;
721 elapsed = (LADSPA_Data) samples * rel;
722 if (elapsed > 1.0f)
723 {
724 state = IDLE;
725 level = 0.0f;
726 samples = 0;
727 }
728 else
729 {
730 level = from_level - elapsed * from_level;
731 }
732 break;
733 default:
734 /* Should never happen */
735 level = 0.0f;
736 }
737
738 output[s] = level;
739 }
740
741 plugin->last_gate = gat;
742 plugin->last_trigger = trg;
743 plugin->from_level = from_level;
744 plugin->level = level;
745 plugin->state = state;
746 plugin->samples = samples;
747 }
748
749 void
_init(void)750 _init (void)
751 {
752 static const unsigned long ids[] = {2021, 2022, 2038};
753 static const char * labels[] = {"dahdsr_g+t_audio",
754 "dahdsr_g+t_control",
755 "dahdsr_cg+t_control"};
756 static const char * names[] = {G_NOP("DAHDSR Envelope with Gate and Trigger (Audio-Rate Inputs)"),
757 G_NOP("DAHDSR Envelope with Gate and Trigger (Control Inputs)"),
758 G_NOP("DAHDSR Envelope with Control Gate and Trigger (Control Inputs)")};
759 char ** port_names;
760 LADSPA_PortDescriptor * port_descriptors;
761 LADSPA_PortRangeHint * port_range_hints;
762 LADSPA_Descriptor * descriptor;
763 int i;
764
765 LADSPA_PortDescriptor gate_port_descriptors[] = {LADSPA_PORT_INPUT | LADSPA_PORT_AUDIO,
766 LADSPA_PORT_INPUT | LADSPA_PORT_AUDIO,
767 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL};
768 LADSPA_PortDescriptor trigger_port_descriptors[] = {LADSPA_PORT_INPUT | LADSPA_PORT_AUDIO,
769 LADSPA_PORT_INPUT | LADSPA_PORT_AUDIO,
770 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL};
771 LADSPA_PortDescriptor delay_port_descriptors[] = {LADSPA_PORT_INPUT | LADSPA_PORT_AUDIO,
772 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL,
773 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL};
774 LADSPA_PortDescriptor attack_port_descriptors[] = {LADSPA_PORT_INPUT | LADSPA_PORT_AUDIO,
775 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL,
776 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL};
777 LADSPA_PortDescriptor hold_port_descriptors[] = {LADSPA_PORT_INPUT | LADSPA_PORT_AUDIO,
778 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL,
779 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL};
780 LADSPA_PortDescriptor decay_port_descriptors[] = {LADSPA_PORT_INPUT | LADSPA_PORT_AUDIO,
781 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL,
782 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL};
783 LADSPA_PortDescriptor sustain_port_descriptors[] = {LADSPA_PORT_INPUT | LADSPA_PORT_AUDIO,
784 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL,
785 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL};
786 LADSPA_PortDescriptor release_port_descriptors[] = {LADSPA_PORT_INPUT | LADSPA_PORT_AUDIO,
787 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL,
788 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL};
789 LADSPA_PortDescriptor output_port_descriptors[] = {LADSPA_PORT_OUTPUT | LADSPA_PORT_AUDIO,
790 LADSPA_PORT_OUTPUT | LADSPA_PORT_AUDIO,
791 LADSPA_PORT_OUTPUT | LADSPA_PORT_AUDIO};
792
793 void (*run_functions[]) (LADSPA_Handle,
794 unsigned long) = {runDahdsr_Audio,
795 runDahdsr_Control,
796 runDahdsr_CGT_Control};
797
798 #ifdef ENABLE_NLS
799 setlocale (LC_ALL, "");
800 bindtextdomain (PACKAGE, LOCALEDIR);
801 textdomain (PACKAGE);
802 #endif
803
804 dahdsr_descriptors = (LADSPA_Descriptor **) calloc (DAHDSR_VARIANT_COUNT, sizeof (LADSPA_Descriptor));
805
806 if (dahdsr_descriptors)
807 {
808 for (i = 0; i < DAHDSR_VARIANT_COUNT; i++)
809 {
810 dahdsr_descriptors[i] = (LADSPA_Descriptor *) malloc (sizeof (LADSPA_Descriptor));
811 descriptor = dahdsr_descriptors[i];
812 if (descriptor)
813 {
814 descriptor->UniqueID = ids[i];
815 descriptor->Label = labels[i];
816 descriptor->Properties = LADSPA_PROPERTY_HARD_RT_CAPABLE;
817 descriptor->Name = G_(names[i]);
818 descriptor->Maker = "Mike Rawes <mike_rawes[at]yahoo.co.uk>";
819 descriptor->Copyright = "GPL";
820
821 descriptor->PortCount = 9;
822
823 port_descriptors = (LADSPA_PortDescriptor *) calloc (9, sizeof (LADSPA_PortDescriptor));
824 descriptor->PortDescriptors = (const LADSPA_PortDescriptor *)port_descriptors;
825
826 port_range_hints = (LADSPA_PortRangeHint *) calloc (9, sizeof (LADSPA_PortRangeHint));
827 descriptor->PortRangeHints = (const LADSPA_PortRangeHint *) port_range_hints;
828
829 port_names = (char **) calloc (9, sizeof (char*));
830 descriptor->PortNames = (const char **) port_names;
831
832 /* Parameters for Gate */
833 port_descriptors[DAHDSR_GATE] = gate_port_descriptors[i];
834 port_names[DAHDSR_GATE] = G_("Gate");
835 port_range_hints[DAHDSR_GATE].HintDescriptor = LADSPA_HINT_TOGGLED;
836
837 /* Parameters for Trigger */
838 port_descriptors[DAHDSR_TRIGGER] = trigger_port_descriptors[i];
839 port_names[DAHDSR_TRIGGER] = G_("Trigger");
840 port_range_hints[DAHDSR_TRIGGER].HintDescriptor = LADSPA_HINT_TOGGLED;
841
842 /* Parameters for Delay Time (s) */
843 port_descriptors[DAHDSR_DELAY] = delay_port_descriptors[i];
844 port_names[DAHDSR_DELAY] = G_("Delay Time (s)");
845 port_range_hints[DAHDSR_DELAY].HintDescriptor = LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_DEFAULT_MINIMUM;
846 port_range_hints[DAHDSR_DELAY].LowerBound = 0.0f;
847
848 /* Parameters for Attack Time (s) */
849 port_descriptors[DAHDSR_ATTACK] = attack_port_descriptors[i];
850 port_names[DAHDSR_ATTACK] = G_("Attack Time (s)");
851 port_range_hints[DAHDSR_ATTACK].HintDescriptor = LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_DEFAULT_MINIMUM;
852 port_range_hints[DAHDSR_ATTACK].LowerBound = 0.0f;
853
854 /* Parameters for Hold Time (s) */
855 port_descriptors[DAHDSR_HOLD] = hold_port_descriptors[i];
856 port_names[DAHDSR_HOLD] = G_("Hold Time (s)");
857 port_range_hints[DAHDSR_HOLD].HintDescriptor = LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_DEFAULT_MINIMUM;
858 port_range_hints[DAHDSR_HOLD].LowerBound = 0.0f;
859
860 /* Parameters for Decay Time (s) */
861 port_descriptors[DAHDSR_DECAY] = decay_port_descriptors[i];
862 port_names[DAHDSR_DECAY] = G_("Decay Time (s)");
863 port_range_hints[DAHDSR_DECAY].HintDescriptor = LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_DEFAULT_MINIMUM;
864 port_range_hints[DAHDSR_DECAY].LowerBound = 0.0f;
865
866 /* Parameters for Sustain Level */
867 port_descriptors[DAHDSR_SUSTAIN] = sustain_port_descriptors[i];
868 port_names[DAHDSR_SUSTAIN] = G_("Sustain Level");
869 port_range_hints[DAHDSR_SUSTAIN].HintDescriptor = LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE |
870 LADSPA_HINT_DEFAULT_MAXIMUM;
871 port_range_hints[DAHDSR_SUSTAIN].LowerBound = 0.0f;
872 port_range_hints[DAHDSR_SUSTAIN].UpperBound = 1.0f;
873
874 /* Parameters for Release Time (s) */
875 port_descriptors[DAHDSR_RELEASE] = release_port_descriptors[i];
876 port_names[DAHDSR_RELEASE] = G_("Release Time (s)");
877 port_range_hints[DAHDSR_RELEASE].HintDescriptor = LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_DEFAULT_MINIMUM;
878 port_range_hints[DAHDSR_RELEASE].LowerBound = 0.0f;
879
880 /* Parameters for Envelope Out */
881 port_descriptors[DAHDSR_OUTPUT] = output_port_descriptors[i];
882 port_names[DAHDSR_OUTPUT] = G_("Envelope Out");
883 port_range_hints[DAHDSR_OUTPUT].HintDescriptor = 0;
884
885 descriptor->activate = activateDahdsr;
886 descriptor->cleanup = cleanupDahdsr;
887 descriptor->connect_port = connectPortDahdsr;
888 descriptor->deactivate = NULL;
889 descriptor->instantiate = instantiateDahdsr;
890 descriptor->run = run_functions[i];
891 descriptor->run_adding = NULL;
892 descriptor->set_run_adding_gain = NULL;
893 }
894 }
895 }
896 }
897
898 void
_fini(void)899 _fini (void)
900 {
901 LADSPA_Descriptor * descriptor;
902 int i;
903
904 if (dahdsr_descriptors)
905 {
906 for (i = 0; i < DAHDSR_VARIANT_COUNT; i++)
907 {
908 descriptor = dahdsr_descriptors[i];
909 if (descriptor)
910 {
911 free ((LADSPA_PortDescriptor *) descriptor->PortDescriptors);
912 free ((char **) descriptor->PortNames);
913 free ((LADSPA_PortRangeHint *) descriptor->PortRangeHints);
914 free (descriptor);
915 }
916 }
917 free (dahdsr_descriptors);
918 }
919 }
920