Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

3174 lines
114KB

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