falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 Activity
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.
6219 Commits
16 Branches
3.6GB
Tree: 9e14f2dc08
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '9e14f2dc08'
${ noResults }
Carla/source/backend/engine/CarlaEngine.cpp

3494 lines
118KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Host

  3.  * Copyright (C) 2011-2021 Filipe Coelho <falktx@falktx.com>

  4.  *

  5.  * This program is free software; you can redistribute it and/or

  6.  * modify it under the terms of the GNU General Public License as

  7.  * published by the Free Software Foundation; either version 2 of

  8.  * the License, or any later version.

  9.  *

  10.  * This program is distributed in the hope that it will be useful,

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

  13.  * GNU General Public License for more details.

  14.  *

  15.  * For a full copy of the GNU General Public License see the doc/GPL.txt file.

  16.  */

  17. 

  18. /* TODO:

  19.  * - complete processRack(): carefully add to input, sorted events

  20.  * - implement processPatchbay()

  21.  * - implement oscSend_control_switch_plugins()

  22.  * - something about the peaks?

  23.  */

  24. 

  25. #include "CarlaEngineClient.hpp"

  26. #include "CarlaEngineInit.hpp"

  27. #include "CarlaEngineInternal.hpp"

  28. #include "CarlaPlugin.hpp"

  29. 

  30. #include "CarlaBackendUtils.hpp"

  31. #include "CarlaBinaryUtils.hpp"

  32. #include "CarlaEngineUtils.hpp"

  33. #include "CarlaMathUtils.hpp"

  34. #include "CarlaPipeUtils.hpp"

  35. #include "CarlaProcessUtils.hpp"

  36. #include "CarlaScopeUtils.hpp"

  37. #include "CarlaStateUtils.hpp"

  38. #include "CarlaMIDI.h"

  39. 

  40. #include "jackbridge/JackBridge.hpp"

  41. 

  42. #include "water/files/File.h"

  43. #include "water/streams/MemoryOutputStream.h"

  44. #include "water/xml/XmlDocument.h"

  45. #include "water/xml/XmlElement.h"

  46. 

  47. #ifdef CARLA_OS_MAC

  48. # include "CarlaMacUtils.hpp"

  49. # if defined(CARLA_OS_64BIT) && defined(HAVE_LIBMAGIC) && ! defined(BUILD_BRIDGE_ALTERNATIVE_ARCH)

  50. #  define ADAPT_FOR_APPLE_SILLICON

  51. # endif

  52. #endif

  53. 

  54. #include <map>

  55. 

  56. // FIXME Remove on 2.1 release

  57. #include "lv2/atom.h"

  58. 

  59. using water::Array;

  60. using water::CharPointer_UTF8;

  61. using water::File;

  62. using water::MemoryOutputStream;

  63. using water::String;

  64. using water::StringArray;

  65. using water::XmlDocument;

  66. using water::XmlElement;

  67. 

  68. // #define SFZ_FILES_USING_SFIZZ

  69. 

  70. CARLA_BACKEND_START_NAMESPACE

  71. 

  72. // -----------------------------------------------------------------------

  73. // Carla Engine

  74. 

  75. CarlaEngine::CarlaEngine()

  76.     : pData(new ProtectedData(this))

  77. {

  78.     carla_debug("CarlaEngine::CarlaEngine()");

  79. }

  80. 

  81. CarlaEngine::~CarlaEngine()

  82. {

  83.     carla_debug("CarlaEngine::~CarlaEngine()");

  84. 

  85.     delete pData;

  86. }

  87. 

  88. // -----------------------------------------------------------------------

  89. // Static calls

  90. 

  91. uint CarlaEngine::getDriverCount()

  92. {

  93.     carla_debug("CarlaEngine::getDriverCount()");

  94.     using namespace EngineInit;

  95. 

  96.     uint count = 0;

  97. 

  98. #ifndef STATIC_PLUGIN_TARGET

  99.     if (jackbridge_is_ok())

  100.         count += 1;

  101. #endif

  102. 

  103. #ifndef BUILD_BRIDGE

  104. # ifdef USING_JUCE_AUDIO_DEVICES

  105.     count += getJuceApiCount();

  106. # endif

  107. # ifdef USING_RTAUDIO

  108.     count += getRtAudioApiCount();

  109. # endif

  110. #endif

  111. 

  112.     return count;

  113. }

  114. 

  115. const char* CarlaEngine::getDriverName(const uint index2)

  116. {

  117.     carla_debug("CarlaEngine::getDriverName(%i)", index2);

  118.     using namespace EngineInit;

  119. 

  120. #ifndef STATIC_PLUGIN_TARGET

  121.     uint index = index2;

  122. 

  123.     if (jackbridge_is_ok() && index-- == 0)

  124.         return "JACK";

  125. #endif

  126. 

  127. #ifndef BUILD_BRIDGE

  128. # ifdef USING_JUCE_AUDIO_DEVICES

  129.     if (const uint count = getJuceApiCount())

  130.     {

  131.         if (index < count)

  132.             return getJuceApiName(index);

  133.         index -= count;

  134.     }

  135. # endif

  136. # ifdef USING_RTAUDIO

  137.     if (const uint count = getRtAudioApiCount())

  138.     {

  139.         if (index < count)

  140.             return getRtAudioApiName(index);

  141.     }

  142. # endif

  143. #endif

  144. 

  145.     carla_stderr("CarlaEngine::getDriverName(%i) - invalid index", index2);

  146.     return nullptr;

  147. }

  148. 

  149. const char* const* CarlaEngine::getDriverDeviceNames(const uint index2)

  150. {

  151.     carla_debug("CarlaEngine::getDriverDeviceNames(%i)", index2);

  152.     using namespace EngineInit;

  153. 

  154. #ifndef STATIC_PLUGIN_TARGET

  155.     uint index = index2;

  156. 

  157.     if (jackbridge_is_ok() && index-- == 0)

  158.     {

  159.         static const char* ret[3] = { "Auto-Connect ON", "Auto-Connect OFF", nullptr };

  160.         return ret;

  161.     }

  162. #endif

  163. 

  164. #ifndef BUILD_BRIDGE

  165. # ifdef USING_JUCE_AUDIO_DEVICES

  166.     if (const uint count = getJuceApiCount())

  167.     {

  168.         if (index < count)

  169.             return getJuceApiDeviceNames(index);

  170.         index -= count;

  171.     }

  172. # endif

  173. # ifdef USING_RTAUDIO

  174.     if (const uint count = getRtAudioApiCount())

  175.     {

  176.         if (index < count)

  177.             return getRtAudioApiDeviceNames(index);

  178.     }

  179. # endif

  180. #endif

  181. 

  182.     carla_stderr("CarlaEngine::getDriverDeviceNames(%i) - invalid index", index2);

  183.     return nullptr;

  184. }

  185. 

  186. const EngineDriverDeviceInfo* CarlaEngine::getDriverDeviceInfo(const uint index2, const char* const deviceName)

  187. {

  188.     carla_debug("CarlaEngine::getDriverDeviceInfo(%i, \"%s\")", index2, deviceName);

  189.     using namespace EngineInit;

  190. 

  191. #ifndef STATIC_PLUGIN_TARGET

  192.     uint index = index2;

  193. 

  194.     if (jackbridge_is_ok() && index-- == 0)

  195.     {

  196.         static EngineDriverDeviceInfo devInfo;

  197.         devInfo.hints       = ENGINE_DRIVER_DEVICE_VARIABLE_BUFFER_SIZE;

  198.         devInfo.bufferSizes = nullptr;

  199.         devInfo.sampleRates = nullptr;

  200.         return &devInfo;

  201.     }

  202. #endif

  203. 

  204. #ifndef BUILD_BRIDGE

  205. # ifdef USING_JUCE_AUDIO_DEVICES

  206.     if (const uint count = getJuceApiCount())

  207.     {

  208.         if (index < count)

  209.             return getJuceDeviceInfo(index, deviceName);

  210.         index -= count;

  211.     }

  212. # endif

  213. # ifdef USING_RTAUDIO

  214.     if (const uint count = getRtAudioApiCount())

  215.     {

  216.         if (index < count)

  217.             return getRtAudioDeviceInfo(index, deviceName);

  218.     }

  219. # endif

  220. #endif

  221. 

  222.     carla_stderr("CarlaEngine::getDriverDeviceNames(%i, \"%s\") - invalid index", index2, deviceName);

  223.     return nullptr;

  224. }

  225. 

  226. bool CarlaEngine::showDriverDeviceControlPanel(const uint index2, const char* const deviceName)

  227. {

  228.     carla_debug("CarlaEngine::showDriverDeviceControlPanel(%i, \"%s\")", index2, deviceName);

  229.     using namespace EngineInit;

  230. 

  231. #ifndef STATIC_PLUGIN_TARGET

  232.     uint index = index2;

  233. 

  234.     if (jackbridge_is_ok() && index-- == 0)

  235.     {

  236.         return false;

  237.     }

  238. #endif

  239. 

  240. #ifndef BUILD_BRIDGE

  241. # ifdef USING_JUCE_AUDIO_DEVICES

  242.     if (const uint count = getJuceApiCount())

  243.     {

  244.         if (index < count)

  245.             return showJuceDeviceControlPanel(index, deviceName);

  246.         index -= count;

  247.     }

  248. # endif

  249. # ifdef USING_RTAUDIO

  250.     if (const uint count = getRtAudioApiCount())

  251.     {

  252.         if (index < count)

  253.             return false;

  254.     }

  255. # endif

  256. #endif

  257. 

  258.     carla_stderr("CarlaEngine::showDriverDeviceControlPanel(%i, \"%s\") - invalid index", index2, deviceName);

  259.     return false;

  260. }

  261. 

  262. CarlaEngine* CarlaEngine::newDriverByName(const char* const driverName)

  263. {

  264.     CARLA_SAFE_ASSERT_RETURN(driverName != nullptr && driverName[0] != '\0', nullptr);

  265.     carla_debug("CarlaEngine::newDriverByName(\"%s\")", driverName);

  266.     using namespace EngineInit;

  267. 

  268.     if (std::strcmp(driverName, "JACK") == 0)

  269.         return newJack();

  270. 

  271. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  272.     if (std::strcmp(driverName, "Dummy") == 0)

  273.         return newDummy();

  274. #endif

  275. 

  276. #ifndef BUILD_BRIDGE

  277. # ifdef USING_JUCE_AUDIO_DEVICES

  278.     // -------------------------------------------------------------------

  279.     // linux

  280. 

  281.     if (std::strcmp(driverName, "ALSA") == 0)

  282.         return newJuce(AUDIO_API_ALSA);

  283. 

  284.     // -------------------------------------------------------------------

  285.     // macos

  286. 

  287.     if (std::strcmp(driverName, "CoreAudio") == 0)

  288.         return newJuce(AUDIO_API_COREAUDIO);

  289. 

  290.     // -------------------------------------------------------------------

  291.     // windows

  292. 

  293.     if (std::strcmp(driverName, "ASIO") == 0)

  294.         return newJuce(AUDIO_API_ASIO);

  295.     if (std::strcmp(driverName, "DirectSound") == 0)

  296.         return newJuce(AUDIO_API_DIRECTSOUND);

  297.     if (std::strcmp(driverName, "WASAPI") == 0 || std::strcmp(driverName, "Windows Audio") == 0)

  298.         return newJuce(AUDIO_API_WASAPI);

  299. # endif

  300. # ifdef USING_RTAUDIO

  301.     // -------------------------------------------------------------------

  302.     // common

  303. 

  304.     if (std::strncmp(driverName, "JACK ", 5) == 0)

  305.         return newRtAudio(AUDIO_API_JACK);

  306.     if (std::strcmp(driverName, "OSS") == 0)

  307.         return newRtAudio(AUDIO_API_OSS);

  308. 

  309.     // -------------------------------------------------------------------

  310.     // linux

  311. 

  312.     if (std::strcmp(driverName, "ALSA") == 0)

  313.         return newRtAudio(AUDIO_API_ALSA);

  314.     if (std::strcmp(driverName, "PulseAudio") == 0)

  315.         return newRtAudio(AUDIO_API_PULSEAUDIO);

  316. 

  317.     // -------------------------------------------------------------------

  318.     // macos

  319. 

  320.     if (std::strcmp(driverName, "CoreAudio") == 0)

  321.         return newRtAudio(AUDIO_API_COREAUDIO);

  322. 

  323.     // -------------------------------------------------------------------

  324.     // windows

  325. 

  326.     if (std::strcmp(driverName, "ASIO") == 0)

  327.         return newRtAudio(AUDIO_API_ASIO);

  328.     if (std::strcmp(driverName, "DirectSound") == 0)

  329.         return newRtAudio(AUDIO_API_DIRECTSOUND);

  330.     if (std::strcmp(driverName, "WASAPI") == 0)

  331.         return newRtAudio(AUDIO_API_WASAPI);

  332. # endif

  333. #endif

  334. 

  335.     carla_stderr("CarlaEngine::newDriverByName(\"%s\") - invalid driver name", driverName);

  336.     return nullptr;

  337. }

  338. 

  339. // -----------------------------------------------------------------------

  340. // Constant values

  341. 

  342. uint CarlaEngine::getMaxClientNameSize() const noexcept

  343. {

  344.     return STR_MAX/2;

  345. }

  346. 

  347. uint CarlaEngine::getMaxPortNameSize() const noexcept

  348. {

  349.     return STR_MAX;

  350. }

  351. 

  352. uint CarlaEngine::getCurrentPluginCount() const noexcept

  353. {

  354.     return pData->curPluginCount;

  355. }

  356. 

  357. uint CarlaEngine::getMaxPluginNumber() const noexcept

  358. {

  359.     return pData->maxPluginNumber;

  360. }

  361. 

  362. // -----------------------------------------------------------------------

  363. // Virtual, per-engine type calls

  364. 

  365. bool CarlaEngine::close()

  366. {

  367.     carla_debug("CarlaEngine::close()");

  368. 

  369.     if (pData->curPluginCount != 0)

  370.     {

  371.         pData->aboutToClose = true;

  372.         removeAllPlugins();

  373.     }

  374. 

  375.     pData->close();

  376. 

  377.     callback(true, true, ENGINE_CALLBACK_ENGINE_STOPPED, 0, 0, 0, 0, 0.0f, nullptr);

  378.     return true;

  379. }

  380. 

  381. bool CarlaEngine::usesConstantBufferSize() const noexcept

  382. {

  383.     return true;

  384. }

  385. 

  386. void CarlaEngine::idle() noexcept

  387. {

  388.     CARLA_SAFE_ASSERT_RETURN(pData->nextAction.opcode == kEnginePostActionNull,);

  389.     CARLA_SAFE_ASSERT_RETURN(pData->nextPluginId == pData->maxPluginNumber,);

  390.     CARLA_SAFE_ASSERT_RETURN(getType() != kEngineTypePlugin,);

  391. 

  392.     const bool engineNotRunning = !isRunning();

  393. 

  394.     for (uint i=0; i < pData->curPluginCount; ++i)

  395.     {

  396.         if (const CarlaPluginPtr plugin = pData->plugins[i].plugin)

  397.         {

  398.             if (plugin->isEnabled())

  399.             {

  400.                 const uint hints = plugin->getHints();

  401. 

  402.                 if (engineNotRunning)

  403.                 {

  404.                     try {

  405.                         plugin->idle();

  406.                     } CARLA_SAFE_EXCEPTION_CONTINUE("Plugin idle");

  407. 

  408.                     if (hints & PLUGIN_HAS_CUSTOM_UI)

  409.                     {

  410.                         try {

  411.                             plugin->uiIdle();

  412.                         } CARLA_SAFE_EXCEPTION_CONTINUE("Plugin uiIdle");

  413.                     }

  414.                 }

  415.                 else if ((hints & PLUGIN_HAS_CUSTOM_UI) != 0 && (hints & PLUGIN_NEEDS_UI_MAIN_THREAD) != 0)

  416.                 {

  417.                     try {

  418.                         plugin->uiIdle();

  419.                     } CARLA_SAFE_EXCEPTION_CONTINUE("Plugin uiIdle");

  420.                 }

  421.             }

  422.         }

  423.     }

  424. 

  425. #if defined(HAVE_LIBLO) && !defined(BUILD_BRIDGE)

  426.     pData->osc.idle();

  427. #endif

  428. 

  429.     pData->deletePluginsAsNeeded();

  430. }

  431. 

  432. CarlaEngineClient* CarlaEngine::addClient(CarlaPluginPtr plugin)

  433. {

  434. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  435.     return new CarlaEngineClientForStandalone(*this, pData->graph, plugin);

  436. #else

  437.     return new CarlaEngineClientForBridge(*this);

  438. 

  439.     // unused

  440.     (void)plugin;

  441. #endif

  442. }

  443. 

  444. float CarlaEngine::getDSPLoad() const noexcept

  445. {

  446. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  447.     return pData->dspLoad;

  448. #else

  449.     return 0.0f;

  450. #endif

  451. }

  452. 

  453. uint32_t CarlaEngine::getTotalXruns() const noexcept

  454. {

  455. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  456.     return pData->xruns;

  457. #else

  458.     return 0;

  459. #endif

  460. }

  461. 

  462. void CarlaEngine::clearXruns() const noexcept

  463. {

  464. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  465.     pData->xruns = 0;

  466. #endif

  467. }

  468. 

  469. bool CarlaEngine::showDeviceControlPanel() const noexcept

  470. {

  471.     return false;

  472. }

  473. 

  474. bool CarlaEngine::setBufferSizeAndSampleRate(const uint, const double)

  475. {

  476.     return false;

  477. }

  478. 

  479. // -----------------------------------------------------------------------

  480. // Plugin management

  481. 

  482. bool CarlaEngine::addPlugin(const BinaryType btype,

  483.                             const PluginType ptype,

  484.                             const char* const filename,

  485.                             const char* const name,

  486.                             const char* const label,

  487.                             const int64_t uniqueId,

  488.                             const void* const extra,

  489.                             const uint options)

  490. {

  491.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->isIdling == 0, "An operation is still being processed, please wait for it to finish");

  492. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  493.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->plugins != nullptr, "Invalid engine internal data");

  494.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->nextPluginId <= pData->maxPluginNumber, "Invalid engine internal data");

  495. #endif

  496.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->nextAction.opcode == kEnginePostActionNull, "Invalid engine internal data");

  497.     CARLA_SAFE_ASSERT_RETURN_ERR(btype != BINARY_NONE, "Invalid plugin binary mode");

  498.     CARLA_SAFE_ASSERT_RETURN_ERR(ptype != PLUGIN_NONE, "Invalid plugin type");

  499.     CARLA_SAFE_ASSERT_RETURN_ERR((filename != nullptr && filename[0] != '\0') || (label != nullptr && label[0] != '\0'), "Invalid plugin filename and label");

  500.     carla_debug("CarlaEngine::addPlugin(%i:%s, %i:%s, \"%s\", \"%s\", \"%s\", " P_INT64 ", %p, %u)",

  501.                 btype, BinaryType2Str(btype), ptype, PluginType2Str(ptype), filename, name, label, uniqueId, extra, options);

  502. 

  503. #ifndef CARLA_OS_WIN

  504.     if (ptype != PLUGIN_JACK && ptype != PLUGIN_LV2 && filename != nullptr && filename[0] != '\0') {

  505.         CARLA_SAFE_ASSERT_RETURN_ERR(filename[0] == CARLA_OS_SEP || filename[0] == '.' || filename[0] == '~', "Invalid plugin filename");

  506.     }

  507. #endif

  508. 

  509.     uint id;

  510. 

  511. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  512.     CarlaPluginPtr oldPlugin;

  513. 

  514.     if (pData->nextPluginId < pData->curPluginCount)

  515.     {

  516.         id = pData->nextPluginId;

  517.         pData->nextPluginId = pData->maxPluginNumber;

  518. 

  519.         oldPlugin = pData->plugins[id].plugin;

  520. 

  521.         CARLA_SAFE_ASSERT_RETURN_ERR(oldPlugin.get() != nullptr, "Invalid replace plugin Id");

  522.     }

  523.     else

  524. #endif

  525.     {

  526.         id = pData->curPluginCount;

  527. 

  528.         if (id == pData->maxPluginNumber)

  529.         {

  530.             setLastError("Maximum number of plugins reached");

  531.             return false;

  532.         }

  533. 

  534. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  535.         CARLA_SAFE_ASSERT_RETURN_ERR(pData->plugins[id].plugin.get() == nullptr, "Invalid engine internal data");

  536. #endif

  537.     }

  538. 

  539.     CarlaPlugin::Initializer initializer = {

  540.         this,

  541.         id,

  542.         filename,

  543.         name,

  544.         label,

  545.         uniqueId,

  546.         options

  547.     };

  548. 

  549.     CarlaPluginPtr plugin;

  550.     CarlaString bridgeBinary(pData->options.binaryDir);

  551. 

  552.     if (bridgeBinary.isNotEmpty())

  553.     {

  554. #ifndef CARLA_OS_WIN

  555.         if (btype == BINARY_NATIVE)

  556.         {

  557.             bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-native";

  558.         }

  559.         else

  560. #endif

  561.         {

  562.             switch (btype)

  563.             {

  564.             case BINARY_POSIX32:

  565.                 bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-posix32";

  566.                 break;

  567.             case BINARY_POSIX64:

  568.                 bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-posix64";

  569.                 break;

  570.             case BINARY_WIN32:

  571. #if defined(CARLA_OS_WIN) && !defined(CARLA_OS_64BIT)

  572.                 bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-native.exe";

  573. #else

  574.                 bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-win32.exe";

  575. #endif

  576.                 break;

  577.             case BINARY_WIN64:

  578. #if defined(CARLA_OS_WIN) && defined(CARLA_OS_64BIT)

  579.                 bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-native.exe";

  580. #else

  581.                 bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-win64.exe";

  582. #endif

  583.                 break;

  584.             default:

  585.                 bridgeBinary.clear();

  586.                 break;

  587.             }

  588.         }

  589. 

  590.         if (! File(bridgeBinary.buffer()).existsAsFile())

  591.             bridgeBinary.clear();

  592.     }

  593. 

  594.     const bool canBeBridged = ptype != PLUGIN_INTERNAL

  595.                            && ptype != PLUGIN_DLS

  596.                            && ptype != PLUGIN_GIG

  597.                            && ptype != PLUGIN_SF2

  598.                            && ptype != PLUGIN_SFZ

  599.                            && ptype != PLUGIN_JACK;

  600. 

  601.     // Prefer bridges for some specific plugins

  602.     bool preferBridges = pData->options.preferPluginBridges;

  603.     const char* needsArchBridge = nullptr;

  604. 

  605. #ifdef CARLA_OS_MAC

  606.     // Plugin might be in quarentine due to Apple stupid notarization rules, let's remove that if possible

  607.     if (canBeBridged && ptype != PLUGIN_LV2 && ptype != PLUGIN_AU)

  608.         removeFileFromQuarantine(filename);

  609. #endif

  610. 

  611. #ifndef BUILD_BRIDGE

  612.     if (canBeBridged && ! preferBridges)

  613.     {

  614. # if 0

  615.         if (ptype == PLUGIN_LV2 && label != nullptr)

  616.         {

  617.             if (std::strncmp(label, "http://calf.sourceforge.net/plugins/", 36) == 0 ||

  618.                 std::strcmp(label, "http://factorial.hu/plugins/lv2/ir") == 0 ||

  619.                 std::strstr(label, "v1.sourceforge.net/lv2") != nullptr)

  620.             {

  621.                 preferBridges = true;

  622.             }

  623.         }

  624. # endif

  625. # ifdef ADAPT_FOR_APPLE_SILLICON

  626.         // see if this binary needs bridging

  627.         if (ptype == PLUGIN_VST2 || ptype == PLUGIN_VST3)

  628.         {

  629.             if (const char* const vst2Binary = findBinaryInBundle(filename))

  630.             {

  631.                 const CarlaMagic magic;

  632.                 if (const char* const output = magic.getFileDescription(vst2Binary))

  633.                 {

  634.                     carla_stdout("VST binary magic output is '%s'", output);

  635. #  ifdef __aarch64__

  636.                     if (std::strstr(output, "arm64") == nullptr && std::strstr(output, "x86_64") != nullptr)

  637.                         needsArchBridge = "x86_64";

  638. #  else

  639.                     if (std::strstr(output, "x86_64") == nullptr && std::strstr(output, "arm64") != nullptr)

  640.                         needsArchBridge = "arm64";

  641. #  endif

  642.                 }

  643.                 else

  644.                 {

  645.                     carla_stdout("VST binary magic output is null");

  646.                 }

  647.             }

  648.             else

  649.             {

  650.                 carla_stdout("Search for binary in VST bundle failed");

  651.             }

  652.         }

  653. # endif

  654.     }

  655. #endif // ! BUILD_BRIDGE

  656. 

  657.     if (canBeBridged && (needsArchBridge || btype != BINARY_NATIVE || (preferBridges && bridgeBinary.isNotEmpty())))

  658.     {

  659.         if (bridgeBinary.isNotEmpty())

  660.         {

  661.             plugin = CarlaPlugin::newBridge(initializer, btype, ptype, needsArchBridge, bridgeBinary);

  662.         }

  663.         else

  664.         {

  665.             setLastError("This Carla build cannot handle this binary");

  666.             return false;

  667.         }

  668.     }

  669.     else

  670.     {

  671. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  672.         bool use16Outs;

  673. #endif

  674.         setLastError("Invalid or unsupported plugin type");

  675. 

  676.         // Some stupid plugins mess up with global signals, err!!

  677.         const CarlaSignalRestorer csr;

  678. 

  679.         switch (ptype)

  680.         {

  681.         case PLUGIN_NONE:

  682.             break;

  683. 

  684.         case PLUGIN_LADSPA:

  685.             plugin = CarlaPlugin::newLADSPA(initializer, (const LADSPA_RDF_Descriptor*)extra);

  686.             break;

  687. 

  688.         case PLUGIN_DSSI:

  689.             plugin = CarlaPlugin::newDSSI(initializer);

  690.             break;

  691. 

  692.         case PLUGIN_LV2:

  693.             plugin = CarlaPlugin::newLV2(initializer);

  694.             break;

  695. 

  696.         case PLUGIN_VST2:

  697.             plugin = CarlaPlugin::newVST2(initializer);

  698.             break;

  699. 

  700.         case PLUGIN_VST3:

  701.             plugin = CarlaPlugin::newVST3(initializer);

  702.             break;

  703. 

  704.         case PLUGIN_AU:

  705.             plugin = CarlaPlugin::newAU(initializer);

  706.             break;

  707. 

  708. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  709.         case PLUGIN_INTERNAL:

  710.             plugin = CarlaPlugin::newNative(initializer);

  711.             break;

  712. 

  713.         case PLUGIN_DLS:

  714.         case PLUGIN_GIG:

  715.         case PLUGIN_SF2:

  716.             use16Outs = (extra != nullptr && std::strcmp((const char*)extra, "true") == 0);

  717.             plugin = CarlaPlugin::newFluidSynth(initializer, ptype, use16Outs);

  718.             break;

  719. 

  720.         case PLUGIN_SFZ:

  721. # ifdef SFZ_FILES_USING_SFIZZ

  722.             {

  723.                 CarlaPlugin::Initializer sfizzInitializer = {

  724.                     this,

  725.                     id,

  726.                     name,

  727.                     "",

  728.                     "http://sfztools.github.io/sfizz",

  729.                     0,

  730.                     options

  731.                 };

  732. 

  733.                 plugin = CarlaPlugin::newLV2(sfizzInitializer);

  734.             }

  735. # else

  736.             plugin = CarlaPlugin::newSFZero(initializer);

  737. # endif

  738.             break;

  739. 

  740.         case PLUGIN_JACK:

  741. # ifndef STATIC_PLUGIN_TARGET

  742.             plugin = CarlaPlugin::newJackApp(initializer);

  743. # else

  744.             setLastError("Static plugin target does not support JACK applications");

  745. # endif

  746.             break;

  747. #else

  748.         case PLUGIN_INTERNAL:

  749.         case PLUGIN_DLS:

  750.         case PLUGIN_GIG:

  751.         case PLUGIN_SF2:

  752.         case PLUGIN_SFZ:

  753.         case PLUGIN_JACK:

  754.             setLastError("Plugin bridges cannot handle this binary");

  755.             break;

  756. #endif

  757.         }

  758.     }

  759. 

  760.     if (plugin.get() == nullptr)

  761.         return false;

  762. 

  763.     plugin->reload();

  764. 

  765. #ifdef SFZ_FILES_USING_SFIZZ

  766.     if (ptype == PLUGIN_SFZ && plugin->getType() == PLUGIN_LV2)

  767.     {

  768.         plugin->setCustomData(LV2_ATOM__Path,

  769.                               "http://sfztools.github.io/sfizz:sfzfile",

  770.                               filename,

  771.                               false);

  772. 

  773.         plugin->restoreLV2State(true);

  774.     }

  775. #endif

  776. 

  777.     bool canRun = true;

  778. 

  779.     if (pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY)

  780.     {

  781.         /**/ if (plugin->getMidiInCount() > 1 || plugin->getMidiOutCount() > 1)

  782.         {

  783.             setLastError("Carla's patchbay mode cannot work with plugins that have multiple MIDI ports, sorry!");

  784.             canRun = false;

  785.         }

  786.     }

  787. 

  788.     if (! canRun)

  789.     {

  790.         return false;

  791.     }

  792. 

  793.     EnginePluginData& pluginData(pData->plugins[id]);

  794.     pluginData.plugin = plugin;

  795.     carla_zeroFloats(pluginData.peaks, 4);

  796. 

  797. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  798.     if (oldPlugin.get() != nullptr)

  799.     {

  800.         CARLA_SAFE_ASSERT(! pData->loadingProject);

  801. 

  802.         const ScopedThreadStopper sts(this);

  803. 

  804.         if (pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY)

  805.             pData->graph.replacePlugin(oldPlugin, plugin);

  806. 

  807.         const bool  wasActive = oldPlugin->getInternalParameterValue(PARAMETER_ACTIVE) >= 0.5f;

  808.         const float oldDryWet = oldPlugin->getInternalParameterValue(PARAMETER_DRYWET);

  809.         const float oldVolume = oldPlugin->getInternalParameterValue(PARAMETER_VOLUME);

  810. 

  811.         oldPlugin->prepareForDeletion();

  812.         pData->pluginsToDelete.push_back(oldPlugin);

  813. 

  814.         if (plugin->getHints() & PLUGIN_CAN_DRYWET)

  815.             plugin->setDryWet(oldDryWet, true, true);

  816. 

  817.         if (plugin->getHints() & PLUGIN_CAN_VOLUME)

  818.             plugin->setVolume(oldVolume, true, true);

  819. 

  820.         plugin->setActive(wasActive, true, true);

  821.         plugin->setEnabled(true);

  822. 

  823.         callback(true, true, ENGINE_CALLBACK_RELOAD_ALL, id, 0, 0, 0, 0.0f, nullptr);

  824.     }

  825.     else if (! pData->loadingProject)

  826. #endif

  827.     {

  828.         plugin->setEnabled(true);

  829. 

  830.         ++pData->curPluginCount;

  831.         callback(true, true, ENGINE_CALLBACK_PLUGIN_ADDED, id, 0, 0, 0, 0.0f, plugin->getName());

  832. 

  833.         if (getType() != kEngineTypeBridge)

  834.             plugin->setActive(true, true, true);

  835. 

  836. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  837.         if (pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY)

  838.             pData->graph.addPlugin(plugin);

  839. #endif

  840.     }

  841. 

  842.     return true;

  843. }

  844. 

  845. bool CarlaEngine::addPlugin(const PluginType ptype,

  846.                             const char* const filename,

  847.                             const char* const name,

  848.                             const char* const label,

  849.                             const int64_t uniqueId,

  850.                             const void* const extra)

  851. {

  852.     return addPlugin(BINARY_NATIVE, ptype, filename, name, label, uniqueId, extra, PLUGIN_OPTIONS_NULL);

  853. }

  854. 

  855. bool CarlaEngine::removePlugin(const uint id)

  856. {

  857.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->isIdling == 0, "An operation is still being processed, please wait for it to finish");

  858. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  859.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->plugins != nullptr, "Invalid engine internal data");

  860.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->curPluginCount != 0, "Invalid engine internal data");

  861. #else

  862.     CARLA_SAFE_ASSERT_RETURN_ERR(id == 0, "Invalid engine internal data");

  863. #endif

  864.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->nextAction.opcode == kEnginePostActionNull, "Invalid engine internal data");

  865.     CARLA_SAFE_ASSERT_RETURN_ERR(id < pData->curPluginCount, "Invalid plugin Id");

  866.     carla_debug("CarlaEngine::removePlugin(%i)", id);

  867. 

  868.     const CarlaPluginPtr plugin = pData->plugins[id].plugin;

  869. 

  870.     CARLA_SAFE_ASSERT_RETURN_ERR(plugin.get() != nullptr, "Could not find plugin to remove");

  871.     CARLA_SAFE_ASSERT_RETURN_ERR(plugin->getId() == id, "Invalid engine internal data");

  872. 

  873.     const ScopedThreadStopper sts(this);

  874. 

  875. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  876.     if (pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY)

  877.         pData->graph.removePlugin(plugin);

  878. 

  879.     const ScopedActionLock sal(this, kEnginePostActionRemovePlugin, id, 0);

  880. 

  881.     /*

  882.     for (uint i=id; i < pData->curPluginCount; ++i)

  883.     {

  884.         CarlaPlugin* const plugin2(pData->plugins[i].plugin);

  885.         CARLA_SAFE_ASSERT_BREAK(plugin2 != nullptr);

  886.         plugin2->updateOscURL();

  887.     }

  888.     */

  889. #else

  890.     pData->curPluginCount = 0;

  891.     pData->plugins[0].plugin = nullptr;

  892.     carla_zeroStruct(pData->plugins[0].peaks);

  893. #endif

  894. 

  895.     plugin->prepareForDeletion();

  896.     pData->pluginsToDelete.push_back(plugin);

  897. 

  898.     callback(true, true, ENGINE_CALLBACK_PLUGIN_REMOVED, id, 0, 0, 0, 0.0f, nullptr);

  899.     return true;

  900. }

  901. 

  902. bool CarlaEngine::removeAllPlugins()

  903. {

  904.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->isIdling == 0, "An operation is still being processed, please wait for it to finish");

  905. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  906.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->plugins != nullptr, "Invalid engine internal data");

  907.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->nextPluginId == pData->maxPluginNumber, "Invalid engine internal data");

  908. #endif

  909.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->nextAction.opcode == kEnginePostActionNull, "Invalid engine internal data");

  910.     carla_debug("CarlaEngine::removeAllPlugins()");

  911. 

  912.     if (pData->curPluginCount == 0)

  913.         return true;

  914. 

  915.     const ScopedThreadStopper sts(this);

  916. 

  917.     const uint curPluginCount = pData->curPluginCount;

  918. 

  919. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  920.     if (pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY)

  921.         pData->graph.removeAllPlugins();

  922. #endif

  923. 

  924.     const ScopedActionLock sal(this, kEnginePostActionZeroCount, 0, 0);

  925. 

  926.     callback(true, false, ENGINE_CALLBACK_IDLE, 0, 0, 0, 0, 0.0f, nullptr);

  927. 

  928.     for (uint i=0; i < curPluginCount; ++i)

  929.     {

  930.         const uint id = curPluginCount - i - 1;

  931.         EnginePluginData& pluginData(pData->plugins[id]);

  932. 

  933.         pluginData.plugin->prepareForDeletion();

  934.         pData->pluginsToDelete.push_back(pluginData.plugin);

  935. 

  936.         pluginData.plugin.reset();

  937.         carla_zeroStruct(pluginData.peaks);

  938. 

  939.         callback(true, true, ENGINE_CALLBACK_PLUGIN_REMOVED, id, 0, 0, 0, 0.0f, nullptr);

  940.         callback(true, false, ENGINE_CALLBACK_IDLE, 0, 0, 0, 0, 0.0f, nullptr);

  941.     }

  942. 

  943.     return true;

  944. }

  945. 

  946. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  947. bool CarlaEngine::renamePlugin(const uint id, const char* const newName)

  948. {

  949.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->isIdling == 0, "An operation is still being processed, please wait for it to finish");

  950.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->plugins != nullptr, "Invalid engine internal data");

  951.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->curPluginCount != 0, "Invalid engine internal data");

  952.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->nextAction.opcode == kEnginePostActionNull, "Invalid engine internal data");

  953.     CARLA_SAFE_ASSERT_RETURN_ERR(id < pData->curPluginCount, "Invalid plugin Id");

  954.     CARLA_SAFE_ASSERT_RETURN_ERR(newName != nullptr && newName[0] != '\0', "Invalid plugin name");

  955.     carla_debug("CarlaEngine::renamePlugin(%i, \"%s\")", id, newName);

  956. 

  957.     const CarlaPluginPtr plugin = pData->plugins[id].plugin;

  958.     CARLA_SAFE_ASSERT_RETURN_ERR(plugin.get() != nullptr, "Could not find plugin to rename");

  959.     CARLA_SAFE_ASSERT_RETURN_ERR(plugin->getId() == id, "Invalid engine internal data");

  960. 

  961.     const char* const uniqueName(getUniquePluginName(newName));

  962.     CARLA_SAFE_ASSERT_RETURN_ERR(uniqueName != nullptr, "Unable to get new unique plugin name");

  963. 

  964.     plugin->setName(uniqueName);

  965. 

  966.     if (pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY)

  967.         pData->graph.renamePlugin(plugin, uniqueName);

  968. 

  969.     callback(true, true, ENGINE_CALLBACK_PLUGIN_RENAMED, id, 0, 0, 0, 0.0f, uniqueName);

  970. 

  971.     delete[] uniqueName;

  972.     return true;

  973. }

  974. 

  975. bool CarlaEngine::clonePlugin(const uint id)

  976. {

  977.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->isIdling == 0, "An operation is still being processed, please wait for it to finish");

  978.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->plugins != nullptr, "Invalid engine internal data");

  979.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->curPluginCount != 0, "Invalid engine internal data");

  980.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->nextAction.opcode == kEnginePostActionNull, "Invalid engine internal data");

  981.     CARLA_SAFE_ASSERT_RETURN_ERR(id < pData->curPluginCount, "Invalid plugin Id");

  982.     carla_debug("CarlaEngine::clonePlugin(%i)", id);

  983. 

  984.     const CarlaPluginPtr plugin = pData->plugins[id].plugin;

  985. 

  986.     CARLA_SAFE_ASSERT_RETURN_ERR(plugin.get() != nullptr, "Could not find plugin to clone");

  987.     CARLA_SAFE_ASSERT_RETURN_ERR(plugin->getId() == id, "Invalid engine internal data");

  988. 

  989.     char label[STR_MAX+1];

  990.     carla_zeroChars(label, STR_MAX+1);

  991. 

  992.     if (! plugin->getLabel(label))

  993.         label[0] = '\0';

  994. 

  995.     const uint pluginCountBefore(pData->curPluginCount);

  996. 

  997.     if (! addPlugin(plugin->getBinaryType(), plugin->getType(),

  998.                     plugin->getFilename(), plugin->getName(), label, plugin->getUniqueId(),

  999.                     plugin->getExtraStuff(), plugin->getOptionsEnabled()))

  1000.         return false;

  1001. 

  1002.     CARLA_SAFE_ASSERT_RETURN_ERR(pluginCountBefore+1 == pData->curPluginCount, "No new plugin found");

  1003. 

  1004.     if (const CarlaPluginPtr newPlugin = pData->plugins[pluginCountBefore].plugin)

  1005.     {

  1006.         if (newPlugin->getType() == PLUGIN_LV2)

  1007.             newPlugin->cloneLV2Files(*plugin);

  1008.         newPlugin->loadStateSave(plugin->getStateSave(true));

  1009.     }

  1010. 

  1011.     return true;

  1012. }

  1013. 

  1014. bool CarlaEngine::replacePlugin(const uint id) noexcept

  1015. {

  1016.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->isIdling == 0, "An operation is still being processed, please wait for it to finish");

  1017.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->plugins != nullptr, "Invalid engine internal data");

  1018.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->curPluginCount != 0, "Invalid engine internal data");

  1019.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->nextAction.opcode == kEnginePostActionNull, "Invalid engine internal data");

  1020.     carla_debug("CarlaEngine::replacePlugin(%i)", id);

  1021. 

  1022.     // might use this to reset

  1023.     if (id == pData->maxPluginNumber)

  1024.     {

  1025.         pData->nextPluginId = pData->maxPluginNumber;

  1026.         return true;

  1027.     }

  1028. 

  1029.     CARLA_SAFE_ASSERT_RETURN_ERR(id < pData->curPluginCount, "Invalid plugin Id");

  1030. 

  1031.     const CarlaPluginPtr plugin = pData->plugins[id].plugin;

  1032. 

  1033.     CARLA_SAFE_ASSERT_RETURN_ERR(plugin.get() != nullptr, "Could not find plugin to replace");

  1034.     CARLA_SAFE_ASSERT_RETURN_ERR(plugin->getId() == id, "Invalid engine internal data");

  1035. 

  1036.     pData->nextPluginId = id;

  1037. 

  1038.     return true;

  1039. }

  1040. 

  1041. bool CarlaEngine::switchPlugins(const uint idA, const uint idB) noexcept

  1042. {

  1043.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->isIdling == 0, "An operation is still being processed, please wait for it to finish");

  1044.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->plugins != nullptr, "Invalid engine internal data");

  1045.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->curPluginCount >= 2, "Invalid engine internal data");

  1046.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->nextAction.opcode == kEnginePostActionNull, "Invalid engine internal data");

  1047.     CARLA_SAFE_ASSERT_RETURN_ERR(idA != idB, "Invalid operation, cannot switch plugin with itself");

  1048.     CARLA_SAFE_ASSERT_RETURN_ERR(idA < pData->curPluginCount, "Invalid plugin Id");

  1049.     CARLA_SAFE_ASSERT_RETURN_ERR(idB < pData->curPluginCount, "Invalid plugin Id");

  1050.     carla_debug("CarlaEngine::switchPlugins(%i)", idA, idB);

  1051. 

  1052.     const CarlaPluginPtr pluginA = pData->plugins[idA].plugin;

  1053.     const CarlaPluginPtr pluginB = pData->plugins[idB].plugin;

  1054. 

  1055.     CARLA_SAFE_ASSERT_RETURN_ERR(pluginA.get() != nullptr, "Could not find plugin to switch");

  1056.     CARLA_SAFE_ASSERT_RETURN_ERR(pluginB.get() != nullptr, "Could not find plugin to switch");

  1057.     CARLA_SAFE_ASSERT_RETURN_ERR(pluginA->getId() == idA, "Invalid engine internal data");

  1058.     CARLA_SAFE_ASSERT_RETURN_ERR(pluginB->getId() == idB, "Invalid engine internal data");

  1059. 

  1060.     const ScopedThreadStopper sts(this);

  1061. 

  1062.     if (pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY)

  1063.         pData->graph.switchPlugins(pluginA, pluginB);

  1064. 

  1065.     const ScopedActionLock sal(this, kEnginePostActionSwitchPlugins, idA, idB);

  1066. 

  1067.     // TODO

  1068.     /*

  1069.     pluginA->updateOscURL();

  1070.     pluginB->updateOscURL();

  1071. 

  1072.     if (isOscControlRegistered())

  1073.         oscSend_control_switch_plugins(idA, idB);

  1074.     */

  1075. 

  1076.     return true;

  1077. }

  1078. #endif

  1079. 

  1080. void CarlaEngine::touchPluginParameter(const uint, const uint32_t, const bool) noexcept

  1081. {

  1082. }

  1083. 

  1084. CarlaPluginPtr CarlaEngine::getPlugin(const uint id) const noexcept

  1085. {

  1086. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1087.     CARLA_SAFE_ASSERT_RETURN_ERRN(pData->plugins != nullptr, "Invalid engine internal data");

  1088.     CARLA_SAFE_ASSERT_RETURN_ERRN(pData->curPluginCount != 0, "Invalid engine internal data");

  1089. #endif

  1090.     CARLA_SAFE_ASSERT_RETURN_ERRN(pData->nextAction.opcode == kEnginePostActionNull, "Invalid engine internal data");

  1091.     CARLA_SAFE_ASSERT_RETURN_ERRN(id < pData->curPluginCount, "Invalid plugin Id");

  1092. 

  1093.     return pData->plugins[id].plugin;

  1094. }

  1095. 

  1096. CarlaPluginPtr CarlaEngine::getPluginUnchecked(const uint id) const noexcept

  1097. {

  1098.     return pData->plugins[id].plugin;

  1099. }

  1100. 

  1101. const char* CarlaEngine::getUniquePluginName(const char* const name) const

  1102. {

  1103.     CARLA_SAFE_ASSERT_RETURN(pData->nextAction.opcode == kEnginePostActionNull, nullptr);

  1104.     CARLA_SAFE_ASSERT_RETURN(name != nullptr && name[0] != '\0', nullptr);

  1105.     carla_debug("CarlaEngine::getUniquePluginName(\"%s\")", name);

  1106. 

  1107.     CarlaString sname;

  1108.     sname = name;

  1109. 

  1110.     if (sname.isEmpty())

  1111.     {

  1112.         sname = "(No name)";

  1113.         return sname.dup();

  1114.     }

  1115. 

  1116.     const std::size_t maxNameSize(carla_minConstrained<uint>(getMaxClientNameSize(), 0xff, 6U) - 6); // 6 = strlen(" (10)") + 1

  1117. 

  1118.     if (maxNameSize == 0 || ! isRunning())

  1119.         return sname.dup();

  1120. 

  1121.     sname.truncate(maxNameSize);

  1122.     sname.replace(':', '.'); // ':' is used in JACK1 to split client/port names

  1123.     sname.replace('/', '.'); // '/' is used by us for client name prefix

  1124. 

  1125.     for (uint i=0; i < pData->curPluginCount; ++i)

  1126.     {

  1127.         const CarlaPluginPtr plugin = pData->plugins[i].plugin;

  1128.         CARLA_SAFE_ASSERT_BREAK(plugin.use_count() > 0);

  1129. 

  1130.         // Check if unique name doesn't exist

  1131.         if (const char* const pluginName = plugin->getName())

  1132.         {

  1133.             if (sname != pluginName)

  1134.                 continue;

  1135.         }

  1136. 

  1137.         // Check if string has already been modified

  1138.         {

  1139.             const std::size_t len(sname.length());

  1140. 

  1141.             // 1 digit, ex: " (2)"

  1142.             if (len > 4 && sname[len-4] == ' ' && sname[len-3] == '(' && sname.isDigit(len-2) && sname[len-1] == ')')

  1143.             {

  1144.                 const int number = sname[len-2] - '0';

  1145. 

  1146.                 if (number == 9)

  1147.                 {

  1148.                     // next number is 10, 2 digits

  1149.                     sname.truncate(len-4);

  1150.                     sname += " (10)";

  1151.                     //sname.replace(" (9)", " (10)");

  1152.                 }

  1153.                 else

  1154.                     sname[len-2] = char('0' + number + 1);

  1155. 

  1156.                 continue;

  1157.             }

  1158. 

  1159.             // 2 digits, ex: " (11)"

  1160.             if (len > 5 && sname[len-5] == ' ' && sname[len-4] == '(' && sname.isDigit(len-3) && sname.isDigit(len-2) && sname[len-1] == ')')

  1161.             {

  1162.                 char n2 = sname[len-2];

  1163.                 char n3 = sname[len-3];

  1164. 

  1165.                 if (n2 == '9')

  1166.                 {

  1167.                     n2 = '0';

  1168.                     n3 = static_cast<char>(n3 + 1);

  1169.                 }

  1170.                 else

  1171.                     n2 = static_cast<char>(n2 + 1);

  1172. 

  1173.                 sname[len-2] = n2;

  1174.                 sname[len-3] = n3;

  1175. 

  1176.                 continue;

  1177.             }

  1178.         }

  1179. 

  1180.         // Modify string if not

  1181.         sname += " (2)";

  1182.     }

  1183. 

  1184.     return sname.dup();

  1185. }

  1186. 

  1187. // -----------------------------------------------------------------------

  1188. // Project management

  1189. 

  1190. bool CarlaEngine::loadFile(const char* const filename)

  1191. {

  1192.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->isIdling == 0, "An operation is still being processed, please wait for it to finish");

  1193.     CARLA_SAFE_ASSERT_RETURN_ERR(filename != nullptr && filename[0] != '\0', "Invalid filename");

  1194.     carla_debug("CarlaEngine::loadFile(\"%s\")", filename);

  1195. 

  1196.     const String jfilename = String(CharPointer_UTF8(filename));

  1197.     File file(jfilename);

  1198.     CARLA_SAFE_ASSERT_RETURN_ERR(file.exists(), "Requested file does not exist or is not a readable");

  1199. 

  1200.     CarlaString baseName(file.getFileNameWithoutExtension().toRawUTF8());

  1201.     CarlaString extension(file.getFileExtension().replace(".","").toLowerCase().toRawUTF8());

  1202. 

  1203.     const uint curPluginId(pData->nextPluginId < pData->curPluginCount ? pData->nextPluginId : pData->curPluginCount);

  1204. 

  1205.     // -------------------------------------------------------------------

  1206.     // NOTE: please keep in sync with carla_get_supported_file_extensions!!

  1207. 

  1208.     if (extension == "carxp" || extension == "carxs")

  1209.         return loadProject(filename, false);

  1210. 

  1211.     // -------------------------------------------------------------------

  1212. 

  1213.     if (extension == "dls")

  1214.         return addPlugin(PLUGIN_DLS, filename, baseName, baseName, 0, nullptr);

  1215. 

  1216.     if (extension == "gig")

  1217.         return addPlugin(PLUGIN_GIG, filename, baseName, baseName, 0, nullptr);

  1218. 

  1219.     if (extension == "sf2" || extension == "sf3")

  1220.         return addPlugin(PLUGIN_SF2, filename, baseName, baseName, 0, nullptr);

  1221. 

  1222.     if (extension == "sfz")

  1223.         return addPlugin(PLUGIN_SFZ, filename, baseName, baseName, 0, nullptr);

  1224. 

  1225.     // -------------------------------------------------------------------

  1226. 

  1227.     if (

  1228.         extension == "mp3"  ||

  1229. #ifdef HAVE_SNDFILE

  1230.         extension == "aif"  ||

  1231.         extension == "aifc" ||

  1232.         extension == "aiff" ||

  1233.         extension == "au"   ||

  1234.         extension == "bwf"  ||

  1235.         extension == "flac" ||

  1236.         extension == "htk"  ||

  1237.         extension == "iff"  ||

  1238.         extension == "mat4" ||

  1239.         extension == "mat5" ||

  1240.         extension == "oga"  ||

  1241.         extension == "ogg"  ||

  1242.         extension == "opus" ||

  1243.         extension == "paf"  ||

  1244.         extension == "pvf"  ||

  1245.         extension == "pvf5" ||

  1246.         extension == "sd2"  ||

  1247.         extension == "sf"   ||

  1248.         extension == "snd"  ||

  1249.         extension == "svx"  ||

  1250.         extension == "vcc"  ||

  1251.         extension == "w64"  ||

  1252.         extension == "wav"  ||

  1253.         extension == "xi"   ||

  1254. #endif

  1255. #ifdef HAVE_FFMPEG

  1256.         extension == "3g2" ||

  1257.         extension == "3gp" ||

  1258.         extension == "aac" ||

  1259.         extension == "ac3" ||

  1260.         extension == "amr" ||

  1261.         extension == "ape" ||

  1262.         extension == "mp2" ||

  1263.         extension == "mpc" ||

  1264.         extension == "wma" ||

  1265. # ifndef HAVE_SNDFILE

  1266.         // FFmpeg without sndfile

  1267.         extension == "flac" ||

  1268.         extension == "oga"  ||

  1269.         extension == "ogg"  ||

  1270.         extension == "w64"  ||

  1271.         extension == "wav"  ||

  1272. # endif

  1273. #endif

  1274.         false

  1275.        )

  1276.     {

  1277.         if (addPlugin(PLUGIN_INTERNAL, nullptr, baseName, "audiofile", 0, nullptr))

  1278.         {

  1279.             if (const CarlaPluginPtr plugin = getPlugin(curPluginId))

  1280.                 plugin->setCustomData(CUSTOM_DATA_TYPE_STRING, "file", filename, true);

  1281.             return true;

  1282.         }

  1283.         return false;

  1284.     }

  1285. 

  1286.     // -------------------------------------------------------------------

  1287. 

  1288.     if (extension == "mid" || extension == "midi")

  1289.     {

  1290.         if (addPlugin(PLUGIN_INTERNAL, nullptr, baseName, "midifile", 0, nullptr))

  1291.         {

  1292.             if (const CarlaPluginPtr plugin = getPlugin(curPluginId))

  1293.                 plugin->setCustomData(CUSTOM_DATA_TYPE_STRING, "file", filename, true);

  1294.             return true;

  1295.         }

  1296.         return false;

  1297.     }

  1298. 

  1299.     // -------------------------------------------------------------------

  1300.     // ZynAddSubFX

  1301. 

  1302.     if (extension == "xmz" || extension == "xiz")

  1303.     {

  1304. #ifdef HAVE_ZYN_DEPS

  1305.         CarlaString nicerName("Zyn - ");

  1306. 

  1307.         const std::size_t sep(baseName.find('-')+1);

  1308. 

  1309.         if (sep < baseName.length())

  1310.             nicerName += baseName.buffer()+sep;

  1311.         else

  1312.             nicerName += baseName;

  1313. 

  1314.         if (addPlugin(PLUGIN_INTERNAL, nullptr, nicerName, "zynaddsubfx", 0, nullptr))

  1315.         {

  1316.             callback(true, true, ENGINE_CALLBACK_UI_STATE_CHANGED, curPluginId, 0, 0, 0, 0.0f, nullptr);

  1317. 

  1318.             if (const CarlaPluginPtr plugin = getPlugin(curPluginId))

  1319.             {

  1320.                 const char* const ext = (extension == "xmz") ? "CarlaAlternateFile1" : "CarlaAlternateFile2";

  1321.                 plugin->setCustomData(CUSTOM_DATA_TYPE_STRING, ext, filename, true);

  1322.             }

  1323. 

  1324.             return true;

  1325.         }

  1326.         return false;

  1327. #else

  1328.         setLastError("This Carla build does not have ZynAddSubFX support");

  1329.         return false;

  1330. #endif

  1331.     }

  1332. 

  1333.     // -------------------------------------------------------------------

  1334.     // Direct plugin binaries

  1335. 

  1336. #ifdef CARLA_OS_MAC

  1337.     if (extension == "vst")

  1338.         return addPlugin(PLUGIN_VST2, filename, nullptr, nullptr, 0, nullptr);

  1339. #else

  1340.     if (extension == "dll" || extension == "so")

  1341.         return addPlugin(getBinaryTypeFromFile(filename), PLUGIN_VST2, filename, nullptr, nullptr, 0, nullptr);

  1342. #endif

  1343. 

  1344. #ifdef USING_JUCE

  1345.     if (extension == "vst3")

  1346.         return addPlugin(getBinaryTypeFromFile(filename), PLUGIN_VST3, filename, nullptr, nullptr, 0, nullptr);

  1347. #endif

  1348. 

  1349.     // -------------------------------------------------------------------

  1350. 

  1351.     setLastError("Unknown file extension");

  1352.     return false;

  1353. }

  1354. 

  1355. bool CarlaEngine::loadProject(const char* const filename, const bool setAsCurrentProject)

  1356. {

  1357.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->isIdling == 0, "An operation is still being processed, please wait for it to finish");

  1358.     CARLA_SAFE_ASSERT_RETURN_ERR(filename != nullptr && filename[0] != '\0', "Invalid filename");

  1359.     carla_debug("CarlaEngine::loadProject(\"%s\")", filename);

  1360. 

  1361.     const String jfilename = String(CharPointer_UTF8(filename));

  1362.     const File file(jfilename);

  1363.     CARLA_SAFE_ASSERT_RETURN_ERR(file.existsAsFile(), "Requested file does not exist or is not a readable file");

  1364. 

  1365.     if (setAsCurrentProject)

  1366.     {

  1367. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1368.         if (pData->currentProjectFilename != filename)

  1369.         {

  1370.             pData->currentProjectFilename = filename;

  1371. 

  1372.             bool found;

  1373.             const size_t r = pData->currentProjectFilename.rfind(CARLA_OS_SEP, &found);

  1374. 

  1375.             if (found)

  1376.             {

  1377.                 pData->currentProjectFolder = filename;

  1378.                 pData->currentProjectFolder[r] = '\0';

  1379.             }

  1380.             else

  1381.             {

  1382.                 pData->currentProjectFolder.clear();

  1383.             }

  1384.         }

  1385. #endif

  1386.     }

  1387. 

  1388.     XmlDocument xml(file);

  1389.     return loadProjectInternal(xml, !setAsCurrentProject);

  1390. }

  1391. 

  1392. bool CarlaEngine::saveProject(const char* const filename, const bool setAsCurrentProject)

  1393. {

  1394.     CARLA_SAFE_ASSERT_RETURN_ERR(filename != nullptr && filename[0] != '\0', "Invalid filename");

  1395.     carla_debug("CarlaEngine::saveProject(\"%s\")", filename);

  1396. 

  1397.     if (setAsCurrentProject)

  1398.     {

  1399. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1400.         if (pData->currentProjectFilename != filename)

  1401.         {

  1402.             pData->currentProjectFilename = filename;

  1403. 

  1404.             bool found;

  1405.             const size_t r = pData->currentProjectFilename.rfind(CARLA_OS_SEP, &found);

  1406. 

  1407.             if (found)

  1408.             {

  1409.                 pData->currentProjectFolder = filename;

  1410.                 pData->currentProjectFolder[r] = '\0';

  1411.             }

  1412.             else

  1413.             {

  1414.                 pData->currentProjectFolder.clear();

  1415.             }

  1416.         }

  1417. #endif

  1418.     }

  1419. 

  1420.     MemoryOutputStream out;

  1421.     saveProjectInternal(out);

  1422. 

  1423.     const String jfilename = String(CharPointer_UTF8(filename));

  1424.     File file(jfilename);

  1425. 

  1426.     if (file.replaceWithData(out.getData(), out.getDataSize()))

  1427.         return true;

  1428. 

  1429.     setLastError("Failed to write file");

  1430.     return false;

  1431. }

  1432. 

  1433. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1434. const char* CarlaEngine::getCurrentProjectFolder() const noexcept

  1435. {

  1436.     return pData->currentProjectFolder.isNotEmpty() ? pData->currentProjectFolder.buffer()

  1437.                                                     : nullptr;

  1438. }

  1439. 

  1440. const char* CarlaEngine::getCurrentProjectFilename() const noexcept

  1441. {

  1442.     return pData->currentProjectFilename;

  1443. }

  1444. 

  1445. void CarlaEngine::clearCurrentProjectFilename() noexcept

  1446. {

  1447.     pData->currentProjectFilename.clear();

  1448.     pData->currentProjectFolder.clear();

  1449. }

  1450. #endif

  1451. 

  1452. // -----------------------------------------------------------------------

  1453. // Information (base)

  1454. 

  1455. uint32_t CarlaEngine::getBufferSize() const noexcept

  1456. {

  1457.     return pData->bufferSize;

  1458. }

  1459. 

  1460. double CarlaEngine::getSampleRate() const noexcept

  1461. {

  1462.     return pData->sampleRate;

  1463. }

  1464. 

  1465. const char* CarlaEngine::getName() const noexcept

  1466. {

  1467.     return pData->name;

  1468. }

  1469. 

  1470. EngineProcessMode CarlaEngine::getProccessMode() const noexcept

  1471. {

  1472.     return pData->options.processMode;

  1473. }

  1474. 

  1475. const EngineOptions& CarlaEngine::getOptions() const noexcept

  1476. {

  1477.     return pData->options;

  1478. }

  1479. 

  1480. EngineTimeInfo CarlaEngine::getTimeInfo() const noexcept

  1481. {

  1482.     return pData->timeInfo;

  1483. }

  1484. 

  1485. // -----------------------------------------------------------------------

  1486. // Information (peaks)

  1487. 

  1488. const float* CarlaEngine::getPeaks(const uint pluginId) const noexcept

  1489. {

  1490.     static const float kFallback[4] = { 0.0f, 0.0f, 0.0f, 0.0f };

  1491. 

  1492.     if (pluginId == MAIN_CARLA_PLUGIN_ID)

  1493.     {

  1494.         // get peak from first plugin, if available

  1495.         if (const uint count = pData->curPluginCount)

  1496.         {

  1497.             pData->peaks[0] = pData->plugins[0].peaks[0];

  1498.             pData->peaks[1] = pData->plugins[0].peaks[1];

  1499.             pData->peaks[2] = pData->plugins[count-1].peaks[2];

  1500.             pData->peaks[3] = pData->plugins[count-1].peaks[3];

  1501.         }

  1502.         else

  1503.         {

  1504.             carla_zeroFloats(pData->peaks, 4);

  1505.         }

  1506. 

  1507.         return pData->peaks;

  1508.     }

  1509. 

  1510.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount, kFallback);

  1511. 

  1512.     return pData->plugins[pluginId].peaks;

  1513. }

  1514. 

  1515. float CarlaEngine::getInputPeak(const uint pluginId, const bool isLeft) const noexcept

  1516. {

  1517.     if (pluginId == MAIN_CARLA_PLUGIN_ID)

  1518.     {

  1519.         // get peak from first plugin, if available

  1520.         if (pData->curPluginCount > 0)

  1521.             return pData->plugins[0].peaks[isLeft ? 0 : 1];

  1522.         return 0.0f;

  1523.     }

  1524. 

  1525.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount, 0.0f);

  1526. 

  1527.     return pData->plugins[pluginId].peaks[isLeft ? 0 : 1];

  1528. }

  1529. 

  1530. float CarlaEngine::getOutputPeak(const uint pluginId, const bool isLeft) const noexcept

  1531. {

  1532.     if (pluginId == MAIN_CARLA_PLUGIN_ID)

  1533.     {

  1534.         // get peak from last plugin, if available

  1535.         if (pData->curPluginCount > 0)

  1536.             return pData->plugins[pData->curPluginCount-1].peaks[isLeft ? 2 : 3];

  1537.         return 0.0f;

  1538.     }

  1539. 

  1540.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount, 0.0f);

  1541. 

  1542.     return pData->plugins[pluginId].peaks[isLeft ? 2 : 3];

  1543. }

  1544. 

  1545. // -----------------------------------------------------------------------

  1546. // Callback

  1547. 

  1548. void CarlaEngine::callback(const bool sendHost, const bool sendOSC,

  1549.                            const EngineCallbackOpcode action, const uint pluginId,

  1550.                            const int value1, const int value2, const int value3,

  1551.                            const float valuef, const char* const valueStr) noexcept

  1552. {

  1553. #ifdef DEBUG

  1554.     if (pData->isIdling)

  1555.         carla_stdout("CarlaEngine::callback [while idling] (%s, %s, %i:%s, %i, %i, %i, %i, %f, \"%s\")",

  1556.                      bool2str(sendHost), bool2str(sendOSC),

  1557.                      action, EngineCallbackOpcode2Str(action), pluginId, value1, value2, value3,

  1558.                      static_cast<double>(valuef), valueStr);

  1559.     else if (action != ENGINE_CALLBACK_IDLE && action != ENGINE_CALLBACK_NOTE_ON && action != ENGINE_CALLBACK_NOTE_OFF)

  1560.         carla_debug("CarlaEngine::callback(%s, %s, %i:%s, %i, %i, %i, %i, %f, \"%s\")",

  1561.                     bool2str(sendHost), bool2str(sendOSC),

  1562.                     action, EngineCallbackOpcode2Str(action), pluginId, value1, value2, value3,

  1563.                     static_cast<double>(valuef), valueStr);

  1564. #endif

  1565. 

  1566.     if (sendHost && pData->callback != nullptr)

  1567.     {

  1568.         if (action == ENGINE_CALLBACK_IDLE)

  1569.             ++pData->isIdling;

  1570. 

  1571.         try {

  1572.             pData->callback(pData->callbackPtr, action, pluginId, value1, value2, value3, valuef, valueStr);

  1573.         } CARLA_SAFE_EXCEPTION("callback")

  1574. 

  1575.         if (action == ENGINE_CALLBACK_IDLE)

  1576.             --pData->isIdling;

  1577.     }

  1578. 

  1579.     if (sendOSC)

  1580.     {

  1581. #if defined(HAVE_LIBLO) && ! defined(BUILD_BRIDGE)

  1582.         if (pData->osc.isControlRegisteredForTCP())

  1583.         {

  1584.             switch (action)

  1585.             {

  1586.             case ENGINE_CALLBACK_RELOAD_INFO:

  1587.             {

  1588.                 CarlaPluginPtr plugin = pData->plugins[pluginId].plugin;

  1589.                 CARLA_SAFE_ASSERT_BREAK(plugin != nullptr);

  1590. 

  1591.                 pData->osc.sendPluginInfo(plugin);

  1592.                 break;

  1593.             }

  1594. 

  1595.             case ENGINE_CALLBACK_RELOAD_PARAMETERS:

  1596.             {

  1597.                 CarlaPluginPtr plugin = pData->plugins[pluginId].plugin;

  1598.                 CARLA_SAFE_ASSERT_BREAK(plugin != nullptr);

  1599. 

  1600.                 pData->osc.sendPluginPortCount(plugin);

  1601. 

  1602.                 if (const uint32_t count = plugin->getParameterCount())

  1603.                 {

  1604.                     for (uint32_t i=0; i<count; ++i)

  1605.                       pData->osc.sendPluginParameterInfo(plugin, i);

  1606.                 }

  1607.                 break;

  1608.             }

  1609. 

  1610.             case ENGINE_CALLBACK_RELOAD_PROGRAMS:

  1611.             {

  1612.                 CarlaPluginPtr plugin = pData->plugins[pluginId].plugin;

  1613.                 CARLA_SAFE_ASSERT_BREAK(plugin != nullptr);

  1614. 

  1615.                 pData->osc.sendPluginProgramCount(plugin);

  1616. 

  1617.                 if (const uint32_t count = plugin->getProgramCount())

  1618.                 {

  1619.                     for (uint32_t i=0; i<count; ++i)

  1620.                       pData->osc.sendPluginProgram(plugin, i);

  1621.                 }

  1622. 

  1623.                 if (const uint32_t count = plugin->getMidiProgramCount())

  1624.                 {

  1625.                     for (uint32_t i=0; i<count; ++i)

  1626.                       pData->osc.sendPluginMidiProgram(plugin, i);

  1627.                 }

  1628.                 break;

  1629.             }

  1630. 

  1631.             case ENGINE_CALLBACK_PLUGIN_ADDED:

  1632.             case ENGINE_CALLBACK_RELOAD_ALL:

  1633.             {

  1634.                 CarlaPluginPtr plugin = pData->plugins[pluginId].plugin;

  1635.                 CARLA_SAFE_ASSERT_BREAK(plugin != nullptr);

  1636. 

  1637.                 pData->osc.sendPluginInfo(plugin);

  1638.                 pData->osc.sendPluginPortCount(plugin);

  1639.                 pData->osc.sendPluginDataCount(plugin);

  1640. 

  1641.                 if (const uint32_t count = plugin->getParameterCount())

  1642.                 {

  1643.                     for (uint32_t i=0; i<count; ++i)

  1644.                       pData->osc.sendPluginParameterInfo(plugin, i);

  1645.                 }

  1646. 

  1647.                 if (const uint32_t count = plugin->getProgramCount())

  1648.                 {

  1649.                     for (uint32_t i=0; i<count; ++i)

  1650.                       pData->osc.sendPluginProgram(plugin, i);

  1651.                 }

  1652. 

  1653.                 if (const uint32_t count = plugin->getMidiProgramCount())

  1654.                 {

  1655.                     for (uint32_t i=0; i<count; ++i)

  1656.                       pData->osc.sendPluginMidiProgram(plugin, i);

  1657.                 }

  1658. 

  1659.                 if (const uint32_t count = plugin->getCustomDataCount())

  1660.                 {

  1661.                     for (uint32_t i=0; i<count; ++i)

  1662.                       pData->osc.sendPluginCustomData(plugin, i);

  1663.                 }

  1664. 

  1665.                 pData->osc.sendPluginInternalParameterValues(plugin);

  1666.                 break;

  1667.             }

  1668. 

  1669.             case ENGINE_CALLBACK_IDLE:

  1670.                 return;

  1671. 

  1672.             default:

  1673.                 break;

  1674.             }

  1675. 

  1676.             pData->osc.sendCallback(action, pluginId, value1, value2, value3, valuef, valueStr);

  1677.         }

  1678. #endif

  1679.     }

  1680. }

  1681. 

  1682. void CarlaEngine::setCallback(const EngineCallbackFunc func, void* const ptr) noexcept

  1683. {

  1684.     carla_debug("CarlaEngine::setCallback(%p, %p)", func, ptr);

  1685. 

  1686.     pData->callback    = func;

  1687.     pData->callbackPtr = ptr;

  1688. }

  1689. 

  1690. // -----------------------------------------------------------------------

  1691. // File Callback

  1692. 

  1693. const char* CarlaEngine::runFileCallback(const FileCallbackOpcode action, const bool isDir, const char* const title, const char* const filter) noexcept

  1694. {

  1695.     CARLA_SAFE_ASSERT_RETURN(title != nullptr && title[0] != '\0', nullptr);

  1696.     CARLA_SAFE_ASSERT_RETURN(filter != nullptr, nullptr);

  1697.     carla_debug("CarlaEngine::runFileCallback(%i:%s, %s, \"%s\", \"%s\")", action, FileCallbackOpcode2Str(action), bool2str(isDir), title, filter);

  1698. 

  1699.     const char* ret = nullptr;

  1700. 

  1701.     if (pData->fileCallback != nullptr)

  1702.     {

  1703.         try {

  1704.             ret = pData->fileCallback(pData->fileCallbackPtr, action, isDir, title, filter);

  1705.         } CARLA_SAFE_EXCEPTION("runFileCallback");

  1706.     }

  1707. 

  1708.     return ret;

  1709. }

  1710. 

  1711. void CarlaEngine::setFileCallback(const FileCallbackFunc func, void* const ptr) noexcept

  1712. {

  1713.     carla_debug("CarlaEngine::setFileCallback(%p, %p)", func, ptr);

  1714. 

  1715.     pData->fileCallback    = func;

  1716.     pData->fileCallbackPtr = ptr;

  1717. }

  1718. 

  1719. // -----------------------------------------------------------------------

  1720. // Transport

  1721. 

  1722. void CarlaEngine::transportPlay() noexcept

  1723. {

  1724.     pData->timeInfo.playing = true;

  1725.     pData->time.setNeedsReset();

  1726. }

  1727. 

  1728. void CarlaEngine::transportPause() noexcept

  1729. {

  1730.     if (pData->timeInfo.playing)

  1731.         pData->time.pause();

  1732.     else

  1733.         pData->time.setNeedsReset();

  1734. }

  1735. 

  1736. void CarlaEngine::transportBPM(const double bpm) noexcept

  1737. {

  1738.     CARLA_SAFE_ASSERT_RETURN(bpm >= 20.0,)

  1739. 

  1740.     try {

  1741.         pData->time.setBPM(bpm);

  1742.     } CARLA_SAFE_EXCEPTION("CarlaEngine::transportBPM");

  1743. }

  1744. 

  1745. void CarlaEngine::transportRelocate(const uint64_t frame) noexcept

  1746. {

  1747.     pData->time.relocate(frame);

  1748. }

  1749. 

  1750. // -----------------------------------------------------------------------

  1751. // Error handling

  1752. 

  1753. const char* CarlaEngine::getLastError() const noexcept

  1754. {

  1755.     return pData->lastError;

  1756. }

  1757. 

  1758. void CarlaEngine::setLastError(const char* const error) const noexcept

  1759. {

  1760.     pData->lastError = error;

  1761. }

  1762. 

  1763. // -----------------------------------------------------------------------

  1764. // Misc

  1765. 

  1766. bool CarlaEngine::isAboutToClose() const noexcept

  1767. {

  1768.     return pData->aboutToClose;

  1769. }

  1770. 

  1771. bool CarlaEngine::setAboutToClose() noexcept

  1772. {

  1773.     carla_debug("CarlaEngine::setAboutToClose()");

  1774. 

  1775.     pData->aboutToClose = true;

  1776. 

  1777.     return (pData->isIdling == 0);

  1778. }

  1779. 

  1780. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1781. bool CarlaEngine::isLoadingProject() const noexcept

  1782. {

  1783.     return pData->loadingProject;

  1784. }

  1785. #endif

  1786. 

  1787. void CarlaEngine::setActionCanceled(const bool canceled) noexcept

  1788. {

  1789.     pData->actionCanceled = canceled;

  1790. }

  1791. 

  1792. bool CarlaEngine::wasActionCanceled() const noexcept

  1793. {

  1794.     return pData->actionCanceled;

  1795. }

  1796. 

  1797. // -----------------------------------------------------------------------

  1798. // Global options

  1799. 

  1800. void CarlaEngine::setOption(const EngineOption option, const int value, const char* const valueStr) noexcept

  1801. {

  1802.     carla_debug("CarlaEngine::setOption(%i:%s, %i, \"%s\")", option, EngineOption2Str(option), value, valueStr);

  1803. 

  1804.     if (isRunning())

  1805.     {

  1806.         switch (option)

  1807.         {

  1808.         case ENGINE_OPTION_PROCESS_MODE:

  1809.         case ENGINE_OPTION_AUDIO_TRIPLE_BUFFER:

  1810.         case ENGINE_OPTION_AUDIO_DRIVER:

  1811.         case ENGINE_OPTION_AUDIO_DEVICE:

  1812.             return carla_stderr("CarlaEngine::setOption(%i:%s, %i, \"%s\") - Cannot set this option while engine is running!",

  1813.                                 option, EngineOption2Str(option), value, valueStr);

  1814.         default:

  1815.             break;

  1816.         }

  1817.     }

  1818. 

  1819.     // do not un-force stereo for rack mode

  1820.     if (pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK && option == ENGINE_OPTION_FORCE_STEREO && value != 0)

  1821.         return;

  1822. 

  1823.     switch (option)

  1824.     {

  1825.     case ENGINE_OPTION_DEBUG:

  1826.         break;

  1827. 

  1828.     case ENGINE_OPTION_PROCESS_MODE:

  1829.         CARLA_SAFE_ASSERT_RETURN(value >= ENGINE_PROCESS_MODE_SINGLE_CLIENT && value <= ENGINE_PROCESS_MODE_BRIDGE,);

  1830.         pData->options.processMode = static_cast<EngineProcessMode>(value);

  1831.         break;

  1832. 

  1833.     case ENGINE_OPTION_TRANSPORT_MODE:

  1834.         CARLA_SAFE_ASSERT_RETURN(value >= ENGINE_TRANSPORT_MODE_DISABLED && value <= ENGINE_TRANSPORT_MODE_BRIDGE,);

  1835.         CARLA_SAFE_ASSERT_RETURN(getType() == kEngineTypeJack || value != ENGINE_TRANSPORT_MODE_JACK,);

  1836.         pData->options.transportMode = static_cast<EngineTransportMode>(value);

  1837.         delete[] pData->options.transportExtra;

  1838.         if (value >= ENGINE_TRANSPORT_MODE_DISABLED && valueStr != nullptr)

  1839.             pData->options.transportExtra = carla_strdup_safe(valueStr);

  1840.         else

  1841.             pData->options.transportExtra = nullptr;

  1842. 

  1843.         pData->time.setNeedsReset();

  1844. 

  1845. #if defined(HAVE_HYLIA) && !defined(BUILD_BRIDGE)

  1846.         // enable link now if needed

  1847.         {

  1848.             const bool linkEnabled = pData->options.transportExtra != nullptr && std::strstr(pData->options.transportExtra, ":link:") != nullptr;

  1849.             pData->time.enableLink(linkEnabled);

  1850.         }

  1851. #endif

  1852.         break;

  1853. 

  1854.     case ENGINE_OPTION_FORCE_STEREO:

  1855.         CARLA_SAFE_ASSERT_RETURN(value == 0 || value == 1,);

  1856.         pData->options.forceStereo = (value != 0);

  1857.         break;

  1858. 

  1859.     case ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

  1860. #ifdef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1861.         CARLA_SAFE_ASSERT_RETURN(value == 0,);

  1862. #else

  1863.         CARLA_SAFE_ASSERT_RETURN(value == 0 || value == 1,);

  1864. #endif

  1865.         pData->options.preferPluginBridges = (value != 0);

  1866.         break;

  1867. 

  1868.     case ENGINE_OPTION_PREFER_UI_BRIDGES:

  1869.         CARLA_SAFE_ASSERT_RETURN(value == 0 || value == 1,);

  1870.         pData->options.preferUiBridges = (value != 0);

  1871.         break;

  1872. 

  1873.     case ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

  1874.         CARLA_SAFE_ASSERT_RETURN(value == 0 || value == 1,);

  1875.         pData->options.uisAlwaysOnTop = (value != 0);

  1876.         break;

  1877. 

  1878.     case ENGINE_OPTION_MAX_PARAMETERS:

  1879.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

  1880.         pData->options.maxParameters = static_cast<uint>(value);

  1881.         break;

  1882. 

  1883.     case ENGINE_OPTION_RESET_XRUNS:

  1884.         CARLA_SAFE_ASSERT_RETURN(value == 0 || value == 1,);

  1885.         pData->options.resetXruns = (value != 0);

  1886.         break;

  1887. 

  1888.     case ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  1889.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

  1890.         pData->options.uiBridgesTimeout = static_cast<uint>(value);

  1891.         break;

  1892. 

  1893.     case ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  1894.         CARLA_SAFE_ASSERT_RETURN(value >= 8,);

  1895.         pData->options.audioBufferSize = static_cast<uint>(value);

  1896.         break;

  1897. 

  1898.     case ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  1899.         CARLA_SAFE_ASSERT_RETURN(value >= 22050,);

  1900.         pData->options.audioSampleRate = static_cast<uint>(value);

  1901.         break;

  1902. 

  1903.     case ENGINE_OPTION_AUDIO_TRIPLE_BUFFER:

  1904.         CARLA_SAFE_ASSERT_RETURN(value == 0 || value == 1,);

  1905.         pData->options.audioTripleBuffer = (value != 0);

  1906.         break;

  1907. 

  1908.     case ENGINE_OPTION_AUDIO_DRIVER:

  1909.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  1910. 

  1911.         if (pData->options.audioDriver != nullptr)

  1912.             delete[] pData->options.audioDriver;

  1913. 

  1914.         pData->options.audioDriver = carla_strdup_safe(valueStr);

  1915.         break;

  1916. 

  1917.     case ENGINE_OPTION_AUDIO_DEVICE:

  1918.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  1919. 

  1920.         if (pData->options.audioDevice != nullptr)

  1921.             delete[] pData->options.audioDevice;

  1922. 

  1923.         pData->options.audioDevice = carla_strdup_safe(valueStr);

  1924.         break;

  1925. 

  1926. #ifndef BUILD_BRIDGE

  1927.     case ENGINE_OPTION_OSC_ENABLED:

  1928.         CARLA_SAFE_ASSERT_RETURN(value == 0 || value == 1,);

  1929.         pData->options.oscEnabled = (value != 0);

  1930.         break;

  1931. 

  1932.     case ENGINE_OPTION_OSC_PORT_TCP:

  1933.         CARLA_SAFE_ASSERT_RETURN(value <= 0 || value >= 1024,);

  1934.         pData->options.oscPortTCP = value;

  1935.         break;

  1936. 

  1937.     case ENGINE_OPTION_OSC_PORT_UDP:

  1938.         CARLA_SAFE_ASSERT_RETURN(value <= 0 || value >= 1024,);

  1939.         pData->options.oscPortUDP = value;

  1940.         break;

  1941. #endif

  1942. 

  1943.     case ENGINE_OPTION_FILE_PATH:

  1944.         CARLA_SAFE_ASSERT_RETURN(value > FILE_NONE,);

  1945.         CARLA_SAFE_ASSERT_RETURN(value <= FILE_MIDI,);

  1946. 

  1947.         switch (value)

  1948.         {

  1949.         case FILE_AUDIO:

  1950.             if (pData->options.pathAudio != nullptr)

  1951.                 delete[] pData->options.pathAudio;

  1952.             if (valueStr != nullptr)

  1953.                 pData->options.pathAudio = carla_strdup_safe(valueStr);

  1954.             else

  1955.                 pData->options.pathAudio = nullptr;

  1956.             break;

  1957.         case FILE_MIDI:

  1958.             if (pData->options.pathMIDI != nullptr)

  1959.                 delete[] pData->options.pathMIDI;

  1960.             if (valueStr != nullptr)

  1961.                 pData->options.pathMIDI = carla_strdup_safe(valueStr);

  1962.             else

  1963.                 pData->options.pathMIDI = nullptr;

  1964.             break;

  1965.         default:

  1966.             return carla_stderr("CarlaEngine::setOption(%i:%s, %i, \"%s\") - Invalid file type",

  1967.                                 option, EngineOption2Str(option), value, valueStr);

  1968.             break;

  1969.         }

  1970.         break;

  1971.     case ENGINE_OPTION_PLUGIN_PATH:

  1972.         CARLA_SAFE_ASSERT_RETURN(value > PLUGIN_NONE,);

  1973.         CARLA_SAFE_ASSERT_RETURN(value <= PLUGIN_SFZ,);

  1974. 

  1975.         switch (value)

  1976.         {

  1977.         case PLUGIN_LADSPA:

  1978.             if (pData->options.pathLADSPA != nullptr)

  1979.                 delete[] pData->options.pathLADSPA;

  1980.             if (valueStr != nullptr)

  1981.                 pData->options.pathLADSPA = carla_strdup_safe(valueStr);

  1982.             else

  1983.                 pData->options.pathLADSPA = nullptr;

  1984.             break;

  1985.         case PLUGIN_DSSI:

  1986.             if (pData->options.pathDSSI != nullptr)

  1987.                 delete[] pData->options.pathDSSI;

  1988.             if (valueStr != nullptr)

  1989.                 pData->options.pathDSSI = carla_strdup_safe(valueStr);

  1990.             else

  1991.                 pData->options.pathDSSI = nullptr;

  1992.             break;

  1993.         case PLUGIN_LV2:

  1994.             if (pData->options.pathLV2 != nullptr)

  1995.                 delete[] pData->options.pathLV2;

  1996.             if (valueStr != nullptr)

  1997.                 pData->options.pathLV2 = carla_strdup_safe(valueStr);

  1998.             else

  1999.                 pData->options.pathLV2 = nullptr;

  2000.             break;

  2001.         case PLUGIN_VST2:

  2002.             if (pData->options.pathVST2 != nullptr)

  2003.                 delete[] pData->options.pathVST2;

  2004.             if (valueStr != nullptr)

  2005.                 pData->options.pathVST2 = carla_strdup_safe(valueStr);

  2006.             else

  2007.                 pData->options.pathVST2 = nullptr;

  2008.             break;

  2009.         case PLUGIN_VST3:

  2010.             if (pData->options.pathVST3 != nullptr)

  2011.                 delete[] pData->options.pathVST3;

  2012.             if (valueStr != nullptr)

  2013.                 pData->options.pathVST3 = carla_strdup_safe(valueStr);

  2014.             else

  2015.                 pData->options.pathVST3 = nullptr;

  2016.             break;

  2017.         case PLUGIN_SF2:

  2018.             if (pData->options.pathSF2 != nullptr)

  2019.                 delete[] pData->options.pathSF2;

  2020.             if (valueStr != nullptr)

  2021.                 pData->options.pathSF2 = carla_strdup_safe(valueStr);

  2022.             else

  2023.                 pData->options.pathSF2 = nullptr;

  2024.             break;

  2025.         case PLUGIN_SFZ:

  2026.             if (pData->options.pathSFZ != nullptr)

  2027.                 delete[] pData->options.pathSFZ;

  2028.             if (valueStr != nullptr)

  2029.                 pData->options.pathSFZ = carla_strdup_safe(valueStr);

  2030.             else

  2031.                 pData->options.pathSFZ = nullptr;

  2032.             break;

  2033.         default:

  2034.             return carla_stderr("CarlaEngine::setOption(%i:%s, %i, \"%s\") - Invalid plugin type",

  2035.                                 option, EngineOption2Str(option), value, valueStr);

  2036.             break;

  2037.         }

  2038.         break;

  2039. 

  2040.     case ENGINE_OPTION_PATH_BINARIES:

  2041.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr && valueStr[0] != '\0',);

  2042. 

  2043.         if (pData->options.binaryDir != nullptr)

  2044.             delete[] pData->options.binaryDir;

  2045. 

  2046.         pData->options.binaryDir = carla_strdup_safe(valueStr);

  2047.         break;

  2048. 

  2049.     case ENGINE_OPTION_PATH_RESOURCES:

  2050.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr && valueStr[0] != '\0',);

  2051. 

  2052.         if (pData->options.resourceDir != nullptr)

  2053.             delete[] pData->options.resourceDir;

  2054. 

  2055.         pData->options.resourceDir = carla_strdup_safe(valueStr);

  2056.         break;

  2057. 

  2058.     case ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR: {

  2059.         CARLA_SAFE_ASSERT_RETURN(pData->options.binaryDir != nullptr && pData->options.binaryDir[0] != '\0',);

  2060. 

  2061. #ifdef CARLA_OS_LINUX

  2062.         const ScopedEngineEnvironmentLocker _seel(this);

  2063. 

  2064.         if (value != 0)

  2065.         {

  2066.             CarlaString interposerPath(CarlaString(pData->options.binaryDir) + "/libcarla_interposer-safe.so");

  2067.             ::setenv("LD_PRELOAD", interposerPath.buffer(), 1);

  2068.         }

  2069.         else

  2070.         {

  2071.             ::unsetenv("LD_PRELOAD");

  2072.         }

  2073. #endif

  2074.     }   break;

  2075. 

  2076.     case ENGINE_OPTION_FRONTEND_BACKGROUND_COLOR:

  2077.         pData->options.bgColor = static_cast<uint>(value);

  2078.         break;

  2079. 

  2080.     case ENGINE_OPTION_FRONTEND_FOREGROUND_COLOR:

  2081.         pData->options.fgColor = static_cast<uint>(value);

  2082.         break;

  2083. 

  2084.     case ENGINE_OPTION_FRONTEND_UI_SCALE:

  2085.         CARLA_SAFE_ASSERT_RETURN(value > 0,);

  2086.         pData->options.uiScale = static_cast<float>(value) / 1000;

  2087.         break;

  2088. 

  2089.     case ENGINE_OPTION_FRONTEND_WIN_ID: {

  2090.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr && valueStr[0] != '\0',);

  2091.         const long long winId(std::strtoll(valueStr, nullptr, 16));

  2092.         CARLA_SAFE_ASSERT_RETURN(winId >= 0,);

  2093.         pData->options.frontendWinId = static_cast<uintptr_t>(winId);

  2094.     }   break;

  2095. 

  2096. #if !defined(BUILD_BRIDGE_ALTERNATIVE_ARCH) && !defined(CARLA_OS_WIN)

  2097.     case ENGINE_OPTION_WINE_EXECUTABLE:

  2098.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr && valueStr[0] != '\0',);

  2099. 

  2100.         if (pData->options.wine.executable != nullptr)

  2101.             delete[] pData->options.wine.executable;

  2102. 

  2103.         pData->options.wine.executable = carla_strdup_safe(valueStr);

  2104.         break;

  2105. 

  2106.     case ENGINE_OPTION_WINE_AUTO_PREFIX:

  2107.         CARLA_SAFE_ASSERT_RETURN(value == 0 || value == 1,);

  2108.         pData->options.wine.autoPrefix = (value != 0);

  2109.         break;

  2110. 

  2111.     case ENGINE_OPTION_WINE_FALLBACK_PREFIX:

  2112.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr && valueStr[0] != '\0',);

  2113. 

  2114.         if (pData->options.wine.fallbackPrefix != nullptr)

  2115.             delete[] pData->options.wine.fallbackPrefix;

  2116. 

  2117.         pData->options.wine.fallbackPrefix = carla_strdup_safe(valueStr);

  2118.         break;

  2119. 

  2120.     case ENGINE_OPTION_WINE_RT_PRIO_ENABLED:

  2121.         CARLA_SAFE_ASSERT_RETURN(value == 0 || value == 1,);

  2122.         pData->options.wine.rtPrio = (value != 0);

  2123.         break;

  2124. 

  2125.     case ENGINE_OPTION_WINE_BASE_RT_PRIO:

  2126.         CARLA_SAFE_ASSERT_RETURN(value >= 1 && value <= 89,);

  2127.         pData->options.wine.baseRtPrio = value;

  2128.         break;

  2129. 

  2130.     case ENGINE_OPTION_WINE_SERVER_RT_PRIO:

  2131.         CARLA_SAFE_ASSERT_RETURN(value >= 1 && value <= 99,);

  2132.         pData->options.wine.serverRtPrio = value;

  2133.         break;

  2134. #endif

  2135. 

  2136. #ifndef BUILD_BRIDGE

  2137.     case ENGINE_OPTION_DEBUG_CONSOLE_OUTPUT:

  2138.         break;

  2139. #endif

  2140. 

  2141.     case ENGINE_OPTION_CLIENT_NAME_PREFIX:

  2142.         if (pData->options.clientNamePrefix != nullptr)

  2143.             delete[] pData->options.clientNamePrefix;

  2144. 

  2145.         pData->options.clientNamePrefix = valueStr != nullptr && valueStr[0] != '\0'

  2146.                                         ? carla_strdup_safe(valueStr)

  2147.                                         : nullptr;

  2148.         break;

  2149. 

  2150.     case ENGINE_OPTION_PLUGINS_ARE_STANDALONE:

  2151.         CARLA_SAFE_ASSERT_RETURN(value == 0 || value == 1,);

  2152.         pData->options.pluginsAreStandalone = (value != 0);

  2153.         break;

  2154.     }

  2155. }

  2156. 

  2157. #ifndef BUILD_BRIDGE

  2158. // -----------------------------------------------------------------------

  2159. // OSC Stuff

  2160. 

  2161. bool CarlaEngine::isOscControlRegistered() const noexcept

  2162. {

  2163. # ifdef HAVE_LIBLO

  2164.     return pData->osc.isControlRegisteredForTCP();

  2165. # else

  2166.     return false;

  2167. # endif

  2168. }

  2169. 

  2170. const char* CarlaEngine::getOscServerPathTCP() const noexcept

  2171. {

  2172. # ifdef HAVE_LIBLO

  2173.     return pData->osc.getServerPathTCP();

  2174. # else

  2175.     return nullptr;

  2176. # endif

  2177. }

  2178. 

  2179. const char* CarlaEngine::getOscServerPathUDP() const noexcept

  2180. {

  2181. # ifdef HAVE_LIBLO

  2182.     return pData->osc.getServerPathUDP();

  2183. # else

  2184.     return nullptr;

  2185. # endif

  2186. }

  2187. #endif

  2188. 

  2189. // -----------------------------------------------------------------------

  2190. // Internal stuff

  2191. 

  2192. void CarlaEngine::bufferSizeChanged(const uint32_t newBufferSize)

  2193. {

  2194.     carla_debug("CarlaEngine::bufferSizeChanged(%i)", newBufferSize);

  2195. 

  2196. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2197.     if (pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK ||

  2198.         pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY)

  2199.     {

  2200.         pData->graph.setBufferSize(newBufferSize);

  2201.     }

  2202. #endif

  2203. 

  2204.     pData->time.updateAudioValues(newBufferSize, pData->sampleRate);

  2205. 

  2206.     for (uint i=0; i < pData->curPluginCount; ++i)

  2207.     {

  2208.         if (const CarlaPluginPtr plugin = pData->plugins[i].plugin)

  2209.         {

  2210.             if (plugin->isEnabled() && plugin->tryLock(true))

  2211.             {

  2212.                 plugin->bufferSizeChanged(newBufferSize);

  2213.                 plugin->unlock();

  2214.             }

  2215.         }

  2216.     }

  2217. 

  2218.     callback(true, true, ENGINE_CALLBACK_BUFFER_SIZE_CHANGED, 0, static_cast<int>(newBufferSize), 0, 0, 0.0f, nullptr);

  2219. }

  2220. 

  2221. void CarlaEngine::sampleRateChanged(const double newSampleRate)

  2222. {

  2223.     carla_debug("CarlaEngine::sampleRateChanged(%g)", newSampleRate);

  2224. 

  2225. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2226.     if (pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK ||

  2227.         pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY)

  2228.     {

  2229.         pData->graph.setSampleRate(newSampleRate);

  2230.     }

  2231. #endif

  2232. 

  2233.     pData->time.updateAudioValues(pData->bufferSize, newSampleRate);

  2234. 

  2235.     for (uint i=0; i < pData->curPluginCount; ++i)

  2236.     {

  2237.         if (const CarlaPluginPtr plugin = pData->plugins[i].plugin)

  2238.         {

  2239.             if (plugin->isEnabled() && plugin->tryLock(true))

  2240.             {

  2241.                 plugin->sampleRateChanged(newSampleRate);

  2242.                 plugin->unlock();

  2243.             }

  2244.         }

  2245.     }

  2246. 

  2247.     callback(true, true, ENGINE_CALLBACK_SAMPLE_RATE_CHANGED, 0, 0, 0, 0, static_cast<float>(newSampleRate), nullptr);

  2248. }

  2249. 

  2250. void CarlaEngine::offlineModeChanged(const bool isOfflineNow)

  2251. {

  2252.     carla_debug("CarlaEngine::offlineModeChanged(%s)", bool2str(isOfflineNow));

  2253. 

  2254. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2255.     if (pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK ||

  2256.         pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY)

  2257.     {

  2258.         pData->graph.setOffline(isOfflineNow);

  2259.     }

  2260. #endif

  2261. 

  2262.     for (uint i=0; i < pData->curPluginCount; ++i)

  2263.     {

  2264.         if (const CarlaPluginPtr plugin = pData->plugins[i].plugin)

  2265.             if (plugin->isEnabled())

  2266.                 plugin->offlineModeChanged(isOfflineNow);

  2267.     }

  2268. }

  2269. 

  2270. void CarlaEngine::setPluginPeaksRT(const uint pluginId, float const inPeaks[2], float const outPeaks[2]) noexcept

  2271. {

  2272.     EnginePluginData& pluginData(pData->plugins[pluginId]);

  2273. 

  2274.     pluginData.peaks[0]  = inPeaks[0];

  2275.     pluginData.peaks[1]  = inPeaks[1];

  2276.     pluginData.peaks[2] = outPeaks[0];

  2277.     pluginData.peaks[3] = outPeaks[1];

  2278. }

  2279. 

  2280. void CarlaEngine::saveProjectInternal(water::MemoryOutputStream& outStream) const

  2281. {

  2282.     // send initial prepareForSave first, giving time for bridges to act

  2283.     for (uint i=0; i < pData->curPluginCount; ++i)

  2284.     {

  2285.         if (const CarlaPluginPtr plugin = pData->plugins[i].plugin)

  2286.         {

  2287.             if (plugin->isEnabled())

  2288.             {

  2289. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2290.                 // deactivate bridge client-side ping check, since some plugins block during save

  2291.                 if (plugin->getHints() & PLUGIN_IS_BRIDGE)

  2292.                     plugin->setCustomData(CUSTOM_DATA_TYPE_STRING, "__CarlaPingOnOff__", "false", false);

  2293. #endif

  2294.                 plugin->prepareForSave(false);

  2295.             }

  2296.         }

  2297.     }

  2298. 

  2299.     outStream << "<?xml version='1.0' encoding='UTF-8'?>\n";

  2300.     outStream << "<!DOCTYPE CARLA-PROJECT>\n";

  2301.     outStream << "<CARLA-PROJECT VERSION='" CARLA_VERSION_STRMIN "'";

  2302. 

  2303. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2304.     if (pData->ignoreClientPrefix)

  2305.         outStream << " IgnoreClientPrefix='true'";

  2306. #endif

  2307. 

  2308.     outStream << ">\n";

  2309. 

  2310.     const bool isPlugin(getType() == kEngineTypePlugin);

  2311.     const EngineOptions& options(pData->options);

  2312. 

  2313.     {

  2314.         MemoryOutputStream outSettings(1024);

  2315. 

  2316.         outSettings << " <EngineSettings>\n";

  2317. 

  2318.         outSettings << "  <ForceStereo>"         << bool2str(options.forceStereo)         << "</ForceStereo>\n";

  2319.         outSettings << "  <PreferPluginBridges>" << bool2str(options.preferPluginBridges) << "</PreferPluginBridges>\n";

  2320.         outSettings << "  <PreferUiBridges>"     << bool2str(options.preferUiBridges)     << "</PreferUiBridges>\n";

  2321.         outSettings << "  <UIsAlwaysOnTop>"      << bool2str(options.uisAlwaysOnTop)      << "</UIsAlwaysOnTop>\n";

  2322. 

  2323.         outSettings << "  <MaxParameters>"       << String(options.maxParameters)    << "</MaxParameters>\n";

  2324.         outSettings << "  <UIBridgesTimeout>"    << String(options.uiBridgesTimeout) << "</UIBridgesTimeout>\n";

  2325. 

  2326.         if (isPlugin)

  2327.         {

  2328.             outSettings << "  <LADSPA_PATH>" << xmlSafeString(options.pathLADSPA, true) << "</LADSPA_PATH>\n";

  2329.             outSettings << "  <DSSI_PATH>"   << xmlSafeString(options.pathDSSI,   true) << "</DSSI_PATH>\n";

  2330.             outSettings << "  <LV2_PATH>"    << xmlSafeString(options.pathLV2,    true) << "</LV2_PATH>\n";

  2331.             outSettings << "  <VST2_PATH>"   << xmlSafeString(options.pathVST2,   true) << "</VST2_PATH>\n";

  2332.             outSettings << "  <VST3_PATH>"   << xmlSafeString(options.pathVST3,   true) << "</VST3_PATH>\n";

  2333.             outSettings << "  <SF2_PATH>"    << xmlSafeString(options.pathSF2,    true) << "</SF2_PATH>\n";

  2334.             outSettings << "  <SFZ_PATH>"    << xmlSafeString(options.pathSFZ,    true) << "</SFZ_PATH>\n";

  2335.         }

  2336. 

  2337.         outSettings << " </EngineSettings>\n";

  2338.         outStream << outSettings;

  2339.     }

  2340. 

  2341.     if (pData->timeInfo.bbt.valid && ! isPlugin)

  2342.     {

  2343.         MemoryOutputStream outTransport(128);

  2344. 

  2345.         outTransport << "\n <Transport>\n";

  2346.         // outTransport << "  <BeatsPerBar>"    << pData->timeInfo.bbt.beatsPerBar    << "</BeatsPerBar>\n";

  2347.         outTransport << "  <BeatsPerMinute>" << pData->timeInfo.bbt.beatsPerMinute << "</BeatsPerMinute>\n";

  2348.         outTransport << " </Transport>\n";

  2349.         outStream << outTransport;

  2350.     }

  2351. 

  2352.     char strBuf[STR_MAX+1];

  2353.     carla_zeroChars(strBuf, STR_MAX+1);

  2354. 

  2355.     for (uint i=0; i < pData->curPluginCount; ++i)

  2356.     {

  2357.         if (const CarlaPluginPtr plugin = pData->plugins[i].plugin)

  2358.         {

  2359.             if (plugin->isEnabled())

  2360.             {

  2361.                 MemoryOutputStream outPlugin(4096), streamPlugin;

  2362.                 plugin->getStateSave(false).dumpToMemoryStream(streamPlugin);

  2363. 

  2364.                 outPlugin << "\n";

  2365. 

  2366.                 if (plugin->getRealName(strBuf))

  2367.                     outPlugin << " <!-- " << xmlSafeString(strBuf, true) << " -->\n";

  2368. 

  2369.                 outPlugin << " <Plugin>\n";

  2370.                 outPlugin << streamPlugin;

  2371.                 outPlugin << " </Plugin>\n";

  2372.                 outStream << outPlugin;

  2373.             }

  2374.         }

  2375.     }

  2376. 

  2377. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2378.     // tell bridges we're done saving

  2379.     for (uint i=0; i < pData->curPluginCount; ++i)

  2380.     {

  2381.         if (const CarlaPluginPtr plugin = pData->plugins[i].plugin)

  2382.             if (plugin->isEnabled() && (plugin->getHints() & PLUGIN_IS_BRIDGE) != 0)

  2383.                 plugin->setCustomData(CUSTOM_DATA_TYPE_STRING, "__CarlaPingOnOff__", "true", false);

  2384.     }

  2385. 

  2386.     // save internal connections

  2387.     if (pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY)

  2388.     {

  2389.         uint posCount = 0;

  2390.         const char* const* const patchbayConns = getPatchbayConnections(false);

  2391.         const PatchbayPosition* const patchbayPos = getPatchbayPositions(false, posCount);

  2392. 

  2393.         if (patchbayConns != nullptr || patchbayPos != nullptr)

  2394.         {

  2395.             MemoryOutputStream outPatchbay(2048);

  2396. 

  2397.             outPatchbay << "\n <Patchbay>\n";

  2398. 

  2399.             if (patchbayConns != nullptr)

  2400.             {

  2401.                 for (int i=0; patchbayConns[i] != nullptr && patchbayConns[i+1] != nullptr; ++i, ++i)

  2402.                 {

  2403.                     const char* const connSource(patchbayConns[i]);

  2404.                     const char* const connTarget(patchbayConns[i+1]);

  2405. 

  2406.                     CARLA_SAFE_ASSERT_CONTINUE(connSource != nullptr && connSource[0] != '\0');

  2407.                     CARLA_SAFE_ASSERT_CONTINUE(connTarget != nullptr && connTarget[0] != '\0');

  2408. 

  2409.                     outPatchbay << "  <Connection>\n";

  2410.                     outPatchbay << "   <Source>" << xmlSafeString(connSource, true) << "</Source>\n";

  2411.                     outPatchbay << "   <Target>" << xmlSafeString(connTarget, true) << "</Target>\n";

  2412.                     outPatchbay << "  </Connection>\n";

  2413.                 }

  2414.             }

  2415. 

  2416.             if (patchbayPos != nullptr && posCount != 0)

  2417.             {

  2418.                 outPatchbay << "  <Positions>\n";

  2419. 

  2420.                 for (uint i=0; i<posCount; ++i)

  2421.                 {

  2422.                     const PatchbayPosition& ppos(patchbayPos[i]);

  2423. 

  2424.                     CARLA_SAFE_ASSERT_CONTINUE(ppos.name != nullptr && ppos.name[0] != '\0');

  2425. 

  2426.                     outPatchbay << "   <Position x1=\"" << ppos.x1 << "\" y1=\"" << ppos.y1;

  2427.                     if (ppos.x2 != 0 || ppos.y2 != 0)

  2428.                         outPatchbay << "\" x2=\"" << ppos.x2 << "\" y2=\"" << ppos.y2;

  2429.                     if (ppos.pluginId >= 0)

  2430.                         outPatchbay << "\" pluginId=\"" << ppos.pluginId;

  2431.                     outPatchbay << "\">\n";

  2432.                     outPatchbay << "    <Name>" << xmlSafeString(ppos.name, true) << "</Name>\n";

  2433.                     outPatchbay << "   </Position>\n";

  2434. 

  2435.                     if (ppos.dealloc)

  2436.                         delete[] ppos.name;

  2437.                 }

  2438. 

  2439.                 outPatchbay << "  </Positions>\n";

  2440.             }

  2441. 

  2442.             outPatchbay << " </Patchbay>\n";

  2443.             outStream << outPatchbay;

  2444. 

  2445.             delete[] patchbayPos;

  2446.         }

  2447. 

  2448.     }

  2449. 

  2450.     // if we're running inside some session-manager (and using JACK), let them handle the connections

  2451.     bool saveExternalConnections, saveExternalPositions = true;

  2452. 

  2453.     /**/ if (isPlugin)

  2454.     {

  2455.         saveExternalConnections = false;

  2456.         saveExternalPositions = false;

  2457.     }

  2458.     else if (std::strcmp(getCurrentDriverName(), "JACK") != 0)

  2459.     {

  2460.         saveExternalConnections = true;

  2461.     }

  2462.     else if (std::getenv("CARLA_DONT_MANAGE_CONNECTIONS") != nullptr)

  2463.     {

  2464.         saveExternalConnections = false;

  2465.     }

  2466.     else

  2467.     {

  2468.         saveExternalConnections = true;

  2469.     }

  2470. 

  2471.     if (saveExternalConnections || saveExternalPositions)

  2472.     {

  2473.         uint posCount = 0;

  2474.         const char* const* const patchbayConns = saveExternalConnections

  2475.                                                ? getPatchbayConnections(true)

  2476.                                                : nullptr;

  2477.         const PatchbayPosition* const patchbayPos = saveExternalPositions

  2478.                                                   ? getPatchbayPositions(true, posCount)

  2479.                                                   : nullptr;

  2480. 

  2481.         if (patchbayConns != nullptr || patchbayPos != nullptr)

  2482.         {

  2483.             MemoryOutputStream outPatchbay(2048);

  2484. 

  2485.             outPatchbay << "\n <ExternalPatchbay>\n";

  2486. 

  2487.             if (patchbayConns != nullptr)

  2488.             {

  2489.                 for (int i=0; patchbayConns[i] != nullptr && patchbayConns[i+1] != nullptr; ++i, ++i )

  2490.                 {

  2491.                     const char* const connSource(patchbayConns[i]);

  2492.                     const char* const connTarget(patchbayConns[i+1]);

  2493. 

  2494.                     CARLA_SAFE_ASSERT_CONTINUE(connSource != nullptr && connSource[0] != '\0');

  2495.                     CARLA_SAFE_ASSERT_CONTINUE(connTarget != nullptr && connTarget[0] != '\0');

  2496. 

  2497.                     outPatchbay << "  <Connection>\n";

  2498.                     outPatchbay << "   <Source>" << xmlSafeString(connSource, true) << "</Source>\n";

  2499.                     outPatchbay << "   <Target>" << xmlSafeString(connTarget, true) << "</Target>\n";

  2500.                     outPatchbay << "  </Connection>\n";

  2501.                 }

  2502.             }

  2503. 

  2504.             if (patchbayPos != nullptr && posCount != 0)

  2505.             {

  2506.                 outPatchbay << "  <Positions>\n";

  2507. 

  2508.                 for (uint i=0; i<posCount; ++i)

  2509.                 {

  2510.                     const PatchbayPosition& ppos(patchbayPos[i]);

  2511. 

  2512.                     CARLA_SAFE_ASSERT_CONTINUE(ppos.name != nullptr && ppos.name[0] != '\0');

  2513. 

  2514.                     outPatchbay << "   <Position x1=\"" << ppos.x1 << "\" y1=\"" << ppos.y1;

  2515.                     if (ppos.x2 != 0 || ppos.y2 != 0)

  2516.                         outPatchbay << "\" x2=\"" << ppos.x2 << "\" y2=\"" << ppos.y2;

  2517.                     if (ppos.pluginId >= 0)

  2518.                         outPatchbay << "\" pluginId=\"" << ppos.pluginId;

  2519.                     outPatchbay << "\">\n";

  2520.                     outPatchbay << "    <Name>" << xmlSafeString(ppos.name, true) << "</Name>\n";

  2521.                     outPatchbay << "   </Position>\n";

  2522. 

  2523.                     if (ppos.dealloc)

  2524.                         delete[] ppos.name;

  2525.                 }

  2526. 

  2527.                 outPatchbay << "  </Positions>\n";

  2528.             }

  2529. 

  2530.             outPatchbay << " </ExternalPatchbay>\n";

  2531.             outStream << outPatchbay;

  2532.         }

  2533.     }

  2534. #endif

  2535. 

  2536.     outStream << "</CARLA-PROJECT>\n";

  2537. }

  2538. 

  2539. static String findBinaryInCustomPath(const char* const searchPath, const char* const binary)

  2540. {

  2541.     const StringArray searchPaths(StringArray::fromTokens(searchPath, CARLA_OS_SPLIT_STR, ""));

  2542. 

  2543.     // try direct filename first

  2544.     String jbinary(binary);

  2545. 

  2546.     // adjust for current platform

  2547. #ifdef CARLA_OS_WIN

  2548.     if (jbinary[0] == '/')

  2549.         jbinary = "C:" + jbinary.replaceCharacter('/', '\\');

  2550. #else

  2551.     if (jbinary[1] == ':' && (jbinary[2] == '\\' || jbinary[2] == '/'))

  2552.         jbinary = jbinary.substring(2).replaceCharacter('\\', '/');

  2553. #endif

  2554. 

  2555.     String filename = File(jbinary).getFileName();

  2556. 

  2557.     int searchFlags = File::findFiles|File::ignoreHiddenFiles;

  2558. 

  2559.     if (filename.endsWithIgnoreCase(".vst3"))

  2560.         searchFlags |= File::findDirectories;

  2561. #ifdef CARLA_OS_MAC

  2562.     else if (filename.endsWithIgnoreCase(".vst"))

  2563.         searchFlags |= File::findDirectories;

  2564. #endif

  2565. 

  2566.     Array<File> results;

  2567.     for (const String *it=searchPaths.begin(), *end=searchPaths.end(); it != end; ++it)

  2568.     {

  2569.         const File path(*it);

  2570. 

  2571.         results.clear();

  2572.         path.findChildFiles(results, searchFlags, true, filename);

  2573. 

  2574.         if (results.size() > 0)

  2575.             return results.getFirst().getFullPathName();

  2576.     }

  2577. 

  2578.     // try changing extension

  2579. #if defined(CARLA_OS_MAC)

  2580.     if (filename.endsWithIgnoreCase(".dll") || filename.endsWithIgnoreCase(".so"))

  2581.         filename = File(jbinary).getFileNameWithoutExtension() + ".dylib";

  2582. #elif defined(CARLA_OS_WIN)

  2583.     if (filename.endsWithIgnoreCase(".dylib") || filename.endsWithIgnoreCase(".so"))

  2584.         filename = File(jbinary).getFileNameWithoutExtension() + ".dll";

  2585. #else

  2586.     if (filename.endsWithIgnoreCase(".dll") || filename.endsWithIgnoreCase(".dylib"))

  2587.         filename = File(jbinary).getFileNameWithoutExtension() + ".so";

  2588. #endif

  2589.     else

  2590.         return String();

  2591. 

  2592.     for (const String *it=searchPaths.begin(), *end=searchPaths.end(); it != end; ++it)

  2593.     {

  2594.         const File path(*it);

  2595. 

  2596.         results.clear();

  2597.         path.findChildFiles(results, searchFlags, true, filename);

  2598. 

  2599.         if (results.size() > 0)

  2600.             return results.getFirst().getFullPathName();

  2601.     }

  2602. 

  2603.     return String();

  2604. }

  2605. 

  2606. bool CarlaEngine::loadProjectInternal(water::XmlDocument& xmlDoc, const bool alwaysLoadConnections)

  2607. {

  2608.     carla_debug("CarlaEngine::loadProjectInternal(%p, %s) - START", &xmlDoc, bool2str(alwaysLoadConnections));

  2609. 

  2610.     CarlaScopedPointer<XmlElement> xmlElement(xmlDoc.getDocumentElement(true));

  2611.     CARLA_SAFE_ASSERT_RETURN_ERR(xmlElement != nullptr, "Failed to parse project file");

  2612. 

  2613.     const String& xmlType(xmlElement->getTagName());

  2614.     const bool isPreset(xmlType.equalsIgnoreCase("carla-preset"));

  2615. 

  2616.     if (! (xmlType.equalsIgnoreCase("carla-project") || isPreset))

  2617.     {

  2618.         callback(true, true, ENGINE_CALLBACK_PROJECT_LOAD_FINISHED, 0, 0, 0, 0, 0.0f, nullptr);

  2619.         setLastError("Not a valid Carla project or preset file");

  2620.         return false;

  2621.     }

  2622. 

  2623.     pData->actionCanceled = false;

  2624.     callback(true, true, ENGINE_CALLBACK_CANCELABLE_ACTION, 0, 1, 0, 0, 0.0f, "Loading project");

  2625. 

  2626. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2627.     if (pData->options.clientNamePrefix != nullptr)

  2628.     {

  2629.         if (carla_isEqual(xmlElement->getDoubleAttribute("VERSION", 0.0), 2.0) ||

  2630.             xmlElement->getBoolAttribute("IgnoreClientPrefix", false))

  2631.         {

  2632.             carla_stdout("Loading project in compatibility mode, will ignore client name prefix");

  2633.             pData->ignoreClientPrefix = true;

  2634.             setOption(ENGINE_OPTION_CLIENT_NAME_PREFIX, 0, "");

  2635.         }

  2636.     }

  2637. 

  2638.     const CarlaScopedValueSetter<bool> csvs(pData->loadingProject, true, false);

  2639. #endif

  2640. 

  2641.     // completely load file

  2642.     xmlElement = xmlDoc.getDocumentElement(false);

  2643.     CARLA_SAFE_ASSERT_RETURN_ERR(xmlElement != nullptr, "Failed to completely parse project file");

  2644. 

  2645.     if (pData->aboutToClose)

  2646.         return true;

  2647. 

  2648.     if (pData->actionCanceled)

  2649.     {

  2650.         setLastError("Project load canceled");

  2651.         return false;

  2652.     }

  2653. 

  2654.     callback(true, false, ENGINE_CALLBACK_IDLE, 0, 0, 0, 0, 0.0f, nullptr);

  2655. 

  2656. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2657.     const bool isMultiClient = pData->options.processMode == ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS;

  2658.     const bool isPatchbay    = pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY;

  2659. #endif

  2660.     const bool isPlugin = getType() == kEngineTypePlugin;

  2661. 

  2662.     // load engine settings first of all

  2663.     if (XmlElement* const elem = isPreset ? nullptr : xmlElement->getChildByName("EngineSettings"))

  2664.     {

  2665.         for (XmlElement* settElem = elem->getFirstChildElement(); settElem != nullptr; settElem = settElem->getNextElement())

  2666.         {

  2667.             const String& tag(settElem->getTagName());

  2668.             const String  text(settElem->getAllSubText().trim());

  2669. 

  2670.             /** some settings might be incorrect or require extra work,

  2671.                 so we call setOption rather than modifying them direly */

  2672. 

  2673.             int option = -1;

  2674.             int value  = 0;

  2675.             const char* valueStr = nullptr;

  2676. 

  2677.             /**/ if (tag == "ForceStereo")

  2678.             {

  2679.                 option = ENGINE_OPTION_FORCE_STEREO;

  2680.                 value  = text == "true" ? 1 : 0;

  2681.             }

  2682.             else if (tag == "PreferPluginBridges")

  2683.             {

  2684.                 option = ENGINE_OPTION_PREFER_PLUGIN_BRIDGES;

  2685.                 value  = text == "true" ? 1 : 0;

  2686.             }

  2687.             else if (tag == "PreferUiBridges")

  2688.             {

  2689.                 option = ENGINE_OPTION_PREFER_UI_BRIDGES;

  2690.                 value  = text == "true" ? 1 : 0;

  2691.             }

  2692.             else if (tag == "UIsAlwaysOnTop")

  2693.             {

  2694.                 option = ENGINE_OPTION_UIS_ALWAYS_ON_TOP;

  2695.                 value  = text == "true" ? 1 : 0;

  2696.             }

  2697.             else if (tag == "MaxParameters")

  2698.             {

  2699.                 option = ENGINE_OPTION_MAX_PARAMETERS;

  2700.                 value  = text.getIntValue();

  2701.             }

  2702.             else if (tag == "UIBridgesTimeout")

  2703.             {

  2704.                 option = ENGINE_OPTION_UI_BRIDGES_TIMEOUT;

  2705.                 value  = text.getIntValue();

  2706.             }

  2707.             else if (isPlugin)

  2708.             {

  2709.                 /**/ if (tag == "LADSPA_PATH")

  2710.                 {

  2711.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2712.                     value    = PLUGIN_LADSPA;

  2713.                     valueStr = text.toRawUTF8();

  2714.                 }

  2715.                 else if (tag == "DSSI_PATH")

  2716.                 {

  2717.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2718.                     value    = PLUGIN_DSSI;

  2719.                     valueStr = text.toRawUTF8();

  2720.                 }

  2721.                 else if (tag == "LV2_PATH")

  2722.                 {

  2723.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2724.                     value    = PLUGIN_LV2;

  2725.                     valueStr = text.toRawUTF8();

  2726.                 }

  2727.                 else if (tag == "VST2_PATH")

  2728.                 {

  2729.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2730.                     value    = PLUGIN_VST2;

  2731.                     valueStr = text.toRawUTF8();

  2732.                 }

  2733.                 else if (tag.equalsIgnoreCase("VST3_PATH"))

  2734.                 {

  2735.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2736.                     value    = PLUGIN_VST3;

  2737.                     valueStr = text.toRawUTF8();

  2738.                 }

  2739.                 else if (tag == "SF2_PATH")

  2740.                 {

  2741.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2742.                     value    = PLUGIN_SF2;

  2743.                     valueStr = text.toRawUTF8();

  2744.                 }

  2745.                 else if (tag == "SFZ_PATH")

  2746.                 {

  2747.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2748.                     value    = PLUGIN_SFZ;

  2749.                     valueStr = text.toRawUTF8();

  2750.                 }

  2751.             }

  2752. 

  2753.             if (option == -1)

  2754.             {

  2755.                 // check old stuff, unhandled now

  2756.                 if (tag == "GIG_PATH")

  2757.                     continue;

  2758.                 // ignored tags

  2759.                 if (tag == "LADSPA_PATH" || tag == "DSSI_PATH" || tag == "LV2_PATH" || tag == "VST2_PATH")

  2760.                     continue;

  2761.                 if (tag == "VST3_PATH" || tag == "AU_PATH")

  2762.                     continue;

  2763.                 if (tag == "SF2_PATH" || tag == "SFZ_PATH")

  2764.                     continue;

  2765. 

  2766.                 // hmm something is wrong..

  2767.                 carla_stderr2("CarlaEngine::loadProjectInternal() - Unhandled option '%s'", tag.toRawUTF8());

  2768.                 continue;

  2769.             }

  2770. 

  2771.             setOption(static_cast<EngineOption>(option), value, valueStr);

  2772.         }

  2773. 

  2774.         if (pData->aboutToClose)

  2775.             return true;

  2776. 

  2777.         if (pData->actionCanceled)

  2778.         {

  2779.             setLastError("Project load canceled");

  2780.             return false;

  2781.         }

  2782.     }

  2783. 

  2784.     // now setup transport

  2785.     if (XmlElement* const elem = (isPreset || isPlugin) ? nullptr : xmlElement->getChildByName("Transport"))

  2786.     {

  2787.         if (XmlElement* const bpmElem = elem->getChildByName("BeatsPerMinute"))

  2788.         {

  2789.             const String bpmText(bpmElem->getAllSubText().trim());

  2790.             const double bpm = bpmText.getDoubleValue();

  2791. 

  2792.             // some sane limits

  2793.             if (bpm >= 20.0 && bpm < 400.0)

  2794.                 pData->time.setBPM(bpm);

  2795. 

  2796.             if (pData->aboutToClose)

  2797.                 return true;

  2798. 

  2799.             if (pData->actionCanceled)

  2800.             {

  2801.                 setLastError("Project load canceled");

  2802.                 return false;

  2803.             }

  2804.         }

  2805.     }

  2806. 

  2807.     // and we handle plugins

  2808.     for (XmlElement* elem = xmlElement->getFirstChildElement(); elem != nullptr; elem = elem->getNextElement())

  2809.     {

  2810.         const String& tagName(elem->getTagName());

  2811. 

  2812.         if (isPreset || tagName == "Plugin")

  2813.         {

  2814.             CarlaStateSave stateSave;

  2815.             stateSave.fillFromXmlElement(isPreset ? xmlElement.get() : elem);

  2816. 

  2817.             if (pData->aboutToClose)

  2818.                 return true;

  2819. 

  2820.             if (pData->actionCanceled)

  2821.             {

  2822.                 setLastError("Project load canceled");

  2823.                 return false;

  2824.             }

  2825. 

  2826.             CARLA_SAFE_ASSERT_CONTINUE(stateSave.type != nullptr);

  2827. 

  2828. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2829.             // compatibility code to load projects with GIG files

  2830.             // FIXME Remove on 2.1 release

  2831.             if (std::strcmp(stateSave.type, "GIG") == 0)

  2832.             {

  2833.                 if (addPlugin(PLUGIN_LV2, "", stateSave.name, "http://linuxsampler.org/plugins/linuxsampler", 0, nullptr))

  2834.                 {

  2835.                     const uint pluginId = pData->curPluginCount;

  2836. 

  2837.                     if (const CarlaPluginPtr plugin = pData->plugins[pluginId].plugin)

  2838.                     {

  2839.                         if (pData->aboutToClose)

  2840.                             return true;

  2841. 

  2842.                         if (pData->actionCanceled)

  2843.                         {

  2844.                             setLastError("Project load canceled");

  2845.                             return false;

  2846.                         }

  2847. 

  2848.                         String lsState;

  2849.                         lsState << "0.35\n";

  2850.                         lsState << "18 0 Chromatic\n";

  2851.                         lsState << "18 1 Drum Kits\n";

  2852.                         lsState << "20 0\n";

  2853.                         lsState << "0 1 " << stateSave.binary << "\n";

  2854.                         lsState << "0 0 0 0 1 0 GIG\n";

  2855. 

  2856.                         plugin->setCustomData(LV2_ATOM__String, "http://linuxsampler.org/schema#state-string", lsState.toRawUTF8(), true);

  2857.                         plugin->restoreLV2State(true);

  2858. 

  2859.                         plugin->setDryWet(stateSave.dryWet, true, true);

  2860.                         plugin->setVolume(stateSave.volume, true, true);

  2861.                         plugin->setBalanceLeft(stateSave.balanceLeft, true, true);

  2862.                         plugin->setBalanceRight(stateSave.balanceRight, true, true);

  2863.                         plugin->setPanning(stateSave.panning, true, true);

  2864.                         plugin->setCtrlChannel(stateSave.ctrlChannel, true, true);

  2865.                         plugin->setActive(stateSave.active, true, true);

  2866.                         plugin->setEnabled(true);

  2867. 

  2868.                         ++pData->curPluginCount;

  2869.                         callback(true, true, ENGINE_CALLBACK_PLUGIN_ADDED, pluginId, 0, 0, 0, 0.0f, plugin->getName());

  2870. 

  2871.                         if (isPatchbay)

  2872.                             pData->graph.addPlugin(plugin);

  2873.                     }

  2874.                     else

  2875.                     {

  2876.                         carla_stderr2("Failed to get new plugin, state will not be restored correctly\n");

  2877.                     }

  2878.                 }

  2879.                 else

  2880.                 {

  2881.                     carla_stderr2("Failed to load a linuxsampler LV2 plugin, GIG file won't be loaded");

  2882.                 }

  2883. 

  2884.                 callback(true, true, ENGINE_CALLBACK_IDLE, 0, 0, 0, 0, 0.0f, nullptr);

  2885.                 continue;

  2886.             }

  2887. # ifdef SFZ_FILES_USING_SFIZZ

  2888.             if (std::strcmp(stateSave.type, "SFZ") == 0)

  2889.             {

  2890.                 if (addPlugin(PLUGIN_LV2, "", stateSave.name, "http://sfztools.github.io/sfizz", 0, nullptr))

  2891.                 {

  2892.                     const uint pluginId = pData->curPluginCount;

  2893. 

  2894.                     if (const CarlaPluginPtr plugin = pData->plugins[pluginId].plugin)

  2895.                     {

  2896.                         if (pData->aboutToClose)

  2897.                             return true;

  2898. 

  2899.                         if (pData->actionCanceled)

  2900.                         {

  2901.                             setLastError("Project load canceled");

  2902.                             return false;

  2903.                         }

  2904. 

  2905.                         plugin->setCustomData(LV2_ATOM__Path,

  2906.                                               "http://sfztools.github.io/sfizz:sfzfile",

  2907.                                               stateSave.binary,

  2908.                                               false);

  2909. 

  2910.                         plugin->restoreLV2State(true);

  2911. 

  2912.                         plugin->setDryWet(stateSave.dryWet, true, true);

  2913.                         plugin->setVolume(stateSave.volume, true, true);

  2914.                         plugin->setBalanceLeft(stateSave.balanceLeft, true, true);

  2915.                         plugin->setBalanceRight(stateSave.balanceRight, true, true);

  2916.                         plugin->setPanning(stateSave.panning, true, true);

  2917.                         plugin->setCtrlChannel(stateSave.ctrlChannel, true, true);

  2918.                         plugin->setActive(stateSave.active, true, true);

  2919.                         plugin->setEnabled(true);

  2920. 

  2921.                         ++pData->curPluginCount;

  2922.                         callback(true, true, ENGINE_CALLBACK_PLUGIN_ADDED, pluginId, 0, 0, 0, 0.0f, plugin->getName());

  2923. 

  2924.                         if (isPatchbay)

  2925.                             pData->graph.addPlugin(plugin);

  2926.                     }

  2927.                     else

  2928.                     {

  2929.                         carla_stderr2("Failed to get new plugin, state will not be restored correctly\n");

  2930.                     }

  2931.                 }

  2932.                 else

  2933.                 {

  2934.                     carla_stderr2("Failed to load a sfizz LV2 plugin, SFZ file won't be loaded");

  2935.                 }

  2936. 

  2937.                 callback(true, true, ENGINE_CALLBACK_IDLE, 0, 0, 0, 0, 0.0f, nullptr);

  2938.                 continue;

  2939.             }

  2940. # endif

  2941. #endif

  2942. 

  2943.             const void* extraStuff    = nullptr;

  2944.             static const char kTrue[] = "true";

  2945. 

  2946.             const PluginType ptype(getPluginTypeFromString(stateSave.type));

  2947. 

  2948.             switch (ptype)

  2949.             {

  2950.             case PLUGIN_SF2:

  2951.                 if (CarlaString(stateSave.label).endsWith(" (16 outs)"))

  2952.                     extraStuff = kTrue;

  2953.                 // fall through

  2954.             case PLUGIN_LADSPA:

  2955.             case PLUGIN_DSSI:

  2956.             case PLUGIN_VST2:

  2957.             case PLUGIN_VST3:

  2958.             case PLUGIN_SFZ:

  2959.                 if (stateSave.binary != nullptr && stateSave.binary[0] != '\0' &&

  2960.                     ! (File::isAbsolutePath(stateSave.binary) && File(stateSave.binary).exists()))

  2961.                 {

  2962.                     const char* searchPath;

  2963. 

  2964.                     switch (ptype)

  2965.                     {

  2966.                     case PLUGIN_LADSPA: searchPath = pData->options.pathLADSPA; break;

  2967.                     case PLUGIN_DSSI:   searchPath = pData->options.pathDSSI;   break;

  2968.                     case PLUGIN_VST2:   searchPath = pData->options.pathVST2;   break;

  2969.                     case PLUGIN_VST3:   searchPath = pData->options.pathVST3;   break;

  2970.                     case PLUGIN_SF2:    searchPath = pData->options.pathSF2;    break;

  2971.                     case PLUGIN_SFZ:    searchPath = pData->options.pathSFZ;    break;

  2972.                     default:            searchPath = nullptr;                   break;

  2973.                     }

  2974. 

  2975.                     if (searchPath != nullptr && searchPath[0] != '\0')

  2976.                     {

  2977.                         carla_stderr("Plugin binary '%s' doesn't exist on this filesystem, let's look for it...",

  2978.                                      stateSave.binary);

  2979. 

  2980.                         String result = findBinaryInCustomPath(searchPath, stateSave.binary);

  2981. 

  2982.                         if (result.isEmpty())

  2983.                         {

  2984.                             switch (ptype)

  2985.                             {

  2986.                             case PLUGIN_LADSPA: searchPath = std::getenv("LADSPA_PATH"); break;

  2987.                             case PLUGIN_DSSI:   searchPath = std::getenv("DSSI_PATH");   break;

  2988.                             case PLUGIN_VST2:   searchPath = std::getenv("VST_PATH");    break;

  2989.                             case PLUGIN_VST3:   searchPath = std::getenv("VST3_PATH");   break;

  2990.                             case PLUGIN_SF2:    searchPath = std::getenv("SF2_PATH");    break;

  2991.                             case PLUGIN_SFZ:    searchPath = std::getenv("SFZ_PATH");    break;

  2992.                             default:            searchPath = nullptr;                    break;

  2993.                             }

  2994. 

  2995.                             if (searchPath != nullptr && searchPath[0] != '\0')

  2996.                                 result = findBinaryInCustomPath(searchPath, stateSave.binary);

  2997.                         }

  2998. 

  2999.                         if (result.isNotEmpty())

  3000.                         {

  3001.                             delete[] stateSave.binary;

  3002.                             stateSave.binary = carla_strdup(result.toRawUTF8());

  3003.                             carla_stderr("Found it! :)");

  3004.                         }

  3005.                         else

  3006.                         {

  3007.                             carla_stderr("Damn, we failed... :(");

  3008.                         }

  3009. 

  3010.                         callback(true, true, ENGINE_CALLBACK_IDLE, 0, 0, 0, 0, 0.0f, nullptr);

  3011.                     }

  3012.                 }

  3013.                 break;

  3014.             default:

  3015.                 break;

  3016.             }

  3017. 

  3018.             BinaryType btype;

  3019. 

  3020.             switch (ptype)

  3021.             {

  3022.             case PLUGIN_LADSPA:

  3023.             case PLUGIN_DSSI:

  3024.             case PLUGIN_LV2:

  3025.             case PLUGIN_VST2:

  3026.             case PLUGIN_VST3:

  3027.                 btype = getBinaryTypeFromFile(stateSave.binary);

  3028.                 break;

  3029.             default:

  3030.                 btype = BINARY_NATIVE;

  3031.                 break;

  3032.             }

  3033. 

  3034.             if (addPlugin(btype, ptype, stateSave.binary,

  3035.                           stateSave.name, stateSave.label, stateSave.uniqueId, extraStuff, stateSave.options))

  3036.             {

  3037. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  3038.                 const uint pluginId = pData->curPluginCount;

  3039. #else

  3040.                 const uint pluginId = 0;

  3041. #endif

  3042. 

  3043.                 if (const CarlaPluginPtr plugin = pData->plugins[pluginId].plugin)

  3044.                 {

  3045.                     if (pData->aboutToClose)

  3046.                         return true;

  3047. 

  3048.                     if (pData->actionCanceled)

  3049.                     {

  3050.                         setLastError("Project load canceled");

  3051.                         return false;

  3052.                     }

  3053. 

  3054.                     // deactivate bridge client-side ping check, since some plugins block during load

  3055.                     if ((plugin->getHints() & PLUGIN_IS_BRIDGE) != 0 && ! isPreset)

  3056.                         plugin->setCustomData(CUSTOM_DATA_TYPE_STRING, "__CarlaPingOnOff__", "false", false);

  3057. 

  3058.                     plugin->loadStateSave(stateSave);

  3059. 

  3060.                     /* NOTE: The following code is the same as the end of addPlugin().

  3061.                      *       When project is loading we do not enable the plugin right away,

  3062.                      *        as we want to load state first.

  3063.                      */

  3064.                     plugin->setEnabled(true);

  3065. 

  3066.                     ++pData->curPluginCount;

  3067.                     callback(true, true, ENGINE_CALLBACK_PLUGIN_ADDED, pluginId, 0, 0, 0, 0.0f, plugin->getName());

  3068. 

  3069. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  3070.                     if (isPatchbay)

  3071.                         pData->graph.addPlugin(plugin);

  3072. #endif

  3073.                 }

  3074.                 else

  3075.                 {

  3076.                     carla_stderr2("Failed to get new plugin, state will not be restored correctly\n");

  3077.                 }

  3078.             }

  3079.             else

  3080.             {

  3081.                 carla_stderr2("Failed to load a plugin '%s', error was:\n%s", stateSave.name, getLastError());

  3082.             }

  3083. 

  3084.             if (! isPreset)

  3085.                 callback(true, true, ENGINE_CALLBACK_IDLE, 0, 0, 0, 0, 0.0f, nullptr);

  3086.         }

  3087. 

  3088.         if (isPreset)

  3089.         {

  3090.             callback(true, true, ENGINE_CALLBACK_PROJECT_LOAD_FINISHED, 0, 0, 0, 0, 0.0f, nullptr);

  3091.             callback(true, true, ENGINE_CALLBACK_CANCELABLE_ACTION, 0, 0, 0, 0, 0.0f, "Loading project");

  3092.             return true;

  3093.         }

  3094.     }

  3095. 

  3096. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  3097.     // tell bridges we're done loading

  3098.     for (uint i=0; i < pData->curPluginCount; ++i)

  3099.     {

  3100.         if (const CarlaPluginPtr plugin = pData->plugins[i].plugin)

  3101.             if (plugin->isEnabled() && (plugin->getHints() & PLUGIN_IS_BRIDGE) != 0)

  3102.                 plugin->setCustomData(CUSTOM_DATA_TYPE_STRING, "__CarlaPingOnOff__", "true", false);

  3103.     }

  3104. 

  3105.     if (pData->aboutToClose)

  3106.         return true;

  3107. 

  3108.     if (pData->actionCanceled)

  3109.     {

  3110.         setLastError("Project load canceled");

  3111.         return false;

  3112.     }

  3113. 

  3114.     // now we handle positions

  3115.     bool loadingAsExternal;

  3116.     std::map<water::String, water::String> mapGroupNamesInternal, mapGroupNamesExternal;

  3117. 

  3118.     bool hasInternalPositions = false;

  3119. 

  3120.     if (XmlElement* const elemPatchbay = xmlElement->getChildByName("Patchbay"))

  3121.     {

  3122.         hasInternalPositions = true;

  3123. 

  3124.         if (XmlElement* const elemPositions = elemPatchbay->getChildByName("Positions"))

  3125.         {

  3126.             String name;

  3127.             PatchbayPosition ppos = { nullptr, -1, 0, 0, 0, 0, false };

  3128. 

  3129.             for (XmlElement* patchElem = elemPositions->getFirstChildElement(); patchElem != nullptr; patchElem = patchElem->getNextElement())

  3130.             {

  3131.                 const String& patchTag(patchElem->getTagName());

  3132. 

  3133.                 if (patchTag != "Position")

  3134.                     continue;

  3135. 

  3136.                 XmlElement* const patchName = patchElem->getChildByName("Name");

  3137.                 CARLA_SAFE_ASSERT_CONTINUE(patchName != nullptr);

  3138. 

  3139.                 const String nameText(patchName->getAllSubText().trim());

  3140.                 name = xmlSafeString(nameText, false);

  3141. 

  3142.                 ppos.name = name.toRawUTF8();

  3143.                 ppos.x1 = patchElem->getIntAttribute("x1");

  3144.                 ppos.y1 = patchElem->getIntAttribute("y1");

  3145.                 ppos.x2 = patchElem->getIntAttribute("x2");

  3146.                 ppos.y2 = patchElem->getIntAttribute("y2");

  3147.                 ppos.pluginId = patchElem->getIntAttribute("pluginId", -1);

  3148.                 ppos.dealloc = false;

  3149. 

  3150.                 loadingAsExternal = ppos.pluginId >= 0 && isMultiClient;

  3151. 

  3152.                 if (name.isNotEmpty() && restorePatchbayGroupPosition(loadingAsExternal, ppos))

  3153.                 {

  3154.                     if (name != ppos.name)

  3155.                     {

  3156.                         carla_stdout("Converted client name '%s' to '%s' for this session",

  3157.                                      name.toRawUTF8(), ppos.name);

  3158.                         if (loadingAsExternal)

  3159.                             mapGroupNamesExternal[name] = ppos.name;

  3160.                         else

  3161.                             mapGroupNamesInternal[name] = ppos.name;

  3162.                     }

  3163. 

  3164.                     if (ppos.dealloc)

  3165.                         std::free(const_cast<char*>(ppos.name));

  3166.                 }

  3167.             }

  3168. 

  3169.             if (pData->aboutToClose)

  3170.                 return true;

  3171. 

  3172.             if (pData->actionCanceled)

  3173.             {

  3174.                 setLastError("Project load canceled");

  3175.                 return false;

  3176.             }

  3177.         }

  3178.     }

  3179. 

  3180.     if (XmlElement* const elemPatchbay = xmlElement->getChildByName("ExternalPatchbay"))

  3181.     {

  3182.         if (XmlElement* const elemPositions = elemPatchbay->getChildByName("Positions"))

  3183.         {

  3184.             String name;

  3185.             PatchbayPosition ppos = { nullptr, -1, 0, 0, 0, 0, false };

  3186. 

  3187.             for (XmlElement* patchElem = elemPositions->getFirstChildElement(); patchElem != nullptr; patchElem = patchElem->getNextElement())

  3188.             {

  3189.                 const String& patchTag(patchElem->getTagName());

  3190. 

  3191.                 if (patchTag != "Position")

  3192.                     continue;

  3193. 

  3194.                 XmlElement* const patchName = patchElem->getChildByName("Name");

  3195.                 CARLA_SAFE_ASSERT_CONTINUE(patchName != nullptr);

  3196. 

  3197.                 const String nameText(patchName->getAllSubText().trim());

  3198.                 name = xmlSafeString(nameText, false);

  3199. 

  3200.                 ppos.name = name.toRawUTF8();

  3201.                 ppos.x1 = patchElem->getIntAttribute("x1");

  3202.                 ppos.y1 = patchElem->getIntAttribute("y1");

  3203.                 ppos.x2 = patchElem->getIntAttribute("x2");

  3204.                 ppos.y2 = patchElem->getIntAttribute("y2");

  3205.                 ppos.pluginId = patchElem->getIntAttribute("pluginId", -1);

  3206.                 ppos.dealloc = false;

  3207. 

  3208.                 loadingAsExternal = ppos.pluginId < 0 || hasInternalPositions || !isPatchbay;

  3209. 

  3210.                 carla_debug("loadingAsExternal: %i because %i %i %i",

  3211.                             loadingAsExternal, ppos.pluginId < 0, hasInternalPositions, !isPatchbay);

  3212. 

  3213.                 if (name.isNotEmpty() && restorePatchbayGroupPosition(loadingAsExternal, ppos))

  3214.                 {

  3215.                     if (name != ppos.name)

  3216.                     {

  3217.                         carla_stdout("Converted client name '%s' to '%s' for this session",

  3218.                                      name.toRawUTF8(), ppos.name);

  3219. 

  3220.                         if (loadingAsExternal)

  3221.                             mapGroupNamesExternal[name] = ppos.name;

  3222.                         else

  3223.                             mapGroupNamesInternal[name] = ppos.name;

  3224.                     }

  3225. 

  3226.                     if (ppos.dealloc)

  3227.                         std::free(const_cast<char*>(ppos.name));

  3228.                 }

  3229.             }

  3230. 

  3231.             if (pData->aboutToClose)

  3232.                 return true;

  3233. 

  3234.             if (pData->actionCanceled)

  3235.             {

  3236.                 setLastError("Project load canceled");

  3237.                 return false;

  3238.             }

  3239.         }

  3240.     }

  3241. 

  3242.     bool hasInternalConnections = false;

  3243. 

  3244.     // and now we handle connections (internal)

  3245.     if (XmlElement* const elem = xmlElement->getChildByName("Patchbay"))

  3246.     {

  3247.         hasInternalConnections = true;

  3248. 

  3249.         if (isPatchbay)

  3250.         {

  3251.             water::String sourcePort, targetPort;

  3252. 

  3253.             for (XmlElement* patchElem = elem->getFirstChildElement(); patchElem != nullptr; patchElem = patchElem->getNextElement())

  3254.             {

  3255.                 const String& patchTag(patchElem->getTagName());

  3256. 

  3257.                 if (patchTag != "Connection")

  3258.                     continue;

  3259. 

  3260.                 sourcePort.clear();

  3261.                 targetPort.clear();

  3262. 

  3263.                 for (XmlElement* connElem = patchElem->getFirstChildElement(); connElem != nullptr; connElem = connElem->getNextElement())

  3264.                 {

  3265.                     const String& tag(connElem->getTagName());

  3266.                     const String  text(connElem->getAllSubText().trim());

  3267. 

  3268.                     /**/ if (tag == "Source")

  3269.                         sourcePort = xmlSafeString(text, false);

  3270.                     else if (tag == "Target")

  3271.                         targetPort = xmlSafeString(text, false);

  3272.                 }

  3273. 

  3274.                 if (sourcePort.isNotEmpty() && targetPort.isNotEmpty())

  3275.                 {

  3276.                     std::map<water::String, water::String>& map(mapGroupNamesInternal);

  3277.                     std::map<water::String, water::String>::iterator it;

  3278. 

  3279.                     if ((it = map.find(sourcePort.upToFirstOccurrenceOf(":", false, false))) != map.end())

  3280.                         sourcePort = it->second + sourcePort.fromFirstOccurrenceOf(":", true, false);

  3281.                     if ((it = map.find(targetPort.upToFirstOccurrenceOf(":", false, false))) != map.end())

  3282.                         targetPort = it->second + targetPort.fromFirstOccurrenceOf(":", true, false);

  3283. 

  3284.                     restorePatchbayConnection(false, sourcePort.toRawUTF8(), targetPort.toRawUTF8());

  3285.                 }

  3286.             }

  3287. 

  3288.             if (pData->aboutToClose)

  3289.                 return true;

  3290. 

  3291.             if (pData->actionCanceled)

  3292.             {

  3293.                 setLastError("Project load canceled");

  3294.                 return false;

  3295.             }

  3296.         }

  3297.     }

  3298. 

  3299.     // if we're running inside some session-manager (and using JACK), let them handle the external connections

  3300.     bool loadExternalConnections;

  3301. 

  3302.     if (alwaysLoadConnections)

  3303.     {

  3304.         loadExternalConnections = true;

  3305.     }

  3306.     else

  3307.     {

  3308.         /**/ if (std::strcmp(getCurrentDriverName(), "JACK") != 0)

  3309.             loadExternalConnections = true;

  3310.         else if (std::getenv("CARLA_DONT_MANAGE_CONNECTIONS") != nullptr)

  3311.             loadExternalConnections = false;

  3312.         else if (std::getenv("LADISH_APP_NAME") != nullptr)

  3313.             loadExternalConnections = false;

  3314.         else if (std::getenv("NSM_URL") != nullptr)

  3315.             loadExternalConnections = false;

  3316.         else

  3317.             loadExternalConnections = true;

  3318.     }

  3319. 

  3320.     // plus external connections too

  3321.     if (loadExternalConnections)

  3322.     {

  3323.         bool isExternal;

  3324.         loadingAsExternal = hasInternalConnections &&

  3325.             (pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK || isPatchbay);

  3326. 

  3327.         for (XmlElement* elem = xmlElement->getFirstChildElement(); elem != nullptr; elem = elem->getNextElement())

  3328.         {

  3329.             const String& tagName(elem->getTagName());

  3330. 

  3331.             // check if we want to load patchbay-mode connections into an external (multi-client) graph

  3332.             if (tagName == "Patchbay")

  3333.             {

  3334.                 if (isPatchbay)

  3335.                     continue;

  3336.                 isExternal = false;

  3337.                 loadingAsExternal = true;

  3338.             }

  3339.             // or load external patchbay connections

  3340.             else if (tagName == "ExternalPatchbay")

  3341.             {

  3342.                 if (! isPatchbay)

  3343.                     loadingAsExternal = true;

  3344.                 isExternal = true;

  3345.             }

  3346.             else

  3347.             {

  3348.                 continue;

  3349.             }

  3350. 

  3351.             water::String sourcePort, targetPort;

  3352. 

  3353.             for (XmlElement* patchElem = elem->getFirstChildElement(); patchElem != nullptr; patchElem = patchElem->getNextElement())

  3354.             {

  3355.                 const String& patchTag(patchElem->getTagName());

  3356. 

  3357.                 if (patchTag != "Connection")

  3358.                     continue;

  3359. 

  3360.                 sourcePort.clear();

  3361.                 targetPort.clear();

  3362. 

  3363.                 for (XmlElement* connElem = patchElem->getFirstChildElement(); connElem != nullptr; connElem = connElem->getNextElement())

  3364.                 {

  3365.                     const String& tag(connElem->getTagName());

  3366.                     const String  text(connElem->getAllSubText().trim());

  3367. 

  3368.                     /**/ if (tag == "Source")

  3369.                         sourcePort = xmlSafeString(text, false);

  3370.                     else if (tag == "Target")

  3371.                         targetPort = xmlSafeString(text, false);

  3372.                 }

  3373. 

  3374.                 if (sourcePort.isNotEmpty() && targetPort.isNotEmpty())

  3375.                 {

  3376.                     std::map<water::String, water::String>& map(loadingAsExternal ? mapGroupNamesExternal

  3377.                                                                                   : mapGroupNamesInternal);

  3378.                     std::map<water::String, water::String>::iterator it;

  3379. 

  3380.                     if (isExternal && isPatchbay && !loadingAsExternal && sourcePort.startsWith("system:capture_"))

  3381.                     {

  3382.                         water::String internalPort = sourcePort.trimCharactersAtStart("system:capture_");

  3383. 

  3384.                         if (pData->graph.getNumAudioOuts() < 3)

  3385.                         {

  3386.                             /**/ if (internalPort == "1")

  3387.                                 internalPort = "Audio Input:Left";

  3388.                             else if (internalPort == "2")

  3389.                                 internalPort = "Audio Input:Right";

  3390.                             else if (internalPort == "3")

  3391.                                 internalPort = "Audio Input:Sidechain";

  3392.                             else

  3393.                                 continue;

  3394.                         }

  3395.                         else

  3396.                         {

  3397.                             internalPort = "Audio Input:Capture " + internalPort;

  3398.                         }

  3399. 

  3400.                         carla_stdout("Converted port name '%s' to '%s' for this session",

  3401.                                      sourcePort.toRawUTF8(), internalPort.toRawUTF8());

  3402.                         sourcePort = internalPort;

  3403.                     }

  3404.                     else if (!isExternal && isMultiClient && sourcePort.startsWith("Audio Input:"))

  3405.                     {

  3406.                         water::String externalPort = sourcePort.trimCharactersAtStart("Audio Input:");

  3407. 

  3408.                         /**/ if (externalPort == "Left")

  3409.                             externalPort = "system:capture_1";

  3410.                         else if (externalPort == "Right")

  3411.                             externalPort = "system:capture_2";

  3412.                         else if (externalPort == "Sidechain")

  3413.                             externalPort = "system:capture_3";

  3414.                         else

  3415.                             externalPort = "system:capture_ " + externalPort.trimCharactersAtStart("Capture ");

  3416. 

  3417.                         carla_stdout("Converted port name '%s' to '%s' for this session",

  3418.                                      sourcePort.toRawUTF8(), externalPort.toRawUTF8());

  3419.                         sourcePort = externalPort;

  3420.                     }

  3421.                     else if ((it = map.find(sourcePort.upToFirstOccurrenceOf(":", false, false))) != map.end())

  3422.                     {

  3423.                         sourcePort = it->second + sourcePort.fromFirstOccurrenceOf(":", true, false);

  3424.                     }

  3425. 

  3426.                     if (isExternal && isPatchbay && !loadingAsExternal && targetPort.startsWith("system:playback_"))

  3427.                     {

  3428.                         water::String internalPort = targetPort.trimCharactersAtStart("system:playback_");

  3429. 

  3430.                         if (pData->graph.getNumAudioOuts() < 3)

  3431.                         {

  3432.                             /**/ if (internalPort == "1")

  3433.                                 internalPort = "Audio Output:Left";

  3434.                             else if (internalPort == "2")

  3435.                                 internalPort = "Audio Output:Right";

  3436.                             else

  3437.                                 continue;

  3438.                         }

  3439.                         else

  3440.                         {

  3441.                             internalPort = "Audio Input:Playback " + internalPort;

  3442.                         }

  3443. 

  3444.                         carla_stdout("Converted port name '%s' to '%s' for this session",

  3445.                                      targetPort.toRawUTF8(), internalPort.toRawUTF8());

  3446.                         targetPort = internalPort;

  3447.                     }

  3448.                     else if (!isExternal && isMultiClient && targetPort.startsWith("Audio Output:"))

  3449.                     {

  3450.                         water::String externalPort = targetPort.trimCharactersAtStart("Audio Output:");

  3451. 

  3452.                         /**/ if (externalPort == "Left")

  3453.                             externalPort = "system:playback_1";

  3454.                         else if (externalPort == "Right")

  3455.                             externalPort = "system:playback_2";

  3456.                         else

  3457.                             externalPort = "system:playback_ " + externalPort.trimCharactersAtStart("Playback ");

  3458. 

  3459.                         carla_stdout("Converted port name '%s' to '%s' for this session",

  3460.                                      targetPort.toRawUTF8(), externalPort.toRawUTF8());

  3461.                         targetPort = externalPort;

  3462.                     }

  3463.                     else if ((it = map.find(targetPort.upToFirstOccurrenceOf(":", false, false))) != map.end())

  3464.                     {

  3465.                         targetPort = it->second + targetPort.fromFirstOccurrenceOf(":", true, false);

  3466.                     }

  3467. 

  3468.                     restorePatchbayConnection(loadingAsExternal, sourcePort.toRawUTF8(), targetPort.toRawUTF8());

  3469.                 }

  3470.             }

  3471.             break;

  3472.         }

  3473.     }

  3474. #endif

  3475. 

  3476.     if (pData->options.resetXruns)

  3477.         clearXruns();

  3478. 

  3479.     callback(true, true, ENGINE_CALLBACK_PROJECT_LOAD_FINISHED, 0, 0, 0, 0, 0.0f, nullptr);

  3480.     callback(true, true, ENGINE_CALLBACK_CANCELABLE_ACTION, 0, 0, 0, 0, 0.0f, "Loading project");

  3481. 

  3482.     carla_debug("CarlaEngine::loadProjectInternal(%p, %s) - END", &xmlDoc, bool2str(alwaysLoadConnections));

  3483.     return true;

  3484. 

  3485. #ifdef BUILD_BRIDGE_ALTERNATIVE_ARCH

  3486.     // unused

  3487.     (void)alwaysLoadConnections;

  3488. #endif

  3489. }

  3490. 

  3491. // -----------------------------------------------------------------------

  3492. 

  3493. CARLA_BACKEND_END_NAMESPACE