1 /*
2 * Carla Plugin Bridge
3 * Copyright (C) 2011-2020 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
20 #include "CarlaBackendUtils.hpp"
21 #include "CarlaBase64Utils.hpp"
22 #include "CarlaBridgeUtils.hpp"
23 #include "CarlaEngineUtils.hpp"
24 #include "CarlaMathUtils.hpp"
25 #include "CarlaPipeUtils.hpp"
26 #include "CarlaScopeUtils.hpp"
27 #include "CarlaShmUtils.hpp"
28 #include "CarlaThread.hpp"
29
30 #include "jackbridge/JackBridge.hpp"
31
32 #include <ctime>
33
34 #include "water/files/File.h"
35 #include "water/misc/Time.h"
36 #include "water/threads/ChildProcess.h"
37
38 // ---------------------------------------------------------------------------------------------------------------------
39
40 using water::ChildProcess;
41 using water::File;
42 using water::String;
43 using water::StringArray;
44 using water::Time;
45
46 CARLA_BACKEND_START_NAMESPACE
47
48 // ---------------------------------------------------------------------------------------------------------------------
49 // Fallback data
50
51 static const ExternalMidiNote kExternalMidiNoteFallback = { -1, 0, 0 };
52
53 // ---------------------------------------------------------------------------------------------------------------------
54
findWinePrefix(const String filename,const int recursionLimit=10)55 static String findWinePrefix(const String filename, const int recursionLimit = 10)
56 {
57 if (recursionLimit == 0 || filename.length() < 5 || ! filename.contains("/"))
58 return "";
59
60 const String path(filename.upToLastOccurrenceOf("/", false, false));
61
62 if (File(path + "/dosdevices").isDirectory())
63 return path;
64
65 return findWinePrefix(path, recursionLimit-1);
66 }
67
68 // ---------------------------------------------------------------------------------------------------------------------
69
70 struct BridgeParamInfo {
71 float value;
72 CarlaString name;
73 CarlaString symbol;
74 CarlaString unit;
75
BridgeParamInfoBridgeParamInfo76 BridgeParamInfo() noexcept
77 : value(0.0f),
78 name(),
79 symbol(),
80 unit() {}
81
82 CARLA_DECLARE_NON_COPY_STRUCT(BridgeParamInfo)
83 };
84
85 // ---------------------------------------------------------------------------------------------------------------------
86
87 class CarlaPluginBridgeThread : public CarlaThread
88 {
89 public:
CarlaPluginBridgeThread(CarlaEngine * const engine,CarlaPlugin * const plugin)90 CarlaPluginBridgeThread(CarlaEngine* const engine, CarlaPlugin* const plugin) noexcept
91 : CarlaThread("CarlaPluginBridgeThread"),
92 kEngine(engine),
93 kPlugin(plugin),
94 fBinaryArchName(),
95 fBridgeBinary(),
96 fLabel(),
97 fShmIds(),
98 #ifndef CARLA_OS_WIN
99 fWinePrefix(),
100 #endif
101 fProcess() {}
102
setData(const char * const winePrefix,const char * const binaryArchName,const char * const bridgeBinary,const char * const label,const char * const shmIds)103 void setData(
104 #ifndef CARLA_OS_WIN
105 const char* const winePrefix,
106 #endif
107 const char* const binaryArchName,
108 const char* const bridgeBinary,
109 const char* const label,
110 const char* const shmIds) noexcept
111 {
112 CARLA_SAFE_ASSERT_RETURN(bridgeBinary != nullptr && bridgeBinary[0] != '\0',);
113 CARLA_SAFE_ASSERT_RETURN(shmIds != nullptr && shmIds[0] != '\0',);
114 CARLA_SAFE_ASSERT(! isThreadRunning());
115
116 #ifndef CARLA_OS_WIN
117 fWinePrefix = winePrefix;
118 #endif
119 fBinaryArchName = binaryArchName;
120 fBridgeBinary = bridgeBinary;
121 fShmIds = shmIds;
122
123 if (label != nullptr)
124 fLabel = label;
125 if (fLabel.isEmpty())
126 fLabel = "(none)";
127 }
128
getProcessPID() const129 uintptr_t getProcessPID() const noexcept
130 {
131 CARLA_SAFE_ASSERT_RETURN(fProcess != nullptr, 0);
132
133 return (uintptr_t)fProcess->getPID();
134 }
135
136 protected:
run()137 void run()
138 {
139 if (fProcess == nullptr)
140 {
141 fProcess = new ChildProcess();
142 }
143 else if (fProcess->isRunning())
144 {
145 carla_stderr("CarlaPluginBridgeThread::run() - already running");
146 }
147
148 char strBuf[STR_MAX+1];
149 strBuf[STR_MAX] = '\0';
150
151 const EngineOptions& options(kEngine->getOptions());
152
153 String filename(kPlugin->getFilename());
154
155 if (filename.isEmpty())
156 filename = "(none)";
157
158 StringArray arguments;
159
160 #ifndef CARLA_OS_WIN
161 // start with "wine" if needed
162 if (fBridgeBinary.endsWithIgnoreCase(".exe"))
163 {
164 String wineCMD;
165
166 if (options.wine.executable != nullptr && options.wine.executable[0] != '\0')
167 {
168 wineCMD = options.wine.executable;
169
170 if (fBridgeBinary.endsWithIgnoreCase("64.exe")
171 && options.wine.executable[0] == CARLA_OS_SEP
172 && File(wineCMD + "64").existsAsFile())
173 wineCMD += "64";
174 }
175 else
176 {
177 wineCMD = "wine";
178 }
179
180 arguments.add(wineCMD);
181 }
182 #endif
183
184 // setup binary arch
185 ChildProcess::Type childType;
186 #ifdef CARLA_OS_MAC
187 if (fBinaryArchName == "arm64")
188 childType = ChildProcess::TypeARM;
189 else if (fBinaryArchName == "x86_64")
190 childType = ChildProcess::TypeIntel;
191 else
192 #endif
193 childType = ChildProcess::TypeAny;
194
195 // bridge binary
196 arguments.add(fBridgeBinary);
197
198 // plugin type
199 arguments.add(getPluginTypeAsString(kPlugin->getType()));
200
201 // filename
202 arguments.add(filename);
203
204 // label
205 arguments.add(fLabel);
206
207 // uniqueId
208 arguments.add(String(static_cast<water::int64>(kPlugin->getUniqueId())));
209
210 bool started;
211
212 {
213 const ScopedEngineEnvironmentLocker _seel(kEngine);
214
215 #ifdef CARLA_OS_LINUX
216 const CarlaScopedEnvVar sev1("LD_LIBRARY_PATH", nullptr);
217 const CarlaScopedEnvVar sev2("LD_PRELOAD", nullptr);
218 #endif
219
220 carla_setenv("ENGINE_OPTION_FORCE_STEREO", bool2str(options.forceStereo));
221 carla_setenv("ENGINE_OPTION_PREFER_PLUGIN_BRIDGES", bool2str(options.preferPluginBridges));
222 carla_setenv("ENGINE_OPTION_PREFER_UI_BRIDGES", bool2str(options.preferUiBridges));
223 carla_setenv("ENGINE_OPTION_UIS_ALWAYS_ON_TOP", bool2str(options.uisAlwaysOnTop));
224
225 std::snprintf(strBuf, STR_MAX, "%u", options.maxParameters);
226 carla_setenv("ENGINE_OPTION_MAX_PARAMETERS", strBuf);
227
228 std::snprintf(strBuf, STR_MAX, "%u", options.uiBridgesTimeout);
229 carla_setenv("ENGINE_OPTION_UI_BRIDGES_TIMEOUT",strBuf);
230
231 if (options.pathLADSPA != nullptr)
232 carla_setenv("ENGINE_OPTION_PLUGIN_PATH_LADSPA", options.pathLADSPA);
233 else
234 carla_setenv("ENGINE_OPTION_PLUGIN_PATH_LADSPA", "");
235
236 if (options.pathDSSI != nullptr)
237 carla_setenv("ENGINE_OPTION_PLUGIN_PATH_DSSI", options.pathDSSI);
238 else
239 carla_setenv("ENGINE_OPTION_PLUGIN_PATH_DSSI", "");
240
241 if (options.pathLV2 != nullptr)
242 carla_setenv("ENGINE_OPTION_PLUGIN_PATH_LV2", options.pathLV2);
243 else
244 carla_setenv("ENGINE_OPTION_PLUGIN_PATH_LV2", "");
245
246 if (options.pathVST2 != nullptr)
247 carla_setenv("ENGINE_OPTION_PLUGIN_PATH_VST2", options.pathVST2);
248 else
249 carla_setenv("ENGINE_OPTION_PLUGIN_PATH_VST2", "");
250
251 if (options.pathVST3 != nullptr)
252 carla_setenv("ENGINE_OPTION_PLUGIN_PATH_VST3", options.pathVST3);
253 else
254 carla_setenv("ENGINE_OPTION_PLUGIN_PATH_VST3", "");
255
256 if (options.pathSF2 != nullptr)
257 carla_setenv("ENGINE_OPTION_PLUGIN_PATH_SF2", options.pathSF2);
258 else
259 carla_setenv("ENGINE_OPTION_PLUGIN_PATH_SF2", "");
260
261 if (options.pathSFZ != nullptr)
262 carla_setenv("ENGINE_OPTION_PLUGIN_PATH_SFZ", options.pathSFZ);
263 else
264 carla_setenv("ENGINE_OPTION_PLUGIN_PATH_SFZ", "");
265
266 if (options.binaryDir != nullptr)
267 carla_setenv("ENGINE_OPTION_PATH_BINARIES", options.binaryDir);
268 else
269 carla_setenv("ENGINE_OPTION_PATH_BINARIES", "");
270
271 if (options.resourceDir != nullptr)
272 carla_setenv("ENGINE_OPTION_PATH_RESOURCES", options.resourceDir);
273 else
274 carla_setenv("ENGINE_OPTION_PATH_RESOURCES", "");
275
276 carla_setenv("ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR", bool2str(options.preventBadBehaviour));
277
278 std::snprintf(strBuf, STR_MAX, P_UINTPTR, options.frontendWinId);
279 carla_setenv("ENGINE_OPTION_FRONTEND_WIN_ID", strBuf);
280
281 carla_setenv("ENGINE_BRIDGE_SHM_IDS", fShmIds.toRawUTF8());
282
283 #ifndef CARLA_OS_WIN
284 if (fWinePrefix.isNotEmpty())
285 {
286 carla_setenv("WINEDEBUG", "-all");
287 carla_setenv("WINEPREFIX", fWinePrefix.toRawUTF8());
288
289 if (options.wine.rtPrio)
290 {
291 carla_setenv("STAGING_SHARED_MEMORY", "1");
292 carla_setenv("WINE_RT_POLICY", "FF");
293
294 std::snprintf(strBuf, STR_MAX, "%i", options.wine.baseRtPrio);
295 carla_setenv("STAGING_RT_PRIORITY_BASE", strBuf);
296 carla_setenv("WINE_RT", strBuf);
297 carla_setenv("WINE_RT_PRIO", strBuf);
298
299 std::snprintf(strBuf, STR_MAX, "%i", options.wine.serverRtPrio);
300 carla_setenv("STAGING_RT_PRIORITY_SERVER", strBuf);
301 carla_setenv("WINE_SVR_RT", strBuf);
302
303 carla_stdout("Using WINEPREFIX '%s', with base RT prio %i and server RT prio %i",
304 fWinePrefix.toRawUTF8(), options.wine.baseRtPrio, options.wine.serverRtPrio);
305 }
306 else
307 {
308 carla_unsetenv("STAGING_SHARED_MEMORY");
309 carla_unsetenv("WINE_RT_POLICY");
310 carla_unsetenv("STAGING_RT_PRIORITY_BASE");
311 carla_unsetenv("STAGING_RT_PRIORITY_SERVER");
312 carla_unsetenv("WINE_RT");
313 carla_unsetenv("WINE_RT_PRIO");
314 carla_unsetenv("WINE_SVR_RT");
315
316 carla_stdout("Using WINEPREFIX '%s', without RT priorities", fWinePrefix.toRawUTF8());
317 }
318 }
319 #endif
320
321 carla_stdout("Starting plugin bridge, command is:\n%s \"%s\" \"%s\" \"%s\" " P_INT64,
322 fBridgeBinary.toRawUTF8(), getPluginTypeAsString(kPlugin->getType()), filename.toRawUTF8(), fLabel.toRawUTF8(), kPlugin->getUniqueId());
323
324 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
325 const File projFolder(kEngine->getCurrentProjectFolder());
326
327 if (projFolder.isNotNull())
328 {
329 const File oldFolder(File::getCurrentWorkingDirectory());
330 projFolder.setAsCurrentWorkingDirectory();
331 started = fProcess->start(arguments, childType);
332 oldFolder.setAsCurrentWorkingDirectory();
333 }
334 else
335 #endif
336 {
337 started = fProcess->start(arguments, childType);
338 }
339 }
340
341 if (! started)
342 {
343 carla_stdout("failed!");
344 fProcess = nullptr;
345 return;
346 }
347
348 for (; fProcess->isRunning() && ! shouldThreadExit();)
349 carla_sleep(1);
350
351 // we only get here if bridge crashed or thread asked to exit
352 if (fProcess->isRunning() && shouldThreadExit())
353 {
354 fProcess->waitForProcessToFinish(2000);
355
356 if (fProcess->isRunning())
357 {
358 carla_stdout("CarlaPluginBridgeThread::run() - bridge refused to close, force kill now");
359 fProcess->kill();
360 }
361 else
362 {
363 carla_stdout("CarlaPluginBridgeThread::run() - bridge auto-closed successfully");
364 }
365 }
366 else
367 {
368 // forced quit, may have crashed
369 if (fProcess->getExitCodeAndClearPID() != 0)
370 {
371 carla_stderr("CarlaPluginBridgeThread::run() - bridge crashed");
372
373 CarlaString errorString("Plugin '" + CarlaString(kPlugin->getName()) + "' has crashed!\n"
374 "Saving now will lose its current settings.\n"
375 "Please remove this plugin, and not rely on it from this point.");
376 kEngine->callback(true, true,
377 CarlaBackend::ENGINE_CALLBACK_ERROR, kPlugin->getId(), 0, 0, 0, 0.0f, errorString);
378 }
379 }
380
381 fProcess = nullptr;
382 }
383
384 private:
385 CarlaEngine* const kEngine;
386 CarlaPlugin* const kPlugin;
387
388 String fBinaryArchName;
389 String fBridgeBinary;
390 String fLabel;
391 String fShmIds;
392 #ifndef CARLA_OS_WIN
393 String fWinePrefix;
394 #endif
395
396 CarlaScopedPointer<ChildProcess> fProcess;
397
398 CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaPluginBridgeThread)
399 };
400
401 // ---------------------------------------------------------------------------------------------------------------------
402
403 class CarlaPluginBridge : public CarlaPlugin
404 {
405 public:
CarlaPluginBridge(CarlaEngine * const engine,const uint id,const BinaryType btype,const PluginType ptype)406 CarlaPluginBridge(CarlaEngine* const engine, const uint id, const BinaryType btype, const PluginType ptype)
407 : CarlaPlugin(engine, id),
408 fBinaryType(btype),
409 fPluginType(ptype),
410 fBridgeVersion(6), // before kPluginBridgeNonRtServerVersion was a thing, API was at 6
411 fInitiated(false),
412 fInitError(false),
413 fSaved(true),
414 fTimedOut(false),
415 fTimedError(false),
416 fBufferSize(engine->getBufferSize()),
417 fProcWaitTime(0),
418 fBridgeBinary(),
419 fBridgeThread(engine, this),
420 fShmAudioPool(),
421 fShmRtClientControl(),
422 fShmNonRtClientControl(),
423 fShmNonRtServerControl(),
424 #ifndef CARLA_OS_WIN
425 fWinePrefix(),
426 #endif
427 fReceivingParamText(),
428 fInfo(),
429 fUniqueId(0),
430 fLatency(0),
431 fParams(nullptr)
432 {
433 carla_debug("CarlaPluginBridge::CarlaPluginBridge(%p, %i, %s, %s)", engine, id, BinaryType2Str(btype), PluginType2Str(ptype));
434
435 pData->hints |= PLUGIN_IS_BRIDGE;
436 }
437
~CarlaPluginBridge()438 ~CarlaPluginBridge() override
439 {
440 carla_debug("CarlaPluginBridge::~CarlaPluginBridge()");
441
442 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
443 // close UI
444 if (pData->hints & PLUGIN_HAS_CUSTOM_UI)
445 pData->transientTryCounter = 0;
446 #endif
447
448 pData->singleMutex.lock();
449 pData->masterMutex.lock();
450
451 if (pData->client != nullptr && pData->client->isActive())
452 pData->client->deactivate(true);
453
454 if (pData->active)
455 {
456 deactivate();
457 pData->active = false;
458 }
459
460 if (fBridgeThread.isThreadRunning())
461 {
462 fShmNonRtClientControl.writeOpcode(kPluginBridgeNonRtClientQuit);
463 fShmNonRtClientControl.commitWrite();
464
465 fShmRtClientControl.writeOpcode(kPluginBridgeRtClientQuit);
466 fShmRtClientControl.commitWrite();
467
468 if (! fTimedOut)
469 waitForClient("stopping", 3000);
470 }
471
472 fBridgeThread.stopThread(3000);
473
474 fShmNonRtServerControl.clear();
475 fShmNonRtClientControl.clear();
476 fShmRtClientControl.clear();
477 fShmAudioPool.clear();
478
479 clearBuffers();
480
481 fInfo.chunk.clear();
482 }
483
484 // -------------------------------------------------------------------
485 // Information (base)
486
getBinaryType() const487 BinaryType getBinaryType() const noexcept override
488 {
489 return fBinaryType;
490 }
491
getType() const492 PluginType getType() const noexcept override
493 {
494 return fPluginType;
495 }
496
getCategory() const497 PluginCategory getCategory() const noexcept override
498 {
499 return fInfo.category;
500 }
501
getUniqueId() const502 int64_t getUniqueId() const noexcept override
503 {
504 return fUniqueId;
505 }
506
getLatencyInFrames() const507 uint32_t getLatencyInFrames() const noexcept override
508 {
509 return fLatency;
510 }
511
512 // -------------------------------------------------------------------
513 // Information (count)
514
getMidiInCount() const515 uint32_t getMidiInCount() const noexcept override
516 {
517 return fInfo.mIns;
518 }
519
getMidiOutCount() const520 uint32_t getMidiOutCount() const noexcept override
521 {
522 return fInfo.mOuts;
523 }
524
525 // -------------------------------------------------------------------
526 // Information (current data)
527
getChunkData(void ** const dataPtr)528 std::size_t getChunkData(void** const dataPtr) noexcept override
529 {
530 CARLA_SAFE_ASSERT_RETURN(pData->options & PLUGIN_OPTION_USE_CHUNKS, 0);
531 CARLA_SAFE_ASSERT_RETURN(dataPtr != nullptr, 0);
532
533 waitForSaved();
534
535 CARLA_SAFE_ASSERT_RETURN(fInfo.chunk.size() > 0, 0);
536
537 #ifdef CARLA_PROPER_CPP11_SUPPORT
538 *dataPtr = fInfo.chunk.data();
539 #else
540 *dataPtr = &fInfo.chunk.front();
541 #endif
542 return fInfo.chunk.size();
543 }
544
545 // -------------------------------------------------------------------
546 // Information (per-plugin data)
547
getOptionsAvailable() const548 uint getOptionsAvailable() const noexcept override
549 {
550 return fInfo.optionsAvailable;
551 }
552
getParameterValue(const uint32_t parameterId) const553 float getParameterValue(const uint32_t parameterId) const noexcept override
554 {
555 CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, 0.0f);
556
557 return fParams[parameterId].value;
558 }
559
getLabel(char * const strBuf) const560 bool getLabel(char* const strBuf) const noexcept override
561 {
562 std::strncpy(strBuf, fInfo.label, STR_MAX);
563 return true;
564 }
565
getMaker(char * const strBuf) const566 bool getMaker(char* const strBuf) const noexcept override
567 {
568 std::strncpy(strBuf, fInfo.maker, STR_MAX);
569 return true;
570 }
571
getCopyright(char * const strBuf) const572 bool getCopyright(char* const strBuf) const noexcept override
573 {
574 std::strncpy(strBuf, fInfo.copyright, STR_MAX);
575 return true;
576 }
577
getRealName(char * const strBuf) const578 bool getRealName(char* const strBuf) const noexcept override
579 {
580 std::strncpy(strBuf, fInfo.name, STR_MAX);
581 return true;
582 }
583
getParameterName(const uint32_t parameterId,char * const strBuf) const584 bool getParameterName(const uint32_t parameterId, char* const strBuf) const noexcept override
585 {
586 CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, false);
587
588 std::strncpy(strBuf, fParams[parameterId].name.buffer(), STR_MAX);
589 return true;
590 }
591
getParameterText(const uint32_t parameterId,char * const strBuf)592 bool getParameterText(const uint32_t parameterId, char* const strBuf) noexcept override
593 {
594 CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, false);
595 CARLA_SAFE_ASSERT_RETURN(! fReceivingParamText.isCurrentlyWaitingData(), false);
596
597 const int32_t parameterIdi = static_cast<int32_t>(parameterId);
598 fReceivingParamText.setTargetData(parameterIdi, strBuf);
599
600 {
601 const CarlaMutexLocker _cml(fShmNonRtClientControl.mutex);
602
603 fShmNonRtClientControl.writeOpcode(kPluginBridgeNonRtClientGetParameterText);
604 fShmNonRtClientControl.writeInt(parameterIdi);
605 fShmNonRtClientControl.commitWrite();
606 }
607
608 if (waitForParameterText())
609 return true;
610
611 std::snprintf(strBuf, STR_MAX, "%.12g", static_cast<double>(fParams[parameterId].value));
612 return false;
613 }
614
getParameterSymbol(const uint32_t parameterId,char * const strBuf) const615 bool getParameterSymbol(const uint32_t parameterId, char* const strBuf) const noexcept override
616 {
617 CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, false);
618
619 std::strncpy(strBuf, fParams[parameterId].symbol.buffer(), STR_MAX);
620 return true;
621 }
622
getParameterUnit(const uint32_t parameterId,char * const strBuf) const623 bool getParameterUnit(const uint32_t parameterId, char* const strBuf) const noexcept override
624 {
625 CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, false);
626
627 std::strncpy(strBuf, fParams[parameterId].unit.buffer(), STR_MAX);
628 return true;
629 }
630
631 // -------------------------------------------------------------------
632 // Set data (state)
633
prepareForSave(bool)634 void prepareForSave(bool) noexcept override
635 {
636 fSaved = false;
637
638 {
639 const CarlaMutexLocker _cml(fShmNonRtClientControl.mutex);
640
641 fShmNonRtClientControl.writeOpcode(kPluginBridgeNonRtClientPrepareForSave);
642 fShmNonRtClientControl.commitWrite();
643 }
644 }
645
waitForParameterText()646 bool waitForParameterText()
647 {
648 bool success;
649 if (fReceivingParamText.wasDataReceived(&success))
650 return success;
651
652 const uint32_t timeoutEnd = Time::getMillisecondCounter() + 500; // 500 ms
653 const bool needsEngineIdle = pData->engine->getType() != kEngineTypePlugin;
654
655 for (; Time::getMillisecondCounter() < timeoutEnd && fBridgeThread.isThreadRunning();)
656 {
657 if (fReceivingParamText.wasDataReceived(&success))
658 return success;
659
660 if (needsEngineIdle)
661 pData->engine->idle();
662
663 carla_msleep(5);
664 }
665
666 if (! fBridgeThread.isThreadRunning())
667 {
668 carla_stderr("CarlaPluginBridge::waitForParameterText() - Bridge is not running");
669 return false;
670 }
671
672 carla_stderr("CarlaPluginBridge::waitForParameterText() - Timeout while requesting text");
673 return false;
674 }
675
waitForSaved()676 void waitForSaved()
677 {
678 if (fSaved)
679 return;
680
681 // TODO: only wait 1 minute for NI plugins
682 const uint32_t timeoutEnd = Time::getMillisecondCounter() + 60*1000; // 60 secs, 1 minute
683 const bool needsEngineIdle = pData->engine->getType() != kEngineTypePlugin;
684
685 for (; Time::getMillisecondCounter() < timeoutEnd && fBridgeThread.isThreadRunning();)
686 {
687 pData->engine->callback(true, true, ENGINE_CALLBACK_IDLE, 0, 0, 0, 0, 0.0f, nullptr);
688
689 if (needsEngineIdle)
690 pData->engine->idle();
691
692 if (fSaved)
693 break;
694
695 carla_msleep(20);
696 }
697
698 if (! fBridgeThread.isThreadRunning())
699 return carla_stderr("CarlaPluginBridge::waitForSaved() - Bridge is not running");
700 if (! fSaved)
701 return carla_stderr("CarlaPluginBridge::waitForSaved() - Timeout while requesting save state");
702 }
703
704 // -------------------------------------------------------------------
705 // Set data (internal stuff)
706
setOption(const uint option,const bool yesNo,const bool sendCallback)707 void setOption(const uint option, const bool yesNo, const bool sendCallback) override
708 {
709 {
710 const CarlaMutexLocker _cml(fShmNonRtClientControl.mutex);
711
712 fShmNonRtClientControl.writeOpcode(kPluginBridgeNonRtClientSetOption);
713 fShmNonRtClientControl.writeUInt(option);
714 fShmNonRtClientControl.writeBool(yesNo);
715 fShmNonRtClientControl.commitWrite();
716 }
717
718 CarlaPlugin::setOption(option, yesNo, sendCallback);
719 }
720
setCtrlChannel(const int8_t channel,const bool sendOsc,const bool sendCallback)721 void setCtrlChannel(const int8_t channel, const bool sendOsc, const bool sendCallback) noexcept override
722 {
723 CARLA_SAFE_ASSERT_RETURN(sendOsc || sendCallback,);
724
725 {
726 const CarlaMutexLocker _cml(fShmNonRtClientControl.mutex);
727
728 fShmNonRtClientControl.writeOpcode(kPluginBridgeNonRtClientSetCtrlChannel);
729 fShmNonRtClientControl.writeShort(channel);
730 fShmNonRtClientControl.commitWrite();
731 }
732
733 CarlaPlugin::setCtrlChannel(channel, sendOsc, sendCallback);
734 }
735
setName(const char * const newName)736 void setName(const char* const newName) override
737 {
738 CarlaPlugin::setName(newName);
739
740 if (pData->uiTitle.isEmpty() && fBridgeVersion >= 8)
741 _setUiTitleFromName();
742 }
743
744 // -------------------------------------------------------------------
745 // Set data (plugin-specific stuff)
746
setParameterValue(const uint32_t parameterId,const float value,const bool sendGui,const bool sendOsc,const bool sendCallback)747 void setParameterValue(const uint32_t parameterId, const float value, const bool sendGui, const bool sendOsc, const bool sendCallback) noexcept override
748 {
749 CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count,);
750 CARLA_SAFE_ASSERT_RETURN(sendGui || sendOsc || sendCallback,);
751
752 const float fixedValue(pData->param.getFixedValue(parameterId, value));
753 fParams[parameterId].value = fixedValue;
754
755 {
756 const CarlaMutexLocker _cml(fShmNonRtClientControl.mutex);
757
758 fShmNonRtClientControl.writeOpcode(kPluginBridgeNonRtClientSetParameterValue);
759 fShmNonRtClientControl.writeUInt(parameterId);
760 fShmNonRtClientControl.writeFloat(value);
761 fShmNonRtClientControl.commitWrite();
762 fShmNonRtClientControl.waitIfDataIsReachingLimit();
763 }
764
765 CarlaPlugin::setParameterValue(parameterId, fixedValue, sendGui, sendOsc, sendCallback);
766 }
767
setParameterValueRT(const uint32_t parameterId,const float value,const bool sendCallbackLater)768 void setParameterValueRT(const uint32_t parameterId, const float value, const bool sendCallbackLater) noexcept override
769 {
770 CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count,);
771
772 const float fixedValue(pData->param.getFixedValue(parameterId, value));
773 fParams[parameterId].value = fixedValue;
774
775 {
776 const CarlaMutexLocker _cml(fShmNonRtClientControl.mutex);
777
778 fShmNonRtClientControl.writeOpcode(kPluginBridgeNonRtClientSetParameterValue);
779 fShmNonRtClientControl.writeUInt(parameterId);
780 fShmNonRtClientControl.writeFloat(value);
781 fShmNonRtClientControl.commitWrite();
782 fShmNonRtClientControl.waitIfDataIsReachingLimit();
783 }
784
785 CarlaPlugin::setParameterValueRT(parameterId, fixedValue, sendCallbackLater);
786 }
787
setParameterMidiChannel(const uint32_t parameterId,const uint8_t channel,const bool sendOsc,const bool sendCallback)788 void setParameterMidiChannel(const uint32_t parameterId, const uint8_t channel, const bool sendOsc, const bool sendCallback) noexcept override
789 {
790 CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count,);
791 CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);
792 CARLA_SAFE_ASSERT_RETURN(sendOsc || sendCallback,);
793
794 {
795 const CarlaMutexLocker _cml(fShmNonRtClientControl.mutex);
796
797 fShmNonRtClientControl.writeOpcode(kPluginBridgeNonRtClientSetParameterMidiChannel);
798 fShmNonRtClientControl.writeUInt(parameterId);
799 fShmNonRtClientControl.writeByte(channel);
800 fShmNonRtClientControl.commitWrite();
801 }
802
803 CarlaPlugin::setParameterMidiChannel(parameterId, channel, sendOsc, sendCallback);
804 }
805
setParameterMappedControlIndex(const uint32_t parameterId,const int16_t index,const bool sendOsc,const bool sendCallback,const bool reconfigureNow)806 void setParameterMappedControlIndex(const uint32_t parameterId, const int16_t index,
807 const bool sendOsc, const bool sendCallback,
808 const bool reconfigureNow) noexcept override
809 {
810 CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count,);
811 CARLA_SAFE_ASSERT_RETURN(index >= CONTROL_INDEX_NONE && index <= CONTROL_INDEX_MAX_ALLOWED,);
812 CARLA_SAFE_ASSERT_RETURN(sendOsc || sendCallback,);
813
814 {
815 const CarlaMutexLocker _cml(fShmNonRtClientControl.mutex);
816
817 fShmNonRtClientControl.writeOpcode(kPluginBridgeNonRtClientSetParameterMappedControlIndex);
818 fShmNonRtClientControl.writeUInt(parameterId);
819 fShmNonRtClientControl.writeShort(index);
820 fShmNonRtClientControl.commitWrite();
821 }
822
823 CarlaPlugin::setParameterMappedControlIndex(parameterId, index, sendOsc, sendCallback, reconfigureNow);
824 }
825
setParameterMappedRange(const uint32_t parameterId,const float minimum,const float maximum,const bool sendOsc,const bool sendCallback)826 void setParameterMappedRange(const uint32_t parameterId, const float minimum, const float maximum, const bool sendOsc, const bool sendCallback) noexcept override
827 {
828 CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count,);
829 CARLA_SAFE_ASSERT_RETURN(sendOsc || sendCallback,);
830
831 // kPluginBridgeNonRtClientSetParameterMappedRange was added in API 7
832 if (fBridgeVersion >= 7)
833 {
834 const CarlaMutexLocker _cml(fShmNonRtClientControl.mutex);
835
836 fShmNonRtClientControl.writeOpcode(kPluginBridgeNonRtClientSetParameterMappedRange);
837 fShmNonRtClientControl.writeUInt(parameterId);
838 fShmNonRtClientControl.writeFloat(minimum);
839 fShmNonRtClientControl.writeFloat(maximum);
840 fShmNonRtClientControl.commitWrite();
841 }
842
843 CarlaPlugin::setParameterMappedRange(parameterId, minimum, maximum, sendOsc, sendCallback);
844 }
845
setProgram(const int32_t index,const bool sendGui,const bool sendOsc,const bool sendCallback,const bool doingInit)846 void setProgram(const int32_t index, const bool sendGui, const bool sendOsc, const bool sendCallback, const bool doingInit) noexcept override
847 {
848 CARLA_SAFE_ASSERT_RETURN(index >= -1 && index < static_cast<int32_t>(pData->prog.count),);
849 CARLA_SAFE_ASSERT_RETURN(sendGui || sendOsc || sendCallback || doingInit,);
850
851 {
852 const CarlaMutexLocker _cml(fShmNonRtClientControl.mutex);
853
854 fShmNonRtClientControl.writeOpcode(kPluginBridgeNonRtClientSetProgram);
855 fShmNonRtClientControl.writeInt(index);
856 fShmNonRtClientControl.commitWrite();
857 }
858
859 CarlaPlugin::setProgram(index, sendGui, sendOsc, sendCallback, doingInit);
860 }
861
setProgramRT(const uint32_t index,const bool sendCallbackLater)862 void setProgramRT(const uint32_t index, const bool sendCallbackLater) noexcept override
863 {
864 CARLA_SAFE_ASSERT_RETURN(index < pData->prog.count,);
865
866 {
867 const CarlaMutexLocker _cml(fShmNonRtClientControl.mutex);
868
869 fShmNonRtClientControl.writeOpcode(kPluginBridgeNonRtClientSetProgram);
870 fShmNonRtClientControl.writeInt(static_cast<int32_t>(index));
871 fShmNonRtClientControl.commitWrite();
872 }
873
874 CarlaPlugin::setProgramRT(index, sendCallbackLater);
875 }
876
setMidiProgram(const int32_t index,const bool sendGui,const bool sendOsc,const bool sendCallback,const bool doingInit)877 void setMidiProgram(const int32_t index, const bool sendGui, const bool sendOsc, const bool sendCallback, const bool doingInit) noexcept override
878 {
879 CARLA_SAFE_ASSERT_RETURN(index >= -1 && index < static_cast<int32_t>(pData->midiprog.count),);
880 CARLA_SAFE_ASSERT_RETURN(sendGui || sendOsc || sendCallback || doingInit,);
881
882 {
883 const CarlaMutexLocker _cml(fShmNonRtClientControl.mutex);
884
885 fShmNonRtClientControl.writeOpcode(kPluginBridgeNonRtClientSetMidiProgram);
886 fShmNonRtClientControl.writeInt(index);
887 fShmNonRtClientControl.commitWrite();
888 }
889
890 CarlaPlugin::setMidiProgram(index, sendGui, sendOsc, sendCallback, doingInit);
891 }
892
setMidiProgramRT(const uint32_t uindex,const bool sendCallbackLater)893 void setMidiProgramRT(const uint32_t uindex, const bool sendCallbackLater) noexcept override
894 {
895 CARLA_SAFE_ASSERT_RETURN(uindex < pData->midiprog.count,);
896
897 {
898 const CarlaMutexLocker _cml(fShmNonRtClientControl.mutex);
899
900 fShmNonRtClientControl.writeOpcode(kPluginBridgeNonRtClientSetMidiProgram);
901 fShmNonRtClientControl.writeInt(static_cast<int32_t>(uindex));
902 fShmNonRtClientControl.commitWrite();
903 }
904
905 CarlaPlugin::setMidiProgramRT(uindex, sendCallbackLater);
906 }
907
setCustomData(const char * const type,const char * const key,const char * const value,const bool sendGui)908 void setCustomData(const char* const type, const char* const key, const char* const value, const bool sendGui) override
909 {
910 CARLA_SAFE_ASSERT_RETURN(type != nullptr && type[0] != '\0',);
911 CARLA_SAFE_ASSERT_RETURN(key != nullptr && key[0] != '\0',);
912 CARLA_SAFE_ASSERT_RETURN(value != nullptr,);
913
914 if (std::strcmp(type, CUSTOM_DATA_TYPE_PROPERTY) == 0)
915 return CarlaPlugin::setCustomData(type, key, value, sendGui);
916
917 if (std::strcmp(type, CUSTOM_DATA_TYPE_STRING) == 0 && std::strcmp(key, "__CarlaPingOnOff__") == 0)
918 {
919 const CarlaMutexLocker _cml(fShmNonRtClientControl.mutex);
920
921 fShmNonRtClientControl.writeOpcode(kPluginBridgeNonRtClientPingOnOff);
922 fShmNonRtClientControl.writeBool(std::strcmp(value, "true") == 0);
923 fShmNonRtClientControl.commitWrite();
924 return;
925 }
926
927 const uint32_t typeLen(static_cast<uint32_t>(std::strlen(type)));
928 const uint32_t keyLen(static_cast<uint32_t>(std::strlen(key)));
929 const uint32_t valueLen(static_cast<uint32_t>(std::strlen(value)));
930
931 {
932 const CarlaMutexLocker _cml(fShmNonRtClientControl.mutex);
933
934 fShmNonRtClientControl.writeOpcode(kPluginBridgeNonRtClientSetCustomData);
935
936 fShmNonRtClientControl.writeUInt(typeLen);
937 fShmNonRtClientControl.writeCustomData(type, typeLen);
938
939 fShmNonRtClientControl.writeUInt(keyLen);
940 fShmNonRtClientControl.writeCustomData(key, keyLen);
941
942 fShmNonRtClientControl.writeUInt(valueLen);
943
944 if (valueLen > 0)
945 fShmNonRtClientControl.writeCustomData(value, valueLen);
946
947 fShmNonRtClientControl.commitWrite();
948 }
949
950 CarlaPlugin::setCustomData(type, key, value, sendGui);
951 }
952
setChunkData(const void * const data,const std::size_t dataSize)953 void setChunkData(const void* const data, const std::size_t dataSize) override
954 {
955 CARLA_SAFE_ASSERT_RETURN(pData->options & PLUGIN_OPTION_USE_CHUNKS,);
956 CARLA_SAFE_ASSERT_RETURN(data != nullptr,);
957 CARLA_SAFE_ASSERT_RETURN(dataSize > 0,);
958
959 CarlaString dataBase64(CarlaString::asBase64(data, dataSize));
960 CARLA_SAFE_ASSERT_RETURN(dataBase64.length() > 0,);
961
962 String filePath(File::getSpecialLocation(File::tempDirectory).getFullPathName());
963
964 filePath += CARLA_OS_SEP_STR ".CarlaChunk_";
965 filePath += fShmAudioPool.getFilenameSuffix();
966
967 if (File(filePath).replaceWithText(dataBase64.buffer()))
968 {
969 const uint32_t ulength(static_cast<uint32_t>(filePath.length()));
970
971 const CarlaMutexLocker _cml(fShmNonRtClientControl.mutex);
972
973 fShmNonRtClientControl.writeOpcode(kPluginBridgeNonRtClientSetChunkDataFile);
974 fShmNonRtClientControl.writeUInt(ulength);
975 fShmNonRtClientControl.writeCustomData(filePath.toRawUTF8(), ulength);
976 fShmNonRtClientControl.commitWrite();
977 }
978
979 // save data internally as well
980 fInfo.chunk.resize(dataSize);
981 #ifdef CARLA_PROPER_CPP11_SUPPORT
982 std::memcpy(fInfo.chunk.data(), data, dataSize);
983 #else
984 std::memcpy(&fInfo.chunk.front(), data, dataSize);
985 #endif
986 }
987
988 // -------------------------------------------------------------------
989 // Set ui stuff
990
setCustomUITitle(const char * const title)991 void setCustomUITitle(const char* const title) noexcept override
992 {
993 carla_debug("CarlaPluginBridge::setCustomUITitle(%s)", title);
994
995 if (fBridgeVersion >= 8)
996 {
997 const uint32_t size = static_cast<uint32_t>(std::strlen(title));
998
999 const CarlaMutexLocker _cml(fShmNonRtClientControl.mutex);
1000
1001 fShmNonRtClientControl.writeOpcode(kPluginBridgeNonRtClientSetWindowTitle);
1002 fShmNonRtClientControl.writeUInt(size);
1003 fShmNonRtClientControl.writeCustomData(title, size);
1004 fShmNonRtClientControl.commitWrite();
1005 }
1006
1007 CarlaPlugin::setCustomUITitle(title);
1008 }
1009
showCustomUI(const bool yesNo)1010 void showCustomUI(const bool yesNo) override
1011 {
1012 if (yesNo && pData->uiTitle.isEmpty() && fBridgeVersion >= 8)
1013 _setUiTitleFromName();
1014
1015 {
1016 const CarlaMutexLocker _cml(fShmNonRtClientControl.mutex);
1017
1018 fShmNonRtClientControl.writeOpcode(yesNo ? kPluginBridgeNonRtClientShowUI : kPluginBridgeNonRtClientHideUI);
1019 fShmNonRtClientControl.commitWrite();
1020 }
1021
1022 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
1023 if (yesNo)
1024 {
1025 pData->tryTransient();
1026 }
1027 else
1028 {
1029 pData->transientTryCounter = 0;
1030 }
1031 #endif
1032 }
1033
idle()1034 void idle() override
1035 {
1036 if (fBridgeThread.isThreadRunning())
1037 {
1038 if (fInitiated && fTimedOut && pData->active)
1039 setActive(false, true, true);
1040
1041 {
1042 const CarlaMutexLocker _cml(fShmNonRtClientControl.mutex);
1043
1044 fShmNonRtClientControl.writeOpcode(kPluginBridgeNonRtClientPing);
1045 fShmNonRtClientControl.commitWrite();
1046 }
1047
1048 try {
1049 handleNonRtData();
1050 } CARLA_SAFE_EXCEPTION("handleNonRtData");
1051 }
1052 else if (fInitiated)
1053 {
1054 fTimedOut = true;
1055 fTimedError = true;
1056 fInitiated = false;
1057 handleProcessStopped();
1058 }
1059
1060 CarlaPlugin::idle();
1061 }
1062
1063 // -------------------------------------------------------------------
1064 // Plugin state
1065
reload()1066 void reload() override
1067 {
1068 CARLA_SAFE_ASSERT_RETURN(pData->engine != nullptr,);
1069 carla_debug("CarlaPluginBridge::reload() - start");
1070
1071 const EngineProcessMode processMode(pData->engine->getProccessMode());
1072
1073 // Safely disable plugin for reload
1074 const ScopedDisabler sd(this);
1075
1076 // cleanup of previous data
1077 pData->audioIn.clear();
1078 pData->audioOut.clear();
1079 pData->cvIn.clear();
1080 pData->cvOut.clear();
1081 pData->event.clear();
1082
1083 bool needsCtrlIn, needsCtrlOut;
1084 needsCtrlIn = needsCtrlOut = false;
1085
1086 if (fInfo.aIns > 0)
1087 {
1088 pData->audioIn.createNew(fInfo.aIns);
1089 }
1090
1091 if (fInfo.aOuts > 0)
1092 {
1093 pData->audioOut.createNew(fInfo.aOuts);
1094 needsCtrlIn = true;
1095 }
1096
1097 if (fInfo.cvIns > 0)
1098 {
1099 pData->cvIn.createNew(fInfo.cvIns);
1100 }
1101
1102 if (fInfo.cvOuts > 0)
1103 {
1104 pData->cvOut.createNew(fInfo.cvOuts);
1105 }
1106
1107 if (fInfo.mIns > 0)
1108 needsCtrlIn = true;
1109
1110 if (fInfo.mOuts > 0)
1111 needsCtrlOut = true;
1112
1113 const uint portNameSize(pData->engine->getMaxPortNameSize());
1114 CarlaString portName;
1115
1116 // Audio Ins
1117 for (uint32_t j=0; j < fInfo.aIns; ++j)
1118 {
1119 portName.clear();
1120
1121 if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)
1122 {
1123 portName = pData->name;
1124 portName += ":";
1125 }
1126
1127 if (fInfo.aInNames != nullptr && fInfo.aInNames[j] != nullptr)
1128 {
1129 portName += fInfo.aInNames[j];
1130 }
1131 else if (fInfo.aIns > 1)
1132 {
1133 portName += "input_";
1134 portName += CarlaString(j+1);
1135 }
1136 else
1137 portName += "input";
1138
1139 portName.truncate(portNameSize);
1140
1141 pData->audioIn.ports[j].port = (CarlaEngineAudioPort*)pData->client->addPort(kEnginePortTypeAudio, portName, true, j);
1142 pData->audioIn.ports[j].rindex = j;
1143 }
1144
1145 // Audio Outs
1146 for (uint32_t j=0; j < fInfo.aOuts; ++j)
1147 {
1148 portName.clear();
1149
1150 if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)
1151 {
1152 portName = pData->name;
1153 portName += ":";
1154 }
1155
1156 if (fInfo.aOutNames != nullptr && fInfo.aOutNames[j] != nullptr)
1157 {
1158 portName += fInfo.aOutNames[j];
1159 }
1160 else if (fInfo.aOuts > 1)
1161 {
1162 portName += "output_";
1163 portName += CarlaString(j+1);
1164 }
1165 else
1166 portName += "output";
1167
1168 portName.truncate(portNameSize);
1169
1170 pData->audioOut.ports[j].port = (CarlaEngineAudioPort*)pData->client->addPort(kEnginePortTypeAudio, portName, false, j);
1171 pData->audioOut.ports[j].rindex = j;
1172 }
1173
1174 // TODO - MIDI
1175
1176 // CV Ins
1177 for (uint32_t j=0; j < fInfo.cvIns; ++j)
1178 {
1179 portName.clear();
1180
1181 if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)
1182 {
1183 portName = pData->name;
1184 portName += ":";
1185 }
1186
1187 if (fInfo.cvInNames != nullptr && fInfo.cvInNames[j] != nullptr)
1188 {
1189 portName += fInfo.cvInNames[j];
1190 }
1191 else if (fInfo.cvIns > 1)
1192 {
1193 portName += "cv_input_";
1194 portName += CarlaString(j+1);
1195 }
1196 else
1197 portName += "cv_input";
1198
1199 portName.truncate(portNameSize);
1200
1201 pData->cvIn.ports[j].port = (CarlaEngineCVPort*)pData->client->addPort(kEnginePortTypeCV, portName, true, j);
1202 pData->cvIn.ports[j].rindex = j;
1203 }
1204
1205 // CV Outs
1206 for (uint32_t j=0; j < fInfo.cvOuts; ++j)
1207 {
1208 portName.clear();
1209
1210 if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)
1211 {
1212 portName = pData->name;
1213 portName += ":";
1214 }
1215
1216 if (fInfo.cvOutNames != nullptr && fInfo.cvOutNames[j] != nullptr)
1217 {
1218 portName += fInfo.cvOutNames[j];
1219 }
1220 else if (fInfo.cvOuts > 1)
1221 {
1222 portName += "cv_output_";
1223 portName += CarlaString(j+1);
1224 }
1225 else
1226 portName += "cv_output";
1227
1228 portName.truncate(portNameSize);
1229
1230 pData->cvOut.ports[j].port = (CarlaEngineCVPort*)pData->client->addPort(kEnginePortTypeCV, portName, false, j);
1231 pData->cvOut.ports[j].rindex = j;
1232 }
1233
1234 if (needsCtrlIn)
1235 {
1236 portName.clear();
1237
1238 if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)
1239 {
1240 portName = pData->name;
1241 portName += ":";
1242 }
1243
1244 portName += "event-in";
1245 portName.truncate(portNameSize);
1246
1247 pData->event.portIn = (CarlaEngineEventPort*)pData->client->addPort(kEnginePortTypeEvent, portName, true, 0);
1248 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
1249 pData->event.cvSourcePorts = pData->client->createCVSourcePorts();
1250 #endif
1251 }
1252
1253 if (needsCtrlOut)
1254 {
1255 portName.clear();
1256
1257 if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)
1258 {
1259 portName = pData->name;
1260 portName += ":";
1261 }
1262
1263 portName += "event-out";
1264 portName.truncate(portNameSize);
1265
1266 pData->event.portOut = (CarlaEngineEventPort*)pData->client->addPort(kEnginePortTypeEvent, portName, false, 0);
1267 }
1268
1269 // extra plugin hints
1270 pData->extraHints = 0x0;
1271
1272 if (fInfo.mIns > 0)
1273 pData->extraHints |= PLUGIN_EXTRA_HINT_HAS_MIDI_IN;
1274
1275 if (fInfo.mOuts > 0)
1276 pData->extraHints |= PLUGIN_EXTRA_HINT_HAS_MIDI_OUT;
1277
1278 bufferSizeChanged(pData->engine->getBufferSize());
1279 reloadPrograms(true);
1280
1281 carla_debug("CarlaPluginBridge::reload() - end");
1282 }
1283
1284 // -------------------------------------------------------------------
1285 // Plugin processing
1286
activate()1287 void activate() noexcept override
1288 {
1289 if (! fBridgeThread.isThreadRunning())
1290 {
1291 CARLA_SAFE_ASSERT_RETURN(restartBridgeThread(),);
1292 }
1293
1294 {
1295 const CarlaMutexLocker _cml(fShmNonRtClientControl.mutex);
1296
1297 fShmNonRtClientControl.writeOpcode(kPluginBridgeNonRtClientActivate);
1298 fShmNonRtClientControl.commitWrite();
1299 }
1300
1301 fTimedOut = false;
1302
1303 try {
1304 waitForClient("activate", 2000);
1305 } CARLA_SAFE_EXCEPTION("activate - waitForClient");
1306 }
1307
deactivate()1308 void deactivate() noexcept override
1309 {
1310 CARLA_SAFE_ASSERT_RETURN(! fTimedError,);
1311
1312 {
1313 const CarlaMutexLocker _cml(fShmNonRtClientControl.mutex);
1314
1315 fShmNonRtClientControl.writeOpcode(kPluginBridgeNonRtClientDeactivate);
1316 fShmNonRtClientControl.commitWrite();
1317 }
1318
1319 fTimedOut = false;
1320
1321 try {
1322 waitForClient("deactivate", 2000);
1323 } CARLA_SAFE_EXCEPTION("deactivate - waitForClient");
1324 }
1325
process(const float * const * const audioIn,float ** const audioOut,const float * const * const cvIn,float ** const cvOut,const uint32_t frames)1326 void process(const float* const* const audioIn,
1327 float** const audioOut,
1328 const float* const* const cvIn,
1329 float** const cvOut,
1330 const uint32_t frames) override
1331 {
1332 // --------------------------------------------------------------------------------------------------------
1333 // Check if active
1334
1335 if (fTimedOut || fTimedError || ! pData->active)
1336 {
1337 // disable any output sound
1338 for (uint32_t i=0; i < pData->audioOut.count; ++i)
1339 carla_zeroFloats(audioOut[i], frames);
1340 for (uint32_t i=0; i < pData->cvOut.count; ++i)
1341 carla_zeroFloats(cvOut[i], frames);
1342 return;
1343 }
1344
1345 // --------------------------------------------------------------------------------------------------------
1346 // Check if needs reset
1347
1348 if (pData->needsReset)
1349 {
1350 // TODO
1351
1352 pData->needsReset = false;
1353 }
1354
1355 // --------------------------------------------------------------------------------------------------------
1356 // Event Input
1357
1358 if (pData->event.portIn != nullptr)
1359 {
1360 // ----------------------------------------------------------------------------------------------------
1361 // MIDI Input (External)
1362
1363 if (pData->extNotes.mutex.tryLock())
1364 {
1365 for (RtLinkedList<ExternalMidiNote>::Itenerator it = pData->extNotes.data.begin2(); it.valid(); it.next())
1366 {
1367 const ExternalMidiNote& note(it.getValue(kExternalMidiNoteFallback));
1368 CARLA_SAFE_ASSERT_CONTINUE(note.channel >= 0 && note.channel < MAX_MIDI_CHANNELS);
1369
1370 uint8_t data1, data2, data3;
1371 data1 = uint8_t((note.velo > 0 ? MIDI_STATUS_NOTE_ON : MIDI_STATUS_NOTE_OFF) | (note.channel & MIDI_CHANNEL_BIT));
1372 data2 = note.note;
1373 data3 = note.velo;
1374
1375 fShmRtClientControl.writeOpcode(kPluginBridgeRtClientMidiEvent);
1376 fShmRtClientControl.writeUInt(0); // time
1377 fShmRtClientControl.writeByte(0); // port
1378 fShmRtClientControl.writeByte(3); // size
1379 fShmRtClientControl.writeByte(data1);
1380 fShmRtClientControl.writeByte(data2);
1381 fShmRtClientControl.writeByte(data3);
1382 fShmRtClientControl.commitWrite();
1383 }
1384
1385 pData->extNotes.data.clear();
1386 pData->extNotes.mutex.unlock();
1387
1388 } // End of MIDI Input (External)
1389
1390 // ----------------------------------------------------------------------------------------------------
1391 // Event Input (System)
1392
1393 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
1394 bool allNotesOffSent = false;
1395
1396 if (cvIn != nullptr && pData->event.cvSourcePorts != nullptr)
1397 {
1398 const bool isSampleAccurate = (pData->options & PLUGIN_OPTION_FIXED_BUFFERS) == 0x0;
1399 pData->event.cvSourcePorts->initPortBuffers(cvIn + pData->cvIn.count, frames, isSampleAccurate, pData->event.portIn);
1400 }
1401 #endif
1402
1403 for (uint32_t i=0, numEvents=pData->event.portIn->getEventCount(); i < numEvents; ++i)
1404 {
1405 EngineEvent& event(pData->event.portIn->getEvent(i));
1406
1407 // Control change
1408 switch (event.type)
1409 {
1410 case kEngineEventTypeNull:
1411 break;
1412
1413 case kEngineEventTypeControl: {
1414 EngineControlEvent& ctrlEvent = event.ctrl;
1415
1416 switch (ctrlEvent.type)
1417 {
1418 case kEngineControlEventTypeNull:
1419 break;
1420
1421 case kEngineControlEventTypeParameter: {
1422 float value;
1423
1424 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
1425 // non-midi
1426 if (event.channel == kEngineEventNonMidiChannel)
1427 {
1428 const uint32_t k = ctrlEvent.param;
1429 CARLA_SAFE_ASSERT_CONTINUE(k < pData->param.count);
1430
1431 ctrlEvent.handled = true;
1432 value = pData->param.getFinalUnnormalizedValue(k, ctrlEvent.normalizedValue);
1433 setParameterValueRT(k, value, true);
1434 continue;
1435 }
1436
1437 // Control backend stuff
1438 if (event.channel == pData->ctrlChannel)
1439 {
1440
1441 if (MIDI_IS_CONTROL_BREATH_CONTROLLER(ctrlEvent.param) && (pData->hints & PLUGIN_CAN_DRYWET) != 0)
1442 {
1443 ctrlEvent.handled = true;
1444 value = ctrlEvent.normalizedValue;
1445 setDryWetRT(value, true);
1446 }
1447 else if (MIDI_IS_CONTROL_CHANNEL_VOLUME(ctrlEvent.param) && (pData->hints & PLUGIN_CAN_VOLUME) != 0)
1448 {
1449 ctrlEvent.handled = true;
1450 value = ctrlEvent.normalizedValue*127.0f/100.0f;
1451 setVolumeRT(value, true);
1452 }
1453 else if (MIDI_IS_CONTROL_BALANCE(ctrlEvent.param) && (pData->hints & PLUGIN_CAN_BALANCE) != 0)
1454 {
1455 float left, right;
1456 value = ctrlEvent.normalizedValue/0.5f - 1.0f;
1457
1458 if (value < 0.0f)
1459 {
1460 left = -1.0f;
1461 right = (value*2.0f)+1.0f;
1462 }
1463 else if (value > 0.0f)
1464 {
1465 left = (value*2.0f)-1.0f;
1466 right = 1.0f;
1467 }
1468 else
1469 {
1470 left = -1.0f;
1471 right = 1.0f;
1472 }
1473
1474 ctrlEvent.handled = true;
1475 setBalanceLeftRT(left, true);
1476 setBalanceRightRT(right, true);
1477 }
1478 }
1479 #endif
1480 // Control plugin parameters
1481 for (uint32_t k=0; k < pData->param.count; ++k)
1482 {
1483 if (pData->param.data[k].midiChannel != event.channel)
1484 continue;
1485 if (pData->param.data[k].mappedControlIndex != ctrlEvent.param)
1486 continue;
1487 if (pData->param.data[k].type != PARAMETER_INPUT)
1488 continue;
1489 if ((pData->param.data[k].hints & PARAMETER_IS_AUTOMABLE) == 0)
1490 continue;
1491
1492 ctrlEvent.handled = true;
1493 value = pData->param.getFinalUnnormalizedValue(k, ctrlEvent.normalizedValue);
1494 setParameterValueRT(k, value, true);
1495 }
1496
1497 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
1498 if (! ctrlEvent.handled)
1499 checkForMidiLearn(event);
1500 #endif
1501
1502 if ((pData->options & PLUGIN_OPTION_SEND_CONTROL_CHANGES) != 0 && ctrlEvent.param < MAX_MIDI_VALUE)
1503 {
1504 fShmRtClientControl.writeOpcode(kPluginBridgeRtClientMidiEvent);
1505 fShmRtClientControl.writeUInt(event.time);
1506 fShmRtClientControl.writeByte(0); // port
1507 fShmRtClientControl.writeByte(3); // size
1508 fShmRtClientControl.writeByte(uint8_t(MIDI_STATUS_CONTROL_CHANGE | (event.channel & MIDI_CHANNEL_BIT)));
1509 fShmRtClientControl.writeByte(uint8_t(ctrlEvent.param));
1510 fShmRtClientControl.writeByte(uint8_t(ctrlEvent.normalizedValue*127.0f));
1511 }
1512 break;
1513 }
1514
1515 case kEngineControlEventTypeMidiBank:
1516 if (pData->options & PLUGIN_OPTION_MAP_PROGRAM_CHANGES)
1517 {
1518 fShmRtClientControl.writeOpcode(kPluginBridgeRtClientControlEventMidiBank);
1519 fShmRtClientControl.writeUInt(event.time);
1520 fShmRtClientControl.writeByte(event.channel);
1521 fShmRtClientControl.writeUShort(event.ctrl.param);
1522 fShmRtClientControl.commitWrite();
1523 }
1524 else if ((pData->options & PLUGIN_OPTION_SEND_PROGRAM_CHANGES) != 0)
1525 {
1526 // VST2's that use banks usually require both a MSB bank message and a LSB bank message. The MSB bank message can just be 0
1527 fShmRtClientControl.writeOpcode(kPluginBridgeRtClientMidiEvent);
1528 fShmRtClientControl.writeUInt(event.time);
1529 fShmRtClientControl.writeByte(0); // port
1530 fShmRtClientControl.writeByte(3); // size
1531 fShmRtClientControl.writeByte(uint8_t(MIDI_STATUS_CONTROL_CHANGE | (event.channel & MIDI_CHANNEL_BIT)));
1532 fShmRtClientControl.writeByte(MIDI_CONTROL_BANK_SELECT);
1533 fShmRtClientControl.writeByte(0);
1534 fShmRtClientControl.commitWrite();
1535
1536 fShmRtClientControl.writeOpcode(kPluginBridgeRtClientMidiEvent);
1537 fShmRtClientControl.writeUInt(event.time);
1538 fShmRtClientControl.writeByte(0); // port
1539 fShmRtClientControl.writeByte(3); // size
1540 fShmRtClientControl.writeByte(uint8_t(MIDI_STATUS_CONTROL_CHANGE | (event.channel & MIDI_CHANNEL_BIT)));
1541 fShmRtClientControl.writeByte(MIDI_CONTROL_BANK_SELECT__LSB);
1542 fShmRtClientControl.writeByte(uint8_t(event.ctrl.param));
1543 fShmRtClientControl.commitWrite();
1544 }
1545 break;
1546
1547 case kEngineControlEventTypeMidiProgram:
1548 if (pData->options & PLUGIN_OPTION_MAP_PROGRAM_CHANGES || pData->options & PLUGIN_OPTION_SEND_PROGRAM_CHANGES)
1549 {
1550 fShmRtClientControl.writeOpcode(kPluginBridgeRtClientControlEventMidiProgram);
1551 fShmRtClientControl.writeUInt(event.time);
1552 fShmRtClientControl.writeByte(event.channel);
1553 fShmRtClientControl.writeUShort(event.ctrl.param);
1554 fShmRtClientControl.commitWrite();
1555 }
1556 break;
1557
1558 case kEngineControlEventTypeAllSoundOff:
1559 if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)
1560 {
1561 fShmRtClientControl.writeOpcode(kPluginBridgeRtClientControlEventAllSoundOff);
1562 fShmRtClientControl.writeUInt(event.time);
1563 fShmRtClientControl.writeByte(event.channel);
1564 fShmRtClientControl.commitWrite();
1565 }
1566 break;
1567
1568 case kEngineControlEventTypeAllNotesOff:
1569 if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)
1570 {
1571 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
1572 if (event.channel == pData->ctrlChannel && ! allNotesOffSent)
1573 {
1574 allNotesOffSent = true;
1575 postponeRtAllNotesOff();
1576 }
1577 #endif
1578
1579 fShmRtClientControl.writeOpcode(kPluginBridgeRtClientControlEventAllNotesOff);
1580 fShmRtClientControl.writeUInt(event.time);
1581 fShmRtClientControl.writeByte(event.channel);
1582 fShmRtClientControl.commitWrite();
1583 }
1584 break;
1585 } // switch (ctrlEvent.type)
1586 break;
1587 } // case kEngineEventTypeControl
1588
1589 case kEngineEventTypeMidi: {
1590 const EngineMidiEvent& midiEvent(event.midi);
1591
1592 if (midiEvent.size == 0 || midiEvent.size >= MAX_MIDI_VALUE)
1593 continue;
1594
1595 const uint8_t* const midiData(midiEvent.size > EngineMidiEvent::kDataSize ? midiEvent.dataExt : midiEvent.data);
1596
1597 uint8_t status = uint8_t(MIDI_GET_STATUS_FROM_DATA(midiData));
1598
1599 if ((status == MIDI_STATUS_NOTE_OFF || status == MIDI_STATUS_NOTE_ON) && (pData->options & PLUGIN_OPTION_SKIP_SENDING_NOTES))
1600 continue;
1601 if (status == MIDI_STATUS_CHANNEL_PRESSURE && (pData->options & PLUGIN_OPTION_SEND_CHANNEL_PRESSURE) == 0)
1602 continue;
1603 if (status == MIDI_STATUS_CONTROL_CHANGE && (pData->options & PLUGIN_OPTION_SEND_CONTROL_CHANGES) == 0)
1604 continue;
1605 if (status == MIDI_STATUS_POLYPHONIC_AFTERTOUCH && (pData->options & PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH) == 0)
1606 continue;
1607 if (status == MIDI_STATUS_PITCH_WHEEL_CONTROL && (pData->options & PLUGIN_OPTION_SEND_PITCHBEND) == 0)
1608 continue;
1609
1610 // Fix bad note-off
1611 if (status == MIDI_STATUS_NOTE_ON && midiData[2] == 0)
1612 status = MIDI_STATUS_NOTE_OFF;
1613
1614 fShmRtClientControl.writeOpcode(kPluginBridgeRtClientMidiEvent);
1615 fShmRtClientControl.writeUInt(event.time);
1616 fShmRtClientControl.writeByte(midiEvent.port);
1617 fShmRtClientControl.writeByte(midiEvent.size);
1618
1619 fShmRtClientControl.writeByte(uint8_t(midiData[0] | (event.channel & MIDI_CHANNEL_BIT)));
1620
1621 for (uint8_t j=1; j < midiEvent.size; ++j)
1622 fShmRtClientControl.writeByte(midiData[j]);
1623
1624 fShmRtClientControl.commitWrite();
1625
1626 if (status == MIDI_STATUS_NOTE_ON)
1627 {
1628 pData->postponeNoteOnRtEvent(true, event.channel, midiData[1], midiData[2]);
1629 }
1630 else if (status == MIDI_STATUS_NOTE_OFF)
1631 {
1632 pData->postponeNoteOffRtEvent(true, event.channel, midiData[1]);
1633 }
1634 } break;
1635 }
1636 }
1637
1638 pData->postRtEvents.trySplice();
1639
1640 } // End of Event Input
1641
1642 if (! processSingle(audioIn, audioOut, cvIn, cvOut, frames))
1643 return;
1644
1645 // --------------------------------------------------------------------------------------------------------
1646 // Control and MIDI Output
1647
1648 if (pData->event.portOut != nullptr)
1649 {
1650 float value;
1651
1652 for (uint32_t k=0; k < pData->param.count; ++k)
1653 {
1654 if (pData->param.data[k].type != PARAMETER_OUTPUT)
1655 continue;
1656
1657 if (pData->param.data[k].mappedControlIndex > 0)
1658 {
1659 value = pData->param.ranges[k].getNormalizedValue(fParams[k].value);
1660 pData->event.portOut->writeControlEvent(0,
1661 pData->param.data[k].midiChannel,
1662 kEngineControlEventTypeParameter,
1663 static_cast<uint16_t>(pData->param.data[k].mappedControlIndex),
1664 -1,
1665 value);
1666 }
1667 }
1668
1669 uint32_t time;
1670 uint8_t port, size;
1671 const uint8_t* midiData(fShmRtClientControl.data->midiOut);
1672
1673 for (std::size_t read=0; read<kBridgeRtClientDataMidiOutSize-kBridgeBaseMidiOutHeaderSize;)
1674 {
1675 // get time
1676 time = *(const uint32_t*)midiData;
1677 midiData += 4;
1678
1679 // get port and size
1680 port = *midiData++;
1681 size = *midiData++;
1682
1683 if (size == 0)
1684 break;
1685
1686 // store midi data advancing as needed
1687 uint8_t data[size];
1688
1689 for (uint8_t j=0; j<size; ++j)
1690 data[j] = *midiData++;
1691
1692 pData->event.portOut->writeMidiEvent(time, size, data);
1693
1694 read += kBridgeBaseMidiOutHeaderSize + size;
1695 }
1696
1697 // TODO
1698 (void)port;
1699
1700 } // End of Control and MIDI Output
1701 }
1702
processSingle(const float * const * const audioIn,float ** const audioOut,const float * const * const cvIn,float ** const cvOut,const uint32_t frames)1703 bool processSingle(const float* const* const audioIn, float** const audioOut,
1704 const float* const* const cvIn, float** const cvOut, const uint32_t frames)
1705 {
1706 CARLA_SAFE_ASSERT_RETURN(! fTimedError, false);
1707 CARLA_SAFE_ASSERT_RETURN(frames > 0, false);
1708 CARLA_SAFE_ASSERT_RETURN(frames <= fBufferSize, false);
1709
1710 if (pData->audioIn.count > 0)
1711 {
1712 CARLA_SAFE_ASSERT_RETURN(audioIn != nullptr, false);
1713 }
1714 if (pData->audioOut.count > 0)
1715 {
1716 CARLA_SAFE_ASSERT_RETURN(audioOut != nullptr, false);
1717 }
1718 if (pData->cvIn.count > 0)
1719 {
1720 CARLA_SAFE_ASSERT_RETURN(cvIn != nullptr, false);
1721 }
1722 if (pData->cvOut.count > 0)
1723 {
1724 CARLA_SAFE_ASSERT_RETURN(cvOut != nullptr, false);
1725 }
1726
1727 // --------------------------------------------------------------------------------------------------------
1728 // Try lock, silence otherwise
1729
1730 #ifndef STOAT_TEST_BUILD
1731 if (pData->engine->isOffline())
1732 {
1733 pData->singleMutex.lock();
1734 }
1735 else
1736 #endif
1737 if (! pData->singleMutex.tryLock())
1738 {
1739 for (uint32_t i=0; i < pData->audioOut.count; ++i)
1740 carla_zeroFloats(audioOut[i], frames);
1741 for (uint32_t i=0; i < pData->cvOut.count; ++i)
1742 carla_zeroFloats(cvOut[i], frames);
1743 return false;
1744 }
1745
1746 // --------------------------------------------------------------------------------------------------------
1747 // Reset audio buffers
1748
1749 for (uint32_t i=0; i < pData->audioIn.count; ++i)
1750 carla_copyFloats(fShmAudioPool.data + (i * fBufferSize), audioIn[i], frames);
1751 for (uint32_t i=0; i < pData->cvIn.count; ++i)
1752 carla_copyFloats(fShmAudioPool.data + ((pData->audioIn.count + pData->audioOut.count + i) * fBufferSize), cvIn[i], frames);
1753
1754 // --------------------------------------------------------------------------------------------------------
1755 // TimeInfo
1756
1757 const EngineTimeInfo timeInfo(pData->engine->getTimeInfo());
1758 BridgeTimeInfo& bridgeTimeInfo(fShmRtClientControl.data->timeInfo);
1759
1760 bridgeTimeInfo.playing = timeInfo.playing;
1761 bridgeTimeInfo.frame = timeInfo.frame;
1762 bridgeTimeInfo.usecs = timeInfo.usecs;
1763 bridgeTimeInfo.validFlags = timeInfo.bbt.valid ? kPluginBridgeTimeInfoValidBBT : 0x0;
1764
1765 if (timeInfo.bbt.valid)
1766 {
1767 bridgeTimeInfo.bar = timeInfo.bbt.bar;
1768 bridgeTimeInfo.beat = timeInfo.bbt.beat;
1769 bridgeTimeInfo.tick = timeInfo.bbt.tick;
1770
1771 bridgeTimeInfo.beatsPerBar = timeInfo.bbt.beatsPerBar;
1772 bridgeTimeInfo.beatType = timeInfo.bbt.beatType;
1773
1774 bridgeTimeInfo.ticksPerBeat = timeInfo.bbt.ticksPerBeat;
1775 bridgeTimeInfo.beatsPerMinute = timeInfo.bbt.beatsPerMinute;
1776 bridgeTimeInfo.barStartTick = timeInfo.bbt.barStartTick;
1777 }
1778
1779 // --------------------------------------------------------------------------------------------------------
1780 // Run plugin
1781
1782 {
1783 fShmRtClientControl.writeOpcode(kPluginBridgeRtClientProcess);
1784 fShmRtClientControl.writeUInt(frames);
1785 fShmRtClientControl.commitWrite();
1786 }
1787
1788 waitForClient("process", fProcWaitTime);
1789
1790 if (fTimedOut)
1791 {
1792 pData->singleMutex.unlock();
1793 return false;
1794 }
1795
1796 for (uint32_t i=0; i < pData->audioOut.count; ++i)
1797 carla_copyFloats(audioOut[i], fShmAudioPool.data + ((pData->audioIn.count + i) * fBufferSize), frames);
1798 for (uint32_t i=0; i < pData->cvOut.count; ++i)
1799 carla_copyFloats(cvOut[i], fShmAudioPool.data + ((pData->audioIn.count + pData->audioOut.count + pData->cvIn.count + i) * fBufferSize), frames);
1800
1801 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
1802 // --------------------------------------------------------------------------------------------------------
1803 // Post-processing (dry/wet, volume and balance)
1804
1805 {
1806 const bool doVolume = (pData->hints & PLUGIN_CAN_VOLUME) != 0 && carla_isNotEqual(pData->postProc.volume, 1.0f);
1807 const bool doDryWet = (pData->hints & PLUGIN_CAN_DRYWET) != 0 && carla_isNotEqual(pData->postProc.dryWet, 1.0f);
1808 const bool doBalance = (pData->hints & PLUGIN_CAN_BALANCE) != 0 && ! (carla_isEqual(pData->postProc.balanceLeft, -1.0f) && carla_isEqual(pData->postProc.balanceRight, 1.0f));
1809 const bool isMono = (pData->audioIn.count == 1);
1810
1811 bool isPair;
1812 float bufValue, oldBufLeft[doBalance ? frames : 1];
1813
1814 for (uint32_t i=0; i < pData->audioOut.count; ++i)
1815 {
1816 // Dry/Wet
1817 if (doDryWet)
1818 {
1819 const uint32_t c = isMono ? 0 : i;
1820
1821 for (uint32_t k=0; k < frames; ++k)
1822 {
1823 # ifndef BUILD_BRIDGE
1824 if (k < pData->latency.frames && pData->latency.buffers != nullptr)
1825 bufValue = pData->latency.buffers[c][k];
1826 else if (pData->latency.frames < frames)
1827 bufValue = audioIn[c][k-pData->latency.frames];
1828 else
1829 # endif
1830 bufValue = audioIn[c][k];
1831
1832 audioOut[i][k] = (audioOut[i][k] * pData->postProc.dryWet) + (bufValue * (1.0f - pData->postProc.dryWet));
1833 }
1834 }
1835
1836 // Balance
1837 if (doBalance)
1838 {
1839 isPair = (i % 2 == 0);
1840
1841 if (isPair)
1842 {
1843 CARLA_ASSERT(i+1 < pData->audioOut.count);
1844 carla_copyFloats(oldBufLeft, audioOut[i], frames);
1845 }
1846
1847 float balRangeL = (pData->postProc.balanceLeft + 1.0f)/2.0f;
1848 float balRangeR = (pData->postProc.balanceRight + 1.0f)/2.0f;
1849
1850 for (uint32_t k=0; k < frames; ++k)
1851 {
1852 if (isPair)
1853 {
1854 // left
1855 audioOut[i][k] = oldBufLeft[k] * (1.0f - balRangeL);
1856 audioOut[i][k] += audioOut[i+1][k] * (1.0f - balRangeR);
1857 }
1858 else
1859 {
1860 // right
1861 audioOut[i][k] = audioOut[i][k] * balRangeR;
1862 audioOut[i][k] += oldBufLeft[k] * balRangeL;
1863 }
1864 }
1865 }
1866
1867 // Volume (and buffer copy)
1868 if (doVolume)
1869 {
1870 for (uint32_t k=0; k < frames; ++k)
1871 audioOut[i][k] *= pData->postProc.volume;
1872 }
1873 }
1874
1875 } // End of Post-processing
1876
1877 # ifndef BUILD_BRIDGE
1878 // --------------------------------------------------------------------------------------------------------
1879 // Save latency values for next callback
1880
1881 if (pData->latency.frames != 0 && pData->latency.buffers != nullptr)
1882 {
1883 const uint32_t latframes = pData->latency.frames;
1884
1885 if (latframes <= frames)
1886 {
1887 for (uint32_t i=0; i < pData->audioIn.count; ++i)
1888 carla_copyFloats(pData->latency.buffers[i], audioIn[i]+(frames-latframes), latframes);
1889 }
1890 else
1891 {
1892 const uint32_t diff = latframes - frames;
1893
1894 for (uint32_t i=0, k; i<pData->audioIn.count; ++i)
1895 {
1896 // push back buffer by 'frames'
1897 for (k=0; k < diff; ++k)
1898 pData->latency.buffers[i][k] = pData->latency.buffers[i][k+frames];
1899
1900 // put current input at the end
1901 for (uint32_t j=0; k < latframes; ++j, ++k)
1902 pData->latency.buffers[i][k] = audioIn[i][j];
1903 }
1904 }
1905 }
1906 # endif
1907 #endif // BUILD_BRIDGE_ALTERNATIVE_ARCH
1908
1909 // --------------------------------------------------------------------------------------------------------
1910
1911 pData->singleMutex.unlock();
1912 return true;
1913 }
1914
bufferSizeChanged(const uint32_t newBufferSize)1915 void bufferSizeChanged(const uint32_t newBufferSize) override
1916 {
1917 fBufferSize = newBufferSize;
1918 resizeAudioPool(newBufferSize);
1919
1920 {
1921 fShmRtClientControl.writeOpcode(kPluginBridgeRtClientSetBufferSize);
1922 fShmRtClientControl.writeUInt(newBufferSize);
1923 fShmRtClientControl.commitWrite();
1924 }
1925
1926 //fProcWaitTime = newBufferSize*1000/pData->engine->getSampleRate();
1927 fProcWaitTime = 1000;
1928
1929 waitForClient("buffersize", 1000);
1930 }
1931
sampleRateChanged(const double newSampleRate)1932 void sampleRateChanged(const double newSampleRate) override
1933 {
1934 {
1935 fShmRtClientControl.writeOpcode(kPluginBridgeRtClientSetSampleRate);
1936 fShmRtClientControl.writeDouble(newSampleRate);
1937 fShmRtClientControl.commitWrite();
1938 }
1939
1940 //fProcWaitTime = pData->engine->getBufferSize()*1000/newSampleRate;
1941 fProcWaitTime = 1000;
1942
1943 waitForClient("samplerate", 1000);
1944 }
1945
offlineModeChanged(const bool isOffline)1946 void offlineModeChanged(const bool isOffline) override
1947 {
1948 {
1949 fShmRtClientControl.writeOpcode(kPluginBridgeRtClientSetOnline);
1950 fShmRtClientControl.writeBool(isOffline);
1951 fShmRtClientControl.commitWrite();
1952 }
1953
1954 waitForClient("offline", 1000);
1955 }
1956
1957 // -------------------------------------------------------------------
1958 // Plugin buffers
1959
clearBuffers()1960 void clearBuffers() noexcept override
1961 {
1962 if (fParams != nullptr)
1963 {
1964 delete[] fParams;
1965 fParams = nullptr;
1966 }
1967
1968 CarlaPlugin::clearBuffers();
1969 }
1970
1971 // -------------------------------------------------------------------
1972 // Post-poned UI Stuff
1973
uiParameterChange(const uint32_t index,const float value)1974 void uiParameterChange(const uint32_t index, const float value) noexcept override
1975 {
1976 CARLA_SAFE_ASSERT_RETURN(index < pData->param.count,);
1977
1978 const CarlaMutexLocker _cml(fShmNonRtClientControl.mutex);
1979
1980 fShmNonRtClientControl.writeOpcode(kPluginBridgeNonRtClientUiParameterChange);
1981 fShmNonRtClientControl.writeUInt(index);
1982 fShmNonRtClientControl.writeFloat(value);
1983 fShmNonRtClientControl.commitWrite();
1984 }
1985
uiProgramChange(const uint32_t index)1986 void uiProgramChange(const uint32_t index) noexcept override
1987 {
1988 CARLA_SAFE_ASSERT_RETURN(index < pData->prog.count,);
1989
1990 const CarlaMutexLocker _cml(fShmNonRtClientControl.mutex);
1991
1992 fShmNonRtClientControl.writeOpcode(kPluginBridgeNonRtClientUiProgramChange);
1993 fShmNonRtClientControl.writeUInt(index);
1994 fShmNonRtClientControl.commitWrite();
1995 }
1996
uiMidiProgramChange(const uint32_t index)1997 void uiMidiProgramChange(const uint32_t index) noexcept override
1998 {
1999 CARLA_SAFE_ASSERT_RETURN(index < pData->midiprog.count,);
2000
2001 const CarlaMutexLocker _cml(fShmNonRtClientControl.mutex);
2002
2003 fShmNonRtClientControl.writeOpcode(kPluginBridgeNonRtClientUiMidiProgramChange);
2004 fShmNonRtClientControl.writeUInt(index);
2005 fShmNonRtClientControl.commitWrite();
2006 }
2007
uiNoteOn(const uint8_t channel,const uint8_t note,const uint8_t velo)2008 void uiNoteOn(const uint8_t channel, const uint8_t note, const uint8_t velo) noexcept override
2009 {
2010 CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);
2011 CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);
2012 CARLA_SAFE_ASSERT_RETURN(velo > 0 && velo < MAX_MIDI_VALUE,);
2013
2014 const CarlaMutexLocker _cml(fShmNonRtClientControl.mutex);
2015
2016 fShmNonRtClientControl.writeOpcode(kPluginBridgeNonRtClientUiNoteOn);
2017 fShmNonRtClientControl.writeByte(channel);
2018 fShmNonRtClientControl.writeByte(note);
2019 fShmNonRtClientControl.writeByte(velo);
2020 fShmNonRtClientControl.commitWrite();
2021 }
2022
uiNoteOff(const uint8_t channel,const uint8_t note)2023 void uiNoteOff(const uint8_t channel, const uint8_t note) noexcept override
2024 {
2025 CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);
2026 CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);
2027
2028 const CarlaMutexLocker _cml(fShmNonRtClientControl.mutex);
2029
2030 fShmNonRtClientControl.writeOpcode(kPluginBridgeNonRtClientUiNoteOff);
2031 fShmNonRtClientControl.writeByte(channel);
2032 fShmNonRtClientControl.writeByte(note);
2033 fShmNonRtClientControl.commitWrite();
2034 }
2035
2036 // -------------------------------------------------------------------
2037 // Internal helper functions
2038
restoreLV2State(bool)2039 void restoreLV2State(bool) noexcept override
2040 {
2041 const CarlaMutexLocker _cml(fShmNonRtClientControl.mutex);
2042
2043 fShmNonRtClientControl.writeOpcode(kPluginBridgeNonRtClientRestoreLV2State);
2044 fShmNonRtClientControl.commitWrite();
2045 }
2046
waitForBridgeSaveSignal()2047 void waitForBridgeSaveSignal() noexcept override
2048 {
2049 // VSTs only save chunks, for which we already have a waitForSaved there
2050 if (fPluginType != PLUGIN_VST2)
2051 waitForSaved();
2052 }
2053
2054 // -------------------------------------------------------------------
2055
handleNonRtData()2056 void handleNonRtData()
2057 {
2058 for (; fShmNonRtServerControl.isDataAvailableForReading();)
2059 {
2060 const PluginBridgeNonRtServerOpcode opcode(fShmNonRtServerControl.readOpcode());
2061 #ifdef DEBUG
2062 if (opcode != kPluginBridgeNonRtServerPong && opcode != kPluginBridgeNonRtServerParameterValue2) {
2063 carla_debug("CarlaPluginBridge::handleNonRtData() - got opcode: %s", PluginBridgeNonRtServerOpcode2str(opcode));
2064 }
2065 #endif
2066 switch (opcode)
2067 {
2068 case kPluginBridgeNonRtServerNull:
2069 case kPluginBridgeNonRtServerPong:
2070 break;
2071
2072 case kPluginBridgeNonRtServerVersion:
2073 fBridgeVersion = fShmNonRtServerControl.readUInt();
2074 break;
2075
2076 case kPluginBridgeNonRtServerPluginInfo1: {
2077 // uint/category, uint/hints, uint/optionsAvailable, uint/optionsEnabled, long/uniqueId
2078 const uint32_t category = fShmNonRtServerControl.readUInt();
2079 const uint32_t hints = fShmNonRtServerControl.readUInt();
2080 const uint32_t optionAv = fShmNonRtServerControl.readUInt();
2081 const uint32_t optionEn = fShmNonRtServerControl.readUInt();
2082 const int64_t uniqueId = fShmNonRtServerControl.readLong();
2083
2084 if (fUniqueId != 0) {
2085 CARLA_SAFE_ASSERT_INT2(fUniqueId == uniqueId, fUniqueId, uniqueId);
2086 }
2087
2088 pData->hints = hints | PLUGIN_IS_BRIDGE;
2089 pData->options = optionEn;
2090
2091 fInfo.category = static_cast<PluginCategory>(category);
2092 fInfo.optionsAvailable = optionAv;
2093 } break;
2094
2095 case kPluginBridgeNonRtServerPluginInfo2: {
2096 // uint/size, str[] (realName), uint/size, str[] (label), uint/size, str[] (maker), uint/size, str[] (copyright)
2097
2098 // realName
2099 const uint32_t realNameSize(fShmNonRtServerControl.readUInt());
2100 char realName[realNameSize+1];
2101 carla_zeroChars(realName, realNameSize+1);
2102 fShmNonRtServerControl.readCustomData(realName, realNameSize);
2103
2104 // label
2105 const uint32_t labelSize(fShmNonRtServerControl.readUInt());
2106 char label[labelSize+1];
2107 carla_zeroChars(label, labelSize+1);
2108 fShmNonRtServerControl.readCustomData(label, labelSize);
2109
2110 // maker
2111 const uint32_t makerSize(fShmNonRtServerControl.readUInt());
2112 char maker[makerSize+1];
2113 carla_zeroChars(maker, makerSize+1);
2114 fShmNonRtServerControl.readCustomData(maker, makerSize);
2115
2116 // copyright
2117 const uint32_t copyrightSize(fShmNonRtServerControl.readUInt());
2118 char copyright[copyrightSize+1];
2119 carla_zeroChars(copyright, copyrightSize+1);
2120 fShmNonRtServerControl.readCustomData(copyright, copyrightSize);
2121
2122 fInfo.name = realName;
2123 fInfo.label = label;
2124 fInfo.maker = maker;
2125 fInfo.copyright = copyright;
2126
2127 if (pData->name == nullptr)
2128 pData->name = pData->engine->getUniquePluginName(realName);
2129 } break;
2130
2131 case kPluginBridgeNonRtServerAudioCount: {
2132 // uint/ins, uint/outs
2133 fInfo.clear();
2134
2135 fInfo.aIns = fShmNonRtServerControl.readUInt();
2136 fInfo.aOuts = fShmNonRtServerControl.readUInt();
2137
2138 if (fInfo.aIns > 0)
2139 {
2140 fInfo.aInNames = new const char*[fInfo.aIns];
2141 carla_zeroPointers(fInfo.aInNames, fInfo.aIns);
2142 }
2143
2144 if (fInfo.aOuts > 0)
2145 {
2146 fInfo.aOutNames = new const char*[fInfo.aOuts];
2147 carla_zeroPointers(fInfo.aOutNames, fInfo.aOuts);
2148 }
2149
2150 } break;
2151
2152 case kPluginBridgeNonRtServerMidiCount: {
2153 // uint/ins, uint/outs
2154 fInfo.mIns = fShmNonRtServerControl.readUInt();
2155 fInfo.mOuts = fShmNonRtServerControl.readUInt();
2156 } break;
2157
2158 case kPluginBridgeNonRtServerCvCount: {
2159 // uint/ins, uint/outs
2160 fInfo.cvIns = fShmNonRtServerControl.readUInt();
2161 fInfo.cvOuts = fShmNonRtServerControl.readUInt();
2162 } break;
2163
2164 case kPluginBridgeNonRtServerParameterCount: {
2165 // uint/count
2166 const uint32_t count = fShmNonRtServerControl.readUInt();
2167
2168 // delete old data
2169 pData->param.clear();
2170
2171 if (fParams != nullptr)
2172 {
2173 delete[] fParams;
2174 fParams = nullptr;
2175 }
2176
2177 if (count > 0)
2178 {
2179 pData->param.createNew(count, false);
2180 fParams = new BridgeParamInfo[count];
2181
2182 // we might not receive all parameter data, so ensure range max is not 0
2183 for (uint32_t i=0; i<count; ++i)
2184 {
2185 pData->param.ranges[i].def = 0.0f;
2186 pData->param.ranges[i].min = 0.0f;
2187 pData->param.ranges[i].max = 1.0f;
2188 pData->param.ranges[i].step = 0.001f;
2189 pData->param.ranges[i].stepSmall = 0.0001f;
2190 pData->param.ranges[i].stepLarge = 0.1f;
2191 }
2192 }
2193 } break;
2194
2195 case kPluginBridgeNonRtServerProgramCount: {
2196 // uint/count
2197 pData->prog.clear();
2198
2199 if (const uint32_t count = fShmNonRtServerControl.readUInt())
2200 pData->prog.createNew(count);
2201
2202 } break;
2203
2204 case kPluginBridgeNonRtServerMidiProgramCount: {
2205 // uint/count
2206 pData->midiprog.clear();
2207
2208 if (const uint32_t count = fShmNonRtServerControl.readUInt())
2209 pData->midiprog.createNew(count);
2210
2211 } break;
2212
2213 case kPluginBridgeNonRtServerPortName: {
2214 // byte/type, uint/index, uint/size, str[] (name)
2215 const uint8_t portType = fShmNonRtServerControl.readByte();
2216 const uint32_t index = fShmNonRtServerControl.readUInt();
2217
2218 // name
2219 const uint32_t nameSize(fShmNonRtServerControl.readUInt());
2220 char* const name = new char[nameSize+1];
2221 carla_zeroChars(name, nameSize+1);
2222 fShmNonRtServerControl.readCustomData(name, nameSize);
2223
2224 CARLA_SAFE_ASSERT_BREAK(portType > kPluginBridgePortNull && portType < kPluginBridgePortTypeCount);
2225
2226 switch (portType)
2227 {
2228 case kPluginBridgePortAudioInput:
2229 CARLA_SAFE_ASSERT_BREAK(index < fInfo.aIns);
2230 fInfo.aInNames[index] = name;
2231 break;
2232 case kPluginBridgePortAudioOutput:
2233 CARLA_SAFE_ASSERT_BREAK(index < fInfo.aOuts);
2234 fInfo.aOutNames[index] = name;
2235 break;
2236 }
2237
2238 } break;
2239
2240 case kPluginBridgeNonRtServerParameterData1: {
2241 // uint/index, int/rindex, uint/type, uint/hints, int/cc
2242 const uint32_t index = fShmNonRtServerControl.readUInt();
2243 const int32_t rindex = fShmNonRtServerControl.readInt();
2244 const uint32_t type = fShmNonRtServerControl.readUInt();
2245 const uint32_t hints = fShmNonRtServerControl.readUInt();
2246 const int16_t ctrl = fShmNonRtServerControl.readShort();
2247
2248 CARLA_SAFE_ASSERT_BREAK(ctrl >= CONTROL_INDEX_NONE && ctrl <= CONTROL_INDEX_MAX_ALLOWED);
2249 CARLA_SAFE_ASSERT_INT2(index < pData->param.count, index, pData->param.count);
2250
2251 if (index < pData->param.count)
2252 {
2253 pData->param.data[index].type = static_cast<ParameterType>(type);
2254 pData->param.data[index].index = static_cast<int32_t>(index);
2255 pData->param.data[index].rindex = rindex;
2256 pData->param.data[index].hints = hints;
2257 pData->param.data[index].mappedControlIndex = ctrl;
2258 }
2259 } break;
2260
2261 case kPluginBridgeNonRtServerParameterData2: {
2262 // uint/index, uint/size, str[] (name), uint/size, str[] (unit)
2263 const uint32_t index = fShmNonRtServerControl.readUInt();
2264
2265 // name
2266 const uint32_t nameSize(fShmNonRtServerControl.readUInt());
2267 char name[nameSize+1];
2268 carla_zeroChars(name, nameSize+1);
2269 fShmNonRtServerControl.readCustomData(name, nameSize);
2270
2271 // symbol
2272 const uint32_t symbolSize(fShmNonRtServerControl.readUInt());
2273 char symbol[symbolSize+1];
2274 carla_zeroChars(symbol, symbolSize+1);
2275 fShmNonRtServerControl.readCustomData(symbol, symbolSize);
2276
2277 // unit
2278 const uint32_t unitSize(fShmNonRtServerControl.readUInt());
2279 char unit[unitSize+1];
2280 carla_zeroChars(unit, unitSize+1);
2281 fShmNonRtServerControl.readCustomData(unit, unitSize);
2282
2283 CARLA_SAFE_ASSERT_INT2(index < pData->param.count, index, pData->param.count);
2284
2285 if (index < pData->param.count)
2286 {
2287 fParams[index].name = name;
2288 fParams[index].symbol = symbol;
2289 fParams[index].unit = unit;
2290 }
2291 } break;
2292
2293 case kPluginBridgeNonRtServerParameterRanges: {
2294 // uint/index, float/def, float/min, float/max, float/step, float/stepSmall, float/stepLarge
2295 const uint32_t index = fShmNonRtServerControl.readUInt();
2296 const float def = fShmNonRtServerControl.readFloat();
2297 const float min = fShmNonRtServerControl.readFloat();
2298 const float max = fShmNonRtServerControl.readFloat();
2299 const float step = fShmNonRtServerControl.readFloat();
2300 const float stepSmall = fShmNonRtServerControl.readFloat();
2301 const float stepLarge = fShmNonRtServerControl.readFloat();
2302
2303 CARLA_SAFE_ASSERT_BREAK(min < max);
2304 CARLA_SAFE_ASSERT_BREAK(def >= min);
2305 CARLA_SAFE_ASSERT_BREAK(def <= max);
2306 CARLA_SAFE_ASSERT_INT2(index < pData->param.count, index, pData->param.count);
2307
2308 if (index < pData->param.count)
2309 {
2310 pData->param.ranges[index].def = def;
2311 pData->param.ranges[index].min = min;
2312 pData->param.ranges[index].max = max;
2313 pData->param.ranges[index].step = step;
2314 pData->param.ranges[index].stepSmall = stepSmall;
2315 pData->param.ranges[index].stepLarge = stepLarge;
2316 }
2317 } break;
2318
2319 case kPluginBridgeNonRtServerParameterValue: {
2320 // uint/index, float/value
2321 const uint32_t index = fShmNonRtServerControl.readUInt();
2322 const float value = fShmNonRtServerControl.readFloat();
2323
2324 if (index < pData->param.count)
2325 {
2326 const float fixedValue(pData->param.getFixedValue(index, value));
2327
2328 if (carla_isNotEqual(fParams[index].value, fixedValue))
2329 {
2330 fParams[index].value = fixedValue;
2331 CarlaPlugin::setParameterValue(index, fixedValue, false, true, true);
2332 }
2333 }
2334 } break;
2335
2336 case kPluginBridgeNonRtServerParameterValue2: {
2337 // uint/index, float/value
2338 const uint32_t index = fShmNonRtServerControl.readUInt();
2339 const float value = fShmNonRtServerControl.readFloat();
2340
2341 if (index < pData->param.count)
2342 {
2343 const float fixedValue(pData->param.getFixedValue(index, value));
2344 fParams[index].value = fixedValue;
2345 }
2346 } break;
2347
2348 case kPluginBridgeNonRtServerParameterTouch: {
2349 // uint/index, bool/touch
2350 const uint32_t index = fShmNonRtServerControl.readUInt();
2351 const bool touch = fShmNonRtServerControl.readBool();
2352
2353 pData->engine->touchPluginParameter(pData->id, index, touch);
2354 } break;
2355
2356 case kPluginBridgeNonRtServerDefaultValue: {
2357 // uint/index, float/value
2358 const uint32_t index = fShmNonRtServerControl.readUInt();
2359 const float value = fShmNonRtServerControl.readFloat();
2360
2361 if (index < pData->param.count)
2362 pData->param.ranges[index].def = value;
2363 } break;
2364
2365 case kPluginBridgeNonRtServerCurrentProgram: {
2366 // int/index
2367 const int32_t index = fShmNonRtServerControl.readInt();
2368
2369 CARLA_SAFE_ASSERT_BREAK(index >= -1);
2370 CARLA_SAFE_ASSERT_INT2(index < static_cast<int32_t>(pData->prog.count), index, pData->prog.count);
2371
2372 CarlaPlugin::setProgram(index, false, true, true);
2373 } break;
2374
2375 case kPluginBridgeNonRtServerCurrentMidiProgram: {
2376 // int/index
2377 const int32_t index = fShmNonRtServerControl.readInt();
2378
2379 CARLA_SAFE_ASSERT_BREAK(index >= -1);
2380 CARLA_SAFE_ASSERT_INT2(index < static_cast<int32_t>(pData->midiprog.count), index, pData->midiprog.count);
2381
2382 CarlaPlugin::setMidiProgram(index, false, true, true);
2383 } break;
2384
2385 case kPluginBridgeNonRtServerProgramName: {
2386 // uint/index, uint/size, str[] (name)
2387 const uint32_t index = fShmNonRtServerControl.readUInt();
2388
2389 // name
2390 const uint32_t nameSize(fShmNonRtServerControl.readUInt());
2391 char name[nameSize+1];
2392 carla_zeroChars(name, nameSize+1);
2393 fShmNonRtServerControl.readCustomData(name, nameSize);
2394
2395 CARLA_SAFE_ASSERT_INT2(index < pData->prog.count, index, pData->prog.count);
2396
2397 if (index < pData->prog.count)
2398 {
2399 if (pData->prog.names[index] != nullptr)
2400 delete[] pData->prog.names[index];
2401 pData->prog.names[index] = carla_strdup(name);
2402 }
2403 } break;
2404
2405 case kPluginBridgeNonRtServerMidiProgramData: {
2406 // uint/index, uint/bank, uint/program, uint/size, str[] (name)
2407 const uint32_t index = fShmNonRtServerControl.readUInt();
2408 const uint32_t bank = fShmNonRtServerControl.readUInt();
2409 const uint32_t program = fShmNonRtServerControl.readUInt();
2410
2411 // name
2412 const uint32_t nameSize(fShmNonRtServerControl.readUInt());
2413 char name[nameSize+1];
2414 carla_zeroChars(name, nameSize+1);
2415 fShmNonRtServerControl.readCustomData(name, nameSize);
2416
2417 CARLA_SAFE_ASSERT_INT2(index < pData->midiprog.count, index, pData->midiprog.count);
2418
2419 if (index < pData->midiprog.count)
2420 {
2421 if (pData->midiprog.data[index].name != nullptr)
2422 delete[] pData->midiprog.data[index].name;
2423 pData->midiprog.data[index].bank = bank;
2424 pData->midiprog.data[index].program = program;
2425 pData->midiprog.data[index].name = carla_strdup(name);
2426 }
2427 } break;
2428
2429 case kPluginBridgeNonRtServerSetCustomData: {
2430 // uint/size, str[], uint/size, str[], uint/size, str[]
2431
2432 // type
2433 const uint32_t typeSize(fShmNonRtServerControl.readUInt());
2434 char type[typeSize+1];
2435 carla_zeroChars(type, typeSize+1);
2436 fShmNonRtServerControl.readCustomData(type, typeSize);
2437
2438 // key
2439 const uint32_t keySize(fShmNonRtServerControl.readUInt());
2440 char key[keySize+1];
2441 carla_zeroChars(key, keySize+1);
2442 fShmNonRtServerControl.readCustomData(key, keySize);
2443
2444 // value
2445 const uint32_t valueSize(fShmNonRtServerControl.readUInt());
2446 char value[valueSize+1];
2447 carla_zeroChars(value, valueSize+1);
2448
2449 if (valueSize > 0)
2450 fShmNonRtServerControl.readCustomData(value, valueSize);
2451
2452 CarlaPlugin::setCustomData(type, key, value, false);
2453 } break;
2454
2455 case kPluginBridgeNonRtServerSetChunkDataFile: {
2456 // uint/size, str[] (filename)
2457
2458 // chunkFilePath
2459 const uint32_t chunkFilePathSize(fShmNonRtServerControl.readUInt());
2460 char chunkFilePath[chunkFilePathSize+1];
2461 carla_zeroChars(chunkFilePath, chunkFilePathSize+1);
2462 fShmNonRtServerControl.readCustomData(chunkFilePath, chunkFilePathSize);
2463
2464 String realChunkFilePath(chunkFilePath);
2465
2466 #ifndef CARLA_OS_WIN
2467 // Using Wine, fix temp dir
2468 if (fBinaryType == BINARY_WIN32 || fBinaryType == BINARY_WIN64)
2469 {
2470 const StringArray driveLetterSplit(StringArray::fromTokens(realChunkFilePath, ":/", ""));
2471 carla_stdout("chunk save path BEFORE => %s", realChunkFilePath.toRawUTF8());
2472
2473 realChunkFilePath = fWinePrefix;
2474 realChunkFilePath += "/drive_";
2475 realChunkFilePath += driveLetterSplit[0].toLowerCase();
2476 realChunkFilePath += driveLetterSplit[1];
2477
2478 realChunkFilePath = realChunkFilePath.replace("\\", "/");
2479 carla_stdout("chunk save path AFTER => %s", realChunkFilePath.toRawUTF8());
2480 }
2481 #endif
2482
2483 File chunkFile(realChunkFilePath);
2484 CARLA_SAFE_ASSERT_BREAK(chunkFile.existsAsFile());
2485
2486 fInfo.chunk = carla_getChunkFromBase64String(chunkFile.loadFileAsString().toRawUTF8());
2487 chunkFile.deleteFile();
2488 } break;
2489
2490 case kPluginBridgeNonRtServerSetLatency:
2491 // uint
2492 fLatency = fShmNonRtServerControl.readUInt();
2493 #ifndef BUILD_BRIDGE
2494 if (! fInitiated)
2495 pData->latency.recreateBuffers(std::max(fInfo.aIns, fInfo.aOuts), fLatency);
2496 #endif
2497 break;
2498
2499 case kPluginBridgeNonRtServerSetParameterText: {
2500 const int32_t index = fShmNonRtServerControl.readInt();
2501
2502 const uint32_t textSize(fShmNonRtServerControl.readUInt());
2503 char text[textSize+1];
2504 carla_zeroChars(text, textSize+1);
2505 fShmNonRtServerControl.readCustomData(text, textSize);
2506
2507 fReceivingParamText.setReceivedData(index, text, textSize);
2508 } break;
2509
2510 case kPluginBridgeNonRtServerReady:
2511 fInitiated = true;
2512 break;
2513
2514 case kPluginBridgeNonRtServerSaved:
2515 fSaved = true;
2516 break;
2517
2518 case kPluginBridgeNonRtServerUiClosed:
2519 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
2520 pData->transientTryCounter = 0;
2521 #endif
2522 pData->engine->callback(true, true, ENGINE_CALLBACK_UI_STATE_CHANGED, pData->id, 0, 0, 0, 0.0f, nullptr);
2523 break;
2524
2525 case kPluginBridgeNonRtServerError: {
2526 // error
2527 const uint32_t errorSize(fShmNonRtServerControl.readUInt());
2528 char error[errorSize+1];
2529 carla_zeroChars(error, errorSize+1);
2530 fShmNonRtServerControl.readCustomData(error, errorSize);
2531
2532 if (fInitiated)
2533 {
2534 pData->engine->callback(true, true, ENGINE_CALLBACK_ERROR, pData->id, 0, 0, 0, 0.0f, error);
2535
2536 // just in case
2537 pData->engine->setLastError(error);
2538 fInitError = true;
2539 }
2540 else
2541 {
2542 pData->engine->setLastError(error);
2543 fInitError = true;
2544 fInitiated = true;
2545 }
2546 } break;
2547 }
2548 }
2549 }
2550
2551 // -------------------------------------------------------------------
2552
getUiBridgeProcessId() const2553 uintptr_t getUiBridgeProcessId() const noexcept override
2554 {
2555 return fBridgeThread.getProcessPID();
2556 }
2557
getExtraStuff() const2558 const void* getExtraStuff() const noexcept override
2559 {
2560 return fBridgeBinary.isNotEmpty() ? fBridgeBinary.buffer() : nullptr;
2561 }
2562
2563 // -------------------------------------------------------------------
2564
init(CarlaPluginPtr plugin,const char * const filename,const char * const name,const char * const label,const int64_t uniqueId,const uint options,const char * const binaryArchName,const char * const bridgeBinary)2565 bool init(CarlaPluginPtr plugin,
2566 const char* const filename,
2567 const char* const name,
2568 const char* const label,
2569 const int64_t uniqueId,
2570 const uint options,
2571 const char* const binaryArchName,
2572 const char* const bridgeBinary)
2573 {
2574 CARLA_SAFE_ASSERT_RETURN(pData->engine != nullptr, false);
2575
2576 // ---------------------------------------------------------------
2577 // first checks
2578
2579 if (pData->client != nullptr)
2580 {
2581 pData->engine->setLastError("Plugin client is already registered");
2582 return false;
2583 }
2584
2585 if (bridgeBinary == nullptr || bridgeBinary[0] == '\0')
2586 {
2587 pData->engine->setLastError("null bridge binary");
2588 return false;
2589 }
2590
2591 // ---------------------------------------------------------------
2592 // set info
2593
2594 if (name != nullptr && name[0] != '\0')
2595 pData->name = pData->engine->getUniquePluginName(name);
2596
2597 if (filename != nullptr && filename[0] != '\0')
2598 pData->filename = carla_strdup(filename);
2599 else
2600 pData->filename = carla_strdup("");
2601
2602 fUniqueId = uniqueId;
2603 fBridgeBinary = bridgeBinary;
2604
2605 std::srand(static_cast<uint>(std::time(nullptr)));
2606
2607 // ---------------------------------------------------------------
2608 // init sem/shm
2609
2610 if (! fShmAudioPool.initializeServer())
2611 {
2612 carla_stderr("Failed to initialize shared memory audio pool");
2613 return false;
2614 }
2615
2616 if (! fShmRtClientControl.initializeServer())
2617 {
2618 carla_stderr("Failed to initialize RT client control");
2619 fShmAudioPool.clear();
2620 return false;
2621 }
2622
2623 if (! fShmNonRtClientControl.initializeServer())
2624 {
2625 carla_stderr("Failed to initialize Non-RT client control");
2626 fShmRtClientControl.clear();
2627 fShmAudioPool.clear();
2628 return false;
2629 }
2630
2631 if (! fShmNonRtServerControl.initializeServer())
2632 {
2633 carla_stderr("Failed to initialize Non-RT server control");
2634 fShmNonRtClientControl.clear();
2635 fShmRtClientControl.clear();
2636 fShmAudioPool.clear();
2637 return false;
2638 }
2639
2640 #ifndef CARLA_OS_WIN
2641 // ---------------------------------------------------------------
2642 // set wine prefix
2643
2644 if (fBridgeBinary.contains(".exe", true))
2645 {
2646 const EngineOptions& engineOptions(pData->engine->getOptions());
2647
2648 if (engineOptions.wine.autoPrefix)
2649 fWinePrefix = findWinePrefix(pData->filename);
2650
2651 if (fWinePrefix.isEmpty())
2652 {
2653 const char* const envWinePrefix(std::getenv("WINEPREFIX"));
2654
2655 if (envWinePrefix != nullptr && envWinePrefix[0] != '\0')
2656 fWinePrefix = envWinePrefix;
2657 else if (engineOptions.wine.fallbackPrefix != nullptr && engineOptions.wine.fallbackPrefix[0] != '\0')
2658 fWinePrefix = engineOptions.wine.fallbackPrefix;
2659 else
2660 fWinePrefix = File::getSpecialLocation(File::userHomeDirectory).getFullPathName() + "/.wine";
2661 }
2662 }
2663 #endif
2664
2665 // ---------------------------------------------------------------
2666 // init bridge thread
2667
2668 {
2669 char shmIdsStr[6*4+1];
2670 carla_zeroChars(shmIdsStr, 6*4+1);
2671
2672 std::strncpy(shmIdsStr+6*0, &fShmAudioPool.filename[fShmAudioPool.filename.length()-6], 6);
2673 std::strncpy(shmIdsStr+6*1, &fShmRtClientControl.filename[fShmRtClientControl.filename.length()-6], 6);
2674 std::strncpy(shmIdsStr+6*2, &fShmNonRtClientControl.filename[fShmNonRtClientControl.filename.length()-6], 6);
2675 std::strncpy(shmIdsStr+6*3, &fShmNonRtServerControl.filename[fShmNonRtServerControl.filename.length()-6], 6);
2676
2677 fBridgeThread.setData(
2678 #ifndef CARLA_OS_WIN
2679 fWinePrefix.toRawUTF8(),
2680 #endif
2681 binaryArchName, bridgeBinary, label, shmIdsStr);
2682 }
2683
2684 if (! restartBridgeThread())
2685 return false;
2686
2687 // ---------------------------------------------------------------
2688 // register client
2689
2690 if (pData->name == nullptr)
2691 {
2692 if (label != nullptr && label[0] != '\0')
2693 pData->name = pData->engine->getUniquePluginName(label);
2694 else
2695 pData->name = pData->engine->getUniquePluginName("unknown");
2696 }
2697
2698 pData->client = pData->engine->addClient(plugin);
2699
2700 if (pData->client == nullptr || ! pData->client->isOk())
2701 {
2702 pData->engine->setLastError("Failed to register plugin client");
2703 return false;
2704 }
2705
2706 // ---------------------------------------------------------------
2707 // set options
2708
2709 pData->options = 0x0;
2710
2711 if ((fInfo.optionsAvailable & PLUGIN_OPTION_FIXED_BUFFERS) == 0x0)
2712 pData->options |= PLUGIN_OPTION_FIXED_BUFFERS;
2713 else if (isPluginOptionEnabled(options, PLUGIN_OPTION_FIXED_BUFFERS))
2714 pData->options |= PLUGIN_OPTION_FIXED_BUFFERS;
2715
2716 if (pData->engine->getOptions().forceStereo)
2717 {
2718 pData->options |= PLUGIN_OPTION_FORCE_STEREO;
2719 }
2720 else if (fInfo.optionsAvailable & PLUGIN_OPTION_FORCE_STEREO)
2721 {
2722 if (options & PLUGIN_OPTION_FORCE_STEREO)
2723 pData->options |= PLUGIN_OPTION_FORCE_STEREO;
2724 }
2725
2726 if (fInfo.optionsAvailable & PLUGIN_OPTION_USE_CHUNKS)
2727 if (isPluginOptionEnabled(options, PLUGIN_OPTION_USE_CHUNKS))
2728 pData->options |= PLUGIN_OPTION_USE_CHUNKS;
2729
2730 if (fInfo.optionsAvailable & PLUGIN_OPTION_SEND_CONTROL_CHANGES)
2731 if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_CONTROL_CHANGES))
2732 pData->options |= PLUGIN_OPTION_SEND_CONTROL_CHANGES;
2733
2734 if (fInfo.optionsAvailable & PLUGIN_OPTION_SEND_CHANNEL_PRESSURE)
2735 if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_CHANNEL_PRESSURE))
2736 pData->options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;
2737
2738 if (fInfo.optionsAvailable & PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH)
2739 if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH))
2740 pData->options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;
2741
2742 if (fInfo.optionsAvailable & PLUGIN_OPTION_SEND_PITCHBEND)
2743 if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_PITCHBEND))
2744 pData->options |= PLUGIN_OPTION_SEND_PITCHBEND;
2745
2746 if (fInfo.optionsAvailable & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)
2747 if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_ALL_SOUND_OFF))
2748 pData->options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;
2749
2750 if (fInfo.optionsAvailable & PLUGIN_OPTION_SKIP_SENDING_NOTES)
2751 if (isPluginOptionInverseEnabled(options, PLUGIN_OPTION_SKIP_SENDING_NOTES))
2752 pData->options |= PLUGIN_OPTION_SKIP_SENDING_NOTES;
2753
2754 if (fInfo.optionsAvailable & PLUGIN_OPTION_SEND_PROGRAM_CHANGES)
2755 {
2756 if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_PROGRAM_CHANGES))
2757 pData->options |= PLUGIN_OPTION_SEND_PROGRAM_CHANGES;
2758 }
2759 else if (fInfo.optionsAvailable & PLUGIN_OPTION_MAP_PROGRAM_CHANGES)
2760 {
2761 if (isPluginOptionEnabled(options, PLUGIN_OPTION_MAP_PROGRAM_CHANGES))
2762 pData->options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;
2763 }
2764
2765 // kPluginBridgeNonRtClientSetOptions was added in API 7
2766 if (fBridgeVersion >= 7)
2767 {
2768 const CarlaMutexLocker _cml(fShmNonRtClientControl.mutex);
2769
2770 fShmNonRtClientControl.writeOpcode(kPluginBridgeNonRtClientSetOptions);
2771 fShmNonRtClientControl.writeUInt(pData->options);
2772 fShmNonRtClientControl.commitWrite();
2773 }
2774
2775 return true;
2776 }
2777
2778 private:
2779 const BinaryType fBinaryType;
2780 const PluginType fPluginType;
2781 uint fBridgeVersion;
2782
2783 bool fInitiated;
2784 bool fInitError;
2785 bool fSaved;
2786 bool fTimedOut;
2787 bool fTimedError;
2788 uint fBufferSize;
2789 uint fProcWaitTime;
2790
2791 CarlaString fBridgeBinary;
2792 CarlaPluginBridgeThread fBridgeThread;
2793
2794 BridgeAudioPool fShmAudioPool;
2795 BridgeRtClientControl fShmRtClientControl;
2796 BridgeNonRtClientControl fShmNonRtClientControl;
2797 BridgeNonRtServerControl fShmNonRtServerControl;
2798
2799 #ifndef CARLA_OS_WIN
2800 String fWinePrefix;
2801 #endif
2802
2803 class ReceivingParamText {
2804 public:
ReceivingParamText()2805 ReceivingParamText() noexcept
2806 : dataRecv(false),
2807 dataOk(false),
2808 index(-1),
2809 strBuf(nullptr),
2810 mutex() {}
2811
isCurrentlyWaitingData() const2812 bool isCurrentlyWaitingData() const noexcept
2813 {
2814 return index >= 0;
2815 }
2816
wasDataReceived(bool * const success) const2817 bool wasDataReceived(bool* const success) const noexcept
2818 {
2819 *success = dataOk;
2820 return dataRecv;
2821 }
2822
setTargetData(const int32_t i,char * const b)2823 void setTargetData(const int32_t i, char* const b) noexcept
2824 {
2825 const CarlaMutexLocker cml(mutex);
2826
2827 dataOk = false;
2828 dataRecv = false;
2829 index = i;
2830 strBuf = b;
2831 }
2832
setReceivedData(const int32_t i,const char * const b,const uint blen)2833 void setReceivedData(const int32_t i, const char* const b, const uint blen) noexcept
2834 {
2835 CarlaScopedValueSetter<bool> svs(dataRecv, false, true);
2836
2837 const CarlaMutexLocker cml(mutex);
2838
2839 // make backup and reset data
2840 const int32_t indexCopy = index;
2841 char* const strBufCopy = strBuf;
2842 index = -1;
2843 strBuf = nullptr;
2844
2845 CARLA_SAFE_ASSERT_RETURN(indexCopy == i,);
2846 CARLA_SAFE_ASSERT_RETURN(strBufCopy != nullptr,);
2847
2848 std::strncpy(strBufCopy, b, std::min(blen, STR_MAX-1U));
2849 dataOk = true;
2850 }
2851
2852 private:
2853 bool dataRecv;
2854 bool dataOk;
2855 int32_t index;
2856 char* strBuf;
2857 CarlaMutex mutex;
2858
2859 CARLA_DECLARE_NON_COPY_CLASS(ReceivingParamText)
2860 } fReceivingParamText;
2861
2862 struct Info {
2863 uint32_t aIns, aOuts;
2864 uint32_t cvIns, cvOuts;
2865 uint32_t mIns, mOuts;
2866 PluginCategory category;
2867 uint optionsAvailable;
2868 CarlaString name;
2869 CarlaString label;
2870 CarlaString maker;
2871 CarlaString copyright;
2872 const char** aInNames;
2873 const char** aOutNames;
2874 const char** cvInNames;
2875 const char** cvOutNames;
2876 std::vector<uint8_t> chunk;
2877
InfoCarlaPluginBridge::Info2878 Info()
2879 : aIns(0),
2880 aOuts(0),
2881 cvIns(0),
2882 cvOuts(0),
2883 mIns(0),
2884 mOuts(0),
2885 category(PLUGIN_CATEGORY_NONE),
2886 optionsAvailable(0),
2887 name(),
2888 label(),
2889 maker(),
2890 copyright(),
2891 aInNames(nullptr),
2892 aOutNames(nullptr),
2893 cvInNames(nullptr),
2894 cvOutNames(nullptr),
2895 chunk() {}
2896
~InfoCarlaPluginBridge::Info2897 ~Info()
2898 {
2899 clear();
2900 }
2901
clearCarlaPluginBridge::Info2902 void clear()
2903 {
2904 if (aInNames != nullptr)
2905 {
2906 CARLA_SAFE_ASSERT_INT(aIns > 0, aIns);
2907
2908 for (uint32_t i=0; i<aIns; ++i)
2909 delete[] aInNames[i];
2910
2911 delete[] aInNames;
2912 aInNames = nullptr;
2913 }
2914
2915 if (aOutNames != nullptr)
2916 {
2917 CARLA_SAFE_ASSERT_INT(aOuts > 0, aOuts);
2918
2919 for (uint32_t i=0; i<aOuts; ++i)
2920 delete[] aOutNames[i];
2921
2922 delete[] aOutNames;
2923 aOutNames = nullptr;
2924 }
2925
2926 if (cvInNames != nullptr)
2927 {
2928 CARLA_SAFE_ASSERT_INT(cvIns > 0, cvIns);
2929
2930 for (uint32_t i=0; i<cvIns; ++i)
2931 delete[] cvInNames[i];
2932
2933 delete[] cvInNames;
2934 cvInNames = nullptr;
2935 }
2936
2937 if (cvOutNames != nullptr)
2938 {
2939 CARLA_SAFE_ASSERT_INT(cvOuts > 0, cvOuts);
2940
2941 for (uint32_t i=0; i<cvOuts; ++i)
2942 delete[] cvOutNames[i];
2943
2944 delete[] cvOutNames;
2945 cvOutNames = nullptr;
2946 }
2947
2948 aIns = aOuts = cvIns = cvOuts = 0;
2949 }
2950
2951 CARLA_DECLARE_NON_COPY_STRUCT(Info)
2952 } fInfo;
2953
2954 int64_t fUniqueId;
2955 uint32_t fLatency;
2956
2957 BridgeParamInfo* fParams;
2958
handleProcessStopped()2959 void handleProcessStopped() noexcept
2960 {
2961 const bool wasActive = pData->active;
2962 pData->active = false;
2963
2964 if (wasActive)
2965 {
2966 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
2967 pData->engine->callback(true, true,
2968 ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,
2969 pData->id,
2970 PARAMETER_ACTIVE,
2971 0, 0,
2972 0.0f,
2973 nullptr);
2974 #endif
2975 }
2976
2977 if (pData->hints & PLUGIN_HAS_CUSTOM_UI)
2978 {
2979 pData->engine->callback(true, true,
2980 ENGINE_CALLBACK_UI_STATE_CHANGED,
2981 pData->id,
2982 0,
2983 0, 0, 0.0f, nullptr);
2984 }
2985 }
2986
resizeAudioPool(const uint32_t bufferSize)2987 void resizeAudioPool(const uint32_t bufferSize)
2988 {
2989 fShmAudioPool.resize(bufferSize, fInfo.aIns+fInfo.aOuts, fInfo.cvIns+fInfo.cvOuts);
2990
2991 fShmRtClientControl.writeOpcode(kPluginBridgeRtClientSetAudioPool);
2992 fShmRtClientControl.writeULong(static_cast<uint64_t>(fShmAudioPool.dataSize));
2993 fShmRtClientControl.commitWrite();
2994
2995 waitForClient("resize-pool", 5000);
2996 }
2997
waitForClient(const char * const action,const uint msecs)2998 void waitForClient(const char* const action, const uint msecs)
2999 {
3000 CARLA_SAFE_ASSERT_RETURN(! fTimedOut,);
3001 CARLA_SAFE_ASSERT_RETURN(! fTimedError,);
3002
3003 if (fShmRtClientControl.waitForClient(msecs))
3004 return;
3005
3006 fTimedOut = true;
3007 carla_stderr2("waitForClient(%s) timed out", action);
3008 }
3009
restartBridgeThread()3010 bool restartBridgeThread()
3011 {
3012 fInitiated = false;
3013 fInitError = false;
3014 fTimedError = false;
3015
3016 // reset memory
3017 fShmRtClientControl.data->procFlags = 0;
3018 carla_zeroStruct(fShmRtClientControl.data->timeInfo);
3019 carla_zeroBytes(fShmRtClientControl.data->midiOut, kBridgeRtClientDataMidiOutSize);
3020
3021 fShmRtClientControl.clearData();
3022 fShmNonRtClientControl.clearData();
3023 fShmNonRtServerControl.clearData();
3024
3025 fShmNonRtClientControl.writeOpcode(kPluginBridgeNonRtClientVersion);
3026 fShmNonRtClientControl.writeUInt(CARLA_PLUGIN_BRIDGE_API_VERSION_CURRENT);
3027
3028 fShmNonRtClientControl.writeUInt(static_cast<uint32_t>(sizeof(BridgeRtClientData)));
3029 fShmNonRtClientControl.writeUInt(static_cast<uint32_t>(sizeof(BridgeNonRtClientData)));
3030 fShmNonRtClientControl.writeUInt(static_cast<uint32_t>(sizeof(BridgeNonRtServerData)));
3031
3032 fShmNonRtClientControl.writeOpcode(kPluginBridgeNonRtClientInitialSetup);
3033 fShmNonRtClientControl.writeUInt(pData->engine->getBufferSize());
3034 fShmNonRtClientControl.writeDouble(pData->engine->getSampleRate());
3035
3036 fShmNonRtClientControl.commitWrite();
3037
3038 if (fShmAudioPool.dataSize != 0)
3039 {
3040 fShmRtClientControl.writeOpcode(kPluginBridgeRtClientSetAudioPool);
3041 fShmRtClientControl.writeULong(static_cast<uint64_t>(fShmAudioPool.dataSize));
3042 fShmRtClientControl.commitWrite();
3043 }
3044 else
3045 {
3046 // testing dummy message
3047 fShmRtClientControl.writeOpcode(kPluginBridgeRtClientNull);
3048 fShmRtClientControl.commitWrite();
3049 }
3050
3051 fBridgeThread.startThread();
3052
3053 const bool needsEngineIdle = pData->engine->getType() != kEngineTypePlugin;
3054 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
3055 const bool needsCancelableAction = ! pData->engine->isLoadingProject();
3056
3057 if (needsCancelableAction)
3058 {
3059 pData->engine->setActionCanceled(false);
3060 pData->engine->callback(true, true,
3061 ENGINE_CALLBACK_CANCELABLE_ACTION,
3062 pData->id,
3063 1,
3064 0, 0, 0.0f,
3065 "Loading plugin bridge");
3066 }
3067 #endif
3068
3069 for (;fBridgeThread.isThreadRunning();)
3070 {
3071 pData->engine->callback(true, true, ENGINE_CALLBACK_IDLE, 0, 0, 0, 0, 0.0f, nullptr);
3072
3073 if (needsEngineIdle)
3074 pData->engine->idle();
3075
3076 idle();
3077
3078 if (fInitiated)
3079 break;
3080 if (pData->engine->isAboutToClose() || pData->engine->wasActionCanceled())
3081 break;
3082
3083 carla_msleep(5);
3084 }
3085
3086 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
3087 if (needsCancelableAction)
3088 {
3089 pData->engine->callback(true, true,
3090 ENGINE_CALLBACK_CANCELABLE_ACTION,
3091 pData->id,
3092 0,
3093 0, 0, 0.0f,
3094 "Loading JACK application");
3095 }
3096 #endif
3097
3098 if (fInitError || ! fInitiated)
3099 {
3100 fBridgeThread.stopThread(6000);
3101
3102 if (! fInitError)
3103 pData->engine->setLastError("Timeout while waiting for a response from plugin-bridge\n"
3104 "(or the plugin crashed on initialization?)");
3105
3106 return false;
3107 }
3108
3109 if (const size_t dataSize = fInfo.chunk.size())
3110 {
3111 #ifdef CARLA_PROPER_CPP11_SUPPORT
3112 void* data = fInfo.chunk.data();
3113 #else
3114 void* data = &fInfo.chunk.front();
3115 #endif
3116 CarlaString dataBase64(CarlaString::asBase64(data, dataSize));
3117 CARLA_SAFE_ASSERT_RETURN(dataBase64.length() > 0, true);
3118
3119 String filePath(File::getSpecialLocation(File::tempDirectory).getFullPathName());
3120
3121 filePath += CARLA_OS_SEP_STR ".CarlaChunk_";
3122 filePath += fShmAudioPool.getFilenameSuffix();
3123
3124 if (File(filePath).replaceWithText(dataBase64.buffer()))
3125 {
3126 const uint32_t ulength(static_cast<uint32_t>(filePath.length()));
3127
3128 const CarlaMutexLocker _cml(fShmNonRtClientControl.mutex);
3129
3130 fShmNonRtClientControl.writeOpcode(kPluginBridgeNonRtClientSetChunkDataFile);
3131 fShmNonRtClientControl.writeUInt(ulength);
3132 fShmNonRtClientControl.writeCustomData(filePath.toRawUTF8(), ulength);
3133 fShmNonRtClientControl.commitWrite();
3134 }
3135 }
3136
3137 return true;
3138 }
3139
_setUiTitleFromName()3140 void _setUiTitleFromName()
3141 {
3142 CarlaString uiName(pData->name);
3143 uiName += " (GUI)";
3144
3145 const uint32_t size = static_cast<uint32_t>(uiName.length());
3146
3147 const CarlaMutexLocker _cml(fShmNonRtClientControl.mutex);
3148
3149 fShmNonRtClientControl.writeOpcode(kPluginBridgeNonRtClientSetWindowTitle);
3150 fShmNonRtClientControl.writeUInt(size);
3151 fShmNonRtClientControl.writeCustomData(uiName.buffer(), size);
3152 fShmNonRtClientControl.commitWrite();
3153 }
3154
3155 CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaPluginBridge)
3156 };
3157
3158 CARLA_BACKEND_END_NAMESPACE
3159
3160 // ---------------------------------------------------------------------------------------------------------------------
3161
3162 CARLA_BACKEND_START_NAMESPACE
3163
newBridge(const Initializer & init,const BinaryType btype,const PluginType ptype,const char * const binaryArchName,const char * bridgeBinary)3164 CarlaPluginPtr CarlaPlugin::newBridge(const Initializer& init,
3165 const BinaryType btype,
3166 const PluginType ptype,
3167 const char* const binaryArchName,
3168 const char* bridgeBinary)
3169 {
3170 carla_debug("CarlaPlugin::newBridge({%p, \"%s\", \"%s\", \"%s\"}, %s, %s, \"%s\", \"%s\")",
3171 init.engine, init.filename, init.name, init.label,
3172 BinaryType2Str(btype), PluginType2Str(ptype), binaryArchName, bridgeBinary);
3173
3174 if (bridgeBinary == nullptr || bridgeBinary[0] == '\0')
3175 {
3176 init.engine->setLastError("Bridge not possible, bridge-binary not found");
3177 return nullptr;
3178 }
3179
3180 #ifndef CARLA_OS_WIN
3181 // FIXME: somewhere, somehow, we end up with double slashes, wine doesn't like that.
3182 if (std::strncmp(bridgeBinary, "//", 2) == 0)
3183 ++bridgeBinary;
3184 #endif
3185
3186 std::shared_ptr<CarlaPluginBridge> plugin(new CarlaPluginBridge(init.engine, init.id, btype, ptype));
3187
3188 if (! plugin->init(plugin, init.filename, init.name, init.label, init.uniqueId, init.options, binaryArchName, bridgeBinary))
3189 return nullptr;
3190
3191 return plugin;
3192 }
3193
3194 CARLA_BACKEND_END_NAMESPACE
3195
3196 // ---------------------------------------------------------------------------------------------------------------------
3197
3198 #ifndef BUILD_BRIDGE
3199 # include "CarlaBridgeUtils.cpp"
3200 #endif
3201
3202 // ---------------------------------------------------------------------------------------------------------------------
3203