?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Implement LV2 ControlInputPort change request feature
[carla.git] / source / backend / plugin / CarlaPluginLADSPADSSI.cpp
blobfa2ad19352c56d542567fa952bcfa19e32380557
1 /*
2 * Carla Plugin, LADSPA/DSSI implementation
3 * Copyright (C) 2011-2023 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 #include "CarlaPluginInternal.hpp"
19 #include "CarlaEngineUtils.hpp"
20
21 #include "CarlaBackendUtils.hpp"
22 #include "CarlaLadspaUtils.hpp"
23 #include "CarlaDssiUtils.hpp"
24 #include "CarlaMathUtils.hpp"
25
26 #if defined(HAVE_LIBLO) && !defined(BUILD_BRIDGE) && !defined(CARLA_OS_WASM)
27 # define CARLA_ENABLE_DSSI_PLUGIN_GUI
28 # include "CarlaOscUtils.hpp"
29 # include "CarlaScopeUtils.hpp"
30 # include "CarlaThread.hpp"
31 # include "water/threads/ChildProcess.h"
32 using water::ChildProcess;
33 #endif
34
35 using water::String;
36 using water::StringArray;
37
38 #define CARLA_PLUGIN_DSSI_OSC_CHECK_OSC_TYPES(/* argc, types, */ argcToCompare, typesToCompare) \
39 /* check argument count */ \
40 if (argc != argcToCompare) \
41 { \
42 carla_stderr("CarlaPluginLADSPADSSI::%s() - argument count mismatch: %i != %i", \
43 __FUNCTION__, argc, argcToCompare); \
44 return; \
45 } \
46 if (argc > 0) \
47 { \
48 /* check for nullness */ \
49 if (types == nullptr || typesToCompare == nullptr) \
50 { \
51 carla_stderr("CarlaPluginLADSPADSSI::%s() - argument types are null", \
52 __FUNCTION__); \
53 return; \
54 } \
55 /* check argument types */ \
56 if (std::strcmp(types, typesToCompare) != 0) \
57 { \
58 carla_stderr("CarlaPluginLADSPADSSI::%s() - argument types mismatch: '%s' != '%s'", \
59 __FUNCTION__, types, typesToCompare); \
60 return; \
61 } \
62 }
63
64 CARLA_BACKEND_START_NAMESPACE
65
66 #ifdef CARLA_ENABLE_DSSI_PLUGIN_GUI
67 // -------------------------------------------------------------------
68 // Fallback data
69
70 static const CustomData kCustomDataFallback = { nullptr, nullptr, nullptr };
71
72 // -------------------------------------------------------------------
73
74 class CarlaThreadDSSIUI : public CarlaThread
75 {
76 public:
77 CarlaThreadDSSIUI(CarlaEngine* const engine, CarlaPlugin* const plugin, const CarlaOscData& oscData) noexcept
78 : CarlaThread("CarlaThreadDSSIUI"),
79 kEngine(engine),
80 kPlugin(plugin),
81 fBinary(),
82 fLabel(),
83 fUiTitle(),
84 fOscData(oscData),
85 fProcess() {}
86
87 void setData(const char* const binary, const char* const label, const char* const uiTitle) noexcept
88 {
89 CARLA_SAFE_ASSERT_RETURN(binary != nullptr && binary[0] != '\0',);
90 CARLA_SAFE_ASSERT_RETURN(label != nullptr,);
91 CARLA_SAFE_ASSERT_RETURN(uiTitle != nullptr && uiTitle[0] != '\0',);
92 CARLA_SAFE_ASSERT(! isThreadRunning());
93
94 fBinary = binary;
95 fLabel = label;
96 fUiTitle = uiTitle;
97
98 if (fLabel.isEmpty())
99 fLabel = "\"\"";
100 }
101
102 void setUITitle(const char* const uiTitle) noexcept
103 {
104 CARLA_SAFE_ASSERT_RETURN(uiTitle != nullptr && uiTitle[0] != '\0',);
105
106 fUiTitle = uiTitle;
107 }
108
109 uintptr_t getProcessId() const noexcept
110 {
111 CARLA_SAFE_ASSERT_RETURN(fProcess != nullptr, 0);
112
113 return (uintptr_t)fProcess->getPID();
114 }
115
116 void run()
117 {
118 carla_stdout("LADSPA/DSSI UI thread started");
119
120 if (fProcess == nullptr)
121 {
122 fProcess = new ChildProcess();
123 }
124 else if (fProcess->isRunning())
125 {
126 carla_stderr("CarlaThreadDSSI::run() - already running, giving up...");
127
128 fProcess->kill();
129 fProcess = nullptr;
130 kEngine->callback(true, true,
131 ENGINE_CALLBACK_UI_STATE_CHANGED,
132 kPlugin->getId(),
133 0,
134 0, 0, 0.0f, nullptr);
135 return;
136 }
137
138 String name(kPlugin->getName());
139 String filename(kPlugin->getFilename());
140
141 if (name.isEmpty())
142 name = "(none)";
143
144 if (filename.isEmpty())
145 filename = "\"\"";
146
147 StringArray arguments;
148
149 // binary
150 arguments.add(fBinary.buffer());
151
152 // osc-url
153 arguments.add(String(kEngine->getOscServerPathUDP()) + String("/") + String(kPlugin->getId()));
154
155 // filename
156 arguments.add(filename);
157
158 // label
159 arguments.add(fLabel.buffer());
160
161 // ui-title
162 arguments.add(fUiTitle.buffer());
163
164 bool started;
165
166 {
167 #ifdef CARLA_OS_LINUX
168 /*
169 * If the frontend uses winId parent, set LD_PRELOAD to auto-map the DSSI UI.
170 * If not, unset LD_PRELOAD.
171 */
172 const uintptr_t winId(kEngine->getOptions().frontendWinId);
173
174 // for CARLA_ENGINE_OPTION_FRONTEND_WIN_ID
175 char winIdStr[STR_MAX+1];
176 winIdStr[STR_MAX] = '\0';
177
178 // for LD_PRELOAD
179 CarlaString ldPreloadValue;
180
181 if (winId != 0)
182 {
183 std::snprintf(winIdStr, STR_MAX, P_UINTPTR, winId);
184 ldPreloadValue = (CarlaString(kEngine->getOptions().binaryDir)
185 + "/libcarla_interposer-x11.so");
186 }
187 else
188 {
189 winIdStr[0] = '\0';
190 }
191
192 const ScopedEngineEnvironmentLocker _seel(kEngine);
193 const CarlaScopedEnvVar _sev1("CARLA_ENGINE_OPTION_FRONTEND_WIN_ID", winIdStr[0] != '\0' ? winIdStr : nullptr);
194 const CarlaScopedEnvVar _sev2("LD_PRELOAD", ldPreloadValue.isNotEmpty() ? ldPreloadValue.buffer() : nullptr);
195 #endif // CARLA_OS_LINUX
196
197 // start the DSSI UI application
198 carla_stdout("starting DSSI UI...");
199 started = fProcess->start(arguments);
200 }
201
202 if (! started)
203 {
204 carla_stdout("failed!");
205 fProcess = nullptr;
206 return;
207 }
208
209 if (waitForOscGuiShow())
210 {
211 for (; fProcess->isRunning() && ! shouldThreadExit();)
212 carla_sleep(1);
213
214 // we only get here if UI was closed or thread asked to exit
215 if (fProcess->isRunning() && shouldThreadExit())
216 {
217 fProcess->waitForProcessToFinish(static_cast<int>(kEngine->getOptions().uiBridgesTimeout));
218
219 if (fProcess->isRunning())
220 {
221 carla_stdout("CarlaThreadDSSIUI::run() - UI refused to close, force kill now");
222 fProcess->kill();
223 }
224 else
225 {
226 carla_stdout("CarlaThreadDSSIUI::run() - UI auto-closed successfully");
227 }
228 }
229 else if (fProcess->getExitCodeAndClearPID() != 0)
230 carla_stderr("CarlaThreadDSSIUI::run() - UI crashed while running");
231 else
232 carla_stdout("CarlaThreadDSSIUI::run() - UI closed cleanly");
233 }
234 else
235 {
236 fProcess->kill();
237 carla_stdout("CarlaThreadDSSIUI::run() - GUI timeout");
238 }
239
240 fProcess = nullptr;
241 kEngine->callback(true, true,
242 ENGINE_CALLBACK_UI_STATE_CHANGED,
243 kPlugin->getId(),
244 0,
245 0, 0, 0.0f, nullptr);
246
247 carla_stdout("LADSPA/DSSI UI thread finished");
248 }
249
250 private:
251 CarlaEngine* const kEngine;
252 CarlaPlugin* const kPlugin;
253
254 CarlaString fBinary;
255 CarlaString fLabel;
256 CarlaString fUiTitle;
257
258 const CarlaOscData& fOscData;
259 CarlaScopedPointer<ChildProcess> fProcess;
260
261 bool waitForOscGuiShow()
262 {
263 carla_stdout("CarlaThreadDSSIUI::waitForOscGuiShow()");
264 const uint uiBridgesTimeout = kEngine->getOptions().uiBridgesTimeout;
265
266 // wait for UI 'update' call
267 for (uint i=0; i < uiBridgesTimeout/100; ++i)
268 {
269 if (fOscData.target != nullptr)
270 {
271 carla_stdout("CarlaThreadDSSIUI::waitForOscGuiShow() - got response, asking UI to show itself now");
272 osc_send_show(fOscData);
273 return true;
274 }
275
276 if (fProcess != nullptr && fProcess->isRunning() && ! shouldThreadExit())
277 carla_msleep(100);
278 else
279 return false;
280 }
281
282 carla_stdout("CarlaThreadDSSIUI::waitForOscGuiShow() - Timeout while waiting for UI to respond"
283 "(waited %u msecs)", uiBridgesTimeout);
284 return false;
285 }
286
287 CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaThreadDSSIUI)
288 };
289 #endif
290
291 // -----------------------------------------------------
292
293 class CarlaPluginLADSPADSSI : public CarlaPlugin
294 {
295 public:
296 CarlaPluginLADSPADSSI(CarlaEngine* const engine, const uint id) noexcept
297 : CarlaPlugin(engine, id),
298 fHandles(),
299 fDescriptor(nullptr),
300 fDssiDescriptor(nullptr),
301 fRdfDescriptor(nullptr),
302 fAudioInBuffers(nullptr),
303 fAudioOutBuffers(nullptr),
304 fExtraStereoBuffer(),
305 fParamBuffers(nullptr),
306 fLatencyIndex(-1),
307 fForcedStereoIn(false),
308 fForcedStereoOut(false),
309 fNeedsFixedBuffers(false),
310 fUsesCustomData(false)
311 #ifdef CARLA_ENABLE_DSSI_PLUGIN_GUI
312 , fOscData(),
313 fThreadUI(engine, this, fOscData),
314 fUiFilename(nullptr)
315 #endif
316 {
317 carla_debug("CarlaPluginLADSPADSSI::CarlaPluginLADSPADSSI(%p, %i)", engine, id);
318
319 carla_zeroPointers(fExtraStereoBuffer, 2);
320 }
321
322 ~CarlaPluginLADSPADSSI() noexcept override
323 {
324 carla_debug("CarlaPluginLADSPADSSI::~CarlaPluginLADSPADSSI()");
325
326 #ifdef CARLA_ENABLE_DSSI_PLUGIN_GUI
327 // close UI
328 if (fUiFilename != nullptr)
329 {
330 showCustomUI(false);
331
332 delete[] fUiFilename;
333 fUiFilename = nullptr;
334 }
335 #endif
336
337 pData->singleMutex.lock();
338 pData->masterMutex.lock();
339
340 if (pData->client != nullptr && pData->client->isActive())
341 pData->client->deactivate(true);
342
343 if (pData->active)
344 {
345 deactivate();
346 pData->active = false;
347 }
348
349 if (fDescriptor != nullptr)
350 {
351 if (fDescriptor->cleanup != nullptr)
352 {
353 for (LinkedList<LADSPA_Handle>::Itenerator it = fHandles.begin2(); it.valid(); it.next())
354 {
355 LADSPA_Handle const handle(it.getValue(nullptr));
356 CARLA_SAFE_ASSERT_CONTINUE(handle != nullptr);
357
358 try {
359 fDescriptor->cleanup(handle);
360 } CARLA_SAFE_EXCEPTION("LADSPA/DSSI cleanup");
361 }
362 }
363
364 fHandles.clear();
365 fDescriptor = nullptr;
366 fDssiDescriptor = nullptr;
367 }
368
369 if (fRdfDescriptor != nullptr)
370 {
371 delete fRdfDescriptor;
372 fRdfDescriptor = nullptr;
373 }
374
375 clearBuffers();
376 }
377
378 // -------------------------------------------------------------------
379 // Information (base)
380
381 PluginType getType() const noexcept override
382 {
383 return fDssiDescriptor != nullptr ? PLUGIN_DSSI : PLUGIN_LADSPA;
384 }
385
386 PluginCategory getCategory() const noexcept override
387 {
388 if (fRdfDescriptor != nullptr)
389 {
390 const LADSPA_RDF_PluginType category = fRdfDescriptor->Type;
391
392 // Specific Types
393 if (category & (LADSPA_RDF_PLUGIN_DELAY|LADSPA_RDF_PLUGIN_REVERB))
394 return PLUGIN_CATEGORY_DELAY;
395 if (category & (LADSPA_RDF_PLUGIN_PHASER|LADSPA_RDF_PLUGIN_FLANGER|LADSPA_RDF_PLUGIN_CHORUS))
396 return PLUGIN_CATEGORY_MODULATOR;
397 if (category & (LADSPA_RDF_PLUGIN_AMPLIFIER))
398 return PLUGIN_CATEGORY_DYNAMICS;
399 if (category & (LADSPA_RDF_PLUGIN_UTILITY|LADSPA_RDF_PLUGIN_SPECTRAL|LADSPA_RDF_PLUGIN_FREQUENCY_METER))
400 return PLUGIN_CATEGORY_UTILITY;
401
402 // Pre-set LADSPA Types
403 if (LADSPA_RDF_IS_PLUGIN_DYNAMICS(category))
404 return PLUGIN_CATEGORY_DYNAMICS;
405 if (LADSPA_RDF_IS_PLUGIN_AMPLITUDE(category))
406 return PLUGIN_CATEGORY_MODULATOR;
407 if (LADSPA_RDF_IS_PLUGIN_EQ(category))
408 return PLUGIN_CATEGORY_EQ;
409 if (LADSPA_RDF_IS_PLUGIN_FILTER(category))
410 return PLUGIN_CATEGORY_FILTER;
411 if (LADSPA_RDF_IS_PLUGIN_FREQUENCY(category))
412 return PLUGIN_CATEGORY_UTILITY;
413 if (LADSPA_RDF_IS_PLUGIN_SIMULATOR(category))
414 return PLUGIN_CATEGORY_OTHER;
415 if (LADSPA_RDF_IS_PLUGIN_TIME(category))
416 return PLUGIN_CATEGORY_DELAY;
417 if (LADSPA_RDF_IS_PLUGIN_GENERATOR(category))
418 return PLUGIN_CATEGORY_SYNTH;
419 }
420
421 if (fDssiDescriptor != nullptr && fDssiDescriptor->run_synth != nullptr)
422 if (pData->audioIn.count == 0 && pData->audioOut.count > 0)
423 return PLUGIN_CATEGORY_SYNTH;
424
425 return CarlaPlugin::getCategory();
426 }
427
428 int64_t getUniqueId() const noexcept override
429 {
430 CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr, 0);
431
432 return static_cast<int64_t>(fDescriptor->UniqueID);
433 }
434
435 uint32_t getLatencyInFrames() const noexcept override
436 {
437 if (fLatencyIndex < 0 || fParamBuffers == nullptr)
438 return 0;
439
440 const float latency(fParamBuffers[fLatencyIndex]);
441 CARLA_SAFE_ASSERT_RETURN(latency >= 0.0f, 0);
442
443 return static_cast<uint32_t>(latency);
444 }
445
446 // -------------------------------------------------------------------
447 // Information (count)
448
449 uint32_t getParameterScalePointCount(const uint32_t parameterId) const noexcept override
450 {
451 CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, 0);
452
453 if (fRdfDescriptor == nullptr)
454 return 0;
455
456 const int32_t rindex(pData->param.data[parameterId].rindex);
457 CARLA_SAFE_ASSERT_RETURN(rindex >= 0, 0);
458
459 if (rindex >= static_cast<int32_t>(fRdfDescriptor->PortCount))
460 return 0;
461
462 const LADSPA_RDF_Port& port(fRdfDescriptor->Ports[rindex]);
463 return static_cast<uint32_t>(port.ScalePointCount);
464 }
465
466 // -------------------------------------------------------------------
467 // Information (current data)
468
469 std::size_t getChunkData(void** const dataPtr) noexcept override
470 {
471 CARLA_SAFE_ASSERT_RETURN(fUsesCustomData, 0);
472 CARLA_SAFE_ASSERT_RETURN(pData->options & PLUGIN_OPTION_USE_CHUNKS, 0);
473 CARLA_SAFE_ASSERT_RETURN(fDssiDescriptor != nullptr, 0);
474 CARLA_SAFE_ASSERT_RETURN(fDssiDescriptor->get_custom_data != nullptr, 0);
475 CARLA_SAFE_ASSERT_RETURN(fHandles.count() > 0, 0);
476 CARLA_SAFE_ASSERT_RETURN(dataPtr != nullptr, 0);
477
478 *dataPtr = nullptr;
479
480 int ret = 0;
481 ulong dataSize = 0;
482
483 try {
484 ret = fDssiDescriptor->get_custom_data(fHandles.getFirst(nullptr), dataPtr, &dataSize);
485 } CARLA_SAFE_EXCEPTION_RETURN("CarlaPluginLADSPADSSI::getChunkData", 0);
486
487 return (ret != 0) ? dataSize : 0;
488 }
489
490 // -------------------------------------------------------------------
491 // Information (per-plugin data)
492
493 uint getOptionsAvailable() const noexcept override
494 {
495 uint options = 0x0;
496
497 // can't disable fixed buffers if using latency
498 if (fLatencyIndex == -1 && ! fNeedsFixedBuffers)
499 options |= PLUGIN_OPTION_FIXED_BUFFERS;
500
501 // can't disable forced stereo if enabled in the engine
502 if (pData->engine->getOptions().forceStereo)
503 pass();
504 // if inputs or outputs are just 1, then yes we can force stereo
505 else if (pData->audioIn.count == 1 || pData->audioOut.count == 1 || fForcedStereoIn || fForcedStereoOut)
506 options |= PLUGIN_OPTION_FORCE_STEREO;
507
508 if (fDssiDescriptor != nullptr)
509 {
510 if (fDssiDescriptor->get_program != nullptr && fDssiDescriptor->select_program != nullptr)
511 options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;
512
513 if (fUsesCustomData)
514 options |= PLUGIN_OPTION_USE_CHUNKS;
515
516 if (fDssiDescriptor->run_synth != nullptr)
517 {
518 options |= PLUGIN_OPTION_SEND_CONTROL_CHANGES;
519 options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;
520 options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;
521 options |= PLUGIN_OPTION_SEND_PITCHBEND;
522 options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;
523 options |= PLUGIN_OPTION_SKIP_SENDING_NOTES;
524 }
525 }
526
527 return options;
528 }
529
530 float getParameterValue(const uint32_t parameterId) const noexcept override
531 {
532 CARLA_SAFE_ASSERT_RETURN(fParamBuffers != nullptr, 0.0f);
533 CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, 0.0f);
534
535 // bad plugins might have set output values out of bounds
536 if (pData->param.data[parameterId].type == PARAMETER_OUTPUT)
537 return pData->param.ranges[parameterId].getFixedValue(fParamBuffers[parameterId]);
538
539 // not output, should be fine
540 return fParamBuffers[parameterId];
541 }
542
543 float getParameterScalePointValue(const uint32_t parameterId, const uint32_t scalePointId) const noexcept override
544 {
545 CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr, 0.0f);
546 CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, 0.0f);
547
548 const int32_t rindex(pData->param.data[parameterId].rindex);
549 CARLA_SAFE_ASSERT_RETURN(rindex >= 0, 0.0f);
550 CARLA_SAFE_ASSERT_RETURN(rindex < static_cast<int32_t>(fRdfDescriptor->PortCount), 0.0f);
551
552 const LADSPA_RDF_Port& port(fRdfDescriptor->Ports[rindex]);
553 CARLA_SAFE_ASSERT_RETURN(scalePointId < port.ScalePointCount, 0.0f);
554
555 const LADSPA_RDF_ScalePoint& scalePoint(port.ScalePoints[scalePointId]);
556 return pData->param.ranges[parameterId].getFixedValue(scalePoint.Value);
557 }
558
559 bool getLabel(char* const strBuf) const noexcept override
560 {
561 CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr, false);
562 CARLA_SAFE_ASSERT_RETURN(fDescriptor->Label != nullptr, false);
563
564 std::strncpy(strBuf, fDescriptor->Label, STR_MAX);
565 return true;
566 }
567
568 bool getMaker(char* const strBuf) const noexcept override
569 {
570 CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr, false);
571 CARLA_SAFE_ASSERT_RETURN(fDescriptor->Maker != nullptr, false);
572
573 if (fRdfDescriptor != nullptr && fRdfDescriptor->Creator != nullptr)
574 std::strncpy(strBuf, fRdfDescriptor->Creator, STR_MAX);
575 else
576 std::strncpy(strBuf, fDescriptor->Maker, STR_MAX);
577
578 return true;
579 }
580
581 bool getCopyright(char* const strBuf) const noexcept override
582 {
583 CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr, false);
584 CARLA_SAFE_ASSERT_RETURN(fDescriptor->Copyright != nullptr, false);
585
586 std::strncpy(strBuf, fDescriptor->Copyright, STR_MAX);
587 return true;
588 }
589
590 bool getRealName(char* const strBuf) const noexcept override
591 {
592 CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr, false);
593 CARLA_SAFE_ASSERT_RETURN(fDescriptor->Name != nullptr, false);
594
595 if (fRdfDescriptor != nullptr && fRdfDescriptor->Title != nullptr)
596 std::strncpy(strBuf, fRdfDescriptor->Title, STR_MAX);
597 else
598 std::strncpy(strBuf, fDescriptor->Name, STR_MAX);
599
600 return true;
601 }
602
603 bool getParameterName(const uint32_t parameterId, char* const strBuf) const noexcept override
604 {
605 CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr, false);
606 CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, false);
607
608 const int32_t rindex(pData->param.data[parameterId].rindex);
609 CARLA_SAFE_ASSERT_RETURN(rindex >= 0, false);
610 CARLA_SAFE_ASSERT_RETURN(rindex < static_cast<int32_t>(fDescriptor->PortCount), false);
611 CARLA_SAFE_ASSERT_RETURN(fDescriptor->PortNames[rindex] != nullptr, false);
612
613 if (! getSeparatedParameterNameOrUnit(fDescriptor->PortNames[rindex], strBuf, true))
614 std::strncpy(strBuf, fDescriptor->PortNames[rindex], STR_MAX);
615
616 return true;
617 }
618
619 bool getParameterUnit(const uint32_t parameterId, char* const strBuf) const noexcept override
620 {
621 CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, false);
622
623 const int32_t rindex(pData->param.data[parameterId].rindex);
624 CARLA_SAFE_ASSERT_RETURN(rindex >= 0, false);
625
626 if (fRdfDescriptor != nullptr && rindex < static_cast<int32_t>(fRdfDescriptor->PortCount))
627 {
628 const LADSPA_RDF_Port& port(fRdfDescriptor->Ports[rindex]);
629
630 if (LADSPA_RDF_PORT_HAS_UNIT(port.Hints))
631 {
632 switch (port.Unit)
633 {
634 case LADSPA_RDF_UNIT_DB:
635 std::strncpy(strBuf, "dB", STR_MAX);
636 return true;
637 case LADSPA_RDF_UNIT_COEF:
638 std::strncpy(strBuf, "(coef)", STR_MAX);
639 return true;
640 case LADSPA_RDF_UNIT_HZ:
641 std::strncpy(strBuf, "Hz", STR_MAX);
642 return true;
643 case LADSPA_RDF_UNIT_S:
644 std::strncpy(strBuf, "s", STR_MAX);
645 return true;
646 case LADSPA_RDF_UNIT_MS:
647 std::strncpy(strBuf, "ms", STR_MAX);
648 return true;
649 case LADSPA_RDF_UNIT_MIN:
650 std::strncpy(strBuf, "min", STR_MAX);
651 return true;
652 }
653 }
654 }
655
656 CARLA_SAFE_ASSERT_RETURN(rindex < static_cast<int32_t>(fDescriptor->PortCount), false);
657 CARLA_SAFE_ASSERT_RETURN(fDescriptor->PortNames[rindex] != nullptr, false);
658
659 return getSeparatedParameterNameOrUnit(fDescriptor->PortNames[rindex], strBuf, false);
660 }
661
662 bool getParameterSymbol(const uint32_t parameterId, char* const strBuf) const noexcept override
663 {
664 CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, false);
665
666 if (fRdfDescriptor == nullptr)
667 return false;
668
669 const int32_t rindex(pData->param.data[parameterId].rindex);
670 CARLA_SAFE_ASSERT_RETURN(rindex >= 0, false);
671
672 if (rindex >= static_cast<int32_t>(fRdfDescriptor->PortCount))
673 return false;
674
675 const LADSPA_RDF_Port& port(fRdfDescriptor->Ports[rindex]);
676
677 if (! LADSPA_RDF_PORT_HAS_LABEL(port.Hints))
678 return false;
679
680 CARLA_SAFE_ASSERT_RETURN(port.Label != nullptr, false);
681
682 std::strncpy(strBuf, port.Label, STR_MAX);
683 return true;
684 }
685
686 bool getParameterScalePointLabel(const uint32_t parameterId, const uint32_t scalePointId, char* const strBuf) const noexcept override
687 {
688 CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr, false);
689 CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, false);
690
691 const int32_t rindex(pData->param.data[parameterId].rindex);
692 CARLA_SAFE_ASSERT_RETURN(rindex >= 0, false);
693 CARLA_SAFE_ASSERT_RETURN(rindex < static_cast<int32_t>(fRdfDescriptor->PortCount), false);
694
695 const LADSPA_RDF_Port& port(fRdfDescriptor->Ports[rindex]);
696 CARLA_SAFE_ASSERT_RETURN(scalePointId < port.ScalePointCount, false);
697
698 const LADSPA_RDF_ScalePoint& scalePoint(port.ScalePoints[scalePointId]);
699 CARLA_SAFE_ASSERT_RETURN(scalePoint.Label != nullptr, false);
700
701 std::strncpy(strBuf, scalePoint.Label, STR_MAX);
702 return true;
703 }
704
705 // -------------------------------------------------------------------
706 // Set data (state)
707
708 // nothing
709
710 // -------------------------------------------------------------------
711 // Set data (internal stuff)
712
713 void setId(const uint newId) noexcept override
714 {
715 CarlaPlugin::setId(newId);
716
717 // UI osc-url uses Id, so we need to close it when it changes
718 // FIXME - must be RT safe
719 showCustomUI(false);
720 }
721
722 // -------------------------------------------------------------------
723 // Set data (plugin-specific stuff)
724
725 void setParameterValue(const uint32_t parameterId, const float value, const bool sendGui, const bool sendOsc, const bool sendCallback) noexcept override
726 {
727 CARLA_SAFE_ASSERT_RETURN(fParamBuffers != nullptr,);
728 CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count,);
729
730 const float fixedValue(pData->param.getFixedValue(parameterId, value));
731 fParamBuffers[parameterId] = fixedValue;
732
733 CarlaPlugin::setParameterValue(parameterId, fixedValue, sendGui, sendOsc, sendCallback);
734 }
735
736 void setParameterValueRT(const uint32_t parameterId, const float value, const uint32_t frameOffset, const bool sendCallbackLater) noexcept override
737 {
738 CARLA_SAFE_ASSERT_RETURN(fParamBuffers != nullptr,);
739 CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count,);
740
741 const float fixedValue(pData->param.getFixedValue(parameterId, value));
742 fParamBuffers[parameterId] = fixedValue;
743
744 CarlaPlugin::setParameterValueRT(parameterId, fixedValue, frameOffset, sendCallbackLater);
745 }
746
747 void setCustomData(const char* const type, const char* const key, const char* const value, const bool sendGui) override
748 {
749 CARLA_SAFE_ASSERT_RETURN(fDssiDescriptor != nullptr,);
750 CARLA_SAFE_ASSERT_RETURN(type != nullptr && type[0] != '\0',);
751 CARLA_SAFE_ASSERT_RETURN(key != nullptr && key[0] != '\0',);
752 CARLA_SAFE_ASSERT_RETURN(value != nullptr,);
753 carla_debug("CarlaPluginLADSPADSSI::setCustomData(%s, %s, %s, %s)", type, key, value, bool2str(sendGui));
754
755 if (std::strcmp(type, CUSTOM_DATA_TYPE_PROPERTY) == 0)
756 return CarlaPlugin::setCustomData(type, key, value, sendGui);
757
758 if (std::strcmp(type, CUSTOM_DATA_TYPE_STRING) != 0)
759 return carla_stderr2("CarlaPluginLADSPADSSI::setCustomData(\"%s\", \"%s\", \"%s\", %s) - type is not string",
760 type, key, value, bool2str(sendGui));
761
762 if (fDssiDescriptor->configure != nullptr && fHandles.count() > 0)
763 {
764 for (LinkedList<LADSPA_Handle>::Itenerator it = fHandles.begin2(); it.valid(); it.next())
765 {
766 LADSPA_Handle const handle(it.getValue(nullptr));
767 CARLA_SAFE_ASSERT_CONTINUE(handle != nullptr);
768
769 try {
770 fDssiDescriptor->configure(handle, key, value);
771 } CARLA_SAFE_EXCEPTION("LADSPA/DSSI setCustomData");
772 }
773 }
774
775 #ifdef CARLA_ENABLE_DSSI_PLUGIN_GUI
776 if (sendGui && fOscData.target != nullptr)
777 osc_send_configure(fOscData, key, value);
778 #endif
779
780 if (std::strcmp(key, "reloadprograms") == 0 || std::strcmp(key, "load") == 0 || std::strncmp(key, "patches", 7) == 0)
781 {
782 const ScopedSingleProcessLocker spl(this, true);
783 reloadPrograms(false);
784 }
785
786 CarlaPlugin::setCustomData(type, key, value, sendGui);
787 }
788
789 void setChunkData(const void* const data, const std::size_t dataSize) override
790 {
791 CARLA_SAFE_ASSERT_RETURN(fUsesCustomData,);
792 CARLA_SAFE_ASSERT_RETURN(pData->options & PLUGIN_OPTION_USE_CHUNKS,);
793 CARLA_SAFE_ASSERT_RETURN(fDssiDescriptor != nullptr,);
794 CARLA_SAFE_ASSERT_RETURN(fDssiDescriptor->set_custom_data != nullptr,);
795 CARLA_SAFE_ASSERT_RETURN(data != nullptr,);
796 CARLA_SAFE_ASSERT_RETURN(dataSize > 0,);
797
798 if (fHandles.count() > 0)
799 {
800 const ScopedSingleProcessLocker spl(this, true);
801
802 for (LinkedList<LADSPA_Handle>::Itenerator it = fHandles.begin2(); it.valid(); it.next())
803 {
804 LADSPA_Handle const handle(it.getValue(nullptr));
805 CARLA_SAFE_ASSERT_CONTINUE(handle != nullptr);
806
807 try {
808 fDssiDescriptor->set_custom_data(handle, const_cast<void*>(data), static_cast<ulong>(dataSize));
809 } CARLA_SAFE_EXCEPTION("CarlaPluginLADSPADSSI::setChunkData");
810 }
811 }
812
813 pData->updateParameterValues(this, true, true, false);
814 }
815
816 void setMidiProgram(const int32_t index, const bool sendGui, const bool sendOsc, const bool sendCallback, const bool doingInit) noexcept override
817 {
818 CARLA_SAFE_ASSERT_RETURN(fDssiDescriptor != nullptr,);
819 CARLA_SAFE_ASSERT_RETURN(fDssiDescriptor->select_program != nullptr,);
820 CARLA_SAFE_ASSERT_RETURN(index >= -1 && index < static_cast<int32_t>(pData->midiprog.count),);
821 CARLA_SAFE_ASSERT_RETURN(sendGui || sendOsc || sendCallback || doingInit,);
822
823 if (index >= 0 && fHandles.count() > 0)
824 {
825 const ScopedSingleProcessLocker spl(this, (sendGui || sendOsc || sendCallback));
826
827 setMidiProgramInDSSI(static_cast<uint32_t>(index));
828 }
829
830 CarlaPlugin::setMidiProgram(index, sendGui, sendOsc, sendCallback, doingInit);
831 }
832
833 void setMidiProgramRT(const uint32_t uindex, const bool sendCallbackLater) noexcept override
834 {
835 CARLA_SAFE_ASSERT_RETURN(fDssiDescriptor != nullptr,);
836 CARLA_SAFE_ASSERT_RETURN(fDssiDescriptor->select_program != nullptr,);
837 CARLA_SAFE_ASSERT_RETURN(uindex < pData->midiprog.count,);
838
839 setMidiProgramInDSSI(uindex);
840
841 CarlaPlugin::setMidiProgramRT(uindex, sendCallbackLater);
842 }
843
844 void setMidiProgramInDSSI(const uint32_t uindex) noexcept
845 {
846 const uint32_t bank(pData->midiprog.data[uindex].bank);
847 const uint32_t program(pData->midiprog.data[uindex].program);
848
849 for (LinkedList<LADSPA_Handle>::Itenerator it = fHandles.begin2(); it.valid(); it.next())
850 {
851 LADSPA_Handle const handle(it.getValue(nullptr));
852 CARLA_SAFE_ASSERT_CONTINUE(handle != nullptr);
853
854 try {
855 fDssiDescriptor->select_program(handle, bank, program);
856 } CARLA_SAFE_EXCEPTION("LADSPA/DSSI setMidiProgram")
857 }
858 }
859
860 #ifdef CARLA_ENABLE_DSSI_PLUGIN_GUI
861 // -------------------------------------------------------------------
862 // Set ui stuff
863
864 void setCustomUITitle(const char* title) noexcept override
865 {
866 fThreadUI.setUITitle(title);
867 CarlaPlugin::setCustomUITitle(title);
868 }
869
870 void showCustomUI(const bool yesNo) override
871 {
872 if (yesNo)
873 {
874 fOscData.clear();
875 fThreadUI.startThread();
876 }
877 else
878 {
879 #ifndef BUILD_BRIDGE
880 pData->transientTryCounter = 0;
881 #endif
882
883 if (fOscData.target != nullptr)
884 {
885 osc_send_hide(fOscData);
886 osc_send_quit(fOscData);
887 fOscData.clear();
888 }
889
890 fThreadUI.stopThread(static_cast<int>(pData->engine->getOptions().uiBridgesTimeout * 2));
891 }
892 }
893 #endif
894
895 // -------------------------------------------------------------------
896 // Plugin state
897
898 void reload() override
899 {
900 CARLA_SAFE_ASSERT_RETURN(pData->engine != nullptr,);
901 CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);
902 CARLA_SAFE_ASSERT_RETURN(fHandles.count() > 0,);
903 carla_debug("CarlaPluginLADSPADSSI::reload() - start");
904
905 const EngineProcessMode processMode(pData->engine->getProccessMode());
906
907 // Safely disable plugin for reload
908 const ScopedDisabler sd(this);
909
910 if (pData->active)
911 deactivate();
912
913 clearBuffers();
914
915 const float sampleRate(static_cast<float>(pData->engine->getSampleRate()));
916 const uint32_t portCount(getSafePortCount());
917
918 uint32_t aIns, aOuts, mIns, params;
919 aIns = aOuts = mIns = params = 0;
920
921 bool forcedStereoIn, forcedStereoOut;
922 forcedStereoIn = forcedStereoOut = false;
923
924 bool needsCtrlIn, needsCtrlOut;
925 needsCtrlIn = needsCtrlOut = false;
926
927 for (uint32_t i=0; i < portCount; ++i)
928 {
929 const LADSPA_PortDescriptor portType(fDescriptor->PortDescriptors[i]);
930
931 if (LADSPA_IS_PORT_AUDIO(portType))
932 {
933 if (LADSPA_IS_PORT_INPUT(portType))
934 aIns += 1;
935 else if (LADSPA_IS_PORT_OUTPUT(portType))
936 aOuts += 1;
937 }
938 else if (LADSPA_IS_PORT_CONTROL(portType))
939 params += 1;
940 }
941
942 if (pData->options & PLUGIN_OPTION_FORCE_STEREO)
943 {
944 if ((aIns == 1 || aOuts == 1) && fHandles.count() == 1 && addInstance())
945 {
946 if (aIns == 1)
947 {
948 aIns = 2;
949 forcedStereoIn = true;
950 }
951 if (aOuts == 1)
952 {
953 aOuts = 2;
954 forcedStereoOut = true;
955 }
956 }
957 }
958
959 if (fDssiDescriptor != nullptr && fDssiDescriptor->run_synth != nullptr)
960 {
961 mIns = 1;
962 needsCtrlIn = true;
963 }
964
965 if (aIns > 0)
966 {
967 pData->audioIn.createNew(aIns);
968 fAudioInBuffers = new float*[aIns];
969
970 for (uint32_t i=0; i < aIns; ++i)
971 fAudioInBuffers[i] = nullptr;
972 }
973
974 if (aOuts > 0)
975 {
976 pData->audioOut.createNew(aOuts);
977 fAudioOutBuffers = new float*[aOuts];
978 needsCtrlIn = true;
979
980 for (uint32_t i=0; i < aOuts; ++i)
981 fAudioOutBuffers[i] = nullptr;
982 }
983
984 if (params > 0)
985 {
986 pData->param.createNew(params, true);
987
988 fParamBuffers = new float[params];
989 carla_zeroFloats(fParamBuffers, params);
990 }
991
992 const uint portNameSize(pData->engine->getMaxPortNameSize());
993 CarlaString portName;
994
995 for (uint32_t i=0, iAudioIn=0, iAudioOut=0, iCtrl=0; i < portCount; ++i)
996 {
997 const LADSPA_PortDescriptor portType = fDescriptor->PortDescriptors[i];
998 const LADSPA_PortRangeHint portRangeHints = fDescriptor->PortRangeHints[i];
999 const bool hasPortRDF = (fRdfDescriptor != nullptr && i < fRdfDescriptor->PortCount);
1000
1001 if (LADSPA_IS_PORT_AUDIO(portType))
1002 {
1003 portName.clear();
1004
1005 if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)
1006 {
1007 portName = pData->name;
1008 portName += ":";
1009 }
1010
1011 if (fDescriptor->PortNames[i] != nullptr && fDescriptor->PortNames[i][0] != '\0')
1012 {
1013 portName += fDescriptor->PortNames[i];
1014 }
1015 else
1016 {
1017 if (LADSPA_IS_PORT_INPUT(portType))
1018 {
1019 if (aIns > 1)
1020 {
1021 portName += "audio-in_";
1022 portName += CarlaString(iAudioIn+1);
1023 }
1024 else
1025 portName += "audio-in";
1026 }
1027 else
1028 {
1029 if (aOuts > 1)
1030 {
1031 portName += "audio-out_";
1032 portName += CarlaString(iAudioOut+1);
1033 }
1034 else
1035 portName += "audio-out";
1036 }
1037 }
1038
1039 portName.truncate(portNameSize);
1040
1041 if (LADSPA_IS_PORT_INPUT(portType))
1042 {
1043 const uint32_t j = iAudioIn++;
1044 pData->audioIn.ports[j].port = (CarlaEngineAudioPort*)pData->client->addPort(kEnginePortTypeAudio, portName, true, j);
1045 pData->audioIn.ports[j].rindex = i;
1046
1047 if (forcedStereoIn)
1048 {
1049 portName += "_2";
1050 pData->audioIn.ports[1].port = (CarlaEngineAudioPort*)pData->client->addPort(kEnginePortTypeAudio, portName, true, 1);
1051 pData->audioIn.ports[1].rindex = i;
1052 }
1053 }
1054 else if (LADSPA_IS_PORT_OUTPUT(portType))
1055 {
1056 const uint32_t j = iAudioOut++;
1057 pData->audioOut.ports[j].port = (CarlaEngineAudioPort*)pData->client->addPort(kEnginePortTypeAudio, portName, false, j);
1058 pData->audioOut.ports[j].rindex = i;
1059
1060 if (forcedStereoOut)
1061 {
1062 portName += "_2";
1063 pData->audioOut.ports[1].port = (CarlaEngineAudioPort*)pData->client->addPort(kEnginePortTypeAudio, portName, false, 1);
1064 pData->audioOut.ports[1].rindex = i;
1065 }
1066 }
1067 else
1068 carla_stderr2("WARNING - Got a broken Port (Audio, but not input or output)");
1069 }
1070 else if (LADSPA_IS_PORT_CONTROL(portType))
1071 {
1072 const uint32_t j = iCtrl++;
1073 pData->param.data[j].index = static_cast<int32_t>(j);
1074 pData->param.data[j].rindex = static_cast<int32_t>(i);
1075
1076 const char* const paramName(fDescriptor->PortNames[i] != nullptr ? fDescriptor->PortNames[i] : "unknown");
1077
1078 float min, max, def, step, stepSmall, stepLarge;
1079
1080 // min value
1081 if (LADSPA_IS_HINT_BOUNDED_BELOW(portRangeHints.HintDescriptor))
1082 min = portRangeHints.LowerBound;
1083 else
1084 min = 0.0f;
1085
1086 // max value
1087 if (LADSPA_IS_HINT_BOUNDED_ABOVE(portRangeHints.HintDescriptor))
1088 max = portRangeHints.UpperBound;
1089 else
1090 max = 1.0f;
1091
1092 if (LADSPA_IS_HINT_SAMPLE_RATE(portRangeHints.HintDescriptor))
1093 {
1094 min *= sampleRate;
1095 max *= sampleRate;
1096 pData->param.data[j].hints |= PARAMETER_USES_SAMPLERATE;
1097 }
1098
1099 if (min >= max)
1100 {
1101 carla_stderr2("WARNING - Broken plugin parameter '%s': min >= max", paramName);
1102 max = min + 0.1f;
1103 }
1104
1105 // default value
1106 if (hasPortRDF && LADSPA_RDF_PORT_HAS_DEFAULT(fRdfDescriptor->Ports[i].Hints))
1107 def = fRdfDescriptor->Ports[i].Default;
1108 else
1109 def = get_default_ladspa_port_value(portRangeHints.HintDescriptor, min, max);
1110
1111 if (def < min)
1112 def = min;
1113 else if (def > max)
1114 def = max;
1115
1116 if (LADSPA_IS_HINT_TOGGLED(portRangeHints.HintDescriptor))
1117 {
1118 step = max - min;
1119 stepSmall = step;
1120 stepLarge = step;
1121 pData->param.data[j].hints |= PARAMETER_IS_BOOLEAN;
1122 }
1123 else if (LADSPA_IS_HINT_INTEGER(portRangeHints.HintDescriptor))
1124 {
1125 step = 1.0f;
1126 stepSmall = 1.0f;
1127 stepLarge = 10.0f;
1128 pData->param.data[j].hints |= PARAMETER_IS_INTEGER;
1129 }
1130 else
1131 {
1132 const float range = max - min;
1133 step = range/100.0f;
1134 stepSmall = range/1000.0f;
1135 stepLarge = range/10.0f;
1136 }
1137
1138 if (LADSPA_IS_PORT_INPUT(portType))
1139 {
1140 pData->param.data[j].type = PARAMETER_INPUT;
1141 pData->param.data[j].hints |= PARAMETER_IS_ENABLED;
1142 pData->param.data[j].hints |= PARAMETER_IS_AUTOMATABLE;
1143 pData->param.data[j].hints |= PARAMETER_CAN_BE_CV_CONTROLLED;
1144 needsCtrlIn = true;
1145
1146 // MIDI CC value
1147 if (fDssiDescriptor != nullptr && fDssiDescriptor->get_midi_controller_for_port != nullptr)
1148 {
1149 const int ctrl = fDssiDescriptor->get_midi_controller_for_port(fHandles.getFirst(nullptr), i);
1150 if (DSSI_CONTROLLER_IS_SET(ctrl) && DSSI_IS_CC(ctrl))
1151 {
1152 const int16_t cc = DSSI_CC_NUMBER(ctrl);
1153 if (cc < MAX_MIDI_CONTROL && ! MIDI_IS_CONTROL_BANK_SELECT(cc))
1154 pData->param.data[j].mappedControlIndex = cc;
1155 }
1156 }
1157 }
1158 else if (LADSPA_IS_PORT_OUTPUT(portType))
1159 {
1160 pData->param.data[j].type = PARAMETER_OUTPUT;
1161
1162 if (std::strcmp(paramName, "latency") == 0 || std::strcmp(paramName, "_latency") == 0)
1163 {
1164 min = 0.0f;
1165 max = sampleRate;
1166 def = 0.0f;
1167 step = 1.0f;
1168 stepSmall = 1.0f;
1169 stepLarge = 1.0f;
1170 pData->param.special[j] = PARAMETER_SPECIAL_LATENCY;
1171 CARLA_SAFE_ASSERT_INT2(fLatencyIndex == static_cast<int32_t>(j), fLatencyIndex, j);
1172 }
1173 else
1174 {
1175 pData->param.data[j].hints |= PARAMETER_IS_ENABLED;
1176 pData->param.data[j].hints |= PARAMETER_IS_AUTOMATABLE;
1177 needsCtrlOut = true;
1178 }
1179 }
1180 else
1181 {
1182 carla_stderr2("WARNING - Got a broken Port (Control, but not input or output)");
1183 }
1184
1185 // extra parameter hints
1186 if (LADSPA_IS_HINT_LOGARITHMIC(portRangeHints.HintDescriptor))
1187 pData->param.data[j].hints |= PARAMETER_IS_LOGARITHMIC;
1188
1189 // check for scalepoints, require at least 2 to make it useful
1190 if (hasPortRDF && fRdfDescriptor->Ports[i].ScalePointCount >= 2)
1191 pData->param.data[j].hints |= PARAMETER_USES_SCALEPOINTS;
1192
1193 pData->param.ranges[j].min = min;
1194 pData->param.ranges[j].max = max;
1195 pData->param.ranges[j].def = def;
1196 pData->param.ranges[j].step = step;
1197 pData->param.ranges[j].stepSmall = stepSmall;
1198 pData->param.ranges[j].stepLarge = stepLarge;
1199
1200 // Start parameters in their default values
1201 fParamBuffers[j] = def;
1202
1203 for (LinkedList<LADSPA_Handle>::Itenerator it = fHandles.begin2(); it.valid(); it.next())
1204 {
1205 LADSPA_Handle const handle(it.getValue(nullptr));
1206 CARLA_SAFE_ASSERT_CONTINUE(handle != nullptr);
1207
1208 try {
1209 fDescriptor->connect_port(handle, i, &fParamBuffers[j]);
1210 } CARLA_SAFE_EXCEPTION("LADSPA/DSSI connect_port (parameter)");
1211 }
1212 }
1213 else
1214 {
1215 // Not Audio or Control
1216 carla_stderr2("ERROR - Got a broken Port (neither Audio or Control)");
1217
1218 for (LinkedList<LADSPA_Handle>::Itenerator it = fHandles.begin2(); it.valid(); it.next())
1219 {
1220 LADSPA_Handle const handle(it.getValue(nullptr));
1221 CARLA_SAFE_ASSERT_CONTINUE(handle != nullptr);
1222
1223 try {
1224 fDescriptor->connect_port(handle, i, nullptr);
1225 } CARLA_SAFE_EXCEPTION("LADSPA/DSSI connect_port (null)");
1226 }
1227 }
1228 }
1229
1230 if (needsCtrlIn)
1231 {
1232 portName.clear();
1233
1234 if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)
1235 {
1236 portName = pData->name;
1237 portName += ":";
1238 }
1239
1240 portName += "events-in";
1241 portName.truncate(portNameSize);
1242
1243 pData->event.portIn = (CarlaEngineEventPort*)pData->client->addPort(kEnginePortTypeEvent, portName, true, 0);
1244 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
1245 pData->event.cvSourcePorts = pData->client->createCVSourcePorts();
1246 #endif
1247 }
1248
1249 if (needsCtrlOut)
1250 {
1251 portName.clear();
1252
1253 if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)
1254 {
1255 portName = pData->name;
1256 portName += ":";
1257 }
1258
1259 portName += "events-out";
1260 portName.truncate(portNameSize);
1261
1262 pData->event.portOut = (CarlaEngineEventPort*)pData->client->addPort(kEnginePortTypeEvent, portName, false, 0);
1263 }
1264
1265 if (forcedStereoIn || forcedStereoOut)
1266 pData->options |= PLUGIN_OPTION_FORCE_STEREO;
1267 else
1268 pData->options &= ~PLUGIN_OPTION_FORCE_STEREO;
1269
1270 // plugin hints
1271 pData->hints = 0x0;
1272
1273 if (LADSPA_IS_HARD_RT_CAPABLE(fDescriptor->Properties))
1274 pData->hints |= PLUGIN_IS_RTSAFE;
1275
1276 #ifdef CARLA_ENABLE_DSSI_PLUGIN_GUI
1277 if (fUiFilename != nullptr)
1278 pData->hints |= PLUGIN_HAS_CUSTOM_UI;
1279 #endif
1280
1281 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
1282 if (aOuts > 0 && (aIns == aOuts || aIns == 1))
1283 pData->hints |= PLUGIN_CAN_DRYWET;
1284
1285 if (aOuts > 0)
1286 pData->hints |= PLUGIN_CAN_VOLUME;
1287
1288 if (aOuts >= 2 && aOuts % 2 == 0)
1289 pData->hints |= PLUGIN_CAN_BALANCE;
1290 #endif
1291
1292 // extra plugin hints
1293 pData->extraHints = 0x0;
1294
1295 if (mIns > 0)
1296 pData->extraHints |= PLUGIN_EXTRA_HINT_HAS_MIDI_IN;
1297
1298 // check initial latency
1299 findInitialLatencyValue(aIns, aOuts);
1300
1301 fForcedStereoIn = forcedStereoIn;
1302 fForcedStereoOut = forcedStereoOut;
1303
1304 bufferSizeChanged(pData->engine->getBufferSize());
1305 reloadPrograms(true);
1306
1307 if (pData->active)
1308 activate();
1309
1310 carla_debug("CarlaPluginLADSPADSSI::reload() - end");
1311 }
1312
1313 void findInitialLatencyValue(const uint32_t aIns, const uint32_t aOuts) const
1314 {
1315 if (fLatencyIndex < 0 || fHandles.count() == 0)
1316 return;
1317
1318 // we need to pre-run the plugin so it can update its latency control-port
1319 const LADSPA_Handle handle(fHandles.getFirst(nullptr));
1320 CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);
1321
1322 float tmpIn[64][2];
1323 float tmpOut[64][2];
1324
1325 for (uint32_t j=0; j < aIns; ++j)
1326 {
1327 tmpIn[j][0] = 0.0f;
1328 tmpIn[j][1] = 0.0f;
1329
1330 try {
1331 fDescriptor->connect_port(handle, pData->audioIn.ports[j].rindex, tmpIn[j]);
1332 } CARLA_SAFE_EXCEPTION("LADSPA/DSSI connect_port (latency input)");
1333 }
1334
1335 for (uint32_t j=0; j < aOuts; ++j)
1336 {
1337 tmpOut[j][0] = 0.0f;
1338 tmpOut[j][1] = 0.0f;
1339
1340 try {
1341 fDescriptor->connect_port(handle, pData->audioOut.ports[j].rindex, tmpOut[j]);
1342 } CARLA_SAFE_EXCEPTION("LADSPA/DSSI connect_port (latency output)");
1343 }
1344
1345 if (fDescriptor->activate != nullptr)
1346 {
1347 try {
1348 fDescriptor->activate(handle);
1349 } CARLA_SAFE_EXCEPTION("LADSPA/DSSI latency activate");
1350 }
1351
1352 try {
1353 fDescriptor->run(handle, 2);
1354 } CARLA_SAFE_EXCEPTION("LADSPA/DSSI latency run");
1355
1356 if (fDescriptor->deactivate != nullptr)
1357 {
1358 try {
1359 fDescriptor->deactivate(handle);
1360 } CARLA_SAFE_EXCEPTION("LADSPA/DSSI latency deactivate");
1361 }
1362
1363 // done, let's get the value
1364 if (const uint32_t latency = getLatencyInFrames())
1365 {
1366 pData->client->setLatency(latency);
1367 #ifndef BUILD_BRIDGE
1368 pData->latency.recreateBuffers(std::max(aIns, aOuts), latency);
1369 #endif
1370 }
1371 }
1372
1373 void reloadPrograms(const bool doInit) override
1374 {
1375 carla_debug("CarlaPluginLADSPADSSI::reloadPrograms(%s)", bool2str(doInit));
1376
1377 const LADSPA_Handle handle(fHandles.getFirst(nullptr));
1378 CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);
1379
1380 const uint32_t oldCount = pData->midiprog.count;
1381 const int32_t current = pData->midiprog.current;
1382
1383 // Delete old programs
1384 pData->midiprog.clear();
1385
1386 // nothing to do for simple LADSPA plugins (do we want to bother with lrdf presets?)
1387 if (fDssiDescriptor == nullptr)
1388 return;
1389
1390 // Query new programs
1391 uint32_t newCount = 0;
1392 if (fDssiDescriptor->get_program != nullptr && fDssiDescriptor->select_program != nullptr)
1393 {
1394 for (; fDssiDescriptor->get_program(handle, newCount) != nullptr;)
1395 ++newCount;
1396 }
1397
1398 if (newCount > 0)
1399 {
1400 pData->midiprog.createNew(newCount);
1401
1402 // Update data
1403 for (uint32_t i=0; i < newCount; ++i)
1404 {
1405 const DSSI_Program_Descriptor* const pdesc(fDssiDescriptor->get_program(handle, i));
1406 CARLA_SAFE_ASSERT_CONTINUE(pdesc != nullptr);
1407 CARLA_SAFE_ASSERT(pdesc->Name != nullptr);
1408
1409 pData->midiprog.data[i].bank = static_cast<uint32_t>(pdesc->Bank);
1410 pData->midiprog.data[i].program = static_cast<uint32_t>(pdesc->Program);
1411 pData->midiprog.data[i].name = carla_strdup(pdesc->Name);
1412 }
1413 }
1414
1415 if (doInit)
1416 {
1417 if (newCount > 0)
1418 setMidiProgram(0, false, false, false, true);
1419 }
1420 else
1421 {
1422 // Check if current program is invalid
1423 bool programChanged = false;
1424
1425 if (newCount == oldCount+1)
1426 {
1427 // one midi program added, probably created by user
1428 pData->midiprog.current = static_cast<int32_t>(oldCount);
1429 programChanged = true;
1430 }
1431 else if (current < 0 && newCount > 0)
1432 {
1433 // programs exist now, but not before
1434 pData->midiprog.current = 0;
1435 programChanged = true;
1436 }
1437 else if (current >= 0 && newCount == 0)
1438 {
1439 // programs existed before, but not anymore
1440 pData->midiprog.current = -1;
1441 programChanged = true;
1442 }
1443 else if (current >= static_cast<int32_t>(newCount))
1444 {
1445 // current midi program > count
1446 pData->midiprog.current = 0;
1447 programChanged = true;
1448 }
1449 else
1450 {
1451 // no change
1452 pData->midiprog.current = current;
1453 }
1454
1455 if (programChanged)
1456 setMidiProgram(pData->midiprog.current, true, true, true, false);
1457
1458 pData->engine->callback(true, true, ENGINE_CALLBACK_RELOAD_PROGRAMS, pData->id, 0, 0, 0, 0.0f, nullptr);
1459 }
1460 }
1461
1462 // -------------------------------------------------------------------
1463 // Plugin processing
1464
1465 void activate() noexcept override
1466 {
1467 CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);
1468
1469 if (fDescriptor->activate != nullptr)
1470 {
1471 for (LinkedList<LADSPA_Handle>::Itenerator it = fHandles.begin2(); it.valid(); it.next())
1472 {
1473 LADSPA_Handle const handle(it.getValue(nullptr));
1474 CARLA_SAFE_ASSERT_CONTINUE(handle != nullptr);
1475
1476 try {
1477 fDescriptor->activate(handle);
1478 } CARLA_SAFE_EXCEPTION("LADSPA/DSSI activate");
1479 }
1480 }
1481 }
1482
1483 void deactivate() noexcept override
1484 {
1485 CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);
1486
1487 if (fDescriptor->deactivate != nullptr)
1488 {
1489 for (LinkedList<LADSPA_Handle>::Itenerator it = fHandles.begin2(); it.valid(); it.next())
1490 {
1491 LADSPA_Handle const handle(it.getValue(nullptr));
1492 CARLA_SAFE_ASSERT_CONTINUE(handle != nullptr);
1493
1494 try {
1495 fDescriptor->deactivate(handle);
1496 } CARLA_SAFE_EXCEPTION("LADSPA/DSSI deactivate");
1497 }
1498 }
1499 }
1500
1501 void process(const float* const* const audioIn, float** const audioOut,
1502 const float* const* const cvIn, float**,
1503 const uint32_t frames) override
1504 {
1505 // --------------------------------------------------------------------------------------------------------
1506 // Check if active
1507
1508 if (! pData->active)
1509 {
1510 // disable any output sound
1511 for (uint32_t i=0; i < pData->audioOut.count; ++i)
1512 carla_zeroFloats(audioOut[i], frames);
1513 return;
1514 }
1515
1516 ulong midiEventCount = 0;
1517 carla_zeroStructs(fMidiEvents, kPluginMaxMidiEvents);
1518
1519 // --------------------------------------------------------------------------------------------------------
1520 // Check if needs reset
1521
1522 if (pData->needsReset)
1523 {
1524 if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)
1525 {
1526 midiEventCount = MAX_MIDI_CHANNELS*2;
1527
1528 for (uchar i=0, k=MAX_MIDI_CHANNELS; i < MAX_MIDI_CHANNELS; ++i)
1529 {
1530 fMidiEvents[i].type = SND_SEQ_EVENT_CONTROLLER;
1531 fMidiEvents[i].data.control.channel = i;
1532 fMidiEvents[i].data.control.param = MIDI_CONTROL_ALL_NOTES_OFF;
1533
1534 fMidiEvents[k+i].type = SND_SEQ_EVENT_CONTROLLER;
1535 fMidiEvents[k+i].data.control.channel = i;
1536 fMidiEvents[k+i].data.control.param = MIDI_CONTROL_ALL_SOUND_OFF;
1537 }
1538 }
1539 else if (pData->ctrlChannel >= 0 && pData->ctrlChannel < MAX_MIDI_CHANNELS)
1540 {
1541 midiEventCount = MAX_MIDI_NOTE;
1542
1543 for (uchar i=0; i < MAX_MIDI_NOTE; ++i)
1544 {
1545 fMidiEvents[i].type = SND_SEQ_EVENT_NOTEOFF;
1546 fMidiEvents[i].data.note.channel = static_cast<uchar>(pData->ctrlChannel);
1547 fMidiEvents[i].data.note.note = i;
1548 }
1549 }
1550
1551 pData->needsReset = false;
1552 }
1553
1554 // --------------------------------------------------------------------------------------------------------
1555 // Event Input and Processing
1556
1557 if (pData->event.portIn != nullptr)
1558 {
1559 // ----------------------------------------------------------------------------------------------------
1560 // MIDI Input (External)
1561
1562 if (pData->extNotes.mutex.tryLock())
1563 {
1564 ExternalMidiNote note = { 0, 0, 0 };
1565
1566 for (; midiEventCount < kPluginMaxMidiEvents && ! pData->extNotes.data.isEmpty();)
1567 {
1568 note = pData->extNotes.data.getFirst(note, true);
1569 CARLA_SAFE_ASSERT_CONTINUE(note.channel >= 0 && note.channel < MAX_MIDI_CHANNELS);
1570
1571 snd_seq_event_t& seqEvent(fMidiEvents[midiEventCount++]);
1572 carla_zeroStruct(seqEvent);
1573
1574 seqEvent.type = (note.velo > 0) ? SND_SEQ_EVENT_NOTEON : SND_SEQ_EVENT_NOTEOFF;
1575 seqEvent.data.note.channel = static_cast<uchar>(note.channel);
1576 seqEvent.data.note.note = note.note;
1577 seqEvent.data.note.velocity = note.velo;
1578 }
1579
1580 pData->extNotes.mutex.unlock();
1581
1582 } // End of MIDI Input (External)
1583
1584 // ----------------------------------------------------------------------------------------------------
1585 // Event Input (System)
1586
1587 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
1588 bool allNotesOffSent = false;
1589 #endif
1590 const bool isSampleAccurate = (pData->options & PLUGIN_OPTION_FIXED_BUFFERS) == 0;
1591
1592 uint32_t startTime = 0;
1593 uint32_t timeOffset = 0;
1594 uint32_t nextBankId;
1595
1596 if (pData->midiprog.current >= 0 && pData->midiprog.count > 0)
1597 nextBankId = pData->midiprog.data[pData->midiprog.current].bank;
1598 else
1599 nextBankId = 0;
1600
1601 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
1602 if (cvIn != nullptr && pData->event.cvSourcePorts != nullptr)
1603 pData->event.cvSourcePorts->initPortBuffers(cvIn, frames, isSampleAccurate, pData->event.portIn);
1604 #endif
1605
1606 for (uint32_t i=0, numEvents=pData->event.portIn->getEventCount(); i < numEvents; ++i)
1607 {
1608 EngineEvent& event(pData->event.portIn->getEvent(i));
1609
1610 uint32_t eventTime = event.time;
1611 CARLA_SAFE_ASSERT_UINT2_CONTINUE(eventTime < frames, eventTime, frames);
1612
1613 if (eventTime < timeOffset)
1614 {
1615 carla_stderr2("Timing error, eventTime:%u < timeOffset:%u for '%s'",
1616 eventTime, timeOffset, pData->name);
1617 eventTime = timeOffset;
1618 }
1619
1620 if (isSampleAccurate && eventTime > timeOffset)
1621 {
1622 if (processSingle(audioIn, audioOut, eventTime - timeOffset, timeOffset, midiEventCount))
1623 {
1624 startTime = 0;
1625 timeOffset = eventTime;
1626 midiEventCount = 0;
1627
1628 if (pData->midiprog.current >= 0 && pData->midiprog.count > 0)
1629 nextBankId = pData->midiprog.data[pData->midiprog.current].bank;
1630 else
1631 nextBankId = 0;
1632 }
1633 else
1634 startTime += timeOffset;
1635 }
1636
1637 switch (event.type)
1638 {
1639 case kEngineEventTypeNull:
1640 break;
1641
1642 case kEngineEventTypeControl: {
1643 EngineControlEvent& ctrlEvent(event.ctrl);
1644
1645 switch (ctrlEvent.type)
1646 {
1647 case kEngineControlEventTypeNull:
1648 break;
1649
1650 case kEngineControlEventTypeParameter: {
1651 float value;
1652
1653 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
1654 // non-midi
1655 if (event.channel == kEngineEventNonMidiChannel)
1656 {
1657 const uint32_t k = ctrlEvent.param;
1658 CARLA_SAFE_ASSERT_CONTINUE(k < pData->param.count);
1659
1660 ctrlEvent.handled = true;
1661 value = pData->param.getFinalUnnormalizedValue(k, ctrlEvent.normalizedValue);
1662 setParameterValueRT(k, value, event.time, true);
1663 continue;
1664 }
1665
1666 // Control backend stuff
1667 if (event.channel == pData->ctrlChannel)
1668 {
1669 if (MIDI_IS_CONTROL_BREATH_CONTROLLER(ctrlEvent.param) && (pData->hints & PLUGIN_CAN_DRYWET) != 0)
1670 {
1671 ctrlEvent.handled = true;
1672 value = ctrlEvent.normalizedValue;
1673 setDryWetRT(value, true);
1674 }
1675 else if (MIDI_IS_CONTROL_CHANNEL_VOLUME(ctrlEvent.param) && (pData->hints & PLUGIN_CAN_VOLUME) != 0)
1676 {
1677 ctrlEvent.handled = true;
1678 value = ctrlEvent.normalizedValue*127.0f/100.0f;
1679 setVolumeRT(value, true);
1680 }
1681 else if (MIDI_IS_CONTROL_BALANCE(ctrlEvent.param) && (pData->hints & PLUGIN_CAN_BALANCE) != 0)
1682 {
1683 float left, right;
1684 value = ctrlEvent.normalizedValue/0.5f - 1.0f;
1685
1686 if (value < 0.0f)
1687 {
1688 left = -1.0f;
1689 right = (value*2.0f)+1.0f;
1690 }
1691 else if (value > 0.0f)
1692 {
1693 left = (value*2.0f)-1.0f;
1694 right = 1.0f;
1695 }
1696 else
1697 {
1698 left = -1.0f;
1699 right = 1.0f;
1700 }
1701
1702 ctrlEvent.handled = true;
1703 setBalanceLeftRT(left, true);
1704 setBalanceRightRT(right, true);
1705 }
1706 }
1707 #endif
1708 // Control plugin parameters
1709 for (uint32_t k=0; k < pData->param.count; ++k)
1710 {
1711 if (pData->param.data[k].midiChannel != event.channel)
1712 continue;
1713 if (pData->param.data[k].mappedControlIndex != ctrlEvent.param)
1714 continue;
1715 if (pData->param.data[k].type != PARAMETER_INPUT)
1716 continue;
1717 if ((pData->param.data[k].hints & PARAMETER_IS_AUTOMATABLE) == 0)
1718 continue;
1719
1720 ctrlEvent.handled = true;
1721 value = pData->param.getFinalUnnormalizedValue(k, ctrlEvent.normalizedValue);
1722 setParameterValueRT(k, value, event.time, true);
1723 }
1724
1725 if ((pData->options & PLUGIN_OPTION_SEND_CONTROL_CHANGES) != 0 && ctrlEvent.param < MAX_MIDI_VALUE)
1726 {
1727 if (midiEventCount >= kPluginMaxMidiEvents)
1728 continue;
1729
1730 snd_seq_event_t& seqEvent(fMidiEvents[midiEventCount++]);
1731 carla_zeroStruct(seqEvent);
1732
1733 seqEvent.time.tick = isSampleAccurate ? startTime : eventTime;
1734
1735 seqEvent.type = SND_SEQ_EVENT_CONTROLLER;
1736 seqEvent.data.control.channel = event.channel;
1737 seqEvent.data.control.param = ctrlEvent.param;
1738 seqEvent.data.control.value = int8_t(ctrlEvent.normalizedValue*127.0f + 0.5f);
1739 }
1740
1741 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
1742 if (! ctrlEvent.handled)
1743 checkForMidiLearn(event);
1744 #endif
1745 break;
1746 } // case kEngineControlEventTypeParameter
1747
1748 case kEngineControlEventTypeMidiBank:
1749 if (event.channel == pData->ctrlChannel && (pData->options & PLUGIN_OPTION_MAP_PROGRAM_CHANGES) != 0)
1750 nextBankId = ctrlEvent.param;
1751 break;
1752
1753 case kEngineControlEventTypeMidiProgram:
1754 if (event.channel == pData->ctrlChannel && (pData->options & PLUGIN_OPTION_MAP_PROGRAM_CHANGES) != 0)
1755 {
1756 const uint32_t nextProgramId = ctrlEvent.param;
1757
1758 for (uint32_t k=0; k < pData->midiprog.count; ++k)
1759 {
1760 if (pData->midiprog.data[k].bank == nextBankId && pData->midiprog.data[k].program == nextProgramId)
1761 {
1762 setMidiProgramRT(k, true);
1763 break;
1764 }
1765 }
1766 }
1767 break;
1768
1769 case kEngineControlEventTypeAllSoundOff:
1770 if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)
1771 {
1772 if (midiEventCount >= kPluginMaxMidiEvents)
1773 continue;
1774
1775 snd_seq_event_t& seqEvent(fMidiEvents[midiEventCount++]);
1776 carla_zeroStruct(seqEvent);
1777
1778 seqEvent.time.tick = isSampleAccurate ? startTime : eventTime;
1779
1780 seqEvent.type = SND_SEQ_EVENT_CONTROLLER;
1781 seqEvent.data.control.channel = event.channel;
1782 seqEvent.data.control.param = MIDI_CONTROL_ALL_SOUND_OFF;
1783 }
1784 break;
1785
1786 case kEngineControlEventTypeAllNotesOff:
1787 if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)
1788 {
1789 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
1790 if (event.channel == pData->ctrlChannel && ! allNotesOffSent)
1791 {
1792 allNotesOffSent = true;
1793 postponeRtAllNotesOff();
1794 }
1795 #endif
1796
1797 if (midiEventCount >= kPluginMaxMidiEvents)
1798 continue;
1799
1800 snd_seq_event_t& seqEvent(fMidiEvents[midiEventCount++]);
1801 carla_zeroStruct(seqEvent);
1802
1803 seqEvent.time.tick = isSampleAccurate ? startTime : eventTime;
1804
1805 seqEvent.type = SND_SEQ_EVENT_CONTROLLER;
1806 seqEvent.data.control.channel = event.channel;
1807 seqEvent.data.control.param = MIDI_CONTROL_ALL_NOTES_OFF;
1808 }
1809 break;
1810 } // switch (ctrlEvent.type)
1811 break;
1812 } // case kEngineEventTypeControl
1813
1814 case kEngineEventTypeMidi: {
1815 if (midiEventCount >= kPluginMaxMidiEvents)
1816 continue;
1817
1818 const EngineMidiEvent& midiEvent(event.midi);
1819
1820 if (midiEvent.size > EngineMidiEvent::kDataSize)
1821 continue;
1822
1823 uint8_t status = uint8_t(MIDI_GET_STATUS_FROM_DATA(midiEvent.data));
1824
1825 // Fix bad note-off (per DSSI spec)
1826 if (status == MIDI_STATUS_NOTE_ON && midiEvent.data[2] == 0)
1827 status = MIDI_STATUS_NOTE_OFF;
1828
1829 snd_seq_event_t& seqEvent(fMidiEvents[midiEventCount++]);
1830 carla_zeroStruct(seqEvent);
1831
1832 seqEvent.time.tick = isSampleAccurate ? startTime : eventTime;
1833
1834 switch (status)
1835 {
1836 case MIDI_STATUS_NOTE_OFF:
1837 if ((pData->options & PLUGIN_OPTION_SKIP_SENDING_NOTES) == 0x0)
1838 {
1839 const uint8_t note = midiEvent.data[1];
1840
1841 seqEvent.type = SND_SEQ_EVENT_NOTEOFF;
1842 seqEvent.data.note.channel = event.channel;
1843 seqEvent.data.note.note = note;
1844
1845 pData->postponeNoteOffRtEvent(true, event.channel, note);
1846 }
1847 break;
1848
1849 case MIDI_STATUS_NOTE_ON:
1850 if ((pData->options & PLUGIN_OPTION_SKIP_SENDING_NOTES) == 0x0)
1851 {
1852 const uint8_t note = midiEvent.data[1];
1853 const uint8_t velo = midiEvent.data[2];
1854
1855 seqEvent.type = SND_SEQ_EVENT_NOTEON;
1856 seqEvent.data.note.channel = event.channel;
1857 seqEvent.data.note.note = note;
1858 seqEvent.data.note.velocity = velo;
1859
1860 pData->postponeNoteOnRtEvent(true, event.channel, note, velo);
1861 }
1862 break;
1863
1864 case MIDI_STATUS_POLYPHONIC_AFTERTOUCH:
1865 if (pData->options & PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH)
1866 {
1867 const uint8_t note = midiEvent.data[1];
1868 const uint8_t pressure = midiEvent.data[2];
1869
1870 seqEvent.type = SND_SEQ_EVENT_KEYPRESS;
1871 seqEvent.data.note.channel = event.channel;
1872 seqEvent.data.note.note = note;
1873 seqEvent.data.note.velocity = pressure;
1874 }
1875 break;
1876
1877 case MIDI_STATUS_CONTROL_CHANGE:
1878 if (pData->options & PLUGIN_OPTION_SEND_CONTROL_CHANGES)
1879 {
1880 const uint8_t control = midiEvent.data[1];
1881 const uint8_t value = midiEvent.data[2];
1882
1883 seqEvent.type = SND_SEQ_EVENT_CONTROLLER;
1884 seqEvent.data.control.channel = event.channel;
1885 seqEvent.data.control.param = control;
1886 seqEvent.data.control.value = value;
1887 }
1888 break;
1889
1890 case MIDI_STATUS_CHANNEL_PRESSURE:
1891 if (pData->options & PLUGIN_OPTION_SEND_CHANNEL_PRESSURE)
1892 {
1893 const uint8_t pressure = midiEvent.data[1];
1894
1895 seqEvent.type = SND_SEQ_EVENT_CHANPRESS;
1896 seqEvent.data.control.channel = event.channel;
1897 seqEvent.data.control.value = pressure;
1898 }
1899 break;
1900
1901 case MIDI_STATUS_PITCH_WHEEL_CONTROL:
1902 if (pData->options & PLUGIN_OPTION_SEND_PITCHBEND)
1903 {
1904 const uint8_t lsb = midiEvent.data[1];
1905 const uint8_t msb = midiEvent.data[2];
1906
1907 seqEvent.type = SND_SEQ_EVENT_PITCHBEND;
1908 seqEvent.data.control.channel = event.channel;
1909 seqEvent.data.control.value = ((msb << 7) | lsb) - 8192;
1910 }
1911 break;
1912
1913 default:
1914 --midiEventCount;
1915 break;
1916 } // switch (status)
1917 } break;
1918 } // switch (event.type)
1919 }
1920
1921 pData->postRtEvents.trySplice();
1922
1923 if (frames > timeOffset)
1924 processSingle(audioIn, audioOut, frames - timeOffset, timeOffset, midiEventCount);
1925
1926 } // End of Event Input and Processing
1927
1928 // --------------------------------------------------------------------------------------------------------
1929 // Plugin processing (no events)
1930
1931 else
1932 {
1933 processSingle(audioIn, audioOut, frames, 0, midiEventCount);
1934
1935 } // End of Plugin processing (no events)
1936
1937 // --------------------------------------------------------------------------------------------------------
1938 // Control Output
1939
1940 if (pData->event.portOut != nullptr)
1941 {
1942 uint8_t channel;
1943 uint16_t param;
1944 float value;
1945
1946 for (uint32_t k=0; k < pData->param.count; ++k)
1947 {
1948 if (pData->param.data[k].type != PARAMETER_OUTPUT)
1949 continue;
1950
1951 pData->param.ranges[k].fixValue(fParamBuffers[k]);
1952
1953 if (pData->param.data[k].mappedControlIndex > 0)
1954 {
1955 channel = pData->param.data[k].midiChannel;
1956 param = static_cast<uint16_t>(pData->param.data[k].mappedControlIndex);
1957 value = pData->param.ranges[k].getNormalizedValue(fParamBuffers[k]);
1958 pData->event.portOut->writeControlEvent(0, channel, kEngineControlEventTypeParameter,
1959 param, -1, value);
1960 }
1961 }
1962 } // End of Control Output
1963
1964 #ifdef BUILD_BRIDGE_ALTERNATIVE_ARCH
1965 return;
1966
1967 // unused
1968 (void)cvIn;
1969 #endif
1970 }
1971
1972 bool processSingle(const float* const* const audioIn, float** const audioOut, const uint32_t frames,
1973 const uint32_t timeOffset, const ulong midiEventCount)
1974 {
1975 CARLA_SAFE_ASSERT_RETURN(frames > 0, false);
1976
1977 if (pData->audioIn.count > 0)
1978 {
1979 CARLA_SAFE_ASSERT_RETURN(audioIn != nullptr, false);
1980 }
1981 if (pData->audioOut.count > 0)
1982 {
1983 CARLA_SAFE_ASSERT_RETURN(audioOut != nullptr, false);
1984 }
1985
1986 // --------------------------------------------------------------------------------------------------------
1987 // Try lock, silence otherwise
1988
1989 #ifndef STOAT_TEST_BUILD
1990 if (pData->engine->isOffline())
1991 {
1992 pData->singleMutex.lock();
1993 }
1994 else
1995 #endif
1996 if (! pData->singleMutex.tryLock())
1997 {
1998 for (uint32_t i=0; i < pData->audioOut.count; ++i)
1999 {
2000 for (uint32_t k=0; k < frames; ++k)
2001 audioOut[i][k+timeOffset] = 0.0f;
2002 }
2003
2004 return false;
2005 }
2006
2007 // --------------------------------------------------------------------------------------------------------
2008 // Set audio buffers
2009
2010 const bool customMonoOut = pData->audioOut.count == 2 && fForcedStereoOut && ! fForcedStereoIn;
2011 const bool customStereoOut = pData->audioOut.count == 2 && fForcedStereoIn && ! fForcedStereoOut;
2012
2013 if (! customMonoOut)
2014 {
2015 for (uint32_t i=0; i < pData->audioOut.count; ++i)
2016 carla_zeroFloats(fAudioOutBuffers[i], frames);
2017 }
2018
2019 for (uint32_t i=0; i < pData->audioIn.count; ++i)
2020 carla_copyFloats(fAudioInBuffers[i], audioIn[i]+timeOffset, frames);
2021
2022 // --------------------------------------------------------------------------------------------------------
2023 // Run plugin
2024
2025 uint instn = 0;
2026 for (LinkedList<LADSPA_Handle>::Itenerator it = fHandles.begin2(); it.valid(); it.next(), ++instn)
2027 {
2028 LADSPA_Handle const handle(it.getValue(nullptr));
2029 CARLA_SAFE_ASSERT_CONTINUE(handle != nullptr);
2030
2031 // ----------------------------------------------------------------------------------------------------
2032 // Mixdown for forced stereo
2033
2034 if (customMonoOut)
2035 carla_zeroFloats(fAudioOutBuffers[instn], frames);
2036
2037 // ----------------------------------------------------------------------------------------------------
2038 // Run it
2039
2040 if (fDssiDescriptor != nullptr && fDssiDescriptor->run_synth != nullptr)
2041 {
2042 try {
2043 fDssiDescriptor->run_synth(handle, frames, fMidiEvents, midiEventCount);
2044 } CARLA_SAFE_EXCEPTION("LADSPA/DSSI run_synth");
2045 }
2046 else
2047 {
2048 try {
2049 fDescriptor->run(handle, frames);
2050 } CARLA_SAFE_EXCEPTION("LADSPA/DSSI run");
2051 }
2052
2053 // ----------------------------------------------------------------------------------------------------
2054 // Mixdown for forced stereo
2055
2056 if (customMonoOut)
2057 carla_multiply(fAudioOutBuffers[instn], 0.5f, frames);
2058 else if (customStereoOut)
2059 carla_copyFloats(fExtraStereoBuffer[instn], fAudioOutBuffers[instn], frames);
2060 }
2061
2062 if (customStereoOut)
2063 {
2064 carla_copyFloats(fAudioOutBuffers[0], fExtraStereoBuffer[0], frames);
2065 carla_copyFloats(fAudioOutBuffers[1], fExtraStereoBuffer[1], frames);
2066 }
2067
2068 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
2069 // --------------------------------------------------------------------------------------------------------
2070 // Post-processing (dry/wet, volume and balance)
2071
2072 {
2073 const bool doDryWet = (pData->hints & PLUGIN_CAN_DRYWET) != 0 && carla_isNotEqual(pData->postProc.dryWet, 1.0f);
2074 const bool doBalance = (pData->hints & PLUGIN_CAN_BALANCE) != 0 && ! (carla_isEqual(pData->postProc.balanceLeft, -1.0f) && carla_isEqual(pData->postProc.balanceRight, 1.0f));
2075 const bool isMono = (pData->audioIn.count == 1);
2076
2077 bool isPair;
2078 float bufValue;
2079 float* const oldBufLeft = pData->postProc.extraBuffer;
2080
2081 for (uint32_t i=0; i < pData->audioOut.count; ++i)
2082 {
2083 // Dry/Wet
2084 if (doDryWet)
2085 {
2086 const uint32_t c = isMono ? 0 : i;
2087
2088 for (uint32_t k=0; k < frames; ++k)
2089 {
2090 # ifndef BUILD_BRIDGE
2091 if (k < pData->latency.frames && pData->latency.buffers != nullptr)
2092 bufValue = pData->latency.buffers[c][k];
2093 else if (pData->latency.frames < frames)
2094 bufValue = fAudioInBuffers[c][k-pData->latency.frames];
2095 else
2096 # endif
2097 bufValue = fAudioInBuffers[c][k];
2098
2099 fAudioOutBuffers[i][k] = (fAudioOutBuffers[i][k] * pData->postProc.dryWet) + (bufValue * (1.0f - pData->postProc.dryWet));
2100 }
2101 }
2102
2103 // Balance
2104 if (doBalance)
2105 {
2106 isPair = (i % 2 == 0);
2107
2108 if (isPair)
2109 {
2110 CARLA_ASSERT(i+1 < pData->audioOut.count);
2111 carla_copyFloats(oldBufLeft, fAudioOutBuffers[i], frames);
2112 }
2113
2114 float balRangeL = (pData->postProc.balanceLeft + 1.0f)/2.0f;
2115 float balRangeR = (pData->postProc.balanceRight + 1.0f)/2.0f;
2116
2117 for (uint32_t k=0; k < frames; ++k)
2118 {
2119 if (isPair)
2120 {
2121 // left
2122 fAudioOutBuffers[i][k] = oldBufLeft[k] * (1.0f - balRangeL);
2123 fAudioOutBuffers[i][k] += fAudioOutBuffers[i+1][k] * (1.0f - balRangeR);
2124 }
2125 else
2126 {
2127 // right
2128 fAudioOutBuffers[i][k] = fAudioOutBuffers[i][k] * balRangeR;
2129 fAudioOutBuffers[i][k] += oldBufLeft[k] * balRangeL;
2130 }
2131 }
2132 }
2133
2134 // Volume (and buffer copy)
2135 {
2136 for (uint32_t k=0; k < frames; ++k)
2137 audioOut[i][k+timeOffset] = fAudioOutBuffers[i][k] * pData->postProc.volume;
2138 }
2139 }
2140
2141 } // End of Post-processing
2142
2143 # ifndef BUILD_BRIDGE
2144 // --------------------------------------------------------------------------------------------------------
2145 // Save latency values for next callback
2146
2147 if (pData->latency.frames != 0 && pData->latency.buffers != nullptr)
2148 {
2149 CARLA_SAFE_ASSERT(timeOffset == 0);
2150 const uint32_t latframes = pData->latency.frames;
2151
2152 if (latframes <= frames)
2153 {
2154 for (uint32_t i=0; i < pData->audioIn.count; ++i)
2155 carla_copyFloats(pData->latency.buffers[i], audioIn[i]+(frames-latframes), latframes);
2156 }
2157 else
2158 {
2159 const uint32_t diff = latframes - frames;
2160
2161 for (uint32_t i=0, k; i<pData->audioIn.count; ++i)
2162 {
2163 // push back buffer by 'frames'
2164 for (k=0; k < diff; ++k)
2165 pData->latency.buffers[i][k] = pData->latency.buffers[i][k+frames];
2166
2167 // put current input at the end
2168 for (uint32_t j=0; k < latframes; ++j, ++k)
2169 pData->latency.buffers[i][k] = audioIn[i][j];
2170 }
2171 }
2172 }
2173 # endif
2174 #else // BUILD_BRIDGE_ALTERNATIVE_ARCH
2175 for (uint32_t i=0; i < pData->audioOut.count; ++i)
2176 {
2177 for (uint32_t k=0; k < frames; ++k)
2178 audioOut[i][k+timeOffset] = fAudioOutBuffers[i][k];
2179 }
2180 #endif
2181
2182 // --------------------------------------------------------------------------------------------------------
2183
2184 pData->singleMutex.unlock();
2185 return true;
2186 }
2187
2188 void bufferSizeChanged(const uint32_t newBufferSize) override
2189 {
2190 CARLA_ASSERT_INT(newBufferSize > 0, newBufferSize);
2191 carla_debug("CarlaPluginLADSPADSSI::bufferSizeChanged(%i) - start", newBufferSize);
2192
2193 for (uint32_t i=0; i < pData->audioIn.count; ++i)
2194 {
2195 if (fAudioInBuffers[i] != nullptr)
2196 delete[] fAudioInBuffers[i];
2197
2198 fAudioInBuffers[i] = new float[newBufferSize];
2199 carla_zeroFloats(fAudioInBuffers[i], newBufferSize);
2200 }
2201
2202 for (uint32_t i=0; i < pData->audioOut.count; ++i)
2203 {
2204 if (fAudioOutBuffers[i] != nullptr)
2205 delete[] fAudioOutBuffers[i];
2206
2207 fAudioOutBuffers[i] = new float[newBufferSize];
2208 carla_zeroFloats(fAudioOutBuffers[i], newBufferSize);
2209 }
2210
2211 if (fExtraStereoBuffer[0] != nullptr)
2212 {
2213 delete[] fExtraStereoBuffer[0];
2214 fExtraStereoBuffer[0] = nullptr;
2215 }
2216
2217 if (fExtraStereoBuffer[1] != nullptr)
2218 {
2219 delete[] fExtraStereoBuffer[1];
2220 fExtraStereoBuffer[1] = nullptr;
2221 }
2222
2223 if (fForcedStereoIn && pData->audioOut.count == 2)
2224 {
2225 fExtraStereoBuffer[0] = new float[newBufferSize];
2226 fExtraStereoBuffer[1] = new float[newBufferSize];
2227 carla_zeroFloats(fExtraStereoBuffer[0], newBufferSize);
2228 carla_zeroFloats(fExtraStereoBuffer[1], newBufferSize);
2229 }
2230
2231 reconnectAudioPorts();
2232
2233 carla_debug("CarlaPluginLADSPADSSI::bufferSizeChanged(%i) - end", newBufferSize);
2234
2235 CarlaPlugin::bufferSizeChanged(newBufferSize);
2236 }
2237
2238 void sampleRateChanged(const double newSampleRate) override
2239 {
2240 CARLA_ASSERT_INT(newSampleRate > 0.0, newSampleRate);
2241 carla_debug("CarlaPluginLADSPADSSI::sampleRateChanged(%g) - start", newSampleRate);
2242
2243 // TODO - handle UI stuff
2244
2245 if (pData->active)
2246 deactivate();
2247
2248 const std::size_t instanceCount(fHandles.count());
2249
2250 if (fDescriptor->cleanup != nullptr)
2251 {
2252 for (LinkedList<LADSPA_Handle>::Itenerator it = fHandles.begin2(); it.valid(); it.next())
2253 {
2254 LADSPA_Handle const handle(it.getValue(nullptr));
2255 CARLA_SAFE_ASSERT_CONTINUE(handle != nullptr);
2256
2257 try {
2258 fDescriptor->cleanup(handle);
2259 } CARLA_SAFE_EXCEPTION("LADSPA/DSSI cleanup");
2260 }
2261 }
2262
2263 fHandles.clear();
2264
2265 for (std::size_t i=0; i<instanceCount; ++i)
2266 addInstance();
2267
2268 reconnectAudioPorts();
2269
2270 if (pData->active)
2271 activate();
2272
2273 carla_debug("CarlaPluginLADSPADSSI::sampleRateChanged(%g) - end", newSampleRate);
2274 }
2275
2276 void reconnectAudioPorts() const noexcept
2277 {
2278 if (fForcedStereoIn)
2279 {
2280 if (LADSPA_Handle const handle = fHandles.getFirst(nullptr))
2281 {
2282 try {
2283 fDescriptor->connect_port(handle, pData->audioIn.ports[0].rindex, fAudioInBuffers[0]);
2284 } CARLA_SAFE_EXCEPTION("LADSPA/DSSI connect_port (forced stereo input, first)");
2285 }
2286
2287 if (LADSPA_Handle const handle = fHandles.getLast(nullptr))
2288 {
2289 try {
2290 fDescriptor->connect_port(handle, pData->audioIn.ports[1].rindex, fAudioInBuffers[1]);
2291 } CARLA_SAFE_EXCEPTION("LADSPA/DSSI connect_port (forced stereo input, last)");
2292 }
2293 }
2294 else
2295 {
2296 for (LinkedList<LADSPA_Handle>::Itenerator it = fHandles.begin2(); it.valid(); it.next())
2297 {
2298 LADSPA_Handle const handle(it.getValue(nullptr));
2299 CARLA_SAFE_ASSERT_CONTINUE(handle != nullptr);
2300
2301 for (uint32_t i=0; i < pData->audioIn.count; ++i)
2302 {
2303 try {
2304 fDescriptor->connect_port(handle, pData->audioIn.ports[i].rindex, fAudioInBuffers[i]);
2305 } CARLA_SAFE_EXCEPTION("LADSPA/DSSI connect_port (audio input)");
2306 }
2307 }
2308 }
2309
2310 if (fForcedStereoOut)
2311 {
2312 if (LADSPA_Handle const handle = fHandles.getFirst(nullptr))
2313 {
2314 try {
2315 fDescriptor->connect_port(handle, pData->audioOut.ports[0].rindex, fAudioOutBuffers[0]);
2316 } CARLA_SAFE_EXCEPTION("LADSPA/DSSI connect_port (forced stereo output, first)");
2317 }
2318
2319 if (LADSPA_Handle const handle = fHandles.getLast(nullptr))
2320 {
2321 try {
2322 fDescriptor->connect_port(handle, pData->audioOut.ports[1].rindex, fAudioOutBuffers[1]);
2323 } CARLA_SAFE_EXCEPTION("LADSPA/DSSI connect_port (forced stereo output, last)");
2324 }
2325 }
2326 else
2327 {
2328 for (LinkedList<LADSPA_Handle>::Itenerator it = fHandles.begin2(); it.valid(); it.next())
2329 {
2330 LADSPA_Handle const handle(it.getValue(nullptr));
2331 CARLA_SAFE_ASSERT_CONTINUE(handle != nullptr);
2332
2333 for (uint32_t i=0; i < pData->audioOut.count; ++i)
2334 {
2335 try {
2336 fDescriptor->connect_port(handle, pData->audioOut.ports[i].rindex, fAudioOutBuffers[i]);
2337 } CARLA_SAFE_EXCEPTION("LADSPA/DSSI connect_port (audio output)");
2338 }
2339 }
2340 }
2341 }
2342
2343 // -------------------------------------------------------------------
2344 // Plugin buffers
2345
2346 void clearBuffers() noexcept override
2347 {
2348 carla_debug("CarlaPluginLADSPADSSI::clearBuffers() - start");
2349
2350 if (fAudioInBuffers != nullptr)
2351 {
2352 for (uint32_t i=0; i < pData->audioIn.count; ++i)
2353 {
2354 if (fAudioInBuffers[i] != nullptr)
2355 {
2356 delete[] fAudioInBuffers[i];
2357 fAudioInBuffers[i] = nullptr;
2358 }
2359 }
2360
2361 delete[] fAudioInBuffers;
2362 fAudioInBuffers = nullptr;
2363 }
2364
2365 if (fAudioOutBuffers != nullptr)
2366 {
2367 for (uint32_t i=0; i < pData->audioOut.count; ++i)
2368 {
2369 if (fAudioOutBuffers[i] != nullptr)
2370 {
2371 delete[] fAudioOutBuffers[i];
2372 fAudioOutBuffers[i] = nullptr;
2373 }
2374 }
2375
2376 delete[] fAudioOutBuffers;
2377 fAudioOutBuffers = nullptr;
2378 }
2379
2380 if (fExtraStereoBuffer[0] != nullptr)
2381 {
2382 delete[] fExtraStereoBuffer[0];
2383 fExtraStereoBuffer[0] = nullptr;
2384 }
2385
2386 if (fExtraStereoBuffer[1] != nullptr)
2387 {
2388 delete[] fExtraStereoBuffer[1];
2389 fExtraStereoBuffer[1] = nullptr;
2390 }
2391
2392 if (fParamBuffers != nullptr)
2393 {
2394 delete[] fParamBuffers;
2395 fParamBuffers = nullptr;
2396 }
2397
2398 CarlaPlugin::clearBuffers();
2399
2400 carla_debug("CarlaPluginLADSPADSSI::clearBuffers() - end");
2401 }
2402
2403 #ifdef CARLA_ENABLE_DSSI_PLUGIN_GUI
2404 // -------------------------------------------------------------------
2405 // OSC stuff
2406
2407 void handleOscMessage(const char* const method, const int argc, const void* const argvx, const char* const types, const lo_message msg) override
2408 {
2409 const lo_address source(lo_message_get_source(msg));
2410 CARLA_SAFE_ASSERT_RETURN(source != nullptr,);
2411
2412 // protocol for DSSI UIs *must* be UDP
2413 CARLA_SAFE_ASSERT_RETURN(lo_address_get_protocol(source) == LO_UDP,);
2414
2415 if (fOscData.source == nullptr)
2416 {
2417 // if no UI is registered yet only "configure" and "update" messages are valid
2418 CARLA_SAFE_ASSERT_RETURN(std::strcmp(method, "configure") == 0 || std::strcmp(method, "update") == 0,)
2419 }
2420 else
2421 {
2422 // make sure message source is the DSSI UI
2423 const char* const msghost = lo_address_get_hostname(source);
2424 const char* const msgport = lo_address_get_port(source);
2425
2426 const char* const ourhost = lo_address_get_hostname(fOscData.source);
2427 const char* const ourport = lo_address_get_port(fOscData.source);
2428
2429 CARLA_SAFE_ASSERT_RETURN(std::strcmp(msghost, ourhost) == 0,);
2430 CARLA_SAFE_ASSERT_RETURN(std::strcmp(msgport, ourport) == 0,);
2431 }
2432
2433 const lo_arg* const* const argv(static_cast<const lo_arg* const*>(argvx));
2434
2435 if (std::strcmp(method, "configure") == 0)
2436 return handleOscMessageConfigure(argc, argv, types);
2437 if (std::strcmp(method, "control") == 0)
2438 return handleOscMessageControl(argc, argv, types);
2439 if (std::strcmp(method, "program") == 0)
2440 return handleOscMessageProgram(argc, argv, types);
2441 if (std::strcmp(method, "midi") == 0)
2442 return handleOscMessageMIDI(argc, argv, types);
2443 if (std::strcmp(method, "update") == 0)
2444 return handleOscMessageUpdate(argc, argv, types, lo_message_get_source(msg));
2445 if (std::strcmp(method, "exiting") == 0)
2446 return handleOscMessageExiting();
2447
2448 carla_stdout("CarlaPluginLADSPADSSI::handleOscMessage() - unknown method '%s'", method);
2449 }
2450
2451 void handleOscMessageConfigure(const int argc, const lo_arg* const* const argv, const char* const types)
2452 {
2453 carla_debug("CarlaPluginLADSPADSSI::handleMsgConfigure()");
2454 CARLA_PLUGIN_DSSI_OSC_CHECK_OSC_TYPES(2, "ss");
2455
2456 const char* const key = (const char*)&argv[0]->s;
2457 const char* const value = (const char*)&argv[1]->s;
2458
2459 setCustomData(CUSTOM_DATA_TYPE_STRING, key, value, false);
2460 }
2461
2462 void handleOscMessageControl(const int argc, const lo_arg* const* const argv, const char* const types)
2463 {
2464 carla_debug("CarlaPluginLADSPADSSI::handleMsgControl()");
2465 CARLA_PLUGIN_DSSI_OSC_CHECK_OSC_TYPES(2, "if");
2466
2467 const int32_t rindex = argv[0]->i;
2468 const float value = argv[1]->f;
2469
2470 setParameterValueByRealIndex(rindex, value, false, true, true);
2471 }
2472
2473 void handleOscMessageProgram(const int argc, const lo_arg* const* const argv, const char* const types)
2474 {
2475 carla_debug("CarlaPluginLADSPADSSI::handleMsgProgram()");
2476 CARLA_PLUGIN_DSSI_OSC_CHECK_OSC_TYPES(2, "ii");
2477
2478 const int32_t bank = argv[0]->i;
2479 const int32_t program = argv[1]->i;
2480
2481 CARLA_SAFE_ASSERT_RETURN(bank >= 0,);
2482 CARLA_SAFE_ASSERT_RETURN(program >= 0,);
2483
2484 setMidiProgramById(static_cast<uint32_t>(bank), static_cast<uint32_t>(program), false, true, true);
2485 }
2486
2487 void handleOscMessageMIDI(const int argc, const lo_arg* const* const argv, const char* const types)
2488 {
2489 carla_debug("CarlaPluginLADSPADSSI::handleMsgMidi()");
2490 CARLA_PLUGIN_DSSI_OSC_CHECK_OSC_TYPES(1, "m");
2491
2492 if (getMidiInCount() == 0)
2493 {
2494 carla_stderr("CarlaPluginLADSPADSSI::handleMsgMidi() - received midi when plugin has no midi inputs");
2495 return;
2496 }
2497
2498 const uint8_t* const data = argv[0]->m;
2499 uint8_t status = data[1];
2500 uint8_t channel = status & 0x0F;
2501
2502 // Fix bad note-off
2503 if (MIDI_IS_STATUS_NOTE_ON(status) && data[3] == 0)
2504 status = MIDI_STATUS_NOTE_OFF;
2505
2506 if (MIDI_IS_STATUS_NOTE_OFF(status))
2507 {
2508 const uint8_t note = data[2];
2509
2510 CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);
2511
2512 sendMidiSingleNote(channel, note, 0, false, true, true);
2513 }
2514 else if (MIDI_IS_STATUS_NOTE_ON(status))
2515 {
2516 const uint8_t note = data[2];
2517 const uint8_t velo = data[3];
2518
2519 CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);
2520 CARLA_SAFE_ASSERT_RETURN(velo < MAX_MIDI_VALUE,);
2521
2522 sendMidiSingleNote(channel, note, velo, false, true, true);
2523 }
2524 }
2525
2526 void handleOscMessageUpdate(const int argc, const lo_arg* const* const argv, const char* const types, const lo_address source)
2527 {
2528 carla_debug("CarlaPluginLADSPADSSI::handleMsgUpdate()");
2529 CARLA_PLUGIN_DSSI_OSC_CHECK_OSC_TYPES(1, "s");
2530
2531 const char* const url = (const char*)&argv[0]->s;
2532
2533 // FIXME - remove debug prints later
2534 carla_stdout("CarlaPluginLADSPADSSI::updateOscData(%p, \"%s\")", source, url);
2535
2536 fOscData.clear();
2537
2538 const int proto = lo_address_get_protocol(source);
2539
2540 {
2541 const char* host = lo_address_get_hostname(source);
2542 const char* port = lo_address_get_port(source);
2543 fOscData.source = lo_address_new_with_proto(proto, host, port);
2544
2545 carla_stdout("CarlaPlugin::updateOscData() - source: host \"%s\", port \"%s\"", host, port);
2546 }
2547
2548 {
2549 char* host = lo_url_get_hostname(url);
2550 char* port = lo_url_get_port(url);
2551 fOscData.path = carla_strdup_free(lo_url_get_path(url));
2552 fOscData.target = lo_address_new_with_proto(proto, host, port);
2553 carla_stdout("CarlaPlugin::updateOscData() - target: host \"%s\", port \"%s\", path \"%s\"", host, port, fOscData.path);
2554
2555 std::free(host);
2556 std::free(port);
2557 }
2558
2559 osc_send_sample_rate(fOscData, static_cast<float>(pData->engine->getSampleRate()));
2560
2561 for (LinkedList<CustomData>::Itenerator it = pData->custom.begin2(); it.valid(); it.next())
2562 {
2563 const CustomData& customData(it.getValue(kCustomDataFallback));
2564 CARLA_SAFE_ASSERT_CONTINUE(customData.isValid());
2565
2566 if (std::strcmp(customData.type, CUSTOM_DATA_TYPE_STRING) == 0)
2567 osc_send_configure(fOscData, customData.key, customData.value);
2568 }
2569
2570 if (pData->prog.current >= 0)
2571 osc_send_program(fOscData, static_cast<uint32_t>(pData->prog.current));
2572
2573 if (pData->midiprog.current >= 0)
2574 {
2575 const MidiProgramData& curMidiProg(pData->midiprog.getCurrent());
2576 osc_send_program(fOscData, curMidiProg.bank, curMidiProg.program);
2577 }
2578
2579 for (uint32_t i=0; i < pData->param.count; ++i)
2580 osc_send_control(fOscData, pData->param.data[i].rindex, getParameterValue(i));
2581
2582 #ifndef BUILD_BRIDGE
2583 if (pData->engine->getOptions().frontendWinId != 0)
2584 pData->transientTryCounter = 1;
2585 #endif
2586
2587 carla_stdout("CarlaPluginLADSPADSSI::updateOscData() - done");
2588 }
2589
2590 void handleOscMessageExiting()
2591 {
2592 carla_debug("CarlaPluginLADSPADSSI::handleMsgExiting()");
2593
2594 // hide UI
2595 showCustomUI(false);
2596
2597 // tell frontend
2598 pData->engine->callback(true, true,
2599 ENGINE_CALLBACK_UI_STATE_CHANGED,
2600 pData->id,
2601 0,
2602 0, 0, 0.0f, nullptr);
2603 }
2604
2605 // -------------------------------------------------------------------
2606 // Post-poned UI Stuff
2607
2608 void uiParameterChange(const uint32_t index, const float value) noexcept override
2609 {
2610 CARLA_SAFE_ASSERT_RETURN(index < pData->param.count,);
2611
2612 if (fOscData.target == nullptr)
2613 return;
2614
2615 osc_send_control(fOscData, pData->param.data[index].rindex, value);
2616 }
2617
2618 void uiMidiProgramChange(const uint32_t index) noexcept override
2619 {
2620 CARLA_SAFE_ASSERT_RETURN(index < pData->midiprog.count,);
2621
2622 if (fOscData.target == nullptr)
2623 return;
2624
2625 osc_send_program(fOscData, pData->midiprog.data[index].bank, pData->midiprog.data[index].program);
2626 }
2627
2628 void uiNoteOn(const uint8_t channel, const uint8_t note, const uint8_t velo) noexcept override
2629 {
2630 CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);
2631 CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);
2632 CARLA_SAFE_ASSERT_RETURN(velo > 0 && velo < MAX_MIDI_VALUE,);
2633
2634 if (fOscData.target == nullptr)
2635 return;
2636
2637 #if 0
2638 uint8_t midiData[4];
2639 midiData[0] = 0;
2640 midiData[1] = uint8_t(MIDI_STATUS_NOTE_ON | (channel & MIDI_CHANNEL_BIT));
2641 midiData[2] = note;
2642 midiData[3] = velo;
2643
2644 osc_send_midi(fOscData, midiData);
2645 #endif
2646 }
2647
2648 void uiNoteOff(const uint8_t channel, const uint8_t note) noexcept override
2649 {
2650 CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);
2651 CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);
2652
2653 if (fOscData.target == nullptr)
2654 return;
2655
2656 #if 0
2657 uint8_t midiData[4];
2658 midiData[0] = 0;
2659 midiData[1] = uint8_t(MIDI_STATUS_NOTE_ON | (channel & MIDI_CHANNEL_BIT));
2660 midiData[2] = note;
2661 midiData[3] = 0;
2662
2663 osc_send_midi(fOscData, midiData);
2664 #endif
2665 }
2666 #endif // CARLA_ENABLE_DSSI_PLUGIN_GUI
2667
2668 // -------------------------------------------------------------------
2669
2670 const void* getNativeDescriptor() const noexcept override
2671 {
2672 return fDssiDescriptor != nullptr
2673 ? (const void*)fDssiDescriptor
2674 : (const void*)fDescriptor;
2675 }
2676
2677 const void* getExtraStuff() const noexcept override
2678 {
2679 if (fDssiDescriptor != nullptr)
2680 {
2681 #ifdef CARLA_ENABLE_DSSI_PLUGIN_GUI
2682 return fUiFilename;
2683 #else
2684 return nullptr;
2685 #endif
2686 }
2687 return fRdfDescriptor;
2688 }
2689
2690 #ifdef CARLA_ENABLE_DSSI_PLUGIN_GUI
2691 uintptr_t getUiBridgeProcessId() const noexcept override
2692 {
2693 return fThreadUI.getProcessId();
2694 }
2695 #endif
2696
2697 // -------------------------------------------------------------------
2698
2699 bool initLADSPA(const CarlaPluginPtr plugin,
2700 const char* const filename, const char* name, const char* const label, const uint options,
2701 const LADSPA_RDF_Descriptor* const rdfDescriptor)
2702 {
2703 CARLA_SAFE_ASSERT_RETURN(pData->engine != nullptr, false);
2704
2705 // ---------------------------------------------------------------
2706 // first checks
2707
2708 if (pData->client != nullptr)
2709 {
2710 pData->engine->setLastError("Plugin client is already registered");
2711 return false;
2712 }
2713
2714 if (filename == nullptr || filename[0] == '\0')
2715 {
2716 pData->engine->setLastError("null filename");
2717 return false;
2718 }
2719
2720 // ---------------------------------------------------------------
2721 // open DLL
2722
2723 if (! pData->libOpen(filename))
2724 {
2725 pData->engine->setLastError(pData->libError(filename));
2726 return false;
2727 }
2728
2729 // ---------------------------------------------------------------
2730 // get DLL main entry
2731
2732 const LADSPA_Descriptor_Function descFn = pData->libSymbol<LADSPA_Descriptor_Function>("ladspa_descriptor");
2733
2734 if (descFn == nullptr)
2735 {
2736 pData->engine->setLastError("Could not find the LASDPA Descriptor in the plugin library");
2737 return false;
2738 }
2739
2740 // ---------------------------------------------------------------
2741 // get descriptor that matches label
2742
2743 // if label is null, get first valid plugin
2744 const bool nullLabel = (label == nullptr || label[0] == '\0');
2745
2746 for (ulong d=0;; ++d)
2747 {
2748 try {
2749 fDescriptor = descFn(d);
2750 }
2751 catch(...) {
2752 carla_stderr2("Caught exception when trying to get LADSPA descriptor");
2753 fDescriptor = nullptr;
2754 break;
2755 }
2756
2757 if (fDescriptor == nullptr)
2758 break;
2759
2760 if (fDescriptor->Label == nullptr || fDescriptor->Label[0] == '\0')
2761 {
2762 carla_stderr2("WARNING - Got an invalid label, will not use this plugin");
2763 fDescriptor = nullptr;
2764 break;
2765 }
2766 if (fDescriptor->run == nullptr)
2767 {
2768 carla_stderr2("WARNING - Plugin has no run, cannot use it");
2769 fDescriptor = nullptr;
2770 break;
2771 }
2772
2773 if (nullLabel || std::strcmp(fDescriptor->Label, label) == 0)
2774 break;
2775 }
2776
2777 if (fDescriptor == nullptr)
2778 {
2779 pData->engine->setLastError("Could not find the requested plugin label in the plugin library");
2780 return false;
2781 }
2782
2783 return init2(plugin, filename, name, options, rdfDescriptor);
2784 }
2785
2786 bool initDSSI(const CarlaPluginPtr plugin,
2787 const char* const filename, const char* name, const char* const label, const uint options)
2788 {
2789 CARLA_SAFE_ASSERT_RETURN(pData->engine != nullptr, false);
2790
2791 // ---------------------------------------------------------------
2792 // first checks
2793
2794 if (pData->client != nullptr)
2795 {
2796 pData->engine->setLastError("Plugin client is already registered");
2797 return false;
2798 }
2799
2800 if (filename == nullptr || filename[0] == '\0')
2801 {
2802 pData->engine->setLastError("null filename");
2803 return false;
2804 }
2805
2806 // ---------------------------------------------------------------
2807 // open DLL
2808
2809 if (! pData->libOpen(filename))
2810 {
2811 pData->engine->setLastError(pData->libError(filename));
2812 return false;
2813 }
2814
2815 // ---------------------------------------------------------------
2816 // get DLL main entry
2817
2818 const DSSI_Descriptor_Function descFn = pData->libSymbol<DSSI_Descriptor_Function>("dssi_descriptor");
2819
2820 if (descFn == nullptr)
2821 {
2822 pData->engine->setLastError("Could not find the DSSI Descriptor in the plugin library");
2823 return false;
2824 }
2825
2826 // ---------------------------------------------------------------
2827 // get descriptor that matches label
2828
2829 // if label is null, get first valid plugin
2830 const bool nullLabel = (label == nullptr || label[0] == '\0');
2831
2832 for (ulong d=0;; ++d)
2833 {
2834 try {
2835 fDssiDescriptor = descFn(d);
2836 }
2837 catch(...) {
2838 carla_stderr2("Caught exception when trying to get DSSI descriptor");
2839 fDescriptor = nullptr;
2840 fDssiDescriptor = nullptr;
2841 break;
2842 }
2843
2844 if (fDssiDescriptor == nullptr)
2845 break;
2846
2847 fDescriptor = fDssiDescriptor->LADSPA_Plugin;
2848
2849 if (fDescriptor == nullptr)
2850 {
2851 carla_stderr2("WARNING - Missing LADSPA interface, will not use this plugin");
2852 fDssiDescriptor = nullptr;
2853 break;
2854 }
2855 if (fDescriptor->Label == nullptr || fDescriptor->Label[0] == '\0')
2856 {
2857 carla_stderr2("WARNING - Got an invalid label, will not use this plugin");
2858 fDescriptor = nullptr;
2859 fDssiDescriptor = nullptr;
2860 break;
2861 }
2862 if (fDescriptor->run == nullptr)
2863 {
2864 carla_stderr2("WARNING - Plugin has no run, cannot use it");
2865 fDescriptor = nullptr;
2866 fDssiDescriptor = nullptr;
2867 break;
2868 }
2869
2870 if (nullLabel || std::strcmp(fDescriptor->Label, label) == 0)
2871 break;
2872 }
2873
2874 if (fDescriptor == nullptr || fDssiDescriptor == nullptr)
2875 {
2876 pData->engine->setLastError("Could not find the requested plugin label in the plugin library");
2877 return false;
2878 }
2879
2880 // ---------------------------------------------------------------
2881 // check if uses global instance
2882
2883 if (fDssiDescriptor->run_synth == nullptr && fDssiDescriptor->run_multiple_synths != nullptr)
2884 {
2885 pData->engine->setLastError("This plugin requires run_multiple_synths which is not supported");
2886 return false;
2887 }
2888
2889 return init2(plugin, filename, name, options, nullptr);
2890 }
2891
2892 bool init2(const CarlaPluginPtr plugin,
2893 const char* const filename, const char* name, const uint options,
2894 const LADSPA_RDF_Descriptor* const rdfDescriptor)
2895 {
2896 // ---------------------------------------------------------------
2897 // check for fixed buffer size requirement
2898
2899 fNeedsFixedBuffers = CarlaString(filename).contains("dssi-vst", true);
2900
2901 if (fNeedsFixedBuffers && ! pData->engine->usesConstantBufferSize())
2902 {
2903 pData->engine->setLastError("Cannot use this plugin under the current engine.\n"
2904 "The plugin requires a fixed block size which is not possible right now.");
2905 return false;
2906 }
2907
2908 // ---------------------------------------------------------------
2909 // get info
2910
2911 if (is_ladspa_rdf_descriptor_valid(rdfDescriptor, fDescriptor))
2912 fRdfDescriptor = ladspa_rdf_dup(rdfDescriptor);
2913
2914 if (name == nullptr || name[0] == '\0')
2915 {
2916 /**/ if (fRdfDescriptor != nullptr && fRdfDescriptor->Title != nullptr && fRdfDescriptor->Title[0] != '\0')
2917 name = fRdfDescriptor->Title;
2918 else if (fDescriptor->Name != nullptr && fDescriptor->Name[0] != '\0')
2919 name = fDescriptor->Name;
2920 else
2921 name = fDescriptor->Label;
2922 }
2923
2924 pData->name = pData->engine->getUniquePluginName(name);
2925 pData->filename = carla_strdup(filename);
2926
2927 // ---------------------------------------------------------------
2928 // register client
2929
2930 pData->client = pData->engine->addClient(plugin);
2931
2932 if (pData->client == nullptr || ! pData->client->isOk())
2933 {
2934 pData->engine->setLastError("Failed to register plugin client");
2935 return false;
2936 }
2937
2938 // ---------------------------------------------------------------
2939 // initialize plugin
2940
2941 if (! addInstance())
2942 return false;
2943
2944 // ---------------------------------------------------------------
2945 // find latency port index
2946
2947 for (uint32_t i=0, iCtrl=0, count=getSafePortCount(); i<count; ++i)
2948 {
2949 const int portType(fDescriptor->PortDescriptors[i]);
2950
2951 if (! LADSPA_IS_PORT_CONTROL(portType))
2952 continue;
2953
2954 const uint32_t index(iCtrl++);
2955
2956 if (! LADSPA_IS_PORT_OUTPUT(portType))
2957 continue;
2958
2959 const char* const portName(fDescriptor->PortNames[i]);
2960 CARLA_SAFE_ASSERT_BREAK(portName != nullptr);
2961
2962 if (std::strcmp(portName, "latency") == 0 ||
2963 std::strcmp(portName, "_latency") == 0)
2964 {
2965 fLatencyIndex = static_cast<int32_t>(index);
2966 break;
2967 }
2968 }
2969
2970 // ---------------------------------------------------------------
2971 // check for custom data extension
2972
2973 if (fDssiDescriptor != nullptr && fDssiDescriptor->configure != nullptr)
2974 {
2975 if (char* const error = fDssiDescriptor->configure(fHandles.getFirst(nullptr), DSSI_CUSTOMDATA_EXTENSION_KEY, ""))
2976 {
2977 if (std::strcmp(error, "true") == 0 && fDssiDescriptor->get_custom_data != nullptr
2978 && fDssiDescriptor->set_custom_data != nullptr)
2979 fUsesCustomData = true;
2980
2981 std::free(error);
2982 }
2983 }
2984
2985 // ---------------------------------------------------------------
2986 // get engine options
2987
2988 const EngineOptions& opts(pData->engine->getOptions());
2989
2990 #ifdef CARLA_ENABLE_DSSI_PLUGIN_GUI
2991 // ---------------------------------------------------------------
2992 // check for gui
2993
2994 if (opts.oscEnabled && opts.oscPortUDP >= 0)
2995 {
2996 if (const char* const guiFilename = find_dssi_ui(filename, fDescriptor->Label))
2997 {
2998 fUiFilename = guiFilename;
2999
3000 CarlaString uiTitle;
3001
3002 if (pData->uiTitle.isNotEmpty())
3003 {
3004 uiTitle = pData->uiTitle;
3005 }
3006 else
3007 {
3008 uiTitle = pData->name;
3009 uiTitle += " (GUI)";
3010 }
3011
3012 fThreadUI.setData(guiFilename, fDescriptor->Label, uiTitle);
3013 }
3014 }
3015 #endif
3016
3017 // ---------------------------------------------------------------
3018 // set options
3019
3020 pData->options = 0x0;
3021
3022 /**/ if (fLatencyIndex >= 0 || fNeedsFixedBuffers)
3023 pData->options |= PLUGIN_OPTION_FIXED_BUFFERS;
3024 else if (options & PLUGIN_OPTION_FIXED_BUFFERS)
3025 pData->options |= PLUGIN_OPTION_FIXED_BUFFERS;
3026
3027 /**/ if (opts.forceStereo)
3028 pData->options |= PLUGIN_OPTION_FORCE_STEREO;
3029 else if (options & PLUGIN_OPTION_FORCE_STEREO)
3030 pData->options |= PLUGIN_OPTION_FORCE_STEREO;
3031
3032 if (fDssiDescriptor != nullptr)
3033 {
3034 if (fDssiDescriptor->get_program != nullptr && fDssiDescriptor->select_program != nullptr)
3035 if (isPluginOptionEnabled(options, PLUGIN_OPTION_MAP_PROGRAM_CHANGES))
3036 pData->options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;
3037
3038 if (fUsesCustomData)
3039 if (isPluginOptionEnabled(options, PLUGIN_OPTION_USE_CHUNKS))
3040 pData->options |= PLUGIN_OPTION_USE_CHUNKS;
3041
3042 if (fDssiDescriptor->run_synth != nullptr)
3043 {
3044 if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_CONTROL_CHANGES))
3045 pData->options |= PLUGIN_OPTION_SEND_CONTROL_CHANGES;
3046 if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_CHANNEL_PRESSURE))
3047 pData->options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;
3048 if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH))
3049 pData->options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;
3050 if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_PITCHBEND))
3051 pData->options |= PLUGIN_OPTION_SEND_PITCHBEND;
3052 if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_ALL_SOUND_OFF))
3053 pData->options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;
3054 if (isPluginOptionInverseEnabled(options, PLUGIN_OPTION_SKIP_SENDING_NOTES))
3055 pData->options |= PLUGIN_OPTION_SKIP_SENDING_NOTES;
3056 }
3057 }
3058
3059 return true;
3060 }
3061
3062 // -------------------------------------------------------------------
3063
3064 private:
3065 LinkedList<LADSPA_Handle> fHandles;
3066 const LADSPA_Descriptor* fDescriptor;
3067 const DSSI_Descriptor* fDssiDescriptor;
3068 const LADSPA_RDF_Descriptor* fRdfDescriptor;
3069
3070 float** fAudioInBuffers;
3071 float** fAudioOutBuffers;
3072 float* fExtraStereoBuffer[2]; // used only if forcedStereoIn and audioOut == 2
3073 float* fParamBuffers;
3074
3075 snd_seq_event_t fMidiEvents[kPluginMaxMidiEvents];
3076
3077 int32_t fLatencyIndex; // -1 if invalid
3078 bool fForcedStereoIn;
3079 bool fForcedStereoOut;
3080 bool fNeedsFixedBuffers;
3081 bool fUsesCustomData;
3082
3083 #ifdef CARLA_ENABLE_DSSI_PLUGIN_GUI
3084 CarlaOscData fOscData;
3085 CarlaThreadDSSIUI fThreadUI;
3086 const char* fUiFilename;
3087 #endif
3088
3089 // -------------------------------------------------------------------
3090
3091 bool addInstance()
3092 {
3093 LADSPA_Handle handle;
3094
3095 try {
3096 handle = fDescriptor->instantiate(fDescriptor, static_cast<ulong>(pData->engine->getSampleRate()));
3097 } CARLA_SAFE_EXCEPTION_RETURN_ERR("LADSPA/DSSI instantiate", "Plugin failed to initialize");
3098
3099 for (uint32_t i=0, count=pData->param.count; i<count; ++i)
3100 {
3101 const int32_t rindex(pData->param.data[i].rindex);
3102 CARLA_SAFE_ASSERT_CONTINUE(rindex >= 0);
3103
3104 try {
3105 fDescriptor->connect_port(handle, static_cast<ulong>(rindex), &fParamBuffers[i]);
3106 } CARLA_SAFE_EXCEPTION("LADSPA/DSSI connect_port");
3107 }
3108
3109 if (fHandles.append(handle))
3110 return true;
3111
3112 try {
3113 fDescriptor->cleanup(handle);
3114 } CARLA_SAFE_EXCEPTION("LADSPA/DSSI cleanup");
3115
3116 pData->engine->setLastError("Out of memory");
3117 return false;
3118 }
3119
3120 uint32_t getSafePortCount() const noexcept
3121 {
3122 if (fDescriptor->PortCount == 0)
3123 return 0;
3124
3125 CARLA_SAFE_ASSERT_RETURN(fDescriptor->PortDescriptors != nullptr, 0);
3126 CARLA_SAFE_ASSERT_RETURN(fDescriptor->PortRangeHints != nullptr, 0);
3127 CARLA_SAFE_ASSERT_RETURN(fDescriptor->PortNames != nullptr, 0);
3128
3129 return static_cast<uint32_t>(fDescriptor->PortCount);
3130 }
3131
3132 bool getSeparatedParameterNameOrUnit(const char* const paramName, char* const strBuf, const bool wantName) const noexcept
3133 {
3134 if (_getSeparatedParameterNameOrUnitImpl(paramName, strBuf, wantName, true))
3135 return true;
3136 if (_getSeparatedParameterNameOrUnitImpl(paramName, strBuf, wantName, false))
3137 return true;
3138 return false;
3139 }
3140
3141 static bool _getSeparatedParameterNameOrUnitImpl(const char* const paramName, char* const strBuf,
3142 const bool wantName, const bool useBracket) noexcept
3143 {
3144 const char* const sepBracketStart = std::strstr(paramName, useBracket ? " [" : " (");
3145
3146 if (sepBracketStart == nullptr)
3147 return false;
3148
3149 const char* const sepBracketEnd = std::strstr(sepBracketStart, useBracket ? "]" : ")");
3150
3151 if (sepBracketEnd == nullptr)
3152 return false;
3153
3154 const std::size_t unitSize = static_cast<std::size_t>(sepBracketEnd-sepBracketStart-2);
3155
3156 if (unitSize > 7) // very unlikely to have such big unit
3157 return false;
3158
3159 const std::size_t sepIndex = std::strlen(paramName)-unitSize-3;
3160
3161 // just in case
3162 if (sepIndex > STR_MAX-3)
3163 return false;
3164
3165 if (wantName)
3166 {
3167 std::strncpy(strBuf, paramName, sepIndex);
3168 strBuf[sepIndex] = '\0';
3169 }
3170 else
3171 {
3172 std::strncpy(strBuf, paramName+(sepIndex+2), unitSize);
3173 strBuf[unitSize] = '\0';
3174 }
3175
3176 return true;
3177 }
3178
3179 // -------------------------------------------------------------------
3180
3181 CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaPluginLADSPADSSI)
3182 };
3183
3184 // -------------------------------------------------------------------------------------------------------------------
3185
3186 CarlaPluginPtr CarlaPlugin::newLADSPA(const Initializer& init, const LADSPA_RDF_Descriptor* const rdfDescriptor)
3187 {
3188 carla_debug("CarlaPlugin::newLADSPA({%p, \"%s\", \"%s\", \"%s\", " P_INT64 ", %x}, %p)",
3189 init.engine, init.filename, init.name, init.label, init.uniqueId, init.options, rdfDescriptor);
3190
3191 std::shared_ptr<CarlaPluginLADSPADSSI> plugin(new CarlaPluginLADSPADSSI(init.engine, init.id));
3192
3193 if (! plugin->initLADSPA(plugin, init.filename, init.name, init.label, init.options, rdfDescriptor))
3194 return nullptr;
3195
3196 return plugin;
3197 }
3198
3199 CarlaPluginPtr CarlaPlugin::newDSSI(const Initializer& init)
3200 {
3201 carla_debug("CarlaPlugin::newDSSI({%p, \"%s\", \"%s\", \"%s\", " P_INT64 ", %x})",
3202 init.engine, init.filename, init.name, init.label, init.uniqueId, init.options);
3203
3204 std::shared_ptr<CarlaPluginLADSPADSSI> plugin(new CarlaPluginLADSPADSSI(init.engine, init.id));
3205
3206 if (! plugin->initDSSI(plugin, init.filename, init.name, init.label, init.options))
3207 return nullptr;
3208
3209 return plugin;
3210 }
3211
3212 // -------------------------------------------------------------------------------------------------------------------
3213
3214 CARLA_BACKEND_END_NAMESPACE