?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Rename a pipe method, add docs
[carla.git] / source / bridges-plugin / CarlaBridgeSingleLV2.cpp
blob9de0e5652f73ff95390d58f64f5c4a4306204e38
1 /*
2 * Carla LV2 Single Plugin
3 * Copyright (C) 2017-2022 Filipe Coelho <falktx@falktx.com>
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
7 * published by the Free Software Foundation; either version 2 of
8 * the License, or any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * For a full copy of the GNU General Public License see the doc/GPL.txt file.
16 */
17
18 #ifndef BUILD_BRIDGE
19 # error This file should not be compiled if not building bridge
20 #endif
21
22 #include "engine/CarlaEngineInternal.hpp"
23 #include "CarlaPlugin.hpp"
24
25 #include "CarlaBackendUtils.hpp"
26 #include "CarlaEngineUtils.hpp"
27 #include "CarlaLv2Utils.hpp"
28 #include "CarlaUtils.h"
29
30 #include "water/files/File.h"
31
32 #ifdef USING_JUCE
33 # include "carla_juce/carla_juce.h"
34 #endif
35
36 template<>
37 void Lv2PluginBaseClass<CARLA_BACKEND_NAMESPACE::EngineTimeInfo>::clearTimeData() noexcept
38 {
39 fLastPositionData.clear();
40 fTimeInfo.clear();
41 }
42
43 // --------------------------------------------------------------------------------------------------------------------
44
45 CARLA_BACKEND_START_NAMESPACE
46
47 class CarlaEngineSingleLV2 : public CarlaEngine,
48 public Lv2PluginBaseClass<EngineTimeInfo>
49 {
50 public:
51 CarlaEngineSingleLV2(const double sampleRate,
52 const char* const bundlePath,
53 const LV2_Feature* const* const features)
54 : Lv2PluginBaseClass<EngineTimeInfo>(sampleRate, features),
55 fPlugin(nullptr)
56 #ifdef USING_JUCE
57 , fJuceInitialiser()
58 #endif
59 {
60 CARLA_SAFE_ASSERT_RETURN(pData->curPluginCount == 0,)
61 CARLA_SAFE_ASSERT_RETURN(pData->plugins == nullptr,);
62
63 if (! loadedInProperHost())
64 return;
65
66 // xxxxx
67 CarlaString binaryDir(bundlePath);
68 binaryDir += CARLA_OS_SEP_STR "bin" CARLA_OS_SEP_STR;
69
70 CarlaString resourceDir(bundlePath);
71 resourceDir += CARLA_OS_SEP_STR "res" CARLA_OS_SEP_STR;
72
73 pData->bufferSize = fBufferSize;
74 pData->sampleRate = sampleRate;
75 pData->initTime(nullptr);
76
77 pData->options.processMode = ENGINE_PROCESS_MODE_BRIDGE;
78 pData->options.transportMode = ENGINE_TRANSPORT_MODE_PLUGIN;
79 pData->options.forceStereo = false;
80 pData->options.preferPluginBridges = false;
81 pData->options.preferUiBridges = false;
82 init("LV2-Export");
83
84 if (pData->options.resourceDir != nullptr)
85 delete[] pData->options.resourceDir;
86 if (pData->options.binaryDir != nullptr)
87 delete[] pData->options.binaryDir;
88
89 pData->options.binaryDir = binaryDir.dup();
90 pData->options.resourceDir = resourceDir.dup();
91
92 setCallback(_engine_callback, this);
93
94 using water::File;
95 const File pluginFile(File::getSpecialLocation(File::currentExecutableFile).withFileExtension("xml"));
96
97 if (! loadProject(pluginFile.getFullPathName().toRawUTF8(), true))
98 {
99 carla_stderr2("Failed to init plugin, possible reasons: %s", getLastError());
100 return;
101 }
102
103 CARLA_SAFE_ASSERT_RETURN(pData->curPluginCount == 1,)
104
105 fPlugin = pData->plugins[0].plugin;
106 CARLA_SAFE_ASSERT_RETURN(fPlugin.get() != nullptr,);
107 CARLA_SAFE_ASSERT_RETURN(fPlugin->isEnabled(),);
108
109 fPorts.hasUI = false;
110 fPorts.usesTime = true;
111 fPorts.numAudioIns = fPlugin->getAudioInCount();
112 fPorts.numAudioOuts = fPlugin->getAudioOutCount();
113 fPorts.numCVIns = fPlugin->getCVInCount();
114 fPorts.numCVOuts = fPlugin->getCVOutCount();
115 fPorts.numMidiIns = fPlugin->getMidiInCount();
116 fPorts.numMidiOuts = fPlugin->getMidiOutCount();
117 fPorts.numParams = fPlugin->getParameterCount();
118
119 fPorts.init();
120
121 for (uint32_t i=0; i < fPorts.numParams; ++i)
122 {
123 fPorts.paramsLast[i] = fPlugin->getParameterValue(i);
124 fPorts.paramsOut [i] = fPlugin->isParameterOutput(i);
125 }
126 }
127
128 ~CarlaEngineSingleLV2()
129 {
130 if (fPlugin.get() != nullptr && fIsActive)
131 fPlugin->setActive(false, false, false);
132
133 fPlugin.reset();
134 close();
135 }
136
137 bool hasPlugin() noexcept
138 {
139 return fPlugin.get() != nullptr;
140 }
141
142 // ----------------------------------------------------------------------------------------------------------------
143 // LV2 functions
144
145 void lv2_activate() noexcept
146 {
147 CARLA_SAFE_ASSERT_RETURN(! fIsActive,);
148
149 resetTimeInfo();
150
151 fPlugin->setActive(true, false, false);
152 fIsActive = true;
153 }
154
155 void lv2_deactivate() noexcept
156 {
157 CARLA_SAFE_ASSERT_RETURN(fIsActive,);
158
159 fIsActive = false;
160 fPlugin->setActive(false, false, false);
161 }
162
163 void lv2_run(const uint32_t frames)
164 {
165 //const PendingRtEventsRunner prt(this, frames);
166
167 if (! lv2_pre_run(frames))
168 {
169 updateParameterOutputs();
170 return;
171 }
172
173 if (fPorts.numMidiIns > 0)
174 {
175 uint32_t engineEventIndex = 0;
176 carla_zeroStructs(pData->events.in, kMaxEngineEventInternalCount);
177
178 for (uint32_t i=0; i < fPorts.numMidiIns; ++i)
179 {
180 LV2_ATOM_SEQUENCE_FOREACH(fPorts.eventsIn[i], event)
181 {
182 if (event == nullptr)
183 continue;
184 if (event->body.type != fURIs.midiEvent)
185 continue;
186 if (event->body.size > 4)
187 continue;
188 if (event->time.frames >= frames)
189 break;
190
191 const uint8_t* const data((const uint8_t*)(event + 1));
192
193 EngineEvent& engineEvent(pData->events.in[engineEventIndex++]);
194
195 engineEvent.time = (uint32_t)event->time.frames;
196 engineEvent.fillFromMidiData((uint8_t)event->body.size, data, (uint8_t)i);
197
198 if (engineEventIndex >= kMaxEngineEventInternalCount)
199 break;
200 }
201 }
202 }
203
204 if (fPorts.numMidiOuts > 0)
205 {
206 carla_zeroStructs(pData->events.out, kMaxEngineEventInternalCount);
207 }
208
209 if (fPlugin->tryLock(fIsOffline))
210 {
211 fPlugin->initBuffers();
212 fPlugin->process(fPorts.audioCVIns,
213 fPorts.audioCVOuts,
214 fPorts.audioCVIns + fPorts.numAudioIns,
215 fPorts.audioCVOuts + fPorts.numAudioOuts,
216 frames);
217 fPlugin->unlock();
218
219 if (fPorts.numMidiOuts > 0)
220 {
221 uint8_t port = 0;
222 uint8_t size = 0;
223 uint8_t mdata[3] = { 0, 0, 0 };
224 uint8_t mdataTmp[EngineMidiEvent::kDataSize];
225 const uint8_t* mdataPtr;
226
227 for (ushort i=0; i < kMaxEngineEventInternalCount; ++i)
228 {
229 const EngineEvent& engineEvent(pData->events.out[i]);
230
231 /**/ if (engineEvent.type == kEngineEventTypeNull)
232 {
233 break;
234 }
235 else if (engineEvent.type == kEngineEventTypeControl)
236 {
237 const EngineControlEvent& ctrlEvent(engineEvent.ctrl);
238
239 size = ctrlEvent.convertToMidiData(engineEvent.channel, mdata);
240 mdataPtr = mdata;
241 }
242 else if (engineEvent.type == kEngineEventTypeMidi)
243 {
244 const EngineMidiEvent& midiEvent(engineEvent.midi);
245
246 port = midiEvent.port;
247 size = midiEvent.size;
248 CARLA_SAFE_ASSERT_CONTINUE(size > 0);
249
250 if (size > EngineMidiEvent::kDataSize)
251 {
252 CARLA_SAFE_ASSERT_CONTINUE(midiEvent.dataExt != nullptr);
253 mdataPtr = midiEvent.dataExt;
254 }
255 else
256 {
257 // set first byte
258 mdataTmp[0] = static_cast<uint8_t>(midiEvent.data[0] | (engineEvent.channel & MIDI_CHANNEL_BIT));
259
260 // copy rest
261 carla_copy<uint8_t>(mdataTmp+1, midiEvent.data+1, size-1U);
262
263 // done
264 mdataPtr = mdataTmp;
265 }
266 }
267 else
268 {
269 continue;
270 }
271
272 if (size > 0 && ! writeMidiEvent(port, engineEvent.time, size, mdataPtr))
273 break;
274 }
275 }
276 }
277 else
278 {
279 for (uint32_t i=0; i<fPorts.numAudioOuts; ++i)
280 carla_zeroFloats(fPorts.audioCVOuts[i], frames);
281 for (uint32_t i=0; i<fPorts.numCVOuts; ++i)
282 carla_zeroFloats(fPorts.audioCVOuts[fPorts.numAudioOuts+i], frames);
283 }
284
285 lv2_post_run(frames);
286 updateParameterOutputs();
287
288 }
289
290 // ----------------------------------------------------------------------------------------------------------------
291
292 bool lv2ui_instantiate(LV2UI_Write_Function writeFunction, LV2UI_Controller controller,
293 LV2UI_Widget* widget, const LV2_Feature* const* features)
294 {
295 fUI.writeFunction = writeFunction;
296 fUI.controller = controller;
297 fUI.host = nullptr;
298
299 const LV2_URID_Map* uridMap = nullptr;
300
301 // ------------------------------------------------------------------------------------------------------------
302 // see if the host supports external-ui, get uridMap
303
304 for (int i=0; features[i] != nullptr; ++i)
305 {
306 if (std::strcmp(features[i]->URI, LV2_EXTERNAL_UI__Host) == 0 ||
307 std::strcmp(features[i]->URI, LV2_EXTERNAL_UI_DEPRECATED_URI) == 0)
308 {
309 fUI.host = (const LV2_External_UI_Host*)features[i]->data;
310 }
311 else if (std::strcmp(features[i]->URI, LV2_URID__map) == 0)
312 {
313 uridMap = (const LV2_URID_Map*)features[i]->data;
314 }
315 }
316
317 if (fUI.host != nullptr)
318 {
319 fPlugin->setCustomUITitle(fUI.host->plugin_human_id);
320 *widget = (LV2_External_UI_Widget_Compat*)this;
321 return true;
322 }
323
324 // ------------------------------------------------------------------------------------------------------------
325 // no external-ui support, use showInterface
326
327 const char* uiTitle = nullptr;
328
329 for (int i=0; features[i] != nullptr; ++i)
330 {
331 if (std::strcmp(features[i]->URI, LV2_OPTIONS__options) == 0)
332 {
333 const LV2_Options_Option* const options((const LV2_Options_Option*)features[i]->data);
334
335 for (int j=0; options[j].key != 0; ++j)
336 {
337 if (options[j].key == uridMap->map(uridMap->handle, LV2_UI__windowTitle))
338 {
339 uiTitle = (const char*)options[j].value;
340 break;
341 }
342 }
343 break;
344 }
345 }
346
347 if (uiTitle == nullptr)
348 uiTitle = fPlugin->getName();
349
350 fPlugin->setCustomUITitle(uiTitle);
351 *widget = nullptr;
352 return true;
353 }
354
355 void lv2ui_port_event(uint32_t portIndex, uint32_t bufferSize, uint32_t format, const void* buffer) const
356 {
357 if (format != 0 || bufferSize != sizeof(float) || buffer == nullptr)
358 return;
359 if (portIndex >= fPorts.indexOffset || ! fUI.isVisible)
360 return;
361
362 const float value(*(const float*)buffer);
363 fPlugin->uiParameterChange(portIndex-fPorts.indexOffset, value);
364 }
365
366 protected:
367 // ----------------------------------------------------------------------------------------------------------------
368 // CarlaEngine virtual calls
369
370 bool init(const char* const clientName) override
371 {
372 carla_stdout("CarlaEngineNative::init(\"%s\")", clientName);
373
374 if (! pData->init(clientName))
375 {
376 close();
377 setLastError("Failed to init internal data");
378 return false;
379 }
380
381 return true;
382 }
383
384 bool hasIdleOnMainThread() const noexcept override
385 {
386 return false;
387 }
388
389 bool isRunning() const noexcept override
390 {
391 return fIsActive;
392 }
393
394 bool isOffline() const noexcept override
395 {
396 return fIsOffline;
397 }
398
399 bool usesConstantBufferSize() const noexcept override
400 {
401 return false;
402 }
403
404 EngineType getType() const noexcept override
405 {
406 return kEngineTypePlugin;
407 }
408
409 const char* getCurrentDriverName() const noexcept override
410 {
411 return "LV2 Plugin";
412 }
413
414 void engineCallback(const EngineCallbackOpcode action, const uint pluginId,
415 const int value1, const int value2, const int value3,
416 const float valuef, const char* const valueStr)
417 {
418 switch (action)
419 {
420 case ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED:
421 if (value1 == PARAMETER_ACTIVE)
422 return;
423 CARLA_SAFE_ASSERT_RETURN(value1 >= 0,);
424 if (fUI.writeFunction != nullptr && fUI.controller != nullptr && fUI.isVisible)
425 {
426 fUI.writeFunction(fUI.controller,
427 static_cast<uint32_t>(value1)+fPorts.indexOffset,
428 sizeof(float), 0, &valuef);
429 }
430 break;
431
432 case ENGINE_CALLBACK_UI_STATE_CHANGED:
433 fUI.isVisible = (value1 == 1);
434 if (fUI.host != nullptr)
435 fUI.host->ui_closed(fUI.controller);
436 break;
437
438 case ENGINE_CALLBACK_IDLE:
439 break;
440
441 default:
442 carla_stdout("engineCallback(%i:%s, %u, %i, %i, %f, %s)",
443 action, EngineCallbackOpcode2Str(action), pluginId,
444 value1, value2, value3,
445 static_cast<double>(valuef), valueStr);
446 break;
447 }
448 }
449
450 // ----------------------------------------------------------------------------------------------------------------
451
452 void handleUiRun() const override
453 {
454 try {
455 fPlugin->uiIdle();
456 } CARLA_SAFE_EXCEPTION("fPlugin->uiIdle()")
457 }
458
459 void handleUiShow() override
460 {
461 fPlugin->showCustomUI(true);
462 fUI.isVisible = true;
463 }
464
465 void handleUiHide() override
466 {
467 fUI.isVisible = false;
468 fPlugin->showCustomUI(false);
469 }
470
471 // ----------------------------------------------------------------------------------------------------------------
472
473 void handleParameterValueChanged(const uint32_t index, const float value) override
474 {
475 fPlugin->setParameterValue(index, value, false, false, false);
476 }
477
478 void handleBufferSizeChanged(const uint32_t bufferSize) override
479 {
480 CarlaEngine::bufferSizeChanged(bufferSize);
481 }
482
483 void handleSampleRateChanged(const double sampleRate) override
484 {
485 CarlaEngine::sampleRateChanged(sampleRate);
486 }
487
488 // ----------------------------------------------------------------------------------------------------------------
489
490 private:
491 CarlaPluginPtr fPlugin;
492
493 #ifdef USING_JUCE
494 CarlaJUCE::ScopedJuceInitialiser_GUI fJuceInitialiser;
495 #endif
496
497 void updateParameterOutputs() noexcept
498 {
499 float value;
500
501 for (uint32_t i=0; i < fPorts.numParams; ++i)
502 {
503 if (! fPorts.paramsOut[i])
504 continue;
505
506 fPorts.paramsLast[i] = value = fPlugin->getParameterValue(i);
507
508 if (fPorts.paramsPtr[i] != nullptr)
509 *fPorts.paramsPtr[i] = value;
510 }
511 }
512
513 bool writeMidiEvent(const uint8_t port, const uint32_t time, const uint8_t midiSize, const uint8_t* midiData)
514 {
515 CARLA_SAFE_ASSERT_RETURN(fPorts.numMidiOuts > 0, false);
516 CARLA_SAFE_ASSERT_RETURN(port < fPorts.numMidiOuts, false);
517 CARLA_SAFE_ASSERT_RETURN(midiData != nullptr, false);
518 CARLA_SAFE_ASSERT_RETURN(midiSize > 0, false);
519
520 LV2_Atom_Sequence* const seq(fPorts.eventsOut[port]);
521 CARLA_SAFE_ASSERT_RETURN(seq != nullptr, false);
522
523 Ports::EventsOutData& mData(fPorts.eventsOutData[port]);
524
525 if (sizeof(LV2_Atom_Event) + midiSize > mData.capacity - mData.offset)
526 return false;
527
528 LV2_Atom_Event* const aev = (LV2_Atom_Event*)(LV2_ATOM_CONTENTS(LV2_Atom_Sequence, seq) + mData.offset);
529
530 aev->time.frames = time;
531 aev->body.size = midiSize;
532 aev->body.type = fURIs.midiEvent;
533 std::memcpy(LV2_ATOM_BODY(&aev->body), midiData, midiSize);
534
535 const uint32_t size = lv2_atom_pad_size(static_cast<uint32_t>(sizeof(LV2_Atom_Event) + midiSize));
536 mData.offset += size;
537 seq->atom.size += size;
538
539 return true;
540 }
541
542 // -------------------------------------------------------------------
543
544 #define handlePtr ((CarlaEngineSingleLV2*)handle)
545
546 static void _engine_callback(void* handle, EngineCallbackOpcode action, uint pluginId,
547 int value1, int value2, int value3,
548 float valuef, const char* valueStr)
549 {
550 handlePtr->engineCallback(action, pluginId, value1, value2, value3, valuef, valueStr);
551 }
552
553 #undef handlePtr
554
555 CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineSingleLV2)
556 };
557
558 CARLA_BACKEND_END_NAMESPACE
559
560 using CARLA_BACKEND_NAMESPACE::CarlaEngineSingleLV2;
561
562 // --------------------------------------------------------------------------------------------------------------------
563 // LV2 DSP functions
564
565 static LV2_Handle lv2_instantiate(const LV2_Descriptor* lv2Descriptor, double sampleRate, const char* bundlePath, const LV2_Feature* const* features)
566 {
567 carla_stdout("lv2_instantiate(%p, %g, %s, %p)", lv2Descriptor, sampleRate, bundlePath, features);
568
569 CarlaEngineSingleLV2* const instance(new CarlaEngineSingleLV2(sampleRate, bundlePath, features));
570
571 if (instance->hasPlugin())
572 return (LV2_Handle)instance;
573
574 delete instance;
575 return nullptr;
576 }
577
578 #define instancePtr ((CarlaEngineSingleLV2*)instance)
579
580 static void lv2_connect_port(LV2_Handle instance, uint32_t port, void* dataLocation)
581 {
582 instancePtr->lv2_connect_port(port, dataLocation);
583 }
584
585 static void lv2_activate(LV2_Handle instance)
586 {
587 carla_debug("lv2_activate(%p)", instance);
588 instancePtr->lv2_activate();
589 }
590
591 static void lv2_run(LV2_Handle instance, uint32_t sampleCount)
592 {
593 instancePtr->lv2_run(sampleCount);
594 }
595
596 static void lv2_deactivate(LV2_Handle instance)
597 {
598 carla_debug("lv2_deactivate(%p)", instance);
599 instancePtr->lv2_deactivate();
600 }
601
602 static void lv2_cleanup(LV2_Handle instance)
603 {
604 carla_debug("lv2_cleanup(%p)", instance);
605 delete instancePtr;
606 }
607
608 static const void* lv2_extension_data(const char* uri)
609 {
610 carla_debug("lv2_extension_data(\"%s\")", uri);
611 return nullptr;
612
613 // unused
614 (void)uri;
615 }
616
617 #undef instancePtr
618
619 // --------------------------------------------------------------------------------------------------------------------
620 // LV2 UI functions
621
622 static LV2UI_Handle lv2ui_instantiate(const LV2UI_Descriptor*, const char*, const char*,
623 LV2UI_Write_Function writeFunction, LV2UI_Controller controller,
624 LV2UI_Widget* widget, const LV2_Feature* const* features)
625 {
626 carla_debug("lv2ui_instantiate(..., %p, %p, %p)", writeFunction, controller, widget, features);
627
628 CarlaEngineSingleLV2* engine = nullptr;
629
630 for (int i=0; features[i] != nullptr; ++i)
631 {
632 if (std::strcmp(features[i]->URI, LV2_INSTANCE_ACCESS_URI) == 0)
633 {
634 engine = (CarlaEngineSingleLV2*)features[i]->data;
635 break;
636 }
637 }
638
639 if (engine == nullptr)
640 {
641 carla_stderr("Host doesn't support instance-access, cannot show UI");
642 return nullptr;
643 }
644
645 if (! engine->lv2ui_instantiate(writeFunction, controller, widget, features))
646 return nullptr;
647
648 return (LV2UI_Handle)engine;
649 }
650
651 #define uiPtr ((CarlaEngineSingleLV2*)ui)
652
653 static void lv2ui_port_event(LV2UI_Handle ui, uint32_t portIndex, uint32_t bufferSize, uint32_t format, const void* buffer)
654 {
655 uiPtr->lv2ui_port_event(portIndex, bufferSize, format, buffer);
656 }
657
658 static void lv2ui_cleanup(LV2UI_Handle ui)
659 {
660 carla_debug("lv2ui_cleanup(%p)", ui);
661 uiPtr->lv2ui_cleanup();
662 }
663
664 static int lv2ui_idle(LV2UI_Handle ui)
665 {
666 return uiPtr->lv2ui_idle();
667 }
668
669 static int lv2ui_show(LV2UI_Handle ui)
670 {
671 carla_debug("lv2ui_show(%p)", ui);
672 return uiPtr->lv2ui_show();
673 }
674
675 static int lv2ui_hide(LV2UI_Handle ui)
676 {
677 carla_debug("lv2ui_hide(%p)", ui);
678 return uiPtr->lv2ui_hide();
679 }
680
681 static const void* lv2ui_extension_data(const char* uri)
682 {
683 carla_debug("lv2ui_extension_data(\"%s\")", uri);
684
685 static const LV2UI_Idle_Interface uiidle = { lv2ui_idle };
686 static const LV2UI_Show_Interface uishow = { lv2ui_show, lv2ui_hide };
687
688 if (std::strcmp(uri, LV2_UI__idleInterface) == 0)
689 return &uiidle;
690 if (std::strcmp(uri, LV2_UI__showInterface) == 0)
691 return &uishow;
692
693 return nullptr;
694 }
695
696 #undef uiPtr
697
698 // --------------------------------------------------------------------------------------------------------------------
699 // Startup code
700
701 CARLA_PLUGIN_EXPORT
702 const LV2_Descriptor* lv2_descriptor(uint32_t index)
703 {
704 carla_debug("lv2_descriptor(%i)", index);
705
706 if (index != 0)
707 return nullptr;
708
709 static CarlaString ret;
710
711 if (ret.isEmpty())
712 {
713 using namespace water;
714 const File file(File::getSpecialLocation(File::currentExecutableFile).withFileExtension("ttl"));
715 #ifdef CARLA_OS_WIN
716 ret = String("file:///" + file.getFullPathName()).toRawUTF8();
717 ret.replace('\\','/');
718 #else
719 ret = String("file://" + file.getFullPathName()).toRawUTF8();
720 #endif
721 }
722
723 carla_stdout("lv2_descriptor(%i) has URI '%s'", index, ret.buffer());
724
725 static const LV2_Descriptor desc = {
726 /* URI */ ret.buffer(),
727 /* instantiate */ lv2_instantiate,
728 /* connect_port */ lv2_connect_port,
729 /* activate */ lv2_activate,
730 /* run */ lv2_run,
731 /* deactivate */ lv2_deactivate,
732 /* cleanup */ lv2_cleanup,
733 /* extension_data */ lv2_extension_data
734 };
735
736 return &desc;
737 }
738
739 CARLA_PLUGIN_EXPORT
740 const LV2UI_Descriptor* lv2ui_descriptor(uint32_t index)
741 {
742 carla_debug("lv2ui_descriptor(%i)", index);
743
744 static CarlaString ret;
745
746 {
747 using namespace water;
748 const File file(File::getSpecialLocation(File::currentExecutableFile).getSiblingFile("ext-ui"));
749 #ifdef CARLA_OS_WIN
750 ret = String("file:///" + file.getFullPathName()).toRawUTF8();
751 ret.replace('\\','/');
752 #else
753 ret = String("file://" + file.getFullPathName()).toRawUTF8();
754 #endif
755 }
756
757 carla_stdout("lv2ui_descriptor(%i) has URI '%s'", index, ret.buffer());
758
759 static const LV2UI_Descriptor lv2UiExtDesc = {
760 /* URI */ ret.buffer(),
761 /* instantiate */ lv2ui_instantiate,
762 /* cleanup */ lv2ui_cleanup,
763 /* port_event */ lv2ui_port_event,
764 /* extension_data */ lv2ui_extension_data
765 };
766
767 return (index == 0) ? &lv2UiExtDesc : nullptr;
768 }
769
770 // --------------------------------------------------------------------------------------------------------------------