?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix build with gcc 4.7
[cadence.git] / src / carla / lv2.cpp
blob34fa05762e48ade71d969d4f7d7fd77ec37fe8a1
1 /* Code for LV2 plugins */
2
3 #include "carla_backend.h"
4 #include "audio_plugin.h"
5 #include "misc.h"
6
7 #include <stdio.h>
8 #include <unistd.h>
9
10 #include <QtGui/QDialog>
11 #include <QtGui/QLayout>
12
13 #include "lv2/lv2.h"
14 #include "lv2/data-access.h"
15 #include "lv2/dynparam.h"
16 #include "lv2/event.h"
17 #include "lv2/event-helpers.h"
18 #include "lv2/instance-access.h"
19 #include "lv2/state.h"
20 #include "lv2/time.h"
21 #include "lv2/uri-map.h"
22 #include "lv2/urid.h"
23 #include "lv2/ui.h"
24 #include "lv2/ui-resize.h"
25 #include "lv2/lv2_external_ui.h"
26 #include "lv2/lv2_rtmempool.h"
27 #include "lv2_rdf.h"
28
29 extern "C" {
30 #include "lv2-rtmempool/rtmempool.h"
31 }
32
33 #define NS_ATOM "http://lv2plug.in/ns/ext/atom#"
34 #define NS_LV2UI "http://lv2plug.in/ns/extensions/ui#"
35
36 // Global variables
37 extern const char* unique_names[MAX_PLUGINS];
38 extern AudioPlugin* AudioPlugins[MAX_PLUGINS];
39 extern ExternalMidiNote ExternalMidiNotes[MAX_MIDI_EVENTS];
40
41 extern volatile double ains_peak[MAX_PLUGINS*2];
42 extern volatile double aouts_peak[MAX_PLUGINS*2];
43
44 // Global JACK client
45 extern jack_client_t* carla_jack_client;
46
47 // Global options
48 extern carla_options_t carla_options;
49
50 // jack.cpp
51 void carla_jack_register_plugin(AudioPlugin* plugin);
52
53 // static max values
54 const unsigned int MAX_EVENT_BUFFER = 0x7FFF; // 32767
55
56 // feature ids
57 const uint16_t lv2_feature_id_uri_map = 0;
58 const uint16_t lv2_feature_id_urid_map = 1;
59 const uint16_t lv2_feature_id_urid_unmap = 2;
60 const uint16_t lv2_feature_id_event = 3;
61 const uint16_t lv2_feature_id_rtmempool = 4;
62 const uint16_t lv2_feature_id_data_access = 5;
63 const uint16_t lv2_feature_id_instance_access = 6;
64 const uint16_t lv2_feature_id_ui_resize = 7;
65 const uint16_t lv2_feature_id_ui_parent = 8;
66 const uint16_t lv2_feature_id_external_ui = 9;
67 const uint16_t lv2_feature_id_external_ui_old = 10;
68 const uint16_t lv2_feature_count = 11;
69
70 // uri[d] map ids
71 const uint16_t CARLA_URI_MAP_ID_EVENT_MIDI = 1; // 0x1
72 const uint16_t CARLA_URI_MAP_ID_EVENT_TIME = 2; // 0x2
73 const uint16_t CARLA_URI_MAP_ID_ATOM_STRING = 3;
74 const uint16_t CARLA_URI_MAP_ID_COUNT = 4;
75
76 // extra plugin hints
77 const unsigned int PLUGIN_HAS_EXTENSION_STATE = 0x100;
78 const unsigned int PLUGIN_HAS_EXTENSION_DYNPARAM = 0x200;
79
80 static LV2_Time_Position carla_lv2_time_pos = { 0, 0, LV2_TIME_STOPPED, 0, 0, 0, 0, 0, 0, 0.0 };
81
82 struct CarlaLv2Event {
83 uint16_t type;
84 jack_port_t* port;
85 LV2_Event_Buffer* buffer;
86 };
87
88 struct CarlaLv2EventData {
89 uint32_t count;
90 CarlaLv2Event* events;
91 };
92
93 class Lv2OscGuiThread : public QThread
94 {
95 public:
96 Lv2OscGuiThread(QObject* parent=0);
97 void set_plugin_id(short plugin_id);
98 void set_ui_type(LV2_Property ui_type);
99 void run();
100
101 private:
102 short plugin_id;
103 LV2_Property ui_type;
104 };
105
106 class Lv2AudioPlugin : public AudioPlugin
107 {
108 public:
109 CarlaLv2EventData evin;
110 CarlaLv2EventData evout;
111
112 LV2_Handle handle;
113 const LV2_Descriptor* descriptor;
114 const LV2_RDF_Descriptor* rdf_descriptor;
115 LV2_Feature* features[lv2_feature_count+1];
116
117 struct {
118 void* lib;
119 LV2UI_Handle handle;
120 LV2UI_Widget widget;
121 const LV2UI_Descriptor* descriptor;
122 const LV2_RDF_UI* rdf_descriptor;
123 } ui;
124
125 bool wants_time_pos;
126 QList<const char*> custom_uri_ids;
127
128 lv2_rtsafe_memory_pool_provider rtmempool_allocator;
129
130 // testing
131 lv2dynparam_host_callbacks dynparam_host;
132 lv2dynparam_plugin_callbacks* dynparam_plugin;
133
134 Lv2AudioPlugin()
135 {
136 qDebug("Lv2AudioPlugin::Lv2AudioPlugin()");
137 type = PLUGIN_LV2;
138
139 evin.count = 0;
140 evin.events = nullptr;
141
142 evout.count = 0;
143 evout.events = nullptr;
144
145 handle = nullptr;
146 descriptor = nullptr;
147 rdf_descriptor = nullptr;
148
149 ui.lib = nullptr;
150 ui.handle = nullptr;
151 ui.descriptor = nullptr;
152 ui.rdf_descriptor = nullptr;
153
154 wants_time_pos = false;
155
156 for (uint16_t i=0; i<lv2_feature_count+1; i++)
157 features[i] = nullptr;
158
159 custom_uri_ids.clear();
160
161 // Fill pre-set URI keys
162 for (uint16_t i=0; i < CARLA_URI_MAP_ID_COUNT; i++)
163 custom_uri_ids.append(nullptr);
164
165 dynparam_host.group_appear = carla_lv2_dynparam_group_appear;
166 dynparam_host.group_disappear = carla_lv2_dynparam_group_disappear;
167 dynparam_host.parameter_appear = carla_lv2_dynparam_parameter_appear;
168 dynparam_host.parameter_disappear = carla_lv2_dynparam_parameter_disappear;
169 dynparam_host.parameter_change = carla_lv2_dynparam_parameter_change;
170 dynparam_host.command_appear = carla_lv2_dynparam_command_appear;
171 dynparam_host.command_disappear = carla_lv2_dynparam_command_disappear;
172 dynparam_plugin = 0;
173 }
174
175 ~Lv2AudioPlugin()
176 {
177 qDebug("Lv2AudioPlugin::~Lv2AudioPlugin()");
178
179 // close UI
180 if (hints & PLUGIN_HAS_GUI)
181 {
182 switch(gui.type)
183 {
184 case GUI_INTERNAL_QT4:
185 case GUI_INTERNAL_X11:
186 break;
187
188 case GUI_EXTERNAL_OSC:
189 if (gui.visible)
190 osc_send_hide(&osc.data);
191
192 osc_send_quit(&osc.data);
193
194 if (osc.thread)
195 {
196 osc.thread->quit();
197
198 if (!osc.thread->wait(3000)) // 3 sec
199 qWarning("Failed to properly stop LV2 OSC GUI thread");
200
201 delete osc.thread;
202 }
203
204 osc_clear_data(&osc.data);
205
206 break;
207
208 case GUI_EXTERNAL_LV2:
209 if (gui.visible)
210 LV2_EXTERNAL_UI_HIDE((lv2_external_ui*)ui.widget);
211
212 break;
213
214 default:
215 break;
216 }
217
218 if (ui.handle && ui.descriptor && ui.descriptor->cleanup)
219 ui.descriptor->cleanup(ui.handle);
220
221 if (features[lv2_feature_id_data_access] && features[lv2_feature_id_data_access]->data)
222 delete (LV2_Extension_Data_Feature*)features[lv2_feature_id_data_access]->data;
223
224 if (features[lv2_feature_id_ui_resize] && features[lv2_feature_id_ui_resize]->data)
225 delete (LV2_UI_Resize_Feature*)features[lv2_feature_id_ui_resize]->data;
226
227 if (features[lv2_feature_id_external_ui] && features[lv2_feature_id_external_ui]->data)
228 delete (lv2_external_ui_host*)features[lv2_feature_id_external_ui]->data;
229
230 ui_lib_close();
231 }
232
233 for (int i=0; i < custom_uri_ids.count(); i++)
234 {
235 if (custom_uri_ids[i])
236 free((void*)custom_uri_ids[i]);
237 }
238
239 custom_uri_ids.clear();
240
241 if (handle && descriptor->deactivate && active_before)
242 descriptor->deactivate(handle);
243
244 if (handle && descriptor->cleanup)
245 descriptor->cleanup(handle);
246
247 if (features[lv2_feature_id_uri_map] && features[lv2_feature_id_uri_map]->data)
248 delete (LV2_URI_Map_Feature*)features[lv2_feature_id_uri_map]->data;
249
250 if (features[lv2_feature_id_urid_map] && features[lv2_feature_id_urid_map]->data)
251 delete (LV2_URID_Map*)features[lv2_feature_id_urid_map]->data;
252
253 if (features[lv2_feature_id_urid_unmap] && features[lv2_feature_id_urid_unmap]->data)
254 delete (LV2_URID_Unmap*)features[lv2_feature_id_urid_unmap]->data;
255
256 if (features[lv2_feature_id_event] && features[lv2_feature_id_event]->data)
257 delete (LV2_Event_Feature*)features[lv2_feature_id_event]->data;
258
259 for (uint16_t j=0; j<lv2_feature_count && features[j]; j++)
260 delete features[j];
261
262 if (rdf_descriptor)
263 lv2_rdf_free(rdf_descriptor);
264
265 lv2_remove_from_jack();
266
267 lv2_delete_buffers();
268 }
269
270 void lv2_remove_from_jack()
271 {
272 qDebug("Lv2AudioPlugin::lv2_remove_from_jack()");
273
274 uint32_t i;
275 for (i=0; i < evin.count; i++)
276 jack_port_unregister(jack_client, evin.events[i].port);
277
278 for (i=0; i < evout.count; i++)
279 jack_port_unregister(jack_client, evout.events[i].port);
280
281 // We set fake min/mout values for easy port-count-info
282 min.count = 0;
283 mout.count = 0;
284
285 qDebug("Lv2AudioPlugin::lv2_remove_from_jack() - end");
286 }
287
288 void lv2_delete_buffers()
289 {
290 qDebug("Lv2AudioPlugin::lv2_delete_buffers()");
291
292 if (evin.count > 0)
293 {
294 for (uint32_t i=0; i < evin.count; i++)
295 free(evin.events[i].buffer);
296
297 delete[] evin.events;
298 }
299
300 if (evout.count > 0)
301 {
302 for (uint32_t i=0; i < evout.count; i++)
303 free(evout.events[i].buffer);
304
305 delete[] evout.events;
306 }
307
308 evin.count = 0;
309 evin.events = nullptr;
310
311 evout.count = 0;
312 evout.events = nullptr;
313
314 qDebug("Lv2AudioPlugin::lv2_delete_buffers() - end");
315 }
316
317 // Used for preset ports
318 int32_t get_parameter_id_from_symbol(const char* symbol)
319 {
320 int32_t param_id = -1;
321 for (uint32_t i=0; i < rdf_descriptor->PortCount; i++)
322 {
323 if (LV2_IS_PORT_CONTROL(rdf_descriptor->Ports[i].Type))
324 {
325 param_id += 1;
326
327 if (strcmp(rdf_descriptor->Ports[i].Symbol, symbol) == 0)
328 return param_id;
329 }
330 }
331 return -1;
332 }
333
334 bool is_ui_resizable()
335 {
336 if (ui.rdf_descriptor)
337 {
338 for (uint32_t i=0; i < ui.rdf_descriptor->FeatureCount; i++)
339 {
340 if (strcmp(ui.rdf_descriptor->Features[i].URI, NS_LV2UI "fixedSize") == 0 || strcmp(ui.rdf_descriptor->Features[i].URI, NS_LV2UI "noUserResize") == 0)
341 return false;
342 }
343 return true;
344 }
345 return false;
346 }
347
348 bool is_ui_bridgeable(uint32_t ui_id)
349 {
350 LV2_RDF_UI* rdf_ui = &rdf_descriptor->UIs[ui_id];
351
352 for (uint32_t i=0; i < rdf_ui->FeatureCount; i++)
353 {
354 if (strcmp(rdf_ui->Features[i].URI, LV2_INSTANCE_ACCESS_URI) == 0 || strcmp(rdf_ui->Features[i].URI, LV2_DATA_ACCESS_URI) == 0)
355 return false;
356 }
357
358 return true;
359 }
360
361 void reinit_external_ui()
362 {
363 qDebug("Lv2AudioPlugin::reinit_external_ui()");
364
365 ui.widget = nullptr;
366 ui.handle = ui.descriptor->instantiate(ui.descriptor,
367 descriptor->URI,
368 ui.rdf_descriptor->Bundle,
369 carla_lv2_ui_write_function,
370 this,
371 &ui.widget,
372 features);
373
374 if (ui.handle && ui.widget)
375 update_ui_ports();
376 else
377 {
378 qDebug("Lv2AudioPlugin::reinit_external_ui() - Failed to re-initiate external UI");
379
380 ui.handle = nullptr;
381 ui.widget = nullptr;
382 callback_action(CALLBACK_SHOW_GUI, id, -1, 0, 0.0);
383 }
384 }
385
386 void update_ui_ports()
387 {
388 qDebug("Lv2AudioPlugin::lv2_ui_update_ports()");
389
390 if (ui.descriptor->port_event)
391 {
392 for (uint32_t i=0; i < param.count; i++)
393 ui.descriptor->port_event(ui.handle, param.data[i].rindex, sizeof(float), 0, &param.buffers[i]);
394 }
395 }
396
397 uint32_t get_custom_uri_id(const char* uri)
398 {
399 qDebug("Lv2AudioPlugin::get_custom_uri_id(%s)", uri);
400
401 for (int i=0; i < custom_uri_ids.count(); i++)
402 {
403 if (custom_uri_ids[i] && strcmp(custom_uri_ids[i], uri) == 0)
404 return i;
405 }
406
407 custom_uri_ids.append(strdup(uri));
408 return custom_uri_ids.count()-1;
409 }
410
411 const char* get_custom_uri_string(int uri_id)
412 {
413 qDebug("Lv2AudioPlugin::get_custom_uri_string(%i)", uri_id);
414
415 if (uri_id < custom_uri_ids.count())
416 return custom_uri_ids.at(uri_id);
417 else
418 return nullptr;
419 }
420
421 void delete_me()
422 {
423 qDebug("Lv2AudioPlugin::delete_me()");
424 delete this;
425 }
426
427 int set_osc_bridge_info(PluginOscBridgeInfoType, lo_arg**)
428 {
429 return 1;
430 }
431
432 PluginCategory get_category()
433 {
434 LV2_Property Category = rdf_descriptor->Type;
435
436 // Specific Types
437 if (Category & LV2_CLASS_REVERB)
438 return PLUGIN_CATEGORY_DELAY;
439
440 // Pre-set LV2 Types
441 else if (LV2_IS_GENERATOR(Category))
442 return PLUGIN_CATEGORY_SYNTH;
443 else if (LV2_IS_UTILITY(Category))
444 return PLUGIN_CATEGORY_UTILITY;
445 else if (LV2_IS_SIMULATOR(Category))
446 return PLUGIN_CATEGORY_OUTRO;
447 else if (LV2_IS_DELAY(Category))
448 return PLUGIN_CATEGORY_DELAY;
449 else if (LV2_IS_MODULATOR(Category))
450 return PLUGIN_CATEGORY_MODULATOR;
451 else if (LV2_IS_FILTER(Category))
452 return PLUGIN_CATEGORY_FILTER;
453 else if (LV2_IS_EQUALISER(Category))
454 return PLUGIN_CATEGORY_EQ;
455 else if (LV2_IS_SPECTRAL(Category))
456 return PLUGIN_CATEGORY_UTILITY;
457 else if (LV2_IS_DISTORTION(Category))
458 return PLUGIN_CATEGORY_OUTRO;
459 else if (LV2_IS_DYNAMICS(Category))
460 return PLUGIN_CATEGORY_DYNAMICS;
461 else
462 return PLUGIN_CATEGORY_NONE;
463 }
464
465 void get_label(char* buf_str)
466 {
467 strncpy(buf_str, rdf_descriptor->URI, STR_MAX);
468 }
469
470 void get_maker(char* buf_str)
471 {
472 strncpy(buf_str, rdf_descriptor->Author, STR_MAX);
473 }
474
475 void get_copyright(char* buf_str)
476 {
477 strncpy(buf_str, rdf_descriptor->License, STR_MAX);
478 }
479
480 void get_real_name(char* buf_str)
481 {
482 strncpy(buf_str, rdf_descriptor->Name, STR_MAX);
483 }
484
485 long get_unique_id()
486 {
487 return rdf_descriptor->UniqueID;
488 }
489
490 void get_parameter_name(uint32_t rindex, char* buf_str)
491 {
492 strncpy(buf_str, rdf_descriptor->Ports[rindex].Name, STR_MAX);
493 }
494
495 void get_parameter_symbol(uint32_t rindex, char* buf_str)
496 {
497 strncpy(buf_str, rdf_descriptor->Ports[rindex].Symbol, STR_MAX);
498 }
499
500 void get_parameter_label(uint32_t rindex, char* buf_str)
501 {
502 LV2_RDF_Port* Port = &rdf_descriptor->Ports[rindex];
503
504 if (LV2_HAVE_UNIT_SYMBOL(Port->Unit.Hints))
505 strncpy(buf_str, Port->Unit.Symbol, STR_MAX);
506
507 else if (LV2_HAVE_UNIT(Port->Unit.Hints))
508 {
509 switch (Port->Unit.Type)
510 {
511 case LV2_UNIT_BAR:
512 strncpy(buf_str, "bars", STR_MAX);
513 return;
514 case LV2_UNIT_BEAT:
515 strncpy(buf_str, "beats", STR_MAX);
516 return;
517 case LV2_UNIT_BPM:
518 strncpy(buf_str, "BPM", STR_MAX);
519 return;
520 case LV2_UNIT_CENT:
521 strncpy(buf_str, "ct", STR_MAX);
522 return;
523 case LV2_UNIT_CM:
524 strncpy(buf_str, "cm", STR_MAX);
525 return;
526 case LV2_UNIT_COEF:
527 strncpy(buf_str, "(coef)", STR_MAX);
528 return;
529 case LV2_UNIT_DB:
530 strncpy(buf_str, "dB", STR_MAX);
531 return;
532 case LV2_UNIT_DEGREE:
533 strncpy(buf_str, "deg", STR_MAX);
534 return;
535 case LV2_UNIT_HZ:
536 strncpy(buf_str, "Hz", STR_MAX);
537 return;
538 case LV2_UNIT_INCH:
539 strncpy(buf_str, "in", STR_MAX);
540 return;
541 case LV2_UNIT_KHZ:
542 strncpy(buf_str, "kHz", STR_MAX);
543 return;
544 case LV2_UNIT_KM:
545 strncpy(buf_str, "km", STR_MAX);
546 return;
547 case LV2_UNIT_M:
548 strncpy(buf_str, "m", STR_MAX);
549 return;
550 case LV2_UNIT_MHZ:
551 strncpy(buf_str, "MHz", STR_MAX);
552 return;
553 case LV2_UNIT_MIDINOTE:
554 strncpy(buf_str, "note", STR_MAX);
555 return;
556 case LV2_UNIT_MILE:
557 strncpy(buf_str, "mi", STR_MAX);
558 return;
559 case LV2_UNIT_MIN:
560 strncpy(buf_str, "min", STR_MAX);
561 return;
562 case LV2_UNIT_MM:
563 strncpy(buf_str, "mm", STR_MAX);
564 return;
565 case LV2_UNIT_MS:
566 strncpy(buf_str, "ms", STR_MAX);
567 return;
568 case LV2_UNIT_OCT:
569 strncpy(buf_str, "oct", STR_MAX);
570 return;
571 case LV2_UNIT_PC:
572 strncpy(buf_str, "%", STR_MAX);
573 return;
574 case LV2_UNIT_S:
575 strncpy(buf_str, "s", STR_MAX);
576 return;
577 case LV2_UNIT_SEMITONE:
578 strncpy(buf_str, "semi", STR_MAX);
579 return;
580 }
581 }
582 *buf_str = 0;
583 }
584
585 uint32_t get_scalepoint_count(uint32_t rindex)
586 {
587 return rdf_descriptor->Ports[rindex].ScalePointCount;
588 }
589
590 double get_scalepoint_value(uint32_t rindex, uint32_t scalepoint_id)
591 {
592 return rdf_descriptor->Ports[rindex].ScalePoints[scalepoint_id].Value;
593 }
594
595 void get_scalepoint_label(uint32_t rindex, uint32_t scalepoint_id, char* buf_str)
596 {
597 strncpy(buf_str, rdf_descriptor->Ports[rindex].ScalePoints[scalepoint_id].Label, STR_MAX);
598 }
599
600 int32_t get_chunk_data(void**)
601 {
602 return 0;
603 }
604
605 void x_set_parameter_value(uint32_t parameter_id, double value, bool gui_send)
606 {
607 if (gui_send && gui.visible)
608 {
609 switch(gui.type)
610 {
611 case GUI_INTERNAL_QT4:
612 case GUI_INTERNAL_X11:
613 case GUI_EXTERNAL_LV2:
614 if (ui.descriptor->port_event)
615 {
616 float fvalue = value;
617 ui.descriptor->port_event(ui.handle, param.data[parameter_id].rindex, sizeof(float), 0, &fvalue);
618 }
619 break;
620
621 case GUI_EXTERNAL_OSC:
622 osc_send_control(&osc.data, param.data[parameter_id].rindex, value);
623 break;
624
625 default:
626 break;
627 }
628 }
629 }
630
631 void x_set_program(uint32_t program_id, bool, bool)
632 {
633 // FIXME - state or ports first? should we block audio thread while restoring state?
634 LV2_RDF_Preset* Preset = &rdf_descriptor->Presets[program_id];
635
636 // set state
637 for (uint32_t i=0; i < Preset->StateCount; i++)
638 set_custom_data(CUSTOM_DATA_STRING, Preset->States[i].Key, Preset->States[i].Value, true);
639
640 // set parameters
641 int32_t param_id;
642
643 for (uint32_t i=0; i < Preset->PortCount; i++)
644 {
645 param_id = get_parameter_id_from_symbol(Preset->Ports[i].Symbol);
646
647 if (param_id >= 0)
648 set_parameter_value(param_id, Preset->Ports[i].Value, true, false, false);
649 else
650 qWarning("Lv2Plugin::x_set_program(%i, ...) - Failed to find parameter '%s'", program_id, Preset->Ports[i].Symbol);
651 }
652 }
653
654 void x_set_midi_program(uint32_t, bool, bool)
655 {
656 }
657
658 void x_set_custom_data(CustomDataType, const char*, const char*, bool)
659 {
660 if ((hints & PLUGIN_HAS_EXTENSION_STATE) > 0 && descriptor->extension_data)
661 {
662 LV2_State_Interface* state = (LV2_State_Interface*)descriptor->extension_data(LV2_STATE_INTERFACE_URI);
663
664 if (state)
665 state->restore(handle, carla_lv2_state_retrieve, this, 0, features);
666 }
667 }
668
669 void set_chunk_data(const char*)
670 {
671 }
672
673 void set_gui_data(int, void* ptr)
674 {
675 switch(gui.type)
676 {
677 case GUI_INTERNAL_QT4:
678 if (ui.widget)
679 {
680 QDialog* qtPtr = (QDialog*)ptr;
681 QWidget* widget = (QWidget*)ui.widget;
682
683 qtPtr->layout()->addWidget(widget);
684 widget->setParent(qtPtr);
685 widget->show();
686 }
687 break;
688
689 case GUI_INTERNAL_X11:
690 if (ui.descriptor)
691 {
692 QDialog* qtPtr = (QDialog*)ptr;
693 features[lv2_feature_id_ui_parent]->data = (void*)qtPtr->winId();
694
695 ui.handle = ui.descriptor->instantiate(ui.descriptor,
696 descriptor->URI,
697 ui.rdf_descriptor->Bundle,
698 carla_lv2_ui_write_function,
699 this,
700 &ui.widget,
701 features);
702
703 if (ui.handle && ui.descriptor->port_event)
704 update_ui_ports();
705 }
706 break;
707
708 default:
709 break;
710 }
711 }
712
713 void show_gui(bool yesno)
714 {
715 switch(gui.type)
716 {
717 case GUI_INTERNAL_QT4:
718 gui.visible = yesno;
719 break;
720
721 case GUI_INTERNAL_X11:
722 gui.visible = yesno;
723
724 if (gui.visible && gui.width > 0 && gui.height > 0)
725 callback_action(CALLBACK_RESIZE_GUI, id, gui.width, gui.height, 0.0);
726
727 break;
728
729 case GUI_EXTERNAL_OSC:
730 if (yesno)
731 {
732 gui.show_now = true;
733
734 // 40 re-tries, 4 secs
735 for (int j=1; j<40 && gui.show_now; j++)
736 {
737 if (osc.data.target)
738 {
739 osc_send_show(&osc.data);
740 gui.visible = true;
741 return;
742 }
743 else
744 // 100 ms
745 usleep(100000);
746 }
747
748 qDebug("Lv2AudioPlugin::show_gui() - GUI timeout");
749 callback_action(CALLBACK_SHOW_GUI, id, 0, 0, 0.0);
750 }
751 else
752 {
753 gui.visible = false;
754 osc_send_hide(&osc.data);
755 osc_send_quit(&osc.data);
756 osc_clear_data(&osc.data);
757 }
758 break;
759
760 case GUI_EXTERNAL_LV2:
761 if (!ui.handle)
762 reinit_external_ui();
763
764 if (ui.handle && ui.widget)
765 {
766 if (yesno)
767 {
768 LV2_EXTERNAL_UI_SHOW((lv2_external_ui*)ui.widget);
769 gui.visible = true;
770 }
771 else
772 {
773 LV2_EXTERNAL_UI_HIDE((lv2_external_ui*)ui.widget);
774 gui.visible = false;
775
776 if (ui.descriptor->cleanup)
777 ui.descriptor->cleanup(ui.handle);
778
779 ui.handle = nullptr;
780 }
781 }
782 else
783 {
784 // failed to init UI
785 gui.visible = false;
786 callback_action(CALLBACK_SHOW_GUI, id, -1, 0, 0.0);
787 }
788 break;
789
790 default:
791 break;
792 }
793 }
794
795 void idle_gui()
796 {
797 switch(gui.type)
798 {
799 case GUI_INTERNAL_QT4:
800 case GUI_INTERNAL_X11:
801 case GUI_EXTERNAL_LV2:
802 if (ui.descriptor->port_event)
803 {
804 for (uint32_t i=0; i < param.count; i++)
805 {
806 if (param.data[i].type == PARAMETER_OUTPUT && (param.data[i].hints & PARAMETER_IS_AUTOMABLE) > 0)
807 ui.descriptor->port_event(ui.handle, param.data[i].rindex, sizeof(float), 0, &param.buffers[i]);
808 }
809 }
810
811 if (gui.type == GUI_EXTERNAL_LV2)
812 LV2_EXTERNAL_UI_RUN((lv2_external_ui*)ui.widget);
813
814 break;
815
816 default:
817 break;
818 }
819 }
820
821 void reload()
822 {
823 qDebug("Lv2AudioPlugin::reload()");
824 short _id = id;
825
826 // Safely disable plugin for reload
827 carla_proc_lock();
828
829 id = -1;
830 if (carla_options.global_jack_client == false)
831 jack_deactivate(jack_client);
832
833 carla_proc_unlock();
834
835 // Unregister jack ports
836 lv2_remove_from_jack();
837 remove_from_jack();
838
839 // Delete old data
840 lv2_delete_buffers();
841 delete_buffers();
842
843 // All invada plugins have broken output ports
844 bool force_strict_bounds = false;
845 if (QString(rdf_descriptor->URI).startsWith("http://invadarecords.com/plugins/lv2/"))
846 force_strict_bounds = true;
847
848 uint32_t ains, aouts, cv_ins, cv_outs, ev_ins, ev_outs, params, j;
849 ains = aouts = cv_ins = cv_outs = ev_ins = ev_outs = params = 0;
850
851 const uint32_t PortCount = rdf_descriptor->PortCount;
852
853 for (uint32_t i=0; i<PortCount; i++)
854 {
855 LV2_Property PortType = rdf_descriptor->Ports[i].Type;
856 if (LV2_IS_PORT_AUDIO(PortType))
857 {
858 if (LV2_IS_PORT_INPUT(PortType))
859 ains += 1;
860 else if (LV2_IS_PORT_OUTPUT(PortType))
861 aouts += 1;
862 }
863 else if (LV2_IS_PORT_CONTROL(PortType))
864 {
865 params += 1;
866 }
867 else if (LV2_IS_PORT_CV(PortType))
868 {
869 if (LV2_IS_PORT_INPUT(PortType))
870 cv_ins += 1;
871 else if (LV2_IS_PORT_OUTPUT(PortType))
872 cv_outs += 1;
873 }
874 else if (LV2_IS_PORT_EVENT(PortType))
875 {
876 if (LV2_IS_PORT_INPUT(PortType))
877 ev_ins += 1;
878 else if (LV2_IS_PORT_OUTPUT(PortType))
879 ev_outs += 1;
880 }
881 }
882
883 if (params == 0 && (hints & PLUGIN_HAS_EXTENSION_DYNPARAM) > 0)
884 {
885 dynparam_plugin = (lv2dynparam_plugin_callbacks*)descriptor->extension_data(LV2DYNPARAM_URI);
886 if (dynparam_plugin)
887 dynparam_plugin->host_attach(handle, &dynparam_host, this);
888 }
889
890 if (ains > 0)
891 {
892 ain.rindexes = new uint32_t[ains];
893 ain.ports = new jack_port_t*[ains];
894 }
895
896 if (aouts > 0)
897 {
898 aout.rindexes = new uint32_t[aouts];
899 aout.ports = new jack_port_t*[aouts];
900 }
901
902 if (ev_ins > 0)
903 {
904 evin.events = new CarlaLv2Event[ev_ins];
905
906 for (j=0; j < ev_ins; j++)
907 {
908 evin.events[j].type = 0;
909 evin.events[j].port = nullptr;
910 evin.events[j].buffer = lv2_event_buffer_new(MAX_EVENT_BUFFER, LV2_EVENT_AUDIO_STAMP);
911 }
912 }
913
914 if (ev_outs > 0)
915 {
916 evout.events = new CarlaLv2Event[ev_outs];
917
918 for (j=0; j<ev_outs; j++)
919 {
920 evout.events[j].type = 0;
921 evout.events[j].port = nullptr;
922 evout.events[j].buffer = lv2_event_buffer_new(MAX_EVENT_BUFFER, LV2_EVENT_AUDIO_STAMP);
923 }
924 }
925
926 if (params > 0)
927 {
928 param.buffers = new float[params];
929 param.data = new ParameterData[params];
930 param.ranges = new ParameterRanges[params];
931 }
932
933 const int port_name_size = jack_port_name_size();
934 char port_name[port_name_size];
935 bool needs_cin = false;
936 bool needs_cout = false;
937
938 for (uint32_t i=0; i<PortCount; i++)
939 {
940 LV2_Property PortType = rdf_descriptor->Ports[i].Type;
941 LV2_Property PortProps = rdf_descriptor->Ports[i].Properties;
942 LV2_RDF_PortPoints PortPoints = rdf_descriptor->Ports[i].Points;
943
944 if (LV2_IS_PORT_AUDIO(PortType) || LV2_IS_PORT_EVENT_MIDI(PortType))
945 {
946 if (carla_options.global_jack_client)
947 {
948 strncpy(port_name, name, (port_name_size/2)-2);
949 strcat(port_name, ":");
950 strncat(port_name, rdf_descriptor->Ports[i].Name, port_name_size/2);
951 }
952 else
953 strncpy(port_name, rdf_descriptor->Ports[i].Name, port_name_size);
954 }
955
956 if (LV2_IS_PORT_AUDIO(PortType))
957 {
958 if (LV2_IS_PORT_INPUT(PortType))
959 {
960 j = ain.count++;
961 ain.ports[j] = jack_port_register(jack_client, port_name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
962 ain.rindexes[j] = i;
963 }
964 else if (LV2_IS_PORT_OUTPUT(PortType))
965 {
966 j = aout.count++;
967 aout.ports[j] = jack_port_register(jack_client, port_name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
968 aout.rindexes[j] = i;
969 needs_cin = true;
970 }
971 else
972 qWarning("WARNING - Got a broken Port (Audio, but not input or output)");
973 }
974 else if (LV2_IS_PORT_CONTROL(PortType))
975 {
976 j = param.count++;
977 param.data[j].index = j;
978 param.data[j].rindex = i;
979 param.data[j].hints = 0;
980 param.data[j].midi_channel = 0;
981 param.data[j].midi_cc = -1;
982
983 double min, max, def, step, step_small, step_large;
984
985 // min value
986 if (LV2_HAVE_MINIMUM_PORT_POINT(PortPoints.Hints))
987 min = PortPoints.Minimum;
988 else
989 min = 0.0;
990
991 // max value
992 if (LV2_HAVE_MAXIMUM_PORT_POINT(PortPoints.Hints))
993 max = PortPoints.Maximum;
994 else
995 max = 1.0;
996
997 if (min > max)
998 max = min;
999 else if (max < min)
1000 min = max;
1001
1002 // default value
1003 if (LV2_HAVE_DEFAULT_PORT_POINT(PortPoints.Hints))
1004 def = PortPoints.Default;
1005 else
1006 {
1007 // no default value
1008 if (min < 0.0 && max > 0.0)
1009 def = 0.0;
1010 else
1011 def = min;
1012 }
1013
1014 if (def < min)
1015 def = min;
1016 else if (def > max)
1017 def = max;
1018
1019 if (max - min == 0.0)
1020 {
1021 qWarning("Broken plugin parameter -> max - min == 0");
1022 max = min + 0.1;
1023 }
1024
1025 if (LV2_IS_PORT_SAMPLE_RATE(PortProps))
1026 {
1027 double sample_rate = get_sample_rate();
1028 min *= sample_rate;
1029 max *= sample_rate;
1030 def *= sample_rate;
1031 param.data[j].hints |= PARAMETER_USES_SAMPLERATE;
1032 }
1033
1034 if (LV2_IS_PORT_INTEGER(PortProps))
1035 {
1036 step = 1.0;
1037 step_small = 1.0;
1038 step_large = 10.0;
1039 }
1040 else if (LV2_IS_PORT_TOGGLED(PortProps))
1041 {
1042 step = max - min;
1043 step_small = step;
1044 step_large = step;
1045 }
1046 else
1047 {
1048 double range = max - min;
1049 step = range/100.0;
1050 step_small = range/1000.0;
1051 step_large = range/10.0;
1052 }
1053
1054 if (LV2_IS_PORT_INPUT(PortType))
1055 {
1056 param.data[j].type = PARAMETER_INPUT;
1057 param.data[j].hints |= PARAMETER_IS_ENABLED;
1058 param.data[j].hints |= PARAMETER_IS_AUTOMABLE;
1059 needs_cin = true;
1060
1061 // MIDI CC value
1062 LV2_RDF_PortMidiMap* PortMidiMap = &rdf_descriptor->Ports[i].MidiMap;
1063 if (LV2_IS_PORT_MIDI_MAP_CC(PortMidiMap->Type))
1064 param.data[j].midi_cc = PortMidiMap->Number;
1065 }
1066 else if (LV2_IS_PORT_OUTPUT(PortType))
1067 {
1068 param.data[j].type = PARAMETER_OUTPUT;
1069 param.data[j].hints |= PARAMETER_IS_ENABLED;
1070
1071 if (LV2_IS_PORT_LATENCY(PortProps) == false)
1072 {
1073 param.data[j].hints |= PARAMETER_IS_AUTOMABLE;
1074 needs_cout = true;
1075 }
1076 else
1077 {
1078 // latency parameter
1079 min = 0;
1080 max = get_sample_rate();
1081 def = 0;
1082 step = 1;
1083 step_small = 1;
1084 step_large = 1;
1085 }
1086 }
1087 else
1088 {
1089 param.data[j].type = PARAMETER_UNKNOWN;
1090 qWarning("WARNING - Got a broken Port (Control, but not input or output)");
1091 }
1092
1093 // extra plugin hints
1094 if (LV2_IS_PORT_ENUMERATION(PortProps))
1095 param.data[j].hints |= PARAMETER_USES_SCALEPOINTS;
1096
1097 if (LV2_IS_PORT_HAS_STRICT_BOUNDS(PortProps) || (force_strict_bounds && LV2_IS_PORT_OUTPUT(PortType)))
1098 param.data[j].hints |= PARAMETER_HAS_STRICT_BOUNDS;
1099
1100 // check if parameter is not automable
1101 if (LV2_IS_PORT_HAS_STRICT_BOUNDS(PortProps))
1102 {
1103 //param.data[j].hints ~= ~PARAMETER_IS_AUTOMABLE;
1104 }
1105
1106 param.ranges[j].min = min;
1107 param.ranges[j].max = max;
1108 param.ranges[j].def = def;
1109 param.ranges[j].step = step;
1110 param.ranges[j].step_small = step_small;
1111 param.ranges[j].step_large = step_large;
1112
1113 // Start parameters in their default values
1114 param.buffers[j] = def;
1115
1116 descriptor->connect_port(handle, i, &param.buffers[j]);
1117 }
1118 else if (LV2_IS_PORT_CV(PortType))
1119 {
1120 if (LV2_IS_PORT_INPUT(PortType))
1121 {
1122 qWarning("WARNING - CV Ports are not supported yet");
1123 }
1124 else if (LV2_IS_PORT_OUTPUT(PortType))
1125 {
1126 qWarning("WARNING - CV Ports are not supported yet");
1127 }
1128 else
1129 qWarning("WARNING - Got a broken Port (CV, but not input or output)");
1130
1131 descriptor->connect_port(handle, i, nullptr);
1132 }
1133 else if (LV2_IS_PORT_EVENT(PortType))
1134 {
1135 if (LV2_IS_PORT_INPUT(PortType))
1136 {
1137 j = evin.count++;
1138 descriptor->connect_port(handle, i, evin.events[j].buffer);
1139
1140 if (LV2_IS_PORT_EVENT_MIDI(PortType))
1141 {
1142 min.count++;
1143 evin.events[j].type |= CARLA_URI_MAP_ID_EVENT_MIDI;
1144 evin.events[j].port = jack_port_register(jack_client, port_name, JACK_DEFAULT_MIDI_TYPE, JackPortIsInput, 0);
1145 }
1146 if (LV2_IS_PORT_EVENT_TIME(PortType))
1147 {
1148 evin.events[j].type |= CARLA_URI_MAP_ID_EVENT_TIME;
1149 wants_time_pos = true;
1150 }
1151 }
1152 else if (LV2_IS_PORT_OUTPUT(PortType))
1153 {
1154 j = evout.count++;
1155 descriptor->connect_port(handle, i, evout.events[j].buffer);
1156
1157 if (LV2_IS_PORT_EVENT_MIDI(PortType))
1158 {
1159 mout.count++;
1160 evout.events[j].type |= CARLA_URI_MAP_ID_EVENT_MIDI;
1161 evout.events[j].port = jack_port_register(jack_client, port_name, JACK_DEFAULT_MIDI_TYPE, JackPortIsOutput, 0);
1162 }
1163 if (LV2_IS_PORT_EVENT_TIME(PortType))
1164 {
1165 evout.events[j].type |= CARLA_URI_MAP_ID_EVENT_TIME;
1166 }
1167 }
1168 else
1169 qWarning("WARNING - Got a broken Port (Event, but not input or output)");
1170 }
1171 else
1172 // Port Type not supported, but it's optional anyway
1173 descriptor->connect_port(handle, i, nullptr);
1174 }
1175
1176 if (needs_cin)
1177 {
1178 if (carla_options.global_jack_client)
1179 {
1180 strncpy(port_name, name, (port_name_size/2)-2);
1181 strcat(port_name, ":control-in");
1182 }
1183 else
1184 strcpy(port_name, "control-in");
1185
1186 param.port_in = jack_port_register(jack_client, port_name, JACK_DEFAULT_MIDI_TYPE, JackPortIsInput, 0);
1187 }
1188
1189 if (needs_cout)
1190 {
1191 if (carla_options.global_jack_client)
1192 {
1193 strncpy(port_name, name, (port_name_size/2)-2);
1194 strcat(port_name, ":control-out");
1195 }
1196 else
1197 strcpy(port_name, "control-out");
1198
1199 param.port_out = jack_port_register(jack_client, port_name, JACK_DEFAULT_MIDI_TYPE, JackPortIsOutput, 0);
1200 }
1201
1202 ain.count = ains;
1203 aout.count = aouts;
1204 evin.count = ev_ins;
1205 evout.count = ev_outs;
1206 param.count = params;
1207
1208 reload_programs(true);
1209
1210 // Check if plugin is synth
1211 if (LV2_IS_GENERATOR(rdf_descriptor->Type))
1212 hints |= PLUGIN_IS_SYNTH;
1213
1214 // Other plugin checks
1215 if (aouts > 0 && (ains == aouts || ains == 1))
1216 hints |= PLUGIN_CAN_DRYWET;
1217
1218 if (aouts > 0)
1219 hints |= PLUGIN_CAN_VOL;
1220
1221 if (aouts >= 2 && aouts%2 == 0)
1222 hints |= PLUGIN_CAN_BALANCE;
1223
1224 carla_proc_lock();
1225 id = _id;
1226 carla_proc_unlock();
1227
1228 if (carla_options.global_jack_client == false)
1229 jack_activate(jack_client);
1230 }
1231
1232 void reload_programs(bool init)
1233 {
1234 qDebug("Lv2AudioPlugin::reload_programs(%s)", bool2str(init));
1235 uint32_t i;
1236
1237 // Delete old programs
1238 if (prog.count > 0)
1239 {
1240 for (uint32_t i=0; i < prog.count; i++)
1241 free((void*)prog.names[i]);
1242
1243 delete[] prog.names;
1244 }
1245 prog.count = 0;
1246
1247 // Query new programs
1248 prog.count = rdf_descriptor->PresetCount;
1249
1250 if (prog.count > 0)
1251 prog.names = new const char* [prog.count];
1252
1253 // Update names
1254 for (i=0; i < prog.count; i++)
1255 prog.names[i] = strdup(rdf_descriptor->Presets[i].Label);
1256
1257 // Update OSC Names
1258 osc_send_set_program_count(&osc.data, id, prog.count);
1259
1260 if (prog.count > 0)
1261 {
1262 for (i=0; i < prog.count; i++)
1263 osc_send_set_program_name(&osc.data, id, i, prog.names[i]);
1264 }
1265
1266 callback_action(CALLBACK_RELOAD_PROGRAMS, id, 0, 0, 0.0);
1267
1268 if (init)
1269 {
1270 if (prog.count > 0)
1271 set_program(0, false, false, false, true);
1272 }
1273
1274 // (LV2 programs don't change during runtime)
1275 }
1276
1277 void prepare_for_save()
1278 {
1279 if ((hints & PLUGIN_HAS_EXTENSION_STATE) > 0 && descriptor->extension_data)
1280 {
1281 LV2_State_Interface* state = (LV2_State_Interface*)descriptor->extension_data(LV2_STATE_INTERFACE_URI);
1282
1283 if (state)
1284 state->save(handle, carla_lv2_state_store, this, 0, features);
1285 }
1286 }
1287
1288 void process(jack_nframes_t nframes)
1289 {
1290 uint32_t i, k;
1291 unsigned short plugin_id = id;
1292 uint32_t midi_event_count = 0;
1293 LV2_Event_Iterator evin_iters[evin.count];
1294
1295 double ains_peak_tmp[2] = { 0.0 };
1296 double aouts_peak_tmp[2] = { 0.0 };
1297
1298 jack_default_audio_sample_t* ains_buffer[ain.count];
1299 jack_default_audio_sample_t* aouts_buffer[aout.count];
1300 jack_default_audio_sample_t* evins_buffer[evin.count];
1301 jack_default_audio_sample_t* evouts_buffer[evout.count];
1302
1303 for (i=0; i < ain.count; i++)
1304 ains_buffer[i] = (jack_default_audio_sample_t*)jack_port_get_buffer(ain.ports[i], nframes);
1305
1306 for (i=0; i < aout.count; i++)
1307 aouts_buffer[i] = (jack_default_audio_sample_t*)jack_port_get_buffer(aout.ports[i], nframes);
1308
1309 for (i=0; i < evin.count; i++)
1310 {
1311 lv2_event_buffer_reset(evin.events[i].buffer, LV2_EVENT_AUDIO_STAMP, (uint8_t*)(evin.events[i].buffer + 1));
1312 lv2_event_begin(&evin_iters[i], evin.events[i].buffer);
1313
1314 if (evin.events[i].port)
1315 evins_buffer[i] = (jack_default_audio_sample_t*)jack_port_get_buffer(evin.events[i].port, nframes);
1316 else
1317 evins_buffer[i] = nullptr;
1318 }
1319
1320 for (i=0; i < evout.count; i++)
1321 {
1322 lv2_event_buffer_reset(evout.events[i].buffer, LV2_EVENT_AUDIO_STAMP, (uint8_t*)(evout.events[i].buffer + 1));
1323
1324 if (evout.events[i].port)
1325 evouts_buffer[i] = (jack_default_audio_sample_t*)jack_port_get_buffer(evout.events[i].port, nframes);
1326 else
1327 evouts_buffer[i] = nullptr;
1328 }
1329
1330 // --------------------------------------------------------------------------------------------------------
1331 // Input VU
1332
1333 if (ain.count > 0)
1334 {
1335 short j2 = (ain.count == 1) ? 0 : 1;
1336
1337 for (k=0; k<nframes; k++)
1338 {
1339 if (ains_buffer[0][k] > ains_peak_tmp[0])
1340 ains_peak_tmp[0] = ains_buffer[0][k];
1341 if (ains_buffer[j2][k] > ains_peak_tmp[1])
1342 ains_peak_tmp[1] = ains_buffer[j2][k];
1343 }
1344 }
1345
1346 CARLA_PROCESS_CONTINUE_CHECK;
1347
1348 // --------------------------------------------------------------------------------------------------------
1349 // Parameters Input [Automation]
1350
1351 if (param.port_in)
1352 {
1353 jack_default_audio_sample_t* pin_buffer = (jack_default_audio_sample_t*)jack_port_get_buffer(param.port_in, nframes);
1354
1355 jack_midi_event_t pin_event;
1356 uint32_t n_pin_events = jack_midi_get_event_count(pin_buffer);
1357
1358 for (i=0; i<n_pin_events; i++)
1359 {
1360 if (jack_midi_event_get(&pin_event, pin_buffer, i) != 0)
1361 break;
1362
1363 unsigned char channel = pin_event.buffer[0] & 0x0F;
1364 unsigned char mode = pin_event.buffer[0] & 0xF0;
1365
1366 // Status change
1367 if (mode == 0xB0)
1368 {
1369 unsigned char status = pin_event.buffer[1] & 0x7F;
1370 unsigned char velo = pin_event.buffer[2] & 0x7F;
1371 double value, velo_per = double(velo)/127;
1372
1373 // Control GUI stuff (channel 0 only)
1374 if (channel == 0)
1375 {
1376 if (status == 0x78)
1377 {
1378 // All Sound Off
1379 set_active(false, false, false);
1380 postpone_event(PostEventParameter, PARAMETER_ACTIVE, 0.0);
1381 break;
1382 }
1383 else if (status == 0x09 && hints & PLUGIN_CAN_DRYWET)
1384 {
1385 // Dry/Wet (using '0x09', undefined)
1386 set_drywet(velo_per, false, false);
1387 postpone_event(PostEventParameter, PARAMETER_DRYWET, velo_per);
1388 }
1389 else if (status == 0x07 && hints & PLUGIN_CAN_VOL)
1390 {
1391 // Volume
1392 value = double(velo)/100;
1393 set_vol(value, false, false);
1394 postpone_event(PostEventParameter, PARAMETER_VOLUME, value);
1395 }
1396 else if (status == 0x08 && hints & PLUGIN_CAN_BALANCE)
1397 {
1398 // Balance
1399 double left, right;
1400 value = (double(velo)-63.5)/63.5;
1401
1402 if (value < 0)
1403 {
1404 left = -1.0;
1405 right = (value*2)+1.0;
1406 }
1407 else if (value > 0)
1408 {
1409 left = (value*2)-1.0;
1410 right = 1.0;
1411 }
1412 else
1413 {
1414 left = -1.0;
1415 right = 1.0;
1416 }
1417
1418 set_balance_left(left, false, false);
1419 set_balance_right(right, false, false);
1420 postpone_event(PostEventParameter, PARAMETER_BALANCE_LEFT, left);
1421 postpone_event(PostEventParameter, PARAMETER_BALANCE_RIGHT, right);
1422 }
1423 }
1424
1425 // Control plugin parameters
1426 for (k=0; k < param.count; k++)
1427 {
1428 if (param.data[k].type == PARAMETER_INPUT && (param.data[k].hints & PARAMETER_IS_AUTOMABLE) > 0 &&
1429 param.data[k].midi_channel == channel && param.data[k].midi_cc == status)
1430 {
1431 value = (velo_per * (param.ranges[k].max - param.ranges[k].min)) + param.ranges[k].min;
1432 set_parameter_value(k, value, false, false, false);
1433 postpone_event(PostEventParameter, k, value);
1434 }
1435 }
1436 }
1437 // Program change
1438 else if (mode == 0xC0)
1439 {
1440 unsigned char program = pin_event.buffer[1] & 0x7F;
1441
1442 if (program < prog.count)
1443 {
1444 set_program(program, false, false, false, false);
1445 postpone_event(PostEventProgram, program, 0.0);
1446 }
1447 }
1448 }
1449 } // End of Parameters Input
1450
1451 CARLA_PROCESS_CONTINUE_CHECK;
1452
1453 // --------------------------------------------------------------------------------------------------------
1454 // MIDI Input (External)
1455
1456 if (min.count > 0)
1457 {
1458 carla_midi_lock();
1459
1460 for (i=0; i<MAX_MIDI_EVENTS && midi_event_count < MAX_MIDI_EVENTS; i++)
1461 {
1462 if (ExternalMidiNotes[i].valid)
1463 {
1464 if (ExternalMidiNotes[i].plugin_id == plugin_id)
1465 {
1466 ExternalMidiNote* enote = &ExternalMidiNotes[i];
1467 enote->valid = false;
1468
1469 for (i=0; i < evin.count; i++)
1470 {
1471 if (evin.events[i].type & CARLA_URI_MAP_ID_EVENT_MIDI)
1472 {
1473 uint8_t* midi_event = lv2_event_reserve(&evin_iters[i], 0, 0, CARLA_URI_MAP_ID_EVENT_MIDI, 3);
1474
1475 if (midi_event)
1476 {
1477 midi_event[0] = enote->onoff ? 0x90 : 0x80;
1478 midi_event[1] = enote->note;
1479 midi_event[2] = enote->velo;
1480 }
1481 }
1482 }
1483
1484 midi_event_count += 1;
1485 }
1486 }
1487 else
1488 break;
1489 }
1490 carla_midi_unlock();
1491
1492 } // End of MIDI Input (External)
1493
1494 CARLA_PROCESS_CONTINUE_CHECK;
1495
1496 // --------------------------------------------------------------------------------------------------------
1497 // MIDI Input (JACK)
1498
1499 for (i=0; i < evin.count; i++)
1500 {
1501 if (!evins_buffer[i])
1502 continue;
1503
1504 uint32_t n_min_events = jack_midi_get_event_count(evins_buffer[i]);
1505 jack_midi_event_t min_event;
1506
1507 for (k=0; k<n_min_events && midi_event_count < MAX_MIDI_EVENTS; k++)
1508 {
1509 if (jack_midi_event_get(&min_event, evins_buffer[i], k) != 0)
1510 break;
1511
1512 //unsigned char channel = min_event.buffer[0] & 0x0F;
1513 unsigned char mode = min_event.buffer[0] & 0xF0;
1514 unsigned char note = min_event.buffer[1] & 0x7F;
1515 unsigned char velo = min_event.buffer[2] & 0x7F;
1516
1517 // fix bad note off (GUI only)
1518 if (mode == 0x90 && velo == 0)
1519 {
1520 mode = 0x80;
1521 velo = 64;
1522 }
1523
1524 if (mode == 0x80)
1525 postpone_event(PostEventNoteOff, note, velo);
1526 else if (mode == 0x90)
1527 postpone_event(PostEventNoteOn, note, velo);
1528
1529 lv2_event_write(&evin_iters[i], min_event.time, 0, CARLA_URI_MAP_ID_EVENT_MIDI, min_event.size, min_event.buffer);
1530
1531 midi_event_count += 1;
1532 }
1533 } // End of MIDI Input (JACK)
1534
1535 CARLA_PROCESS_CONTINUE_CHECK;
1536
1537 // --------------------------------------------------------------------------------------------------------
1538 // LV2 Transport
1539
1540 if (wants_time_pos)
1541 {
1542 jack_position_t pos;
1543 jack_transport_state_t state = jack_transport_query(jack_client, &pos);
1544
1545 carla_lv2_time_pos.frame = 0;
1546 carla_lv2_time_pos.flags = 0;
1547 carla_lv2_time_pos.bar = 0;
1548 carla_lv2_time_pos.beat = 0;
1549 carla_lv2_time_pos.tick = 0;
1550 carla_lv2_time_pos.beats_per_bar = 0;
1551 carla_lv2_time_pos.beat_type = 0;
1552 carla_lv2_time_pos.ticks_per_beat = 0;
1553 carla_lv2_time_pos.beats_per_minute = 0.0;
1554
1555 if (state == JackTransportRolling)
1556 carla_lv2_time_pos.state = LV2_TIME_ROLLING;
1557 else
1558 carla_lv2_time_pos.state = LV2_TIME_STOPPED;
1559
1560 if (pos.unique_1 == pos.unique_2)
1561 {
1562 carla_lv2_time_pos.frame = pos.frame;
1563
1564 if (pos.valid & JackPositionBBT)
1565 {
1566 carla_lv2_time_pos.bar = pos.bar;
1567 carla_lv2_time_pos.beat = pos.beat;
1568 carla_lv2_time_pos.tick = pos.tick;
1569 carla_lv2_time_pos.beats_per_bar = pos.beats_per_bar;
1570 carla_lv2_time_pos.beat_type = pos.beat_type;
1571 carla_lv2_time_pos.ticks_per_beat = pos.ticks_per_beat;
1572 carla_lv2_time_pos.beats_per_minute = pos.beats_per_minute;
1573
1574 carla_lv2_time_pos.flags |= LV2_TIME_HAS_BBT;
1575 }
1576 }
1577
1578 for (i=0; i < evin.count; i++)
1579 {
1580 if (evin.events[i].type & CARLA_URI_MAP_ID_EVENT_TIME)
1581 lv2_event_write(&evin_iters[i], 0, 0, CARLA_URI_MAP_ID_EVENT_TIME, sizeof(LV2_Time_Position), (uint8_t*)&carla_lv2_time_pos);
1582 }
1583 }
1584
1585 // End of LV2 Transport
1586
1587 CARLA_PROCESS_CONTINUE_CHECK;
1588
1589 // --------------------------------------------------------------------------------------------------------
1590 // Plugin processing
1591
1592 if (active)
1593 {
1594 if (!active_before)
1595 {
1596 if (descriptor->activate)
1597 descriptor->activate(handle);
1598 }
1599
1600 for (i=0; i < ain.count; i++)
1601 descriptor->connect_port(handle, ain.rindexes[i], ains_buffer[i]);
1602
1603 for (i=0; i < aout.count; i++)
1604 descriptor->connect_port(handle, aout.rindexes[i], aouts_buffer[i]);
1605
1606 if (descriptor->run)
1607 descriptor->run(handle, nframes);
1608 }
1609 else
1610 {
1611 if (active_before)
1612 {
1613 if (descriptor->deactivate)
1614 descriptor->deactivate(handle);
1615 }
1616 }
1617
1618 CARLA_PROCESS_CONTINUE_CHECK;
1619
1620 // --------------------------------------------------------------------------------------------------------
1621 // Post-processing (dry/wet, volume and balance)
1622
1623 if (active)
1624 {
1625 double bal_rangeL, bal_rangeR;
1626 jack_default_audio_sample_t old_bal_left[nframes];
1627
1628 for (i=0; i < aout.count; i++)
1629 {
1630 // Dry/Wet and Volume
1631 for (k=0; k<nframes; k++)
1632 {
1633 if (hints & PLUGIN_CAN_DRYWET && x_drywet != 1.0)
1634 {
1635 if (aout.count == 1)
1636 aouts_buffer[i][k] = (aouts_buffer[i][k]*x_drywet)+(ains_buffer[0][k]*(1.0-x_drywet));
1637 else
1638 aouts_buffer[i][k] = (aouts_buffer[i][k]*x_drywet)+(ains_buffer[i][k]*(1.0-x_drywet));
1639 }
1640
1641 if (hints & PLUGIN_CAN_VOL)
1642 aouts_buffer[i][k] *= x_vol;
1643 }
1644
1645 // Balance
1646 if (hints & PLUGIN_CAN_BALANCE)
1647 {
1648 if (i%2 == 0)
1649 memcpy(&old_bal_left, aouts_buffer[i], sizeof(jack_default_audio_sample_t)*nframes);
1650
1651 bal_rangeL = (x_bal_left+1.0)/2;
1652 bal_rangeR = (x_bal_right+1.0)/2;
1653
1654 for (k=0; k<nframes; k++)
1655 {
1656 if (i%2 == 0)
1657 {
1658 // left output
1659 aouts_buffer[i][k] = old_bal_left[k]*(1.0-bal_rangeL);
1660 aouts_buffer[i][k] += aouts_buffer[i+1][k]*(1.0-bal_rangeR);
1661 }
1662 else
1663 {
1664 // right
1665 aouts_buffer[i][k] = aouts_buffer[i][k]*bal_rangeR;
1666 aouts_buffer[i][k] += old_bal_left[k]*bal_rangeL;
1667 }
1668 }
1669 }
1670
1671 // Output VU
1672 if (i < 2)
1673 {
1674 for (k=0; k<nframes; k++)
1675 {
1676 if (aouts_buffer[i][k] > aouts_peak_tmp[i])
1677 aouts_peak_tmp[i] = aouts_buffer[i][k];
1678 }
1679 }
1680 }
1681 }
1682 else
1683 {
1684 // disable any output sound if not active
1685 for (i=0; i < aout.count; i++)
1686 memset(aouts_buffer[i], 0.0f, sizeof(jack_default_audio_sample_t)*nframes);
1687
1688 aouts_peak_tmp[0] = 0.0;
1689 aouts_peak_tmp[1] = 0.0;
1690
1691 } // End of Post-processing
1692
1693 CARLA_PROCESS_CONTINUE_CHECK;
1694
1695 // --------------------------------------------------------------------------------------------------------
1696 // Control Output
1697
1698 if (param.port_out)
1699 {
1700 jack_default_audio_sample_t* cout_buffer = (jack_default_audio_sample_t*)jack_port_get_buffer(param.port_out, nframes);
1701 jack_midi_clear_buffer(cout_buffer);
1702
1703 double value_per;
1704
1705 for (k=0; k < param.count; k++)
1706 {
1707 if (param.data[k].type == PARAMETER_OUTPUT && param.data[k].midi_cc >= 0)
1708 {
1709 value_per = (param.buffers[k] - param.ranges[k].min)/(param.ranges[k].max - param.ranges[k].min);
1710
1711 jack_midi_data_t* event_buffer = jack_midi_event_reserve(cout_buffer, 0, 3);
1712 event_buffer[0] = 0xB0 + param.data[k].midi_channel;
1713 event_buffer[1] = param.data[k].midi_cc;
1714 event_buffer[2] = 127*value_per;
1715 }
1716 }
1717 } // End of Control Output
1718
1719 CARLA_PROCESS_CONTINUE_CHECK;
1720
1721 // --------------------------------------------------------------------------------------------------------
1722 // MIDI Output
1723
1724 for (i=0; i < evout.count; i++)
1725 {
1726 if (!evouts_buffer[i])
1727 continue;
1728
1729 jack_midi_clear_buffer(evouts_buffer[i]);
1730
1731 LV2_Event* ev;
1732 uint8_t* data;
1733
1734 LV2_Event_Iterator iter;
1735 lv2_event_begin(&iter, evout.events[i].buffer);
1736
1737 for (k=0; k < iter.buf->event_count; k++)
1738 {
1739 ev = lv2_event_get(&iter, &data);
1740 if (ev && data)
1741 jack_midi_event_write(evouts_buffer[i], ev->frames, data, ev->size);
1742
1743 lv2_event_increment(&iter);
1744 }
1745 } // End of MIDI Output
1746
1747 CARLA_PROCESS_CONTINUE_CHECK;
1748
1749 // --------------------------------------------------------------------------------------------------------
1750 // Peak Values
1751
1752 ains_peak[(plugin_id*2)+0] = ains_peak_tmp[0];
1753 ains_peak[(plugin_id*2)+1] = ains_peak_tmp[1];
1754 aouts_peak[(plugin_id*2)+0] = aouts_peak_tmp[0];
1755 aouts_peak[(plugin_id*2)+1] = aouts_peak_tmp[1];
1756
1757 active_before = active;
1758 }
1759
1760 void buffer_size_changed(jack_nframes_t)
1761 {
1762 }
1763
1764 // ----------------- URI-Map Feature -------------------------------------------------
1765 static uint32_t carla_lv2_uri_to_id(LV2_URI_Map_Callback_Data data, const char* map, const char* uri)
1766 {
1767 qDebug("Lv2AudioPlugin::carla_lv2_uri_to_id(%p, %s, %s)", data, map, uri);
1768
1769 if (map && strcmp(map, LV2_EVENT_URI) == 0)
1770 {
1771 // Event types
1772 if (strcmp(uri, "http://lv2plug.in/ns/ext/midi#MidiEvent") == 0)
1773 return CARLA_URI_MAP_ID_EVENT_MIDI;
1774 else if (strcmp(uri, "http://lv2plug.in/ns/ext/time#Position") == 0)
1775 return CARLA_URI_MAP_ID_EVENT_TIME;
1776 }
1777 else if (strcmp(uri, NS_ATOM "String") == 0)
1778 {
1779 return CARLA_URI_MAP_ID_ATOM_STRING;
1780 }
1781
1782 // Custom types
1783 if (data)
1784 {
1785 Lv2AudioPlugin* plugin = (Lv2AudioPlugin*)data;
1786 return plugin->get_custom_uri_id(uri);
1787 }
1788
1789 return 0;
1790 }
1791
1792 // ----------------- URID Feature ----------------------------------------------------
1793 static LV2_URID carla_lv2_urid_map(LV2_URID_Map_Handle handle, const char* uri)
1794 {
1795 qDebug("Lv2AudioPlugin::carla_lv2_urid_map(%p, %s)", handle, uri);
1796
1797 if (strcmp(uri, "http://lv2plug.in/ns/ext/midi#MidiEvent") == 0)
1798 return CARLA_URI_MAP_ID_EVENT_MIDI;
1799 else if (strcmp(uri, "http://lv2plug.in/ns/ext/time#Position") == 0)
1800 return CARLA_URI_MAP_ID_EVENT_TIME;
1801 else if (strcmp(uri, NS_ATOM "String") == 0)
1802 return CARLA_URI_MAP_ID_ATOM_STRING;
1803
1804 // Custom types
1805 if (handle)
1806 {
1807 Lv2AudioPlugin* plugin = (Lv2AudioPlugin*)handle;
1808 return plugin->get_custom_uri_id(uri);
1809 }
1810
1811 return 0;
1812 }
1813
1814 static const char* carla_lv2_urid_unmap(LV2_URID_Map_Handle handle, LV2_URID urid)
1815 {
1816 qDebug("Lv2AudioPlugin::carla_lv2_urid_unmap(%p, %i)", handle, urid);
1817
1818 if (urid == CARLA_URI_MAP_ID_EVENT_MIDI)
1819 return "http://lv2plug.in/ns/ext/midi#MidiEvent";
1820 else if (urid == CARLA_URI_MAP_ID_EVENT_TIME)
1821 return "http://lv2plug.in/ns/ext/time#Position";
1822 else if (urid == CARLA_URI_MAP_ID_ATOM_STRING)
1823 return NS_ATOM "String";
1824
1825 // Custom types
1826 if (handle)
1827 {
1828 Lv2AudioPlugin* plugin = (Lv2AudioPlugin*)handle;
1829 return plugin->get_custom_uri_string(urid);
1830 }
1831
1832 return nullptr;
1833 }
1834
1835 // ----------------- DynParam Feature ------------------------------------------------
1836 static unsigned char carla_lv2_dynparam_group_appear(void* instance_host_context,
1837 void* parent_group_host_context,
1838 lv2dynparam_group_handle group,
1839 const lv2dynparam_hints* hints_ptr,
1840 void** group_host_context)
1841 {
1842 qWarning("Lv2AudioPlugin::carla_lv2_dynparam_group_appear(%p, %p, %p, %p, %p) - %i",
1843 instance_host_context, parent_group_host_context, group, hints_ptr, group_host_context, hints_ptr->count);
1844
1845 for (unsigned char i=0; i < hints_ptr->count; i++)
1846 qWarning("Lv2AudioPlugin::carla_lv2_dynparam_group_appear -> %s | %s", hints_ptr->names[i], hints_ptr->values[i]);
1847
1848 return 1;
1849 }
1850
1851 static unsigned char carla_lv2_dynparam_group_disappear(void* instance_host_context, void* group_host_context)
1852 {
1853 qWarning("Lv2AudioPlugin::carla_lv2_dynparam_group_disappear(%p, %p)", instance_host_context, group_host_context);
1854 return 1;
1855 }
1856
1857 static unsigned char carla_lv2_dynparam_parameter_appear(void* instance_host_context,
1858 void* group_host_context,
1859 lv2dynparam_parameter_handle parameter,
1860 const lv2dynparam_hints* hints_ptr,
1861 void** parameter_host_context)
1862 {
1863 qWarning("Lv2AudioPlugin::carla_lv2_dynparam_parameter_appear(%p, %p, %p, %p, %p) - %i",
1864 instance_host_context, group_host_context, parameter, hints_ptr, parameter_host_context, hints_ptr->count);
1865
1866 for (unsigned char i=0; i < hints_ptr->count; i++)
1867 qWarning("Lv2AudioPlugin::carla_lv2_dynparam_parameter_appear -> %s | %s", hints_ptr->names[i], hints_ptr->values[i]);
1868
1869 return 1;
1870 }
1871
1872 static unsigned char carla_lv2_dynparam_parameter_disappear(void* instance_host_context, void* parameter_host_context)
1873 {
1874 qWarning("Lv2AudioPlugin::carla_lv2_dynparam_parameter_disappear(%p, %p)", instance_host_context, parameter_host_context);
1875 return 1;
1876 }
1877
1878 static unsigned char carla_lv2_dynparam_parameter_change(void* instance_host_context, void* parameter_host_context)
1879 {
1880 qWarning("Lv2AudioPlugin::carla_lv2_dynparam_parameter_change(%p, %p)", instance_host_context, parameter_host_context);
1881 return 1;
1882 }
1883
1884 static unsigned char carla_lv2_dynparam_command_appear(void* instance_host_context,
1885 void* group_host_context,
1886 lv2dynparam_command_handle command,
1887 const lv2dynparam_hints* hints_ptr,
1888 void** command_host_context)
1889 {
1890 qWarning("Lv2AudioPlugin::carla_lv2_dynparam_command_appear(%p, %p, %p, %p, %p)",
1891 instance_host_context, group_host_context, command, hints_ptr, command_host_context);
1892 return 1;
1893 }
1894
1895 static unsigned char carla_lv2_dynparam_command_disappear(void* instance_host_context, void* command_host_context)
1896 {
1897 qWarning("Lv2AudioPlugin::carla_lv2_dynparam_(%p, %p)", instance_host_context, command_host_context);
1898 return 1;
1899 }
1900
1901 // ----------------- Event Feature ---------------------------------------------------
1902 static uint32_t carla_lv2_event_ref(LV2_Event_Callback_Data data, LV2_Event* event)
1903 {
1904 qDebug("Lv2AudioPlugin::carla_lv2_event_ref(%p, %p)", data, event);
1905
1906 // TODO
1907 return 0;
1908 }
1909
1910 static uint32_t carla_lv2_event_unref(LV2_Event_Callback_Data data, LV2_Event* event)
1911 {
1912 qDebug("Lv2AudioPlugin::carla_lv2_event_unref(%p, %p)", data, event);
1913
1914 // TODO
1915 return 0;
1916 }
1917
1918 // ----------------- State Feature ---------------------------------------------------
1919 static int carla_lv2_state_store(LV2_State_Handle handle, uint32_t key, const void* value, size_t size, uint32_t type, uint32_t flags)
1920 {
1921 qDebug("Lv2AudioPlugin::carla_lv2_state_store(%p, %i, %p, " P_SIZE ", %i, %i)", handle, key, value, size, type, flags);
1922
1923 if (handle)
1924 {
1925 Lv2AudioPlugin* plugin = (Lv2AudioPlugin*)handle;
1926 const char* uri_key = plugin->get_custom_uri_string(key);
1927
1928 if (uri_key > 0 && (flags & LV2_STATE_IS_POD) > 0)
1929 {
1930 qDebug("Lv2AudioPlugin::carla_lv2_state_store(%p, %i, %p, " P_SIZE ", %i, %i) - Got uri_key and flags", handle, key, value, size, type, flags);
1931
1932 CustomDataType dtype;
1933
1934 if (type == CARLA_URI_MAP_ID_ATOM_STRING)
1935 dtype = CUSTOM_DATA_STRING;
1936 else if (type >= CARLA_URI_MAP_ID_COUNT)
1937 dtype = CUSTOM_DATA_BINARY;
1938 else
1939 dtype = CUSTOM_DATA_INVALID;
1940
1941 if (value && dtype != CUSTOM_DATA_INVALID)
1942 {
1943 // Check if we already have this key
1944 for (int i=0; i < plugin->custom.count(); i++)
1945 {
1946 if (strcmp(plugin->custom[i].key, uri_key) == 0)
1947 {
1948 free((void*)plugin->custom[i].value);
1949
1950 if (dtype == CUSTOM_DATA_STRING)
1951 plugin->custom[i].value = strdup((const char*)value);
1952 else
1953 {
1954 QByteArray chunk((const char*)value, size);
1955 plugin->custom[i].value = strdup(chunk.toBase64().data());
1956 }
1957
1958 return 0;
1959 }
1960 }
1961
1962 // Add a new one then
1963 CustomData new_data;
1964 new_data.type = dtype;
1965 new_data.key = strdup(uri_key);
1966
1967 if (dtype == CUSTOM_DATA_STRING)
1968 new_data.value = strdup((const char*)value);
1969 else
1970 {
1971 QByteArray chunk((const char*)value, size);
1972 new_data.value = strdup(chunk.toBase64().data());
1973 }
1974
1975 plugin->custom.append(new_data);
1976
1977 return 0;
1978 }
1979 else
1980 qCritical("Lv2AudioPlugin::carla_lv2_state_store(%p, %i, %p, " P_SIZE ", %i, %i) - Invalid data", handle, key, value, size, type, flags);
1981 }
1982 else
1983 qWarning("Lv2AudioPlugin::carla_lv2_state_store(%p, %i, %p, " P_SIZE ", %i, %i) - Invalid attributes", handle, key, value, size, type, flags);
1984 }
1985 else
1986 qCritical("Lv2AudioPlugin::carla_lv2_state_store(%p, %i, %p, " P_SIZE ", %i, %i) - Invalid handle", handle, key, value, size, type, flags);
1987
1988 return 1;
1989 }
1990
1991 static const void* carla_lv2_state_retrieve(LV2_State_Handle handle, uint32_t key, size_t* size, uint32_t* type, uint32_t* flags)
1992 {
1993 qDebug("Lv2AudioPlugin::carla_lv2_state_retrieve(%p, %i, %p, %p, %p)", handle, key, size, type, flags);
1994
1995 if (handle)
1996 {
1997 Lv2AudioPlugin* plugin = (Lv2AudioPlugin*)handle;
1998 const char* uri_key = plugin->get_custom_uri_string(key);
1999
2000 if (uri_key)
2001 {
2002 const char* string_data = nullptr;
2003 CustomDataType dtype = CUSTOM_DATA_INVALID;
2004
2005 for (int i=0; i < plugin->custom.count(); i++)
2006 {
2007 if (strcmp(plugin->custom[i].key, uri_key) == 0)
2008 {
2009 dtype = plugin->custom[i].type;
2010 string_data = plugin->custom[i].value;
2011 break;
2012 }
2013 }
2014
2015 if (string_data)
2016 {
2017 *size = 0;
2018 *type = 0;
2019 *flags = 0;
2020
2021 if (dtype == CUSTOM_DATA_STRING)
2022 {
2023 *type = CARLA_URI_MAP_ID_ATOM_STRING;
2024 return string_data;
2025 }
2026 else if (dtype == CUSTOM_DATA_BINARY)
2027 {
2028 static QByteArray chunk;
2029 chunk = QByteArray::fromBase64(string_data);
2030
2031 *size = chunk.size();
2032 *type = key;
2033 return chunk.data();
2034 }
2035 else
2036 qCritical("Lv2AudioPlugin::carla_lv2_state_retrieve(%p, %i, %p, %p, %p) - Invalid key type", handle, key, size, type, flags);
2037 }
2038 else
2039 qCritical("Lv2AudioPlugin::carla_lv2_state_retrieve(%p, %i, %p, %p, %p) - Invalid key", handle, key, size, type, flags);
2040 }
2041 else
2042 qCritical("Lv2AudioPlugin::carla_lv2_state_retrieve(%p, %i, %p, %p, %p) - Failed to find key", handle, key, size, type, flags);
2043 }
2044 else
2045 qCritical("Lv2AudioPlugin::carla_lv2_state_retrieve(%p, %i, %p, %p, %p) - Invalid handle", handle, key, size, type, flags);
2046
2047 return nullptr;
2048 }
2049
2050 #if 0
2051 static char* carla_lv2_state_get_abstract_path(LV2_State_Map_Path_Handle handle, const char* absolute_path)
2052 {
2053 qDebug("Lv2AudioPlugin::carla_lv2_state_get_abstract_path(%p, %s)", handle, absolute_path);
2054 return strdup("");
2055 }
2056
2057 static char* carla_lv2_state_get_absolute_path(LV2_State_Map_Path_Handle handle, const char* abstract_path)
2058 {
2059 qDebug("Lv2AudioPlugin::carla_lv2_state_get_absolute_path(%p, %s)", handle, abstract_path);
2060 return strdup("");
2061 }
2062
2063 static char* carla_lv2_state_make_path(LV2_State_Make_Path_Handle handle, const char* path)
2064 {
2065 qDebug("Lv2AudioPlugin::carla_lv2_state_make_path(%p, %s)", handle, path);
2066 return strdup("");
2067 }
2068 #endif
2069
2070 // ----------------- External UI Feature ---------------------------------------------
2071 static void carla_lv2_external_ui_closed(LV2UI_Controller controller)
2072 {
2073 qDebug("Lv2AudioPlugin::carla_lv2_external_ui_closed(%p)", controller);
2074
2075 if (controller)
2076 {
2077 Lv2AudioPlugin* plugin = (Lv2AudioPlugin*)controller;
2078 plugin->gui.visible = false;
2079
2080 if (plugin->ui.descriptor->cleanup)
2081 plugin->ui.descriptor->cleanup(plugin->ui.handle);
2082
2083 plugin->ui.handle = nullptr;
2084 callback_action(CALLBACK_SHOW_GUI, plugin->id, 0, 0, 0.0);
2085 }
2086 }
2087
2088 // ----------------- UI Resize Feature -----------------------------------------------
2089 static int carla_lv2_ui_resize(LV2_UI_Resize_Feature_Data data, int width, int height)
2090 {
2091 qDebug("Lv2AudioPlugin::carla_lv2_ui_resized(%p, %i, %i)", data, width, height);
2092
2093 if (data)
2094 {
2095 Lv2AudioPlugin* plugin = (Lv2AudioPlugin*)data;
2096 plugin->gui.width = width;
2097 plugin->gui.height = height;
2098 callback_action(CALLBACK_RESIZE_GUI, plugin->id, width, height, 0.0);
2099 return 0;
2100 }
2101
2102 return 1;
2103 }
2104
2105 // ----------------- UI Extension ----------------------------------------------------
2106 static void carla_lv2_ui_write_function(LV2UI_Controller controller, uint32_t port_index, uint32_t buffer_size, uint32_t format, const void* buffer)
2107 {
2108 qDebug("Lv2AudioPlugin::carla_lv2_ui_write_function(%p, %i, %i, %i, %p)", controller, port_index, buffer_size, format, buffer);
2109
2110 if (controller)
2111 {
2112 Lv2AudioPlugin* plugin = (Lv2AudioPlugin*)controller;
2113
2114 if (format == 0 && buffer_size == sizeof(float))
2115 {
2116 int32_t param_id = -1;
2117 float value = *(float*)buffer;
2118
2119 for (uint32_t i=0; i < plugin->param.count; i++)
2120 {
2121 if (plugin->param.data[i].rindex == (int32_t)port_index)
2122 {
2123 param_id = i; //plugin->param.data[i].index;
2124 break;
2125 }
2126 }
2127
2128 if (param_id > -1) // && plugin->ctrl.data[param_id].type == PARAMETER_INPUT
2129 plugin->set_parameter_value(param_id, value, false, true, true);
2130 }
2131 }
2132 }
2133
2134 bool ui_lib_open(const char* filename)
2135 {
2136 #ifdef __WINDOWS__
2137 ui.lib = LoadLibraryA(filename);
2138 #else
2139 ui.lib = dlopen(filename, RTLD_NOW);
2140 #endif
2141 return bool(ui.lib);
2142 }
2143
2144 bool ui_lib_close()
2145 {
2146 if (ui.lib)
2147 #ifdef __WINDOWS__
2148 return FreeLibrary((HMODULE)ui.lib) != 0;
2149 #else
2150 return dlclose(ui.lib) != 0;
2151 #endif
2152 else
2153 return false;
2154 }
2155
2156 void* ui_lib_symbol(const char* symbol)
2157 {
2158 if (ui.lib)
2159 #ifdef __WINDOWS__
2160 return (void*)GetProcAddress((HMODULE)ui.lib, symbol);
2161 #else
2162 return dlsym(ui.lib, symbol);
2163 #endif
2164 else
2165 return nullptr;
2166 }
2167
2168 const char* ui_lib_error()
2169 {
2170 #ifdef __WINDOWS__
2171 return "Unknown error";
2172 #else
2173 return dlerror();
2174 #endif
2175 }
2176 };
2177
2178 Lv2OscGuiThread::Lv2OscGuiThread(QObject* parent) :
2179 QThread(parent)
2180 {
2181 plugin_id = -1;
2182 ui_type = 0x0;
2183 }
2184
2185 void Lv2OscGuiThread::set_plugin_id(short plugin_id_)
2186 {
2187 plugin_id = plugin_id_;
2188 }
2189
2190 void Lv2OscGuiThread::set_ui_type(LV2_Property ui_type_)
2191 {
2192 ui_type = ui_type_;
2193 }
2194
2195 void Lv2OscGuiThread::run()
2196 {
2197 if (plugin_id < 0 || plugin_id > MAX_PLUGINS)
2198 {
2199 qCritical("Lv2OscGuiThread::run() - invalid plugin id '%i'", plugin_id);
2200 return;
2201 }
2202
2203 Lv2AudioPlugin* plugin = (Lv2AudioPlugin*)AudioPlugins[plugin_id];
2204
2205 if (!plugin)
2206 {
2207 qCritical("Lv2OscGuiThread::run() - invalid plugin");
2208 return;
2209 }
2210
2211 if (plugin->id != plugin_id)
2212 {
2213 qCritical("Lv2OscGuiThread::run() - plugin mismatch '%i'' != '%i'", plugin->id, plugin_id);
2214 return;
2215 }
2216
2217 const char* bridge_bin = nullptr;
2218
2219 switch(ui_type)
2220 {
2221 case LV2_UI_X11:
2222 bridge_bin = carla_options.bridge_path_lv2_x11;
2223 break;
2224 case LV2_UI_GTK2:
2225 bridge_bin = carla_options.bridge_path_lv2_gtk2;
2226 break;
2227 case LV2_UI_QT4:
2228 bridge_bin = carla_options.bridge_path_lv2_qt4;
2229 break;
2230 default:
2231 qCritical("Lv2OscGuiThread::run() - invalid UI Type");
2232 return;
2233 }
2234
2235 QString cmd = QString("%1 '%2' '%3 (GUI)' '%4' '%5' '%6' '%7/%8' %9").arg(bridge_bin).arg(plugin->descriptor->URI).arg(plugin->name).arg(plugin->ui.descriptor->URI).arg(
2236 plugin->ui.rdf_descriptor->Binary).arg(plugin->ui.rdf_descriptor->Bundle).arg(get_host_osc_url()).arg(plugin_id).arg(plugin->is_ui_resizable() ? "true" : "false");
2237
2238 qDebug("Lv2OscGuiThread::run() - command: %s", cmd.toStdString().data());
2239
2240 int ret;
2241
2242 while (plugin && plugin->id == plugin_id && carla_is_engine_running())
2243 {
2244 if (plugin->gui.show_now)
2245 {
2246 ret = system(cmd.toStdString().data());
2247 plugin->gui.visible = false;
2248 plugin->gui.show_now = false;
2249
2250 if (ret == 0)
2251 {
2252 // Hide
2253 callback_action(CALLBACK_SHOW_GUI, plugin_id, 0, 0, 0.0);
2254 }
2255 else
2256 {
2257 // Kill
2258 callback_action(CALLBACK_SHOW_GUI, plugin_id, -1, 0, 0.0);
2259 qWarning("Lv2OscGuiThread::run() - LV2 OSC GUI crashed");
2260 break;
2261 }
2262 }
2263 else
2264 sleep(1);
2265 }
2266
2267 if (plugin->gui.name)
2268 free((void*)plugin->gui.name);
2269
2270 plugin->gui.name = nullptr;
2271 plugin->gui.visible = false;
2272 }
2273
2274 short add_plugin_lv2(const char* filename, const char* label, void* extra_stuff)
2275 {
2276 qDebug("add_plugin_lv2(%s, %s, %p)", filename, label, extra_stuff);
2277
2278 int id = get_new_plugin_id();
2279
2280 if (id >= 0)
2281 {
2282 LV2_RDF_Descriptor* rdf_descriptor = (LV2_RDF_Descriptor*)extra_stuff;
2283
2284 if (rdf_descriptor)
2285 {
2286 Lv2AudioPlugin* plugin = new Lv2AudioPlugin;
2287
2288 if ((plugin->lib_open(rdf_descriptor->Binary)))
2289 {
2290 LV2_Descriptor_Function descfn = (LV2_Descriptor_Function)plugin->lib_symbol("lv2_descriptor");
2291
2292 if (descfn)
2293 {
2294 uint32_t i = 0;
2295 while ((plugin->descriptor = descfn(i++)))
2296 {
2297 if (strcmp(plugin->descriptor->URI, label) == 0)
2298 break;
2299 }
2300
2301 if (plugin->descriptor)
2302 {
2303 bool can_continue = true;
2304
2305 // Check supported ports
2306 for (i=0; i < rdf_descriptor->PortCount; i++)
2307 {
2308 LV2_Property PortType = rdf_descriptor->Ports[i].Type;
2309 if (!LV2_IS_PORT_AUDIO(PortType) && !LV2_IS_PORT_CONTROL(PortType) && !LV2_IS_PORT_CV(PortType) && !LV2_IS_PORT_EVENT(PortType))
2310 {
2311 if (!LV2_IS_PORT_OPTIONAL(rdf_descriptor->Ports[i].Properties))
2312 {
2313 set_last_error("Plugin requires a port that is not currently supported");
2314 can_continue = false;
2315 break;
2316 }
2317 }
2318 }
2319
2320 // Check supported features
2321 for (i=0; i < rdf_descriptor->FeatureCount; i++)
2322 {
2323 if (is_lv2_feature_supported(rdf_descriptor->Features[i].URI) == false)
2324 {
2325 if (LV2_IS_FEATURE_REQUIRED(rdf_descriptor->Features[i].Type))
2326 {
2327 QString msg = QString("Plugin requires a feature that is not supported:\n%1").arg(rdf_descriptor->Features[i].URI);
2328 set_last_error(msg.toStdString().data());
2329 can_continue = false;
2330 break;
2331 }
2332 else
2333 qDebug("Plugin wants a feature that is not supported:\n%s", rdf_descriptor->Features[i].URI);
2334 }
2335 }
2336
2337 // Check extensions
2338 for (i=0; i < rdf_descriptor->ExtensionCount; i++)
2339 {
2340 if (strcmp(rdf_descriptor->Extensions[i], LV2_STATE_INTERFACE_URI) == 0)
2341 plugin->hints |= PLUGIN_HAS_EXTENSION_STATE;
2342 else if (strcmp(rdf_descriptor->Extensions[i], LV2DYNPARAM_URI) == 0)
2343 plugin->hints |= PLUGIN_HAS_EXTENSION_DYNPARAM;
2344 else
2345 qDebug("Plugin has non-supported extension: '%s'", rdf_descriptor->Extensions[i]);
2346 }
2347
2348 if (can_continue)
2349 {
2350 // Initialize features
2351 LV2_URI_Map_Feature* URI_Map_Feature = new LV2_URI_Map_Feature;
2352 URI_Map_Feature->callback_data = plugin;
2353 URI_Map_Feature->uri_to_id = plugin->carla_lv2_uri_to_id;
2354
2355 LV2_URID_Map* URID_Map_Feature = new LV2_URID_Map;
2356 URID_Map_Feature->handle = plugin;
2357 URID_Map_Feature->map = plugin->carla_lv2_urid_map;
2358
2359 LV2_URID_Unmap* URID_Unmap_Feature = new LV2_URID_Unmap;
2360 URID_Unmap_Feature->handle = plugin;
2361 URID_Unmap_Feature->unmap = plugin->carla_lv2_urid_unmap;
2362
2363 LV2_Event_Feature* Event_Feature = new LV2_Event_Feature;
2364 Event_Feature->callback_data = plugin;
2365 Event_Feature->lv2_event_ref = plugin->carla_lv2_event_ref;
2366 Event_Feature->lv2_event_unref = plugin->carla_lv2_event_unref;
2367
2368 #if 0
2369 LV2_State_Map_Path* State_Map_Path_Feature = new LV2_State_Map_Path;
2370 State_Map_Path_Feature->handle = plugin;
2371 State_Map_Path_Feature->abstract_path = plugin->carla_lv2_state_get_abstract_path;
2372 State_Map_Path_Feature->absolute_path = plugin->carla_lv2_state_get_absolute_path;
2373
2374 LV2_State_Make_Path* State_Make_Path_Feature = new LV2_State_Make_Path;
2375 State_Make_Path_Feature->handle = plugin;
2376 State_Make_Path_Feature->path = plugin->carla_lv2_state_make_path;
2377 #endif
2378
2379 plugin->features[lv2_feature_id_uri_map] = new LV2_Feature;
2380 plugin->features[lv2_feature_id_uri_map]->URI = LV2_URI_MAP_URI;
2381 plugin->features[lv2_feature_id_uri_map]->data = URI_Map_Feature;
2382
2383 plugin->features[lv2_feature_id_urid_map] = new LV2_Feature;
2384 plugin->features[lv2_feature_id_urid_map]->URI = LV2_URID_MAP_URI;
2385 plugin->features[lv2_feature_id_urid_map]->data = URID_Map_Feature;
2386
2387 plugin->features[lv2_feature_id_urid_unmap] = new LV2_Feature;
2388 plugin->features[lv2_feature_id_urid_unmap]->URI = LV2_URID_UNMAP_URI;
2389 plugin->features[lv2_feature_id_urid_unmap]->data = URID_Unmap_Feature;
2390
2391 plugin->features[lv2_feature_id_event] = new LV2_Feature;
2392 plugin->features[lv2_feature_id_event]->URI = LV2_EVENT_URI;
2393 plugin->features[lv2_feature_id_event]->data = Event_Feature;
2394
2395 /* initialize rtsafe mempool host feature */
2396 rtmempool_allocator_init(&plugin->rtmempool_allocator);
2397
2398 plugin->features[lv2_feature_id_rtmempool] = new LV2_Feature;
2399 plugin->features[lv2_feature_id_rtmempool]->URI = LV2_RTSAFE_MEMORY_POOL_URI;
2400 plugin->features[lv2_feature_id_rtmempool]->data = &plugin->rtmempool_allocator;
2401
2402 #if 0
2403 plugin->features[lv2_feature_id_state_map_path] = new LV2_Feature;
2404 plugin->features[lv2_feature_id_state_map_path]->URI = LV2_STATE_MAP_PATH_URI;
2405 plugin->features[lv2_feature_id_state_map_path]->data = State_Map_Path_Feature;
2406
2407 plugin->features[lv2_feature_id_state_make_path] = new LV2_Feature;
2408 plugin->features[lv2_feature_id_state_make_path]->URI = LV2_STATE_MAKE_PATH_URI;
2409 plugin->features[lv2_feature_id_state_make_path]->data = State_Make_Path_Feature;
2410 #endif
2411
2412 plugin->handle = plugin->descriptor->instantiate(plugin->descriptor, get_sample_rate(), rdf_descriptor->Bundle, plugin->features);
2413
2414 if (plugin->handle)
2415 {
2416 plugin->name = get_unique_name(rdf_descriptor->Name);
2417 plugin->filename = strdup(filename);
2418
2419 plugin->rdf_descriptor = lv2_rdf_dup(rdf_descriptor);
2420
2421 if (carla_options.global_jack_client)
2422 plugin->jack_client = carla_jack_client;
2423 else
2424 carla_jack_register_plugin(plugin);
2425
2426 if (plugin->jack_client)
2427 {
2428 plugin->reload();
2429
2430 plugin->id = id;
2431 unique_names[id] = plugin->name;
2432 AudioPlugins[id] = plugin;
2433
2434 // ----------------- GUI Stuff -------------------------------------------------------
2435
2436 uint32_t UICount = plugin->rdf_descriptor->UICount;
2437
2438 if (UICount > 0)
2439 {
2440 // Find more appropriate UI (Qt4 -> X11 -> Gtk2 -> External, use bridges whenever possible)
2441 int eQt4, eX11, eGtk2, iX11, iQt4, iExt, iFinal;
2442 eQt4 = eX11 = eGtk2 = iQt4 = iX11 = iExt = iFinal = -1;
2443
2444 for (i=0; i < UICount; i++)
2445 {
2446 switch(plugin->rdf_descriptor->UIs[i].Type)
2447 {
2448 case LV2_UI_QT4:
2449 if (plugin->is_ui_bridgeable(i))
2450 eQt4 = i;
2451 else
2452 iQt4 = i;
2453 break;
2454
2455 case LV2_UI_X11:
2456 if (plugin->is_ui_bridgeable(i))
2457 eX11 = i;
2458 else
2459 iX11 = i;
2460 break;
2461
2462 case LV2_UI_GTK2:
2463 eGtk2 = i;
2464 break;
2465
2466 case LV2_UI_EXTERNAL:
2467 case LV2_UI_OLD_EXTERNAL:
2468 iExt = i;
2469 break;
2470
2471 default:
2472 break;
2473 }
2474 }
2475
2476 if (eQt4 >= 0)
2477 iFinal = eQt4;
2478 else if (eX11 >= 0)
2479 iFinal = eX11;
2480 else if (eGtk2 >= 0)
2481 iFinal = eGtk2;
2482 else if (iQt4 >= 0)
2483 iFinal = iQt4;
2484 else if (iX11 >= 0)
2485 iFinal = iX11;
2486 else if (iExt >= 0)
2487 iFinal = iExt;
2488
2489 bool is_bridged = (iFinal == eQt4 || iFinal == eX11 || iFinal == eGtk2);
2490
2491 // Use proper UI now
2492 if (iFinal >= 0)
2493 {
2494 plugin->ui.rdf_descriptor = &plugin->rdf_descriptor->UIs[iFinal];
2495
2496 // Check supported UI features
2497 can_continue = true;
2498
2499 for (i=0; i < plugin->ui.rdf_descriptor->FeatureCount; i++)
2500 {
2501 if (is_lv2_ui_feature_supported(plugin->ui.rdf_descriptor->Features[i].URI) == false)
2502 {
2503 if (LV2_IS_FEATURE_REQUIRED(plugin->ui.rdf_descriptor->Features[i].Type))
2504 {
2505 qCritical("Plugin requires a feature that is not supported:\n%s", plugin->ui.rdf_descriptor->Features[i].URI);
2506 can_continue = false;
2507 break;
2508 }
2509 else
2510 qDebug("UI wants a feature that is not supported:\n%s", plugin->ui.rdf_descriptor->Features[i].URI);
2511 }
2512 }
2513
2514 if (can_continue)
2515 {
2516 if ((plugin->ui_lib_open(plugin->ui.rdf_descriptor->Binary)))
2517 {
2518 LV2UI_DescriptorFunction ui_descfn = (LV2UI_DescriptorFunction)plugin->ui_lib_symbol("lv2ui_descriptor");
2519
2520 if (ui_descfn)
2521 {
2522 i = 0;
2523 while ((plugin->ui.descriptor = ui_descfn(i++)))
2524 {
2525 if (strcmp(plugin->ui.descriptor->URI, plugin->ui.rdf_descriptor->URI) == 0)
2526 break;
2527 }
2528
2529 if (plugin->ui.descriptor)
2530 {
2531 // UI Window Title
2532 char gui_name[strlen(plugin->name)+7];
2533 sprintf(gui_name, "%s (GUI)", plugin->name);
2534 plugin->gui.name = strdup(gui_name);
2535
2536 LV2_Property UiType = plugin->ui.rdf_descriptor->Type;
2537
2538 if (is_bridged)
2539 {
2540 Lv2OscGuiThread* lv2_thread = new Lv2OscGuiThread();
2541 lv2_thread->set_plugin_id(plugin->id);
2542 lv2_thread->set_ui_type(UiType);
2543 lv2_thread->start();
2544
2545 plugin->gui.type = GUI_EXTERNAL_OSC;
2546 plugin->osc.thread = lv2_thread;
2547
2548 switch (UiType)
2549 {
2550 case LV2_UI_QT4:
2551 qDebug("Will use LV2 Qt4 UI, bridged");
2552 break;
2553
2554 case LV2_UI_X11:
2555 qDebug("Will use LV2 X11 UI, bridged");
2556 break;
2557
2558 case LV2_UI_GTK2:
2559 qDebug("Will use LV2 Gtk2 UI, bridged");
2560 break;
2561
2562 default:
2563 qDebug("Will use LV2 Unknown UI, bridged");
2564 break;
2565 }
2566 }
2567 else
2568 {
2569 // Initialize UI features
2570 LV2_Extension_Data_Feature* UI_Data_Feature = new LV2_Extension_Data_Feature;
2571 UI_Data_Feature->data_access = plugin->descriptor->extension_data;
2572
2573 LV2_UI_Resize_Feature* UI_Resize_Feature = new LV2_UI_Resize_Feature;
2574 UI_Resize_Feature->data = plugin;
2575 UI_Resize_Feature->ui_resize = plugin->carla_lv2_ui_resize;
2576
2577 lv2_external_ui_host* External_UI_Feature = new lv2_external_ui_host;
2578 External_UI_Feature->ui_closed = plugin->carla_lv2_external_ui_closed;
2579 External_UI_Feature->plugin_human_id = plugin->gui.name;
2580
2581 plugin->features[lv2_feature_id_data_access] = new LV2_Feature;
2582 plugin->features[lv2_feature_id_data_access]->URI = LV2_DATA_ACCESS_URI;
2583 plugin->features[lv2_feature_id_data_access]->data = UI_Data_Feature;
2584
2585 plugin->features[lv2_feature_id_instance_access] = new LV2_Feature;
2586 plugin->features[lv2_feature_id_instance_access]->URI = LV2_INSTANCE_ACCESS_URI;
2587 plugin->features[lv2_feature_id_instance_access]->data = plugin->handle;
2588
2589 plugin->features[lv2_feature_id_ui_resize] = new LV2_Feature;
2590 plugin->features[lv2_feature_id_ui_resize]->URI = LV2_UI_RESIZE_URI "#UIResize";
2591 plugin->features[lv2_feature_id_ui_resize]->data = UI_Resize_Feature;
2592
2593 plugin->features[lv2_feature_id_ui_parent] = new LV2_Feature;
2594 plugin->features[lv2_feature_id_ui_parent]->URI = LV2_UI_URI "#parent";
2595 plugin->features[lv2_feature_id_ui_parent]->data = nullptr;
2596
2597 plugin->features[lv2_feature_id_external_ui] = new LV2_Feature;
2598 plugin->features[lv2_feature_id_external_ui]->URI = LV2_EXTERNAL_UI_URI;
2599 plugin->features[lv2_feature_id_external_ui]->data = External_UI_Feature;
2600
2601 plugin->features[lv2_feature_id_external_ui_old] = new LV2_Feature;
2602 plugin->features[lv2_feature_id_external_ui_old]->URI = LV2_EXTERNAL_UI_DEPRECATED_URI;
2603 plugin->features[lv2_feature_id_external_ui_old]->data = External_UI_Feature;
2604
2605 switch (UiType)
2606 {
2607 case LV2_UI_QT4:
2608 qDebug("Will use LV2 Qt4 UI");
2609 plugin->gui.type = GUI_INTERNAL_QT4;
2610 plugin->gui.resizable = plugin->is_ui_resizable();
2611
2612 plugin->ui.handle = plugin->ui.descriptor->instantiate(plugin->ui.descriptor,
2613 plugin->descriptor->URI,
2614 plugin->ui.rdf_descriptor->Bundle,
2615 plugin->carla_lv2_ui_write_function,
2616 plugin,
2617 &plugin->ui.widget,
2618 plugin->features);
2619
2620 if (plugin->ui.handle && plugin->ui.descriptor->port_event)
2621 plugin->update_ui_ports();
2622
2623 break;
2624
2625 case LV2_UI_X11:
2626 qDebug("Will use LV2 X11 UI");
2627 plugin->gui.type = GUI_INTERNAL_X11;
2628 plugin->gui.resizable = plugin->is_ui_resizable();
2629 break;
2630
2631 case LV2_UI_GTK2:
2632 qDebug("Will use LV2 Gtk2 UI, NOT!");
2633 break;
2634
2635 case LV2_UI_EXTERNAL:
2636 case LV2_UI_OLD_EXTERNAL:
2637 qDebug("Will use LV2 External UI");
2638 plugin->gui.type = GUI_EXTERNAL_LV2;
2639 break;
2640
2641 default:
2642 break;
2643 }
2644 }
2645 }
2646 else
2647 {
2648 qCritical("Could not find the requested GUI in the plugin UI library");
2649 plugin->ui_lib_close();
2650 plugin->ui.lib = nullptr;
2651 plugin->ui.descriptor = nullptr;
2652 plugin->ui.rdf_descriptor = nullptr;
2653 }
2654 }
2655 else
2656 {
2657 qCritical("Could not find the LV2UI Descriptor in the UI library");
2658 plugin->ui_lib_close();
2659 plugin->ui.lib = nullptr;
2660 plugin->ui.rdf_descriptor = nullptr;
2661 }
2662 }
2663 else
2664 {
2665 qCritical("Could not load UI library, error was: \n%s", plugin->ui_lib_error());
2666 plugin->ui.lib = nullptr;
2667 }
2668 }
2669 else
2670 {
2671 // Some UI Feature not supported
2672 plugin->ui.lib = nullptr;
2673 plugin->ui.rdf_descriptor = nullptr;
2674 }
2675 }
2676 else
2677 qWarning("Failed to find an appropriate LV2 UI for this plugin");
2678 }
2679
2680 // ----------------- End of GUI Stuff ------------------------------------------------
2681
2682 if (plugin->gui.type != GUI_NONE)
2683 plugin->hints |= PLUGIN_HAS_GUI;
2684
2685 osc_new_plugin(plugin);
2686 }
2687 else
2688 {
2689 set_last_error("Failed to register plugin in JACK");
2690 delete plugin;
2691 id = -1;
2692 }
2693 }
2694 else
2695 {
2696 set_last_error("Plugin failed to initialize");
2697 delete plugin;
2698 id = -1;
2699 }
2700 }
2701 else
2702 {
2703 delete plugin;
2704 id = -1;
2705 }
2706 }
2707 else
2708 {
2709 set_last_error("Could not find the requested plugin URI in the plugin library");
2710 delete plugin;
2711 id = -1;
2712 }
2713 }
2714 else
2715 {
2716 set_last_error("Could not find the LV2 Descriptor in the plugin library");
2717 delete plugin;
2718 id = -1;
2719 }
2720 }
2721 else
2722 {
2723 set_last_error(plugin->lib_error());
2724 delete plugin;
2725 id = -1;
2726 }
2727 }
2728 else
2729 {
2730 set_last_error("Failed to find the requested plugin in the LV2 Bundle");
2731 id = -1;
2732 }
2733 }
2734 else
2735 set_last_error("Maximum number of plugins reached");
2736
2737 return id;
2738 }
Cadence is a set of tools useful for Audio-related tasks, using Python and Qt