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.
6169 Commits
16 Branches
14GB
Tree: eab801201f
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'eab801201f'
${ noResults }
Carla/source/backend/engine/CarlaEngine.cpp

3471 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.     if (jackbridge_is_ok())

  99.         count += 1;

  100. 

  101. #ifndef BUILD_BRIDGE

  102. # ifdef USING_JUCE_AUDIO_DEVICES

  103.     count += getJuceApiCount();

  104. # else

  105.     count += getRtAudioApiCount();

  106. # endif

  107. #endif

  108. 

  109.     return count;

  110. }

  111. 

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

  113. {

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

  115.     using namespace EngineInit;

  116. 

  117.     uint index = index2;

  118. 

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

  120.         return "JACK";

  121. 

  122. #ifndef BUILD_BRIDGE

  123. # ifdef USING_JUCE_AUDIO_DEVICES

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

  125.     {

  126.         if (index < count)

  127.             return getJuceApiName(index);

  128.         index -= count;

  129.     }

  130. # else

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

  132.     {

  133.         if (index < count)

  134.             return getRtAudioApiName(index);

  135.     }

  136. # endif

  137. #endif

  138. 

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

  140.     return nullptr;

  141. }

  142. 

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

  144. {

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

  146.     using namespace EngineInit;

  147. 

  148.     uint index = index2;

  149. 

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

  151.     {

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

  153.         return ret;

  154.     }

  155. 

  156. #ifndef BUILD_BRIDGE

  157. # ifdef USING_JUCE_AUDIO_DEVICES

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

  159.     {

  160.         if (index < count)

  161.             return getJuceApiDeviceNames(index);

  162.         index -= count;

  163.     }

  164. # else

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

  166.     {

  167.         if (index < count)

  168.             return getRtAudioApiDeviceNames(index);

  169.     }

  170. # endif

  171. #endif

  172. 

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

  174.     return nullptr;

  175. }

  176. 

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

  178. {

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

  180.     using namespace EngineInit;

  181. 

  182.     uint index = index2;

  183. 

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

  185.     {

  186.         static EngineDriverDeviceInfo devInfo;

  187.         devInfo.hints       = ENGINE_DRIVER_DEVICE_VARIABLE_BUFFER_SIZE;

  188.         devInfo.bufferSizes = nullptr;

  189.         devInfo.sampleRates = nullptr;

  190.         return &devInfo;

  191.     }

  192. 

  193. #ifndef BUILD_BRIDGE

  194. # ifdef USING_JUCE_AUDIO_DEVICES

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

  196.     {

  197.         if (index < count)

  198.             return getJuceDeviceInfo(index, deviceName);

  199.         index -= count;

  200.     }

  201. # else

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

  203.     {

  204.         if (index < count)

  205.             return getRtAudioDeviceInfo(index, deviceName);

  206.     }

  207. # endif

  208. #endif

  209. 

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

  211.     return nullptr;

  212. }

  213. 

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

  215. {

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

  217.     using namespace EngineInit;

  218. 

  219.     uint index = index2;

  220. 

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

  222.     {

  223.         return false;

  224.     }

  225. 

  226. #ifndef BUILD_BRIDGE

  227. # ifdef USING_JUCE_AUDIO_DEVICES

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

  229.     {

  230.         if (index < count)

  231.             return showJuceDeviceControlPanel(index, deviceName);

  232.         index -= count;

  233.     }

  234. # else

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

  236.     {

  237.         if (index < count)

  238.             return false;

  239.     }

  240. # endif

  241. #endif

  242. 

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

  244.     return false;

  245. }

  246. 

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

  248. {

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

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

  251.     using namespace EngineInit;

  252. 

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

  254.         return newJack();

  255. 

  256. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  258.         return newDummy();

  259. #endif

  260. 

  261. #ifndef BUILD_BRIDGE

  262. # ifdef USING_JUCE_AUDIO_DEVICES

  263.     // -------------------------------------------------------------------

  264.     // linux

  265. 

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

  267.         return newJuce(AUDIO_API_ALSA);

  268. 

  269.     // -------------------------------------------------------------------

  270.     // macos

  271. 

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

  273.         return newJuce(AUDIO_API_COREAUDIO);

  274. 

  275.     // -------------------------------------------------------------------

  276.     // windows

  277. 

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

  279.         return newJuce(AUDIO_API_ASIO);

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

  281.         return newJuce(AUDIO_API_DIRECTSOUND);

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

  283.         return newJuce(AUDIO_API_WASAPI);

  284. # else

  285.     // -------------------------------------------------------------------

  286.     // common

  287. 

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

  289.         return newRtAudio(AUDIO_API_JACK);

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

  291.         return newRtAudio(AUDIO_API_OSS);

  292. 

  293.     // -------------------------------------------------------------------

  294.     // linux

  295. 

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

  297.         return newRtAudio(AUDIO_API_ALSA);

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

  299.         return newRtAudio(AUDIO_API_PULSEAUDIO);

  300. 

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

  302.     // macos

  303. 

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

  305.         return newRtAudio(AUDIO_API_COREAUDIO);

  306. 

  307.     // -------------------------------------------------------------------

  308.     // windows

  309. 

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

  311.         return newRtAudio(AUDIO_API_ASIO);

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

  313.         return newRtAudio(AUDIO_API_DIRECTSOUND);

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

  315.         return newRtAudio(AUDIO_API_WASAPI);

  316. # endif

  317. #endif

  318. 

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

  320.     return nullptr;

  321. }

  322. 

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

  324. // Constant values

  325. 

  326. uint CarlaEngine::getMaxClientNameSize() const noexcept

  327. {

  328.     return STR_MAX/2;

  329. }

  330. 

  331. uint CarlaEngine::getMaxPortNameSize() const noexcept

  332. {

  333.     return STR_MAX;

  334. }

  335. 

  336. uint CarlaEngine::getCurrentPluginCount() const noexcept

  337. {

  338.     return pData->curPluginCount;

  339. }

  340. 

  341. uint CarlaEngine::getMaxPluginNumber() const noexcept

  342. {

  343.     return pData->maxPluginNumber;

  344. }

  345. 

  346. // -----------------------------------------------------------------------

  347. // Virtual, per-engine type calls

  348. 

  349. bool CarlaEngine::close()

  350. {

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

  352. 

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

  354.     {

  355.         pData->aboutToClose = true;

  356.         removeAllPlugins();

  357.     }

  358. 

  359.     pData->close();

  360. 

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

  362.     return true;

  363. }

  364. 

  365. bool CarlaEngine::usesConstantBufferSize() const noexcept

  366. {

  367.     return true;

  368. }

  369. 

  370. void CarlaEngine::idle() noexcept

  371. {

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

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

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

  375. 

  376.     const bool engineNotRunning = !isRunning();

  377. 

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

  379.     {

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

  381.         {

  382.             if (plugin->isEnabled())

  383.             {

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

  385. 

  386.                 if (engineNotRunning)

  387.                 {

  388.                     try {

  389.                         plugin->idle();

  390.                     } CARLA_SAFE_EXCEPTION_CONTINUE("Plugin idle");

  391. 

  392.                     if (hints & PLUGIN_HAS_CUSTOM_UI)

  393.                     {

  394.                         try {

  395.                             plugin->uiIdle();

  396.                         } CARLA_SAFE_EXCEPTION_CONTINUE("Plugin uiIdle");

  397.                     }

  398.                 }

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

  400.                 {

  401.                     try {

  402.                         plugin->uiIdle();

  403.                     } CARLA_SAFE_EXCEPTION_CONTINUE("Plugin uiIdle");

  404.                 }

  405.             }

  406.         }

  407.     }

  408. 

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

  410.     pData->osc.idle();

  411. #endif

  412. 

  413.     pData->deletePluginsAsNeeded();

  414. }

  415. 

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

  417. {

  418. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  420. #else

  421.     return new CarlaEngineClientForBridge(*this);

  422. 

  423.     // unused

  424.     (void)plugin;

  425. #endif

  426. }

  427. 

  428. float CarlaEngine::getDSPLoad() const noexcept

  429. {

  430. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  431.     return pData->dspLoad;

  432. #else

  433.     return 0.0f;

  434. #endif

  435. }

  436. 

  437. uint32_t CarlaEngine::getTotalXruns() const noexcept

  438. {

  439. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  440.     return pData->xruns;

  441. #else

  442.     return 0;

  443. #endif

  444. }

  445. 

  446. void CarlaEngine::clearXruns() const noexcept

  447. {

  448. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  449.     pData->xruns = 0;

  450. #endif

  451. }

  452. 

  453. bool CarlaEngine::showDeviceControlPanel() const noexcept

  454. {

  455.     return false;

  456. }

  457. 

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

  459. {

  460.     return false;

  461. }

  462. 

  463. // -----------------------------------------------------------------------

  464. // Plugin management

  465. 

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

  467.                             const PluginType ptype,

  468.                             const char* const filename,

  469.                             const char* const name,

  470.                             const char* const label,

  471.                             const int64_t uniqueId,

  472.                             const void* const extra,

  473.                             const uint options)

  474. {

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

  476. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

  479. #endif

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

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

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

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

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

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

  486. 

  487. #ifndef CARLA_OS_WIN

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

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

  490.     }

  491. #endif

  492. 

  493.     uint id;

  494. 

  495. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  496.     CarlaPluginPtr oldPlugin;

  497. 

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

  499.     {

  500.         id = pData->nextPluginId;

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

  502. 

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

  504. 

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

  506.     }

  507.     else

  508. #endif

  509.     {

  510.         id = pData->curPluginCount;

  511. 

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

  513.         {

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

  515.             return false;

  516.         }

  517. 

  518. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  520. #endif

  521.     }

  522. 

  523.     CarlaPlugin::Initializer initializer = {

  524.         this,

  525.         id,

  526.         filename,

  527.         name,

  528.         label,

  529.         uniqueId,

  530.         options

  531.     };

  532. 

  533.     CarlaPluginPtr plugin;

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

  535. 

  536.     if (bridgeBinary.isNotEmpty())

  537.     {

  538. #ifndef CARLA_OS_WIN

  539.         if (btype == BINARY_NATIVE)

  540.         {

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

  542.         }

  543.         else

  544. #endif

  545.         {

  546.             switch (btype)

  547.             {

  548.             case BINARY_POSIX32:

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

  550.                 break;

  551.             case BINARY_POSIX64:

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

  553.                 break;

  554.             case BINARY_WIN32:

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

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

  557. #else

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

  559. #endif

  560.                 break;

  561.             case BINARY_WIN64:

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

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

  564. #else

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

  566. #endif

  567.                 break;

  568.             default:

  569.                 bridgeBinary.clear();

  570.                 break;

  571.             }

  572.         }

  573. 

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

  575.             bridgeBinary.clear();

  576.     }

  577. 

  578.     const bool canBeBridged = ptype != PLUGIN_INTERNAL

  579.                            && ptype != PLUGIN_DLS

  580.                            && ptype != PLUGIN_GIG

  581.                            && ptype != PLUGIN_SF2

  582.                            && ptype != PLUGIN_SFZ

  583.                            && ptype != PLUGIN_JACK;

  584. 

  585.     // Prefer bridges for some specific plugins

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

  587.     const char* needsArchBridge = nullptr;

  588. 

  589. #ifdef CARLA_OS_MAC

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

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

  592.         removeFileFromQuarantine(filename);

  593. #endif

  594. 

  595. #ifndef BUILD_BRIDGE

  596.     if (canBeBridged && ! preferBridges)

  597.     {

  598. # if 0

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

  600.         {

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

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

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

  604.             {

  605.                 preferBridges = true;

  606.             }

  607.         }

  608. # endif

  609. # ifdef ADAPT_FOR_APPLE_SILLICON

  610.         // see if this binary needs bridging

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

  612.         {

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

  614.             {

  615.                 const CarlaMagic magic;

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

  617.                 {

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

  619. #  ifdef __aarch64__

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

  621.                         needsArchBridge = "x86_64";

  622. #  else

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

  624.                         needsArchBridge = "arm64";

  625. #  endif

  626.                 }

  627.                 else

  628.                 {

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

  630.                 }

  631.             }

  632.             else

  633.             {

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

  635.             }

  636.         }

  637. # endif

  638.     }

  639. #endif // ! BUILD_BRIDGE

  640. 

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

  642.     {

  643.         if (bridgeBinary.isNotEmpty())

  644.         {

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

  646.         }

  647.         else

  648.         {

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

  650.             return false;

  651.         }

  652.     }

  653.     else

  654.     {

  655. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  656.         bool use16Outs;

  657. #endif

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

  659. 

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

  661.         const CarlaSignalRestorer csr;

  662. 

  663.         switch (ptype)

  664.         {

  665.         case PLUGIN_NONE:

  666.             break;

  667. 

  668.         case PLUGIN_LADSPA:

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

  670.             break;

  671. 

  672.         case PLUGIN_DSSI:

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

  674.             break;

  675. 

  676.         case PLUGIN_LV2:

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

  678.             break;

  679. 

  680.         case PLUGIN_VST2:

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

  682.             break;

  683. 

  684.         case PLUGIN_VST3:

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

  686.             break;

  687. 

  688.         case PLUGIN_AU:

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

  690.             break;

  691. 

  692. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  693.         case PLUGIN_INTERNAL:

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

  695.             break;

  696. 

  697.         case PLUGIN_DLS:

  698.         case PLUGIN_GIG:

  699.         case PLUGIN_SF2:

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

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

  702.             break;

  703. 

  704.         case PLUGIN_SFZ:

  705. # ifdef SFZ_FILES_USING_SFIZZ

  706.             {

  707.                 CarlaPlugin::Initializer sfizzInitializer = {

  708.                     this,

  709.                     id,

  710.                     name,

  711.                     "",

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

  713.                     0,

  714.                     options

  715.                 };

  716. 

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

  718.             }

  719. # else

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

  721. # endif

  722.             break;

  723. 

  724.         case PLUGIN_JACK:

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

  726.             break;

  727. #else

  728.         case PLUGIN_INTERNAL:

  729.         case PLUGIN_DLS:

  730.         case PLUGIN_GIG:

  731.         case PLUGIN_SF2:

  732.         case PLUGIN_SFZ:

  733.         case PLUGIN_JACK:

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

  735.             break;

  736. #endif

  737.         }

  738.     }

  739. 

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

  741.         return false;

  742. 

  743.     plugin->reload();

  744. 

  745. #ifdef SFZ_FILES_USING_SFIZZ

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

  747.     {

  748.         plugin->setCustomData(LV2_ATOM__Path,

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

  750.                               filename,

  751.                               false);

  752. 

  753.         plugin->restoreLV2State(true);

  754.     }

  755. #endif

  756. 

  757.     bool canRun = true;

  758. 

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

  760.     {

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

  762.         {

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

  764.             canRun = false;

  765.         }

  766.     }

  767. 

  768.     if (! canRun)

  769.     {

  770.         return false;

  771.     }

  772. 

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

  774.     pluginData.plugin = plugin;

  775.     carla_zeroFloats(pluginData.peaks, 4);

  776. 

  777. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  779.     {

  780.         CARLA_SAFE_ASSERT(! pData->loadingProject);

  781. 

  782.         const ScopedThreadStopper sts(this);

  783. 

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

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

  786. 

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

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

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

  790. 

  791.         oldPlugin->prepareForDeletion();

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

  793. 

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

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

  796. 

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

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

  799. 

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

  801.         plugin->setEnabled(true);

  802. 

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

  804.     }

  805.     else if (! pData->loadingProject)

  806. #endif

  807.     {

  808.         plugin->setEnabled(true);

  809. 

  810.         ++pData->curPluginCount;

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

  812. 

  813.         if (getType() != kEngineTypeBridge)

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

  815. 

  816. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

  819. #endif

  820.     }

  821. 

  822.     return true;

  823. }

  824. 

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

  826.                             const char* const filename,

  827.                             const char* const name,

  828.                             const char* const label,

  829.                             const int64_t uniqueId,

  830.                             const void* const extra)

  831. {

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

  833. }

  834. 

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

  836. {

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

  838. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

  841. #else

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

  843. #endif

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

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

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

  847. 

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

  849. 

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

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

  852. 

  853.     const ScopedThreadStopper sts(this);

  854. 

  855. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

  858. 

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

  860. 

  861.     /*

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

  863.     {

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

  865.         CARLA_SAFE_ASSERT_BREAK(plugin2 != nullptr);

  866.         plugin2->updateOscURL();

  867.     }

  868.     */

  869. #else

  870.     pData->curPluginCount = 0;

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

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

  873. #endif

  874. 

  875.     plugin->prepareForDeletion();

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

  877. 

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

  879.     return true;

  880. }

  881. 

  882. bool CarlaEngine::removeAllPlugins()

  883. {

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

  885. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

  888. #endif

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

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

  891. 

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

  893.         return true;

  894. 

  895.     const ScopedThreadStopper sts(this);

  896. 

  897.     const uint curPluginCount = pData->curPluginCount;

  898. 

  899. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  901.         pData->graph.removeAllPlugins();

  902. #endif

  903. 

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

  905. 

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

  907. 

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

  909.     {

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

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

  912. 

  913.         pluginData.plugin->prepareForDeletion();

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

  915. 

  916.         pluginData.plugin.reset();

  917.         carla_zeroStruct(pluginData.peaks);

  918. 

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

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

  921.     }

  922. 

  923.     return true;

  924. }

  925. 

  926. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  928. {

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

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

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

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

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

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

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

  936. 

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

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

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

  940. 

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

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

  943. 

  944.     plugin->setName(uniqueName);

  945. 

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

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

  948. 

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

  950. 

  951.     delete[] uniqueName;

  952.     return true;

  953. }

  954. 

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

  956. {

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

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

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

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

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

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

  963. 

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

  965. 

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

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

  968. 

  969.     char label[STR_MAX+1];

  970.     carla_zeroChars(label, STR_MAX+1);

  971. 

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

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

  974. 

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

  976. 

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

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

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

  980.         return false;

  981. 

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

  983. 

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

  985.     {

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

  987.             newPlugin->cloneLV2Files(*plugin);

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

  989.     }

  990. 

  991.     return true;

  992. }

  993. 

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

  995. {

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

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

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

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

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

  1001. 

  1002.     // might use this to reset

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

  1004.     {

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

  1006.         return true;

  1007.     }

  1008. 

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

  1010. 

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

  1012. 

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

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

  1015. 

  1016.     pData->nextPluginId = id;

  1017. 

  1018.     return true;

  1019. }

  1020. 

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

  1022. {

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

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

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

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

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

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

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

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

  1031. 

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

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

  1034. 

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

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

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

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

  1039. 

  1040.     const ScopedThreadStopper sts(this);

  1041. 

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

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

  1044. 

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

  1046. 

  1047.     // TODO

  1048.     /*

  1049.     pluginA->updateOscURL();

  1050.     pluginB->updateOscURL();

  1051. 

  1052.     if (isOscControlRegistered())

  1053.         oscSend_control_switch_plugins(idA, idB);

  1054.     */

  1055. 

  1056.     return true;

  1057. }

  1058. #endif

  1059. 

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

  1061. {

  1062. }

  1063. 

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

  1065. {

  1066. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

  1069. #endif

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

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

  1072. 

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

  1074. }

  1075. 

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

  1077. {

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

  1079. }

  1080. 

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

  1082. {

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

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

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

  1086. 

  1087.     CarlaString sname;

  1088.     sname = name;

  1089. 

  1090.     if (sname.isEmpty())

  1091.     {

  1092.         sname = "(No name)";

  1093.         return sname.dup();

  1094.     }

  1095. 

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

  1097. 

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

  1099.         return sname.dup();

  1100. 

  1101.     sname.truncate(maxNameSize);

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

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

  1104. 

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

  1106.     {

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

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

  1109. 

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

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

  1112.         {

  1113.             if (sname != pluginName)

  1114.                 continue;

  1115.         }

  1116. 

  1117.         // Check if string has already been modified

  1118.         {

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

  1120. 

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

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

  1123.             {

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

  1125. 

  1126.                 if (number == 9)

  1127.                 {

  1128.                     // next number is 10, 2 digits

  1129.                     sname.truncate(len-4);

  1130.                     sname += " (10)";

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

  1132.                 }

  1133.                 else

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

  1135. 

  1136.                 continue;

  1137.             }

  1138. 

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

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

  1141.             {

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

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

  1144. 

  1145.                 if (n2 == '9')

  1146.                 {

  1147.                     n2 = '0';

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

  1149.                 }

  1150.                 else

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

  1152. 

  1153.                 sname[len-2] = n2;

  1154.                 sname[len-3] = n3;

  1155. 

  1156.                 continue;

  1157.             }

  1158.         }

  1159. 

  1160.         // Modify string if not

  1161.         sname += " (2)";

  1162.     }

  1163. 

  1164.     return sname.dup();

  1165. }

  1166. 

  1167. // -----------------------------------------------------------------------

  1168. // Project management

  1169. 

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

  1171. {

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

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

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

  1175. 

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

  1177.     File file(jfilename);

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

  1179. 

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

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

  1182. 

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

  1184. 

  1185.     // -------------------------------------------------------------------

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

  1187. 

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

  1189.         return loadProject(filename, false);

  1190. 

  1191.     // -------------------------------------------------------------------

  1192. 

  1193.     if (extension == "dls")

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

  1195. 

  1196.     if (extension == "gig")

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

  1198. 

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

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

  1201. 

  1202.     if (extension == "sfz")

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

  1204. 

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

  1206. 

  1207.     if (

  1208.         extension == "mp3"  ||

  1209. #ifdef HAVE_SNDFILE

  1210.         extension == "aif"  ||

  1211.         extension == "aifc" ||

  1212.         extension == "aiff" ||

  1213.         extension == "au"   ||

  1214.         extension == "bwf"  ||

  1215.         extension == "flac" ||

  1216.         extension == "htk"  ||

  1217.         extension == "iff"  ||

  1218.         extension == "mat4" ||

  1219.         extension == "mat5" ||

  1220.         extension == "oga"  ||

  1221.         extension == "ogg"  ||

  1222.         extension == "opus" ||

  1223.         extension == "paf"  ||

  1224.         extension == "pvf"  ||

  1225.         extension == "pvf5" ||

  1226.         extension == "sd2"  ||

  1227.         extension == "sf"   ||

  1228.         extension == "snd"  ||

  1229.         extension == "svx"  ||

  1230.         extension == "vcc"  ||

  1231.         extension == "w64"  ||

  1232.         extension == "wav"  ||

  1233.         extension == "xi"   ||

  1234. #endif

  1235. #ifdef HAVE_FFMPEG

  1236.         extension == "3g2" ||

  1237.         extension == "3gp" ||

  1238.         extension == "aac" ||

  1239.         extension == "ac3" ||

  1240.         extension == "amr" ||

  1241.         extension == "ape" ||

  1242.         extension == "mp2" ||

  1243.         extension == "mpc" ||

  1244.         extension == "wma" ||

  1245. # ifndef HAVE_SNDFILE

  1246.         // FFmpeg without sndfile

  1247.         extension == "flac" ||

  1248.         extension == "oga"  ||

  1249.         extension == "ogg"  ||

  1250.         extension == "w64"  ||

  1251.         extension == "wav"  ||

  1252. # endif

  1253. #endif

  1254.         false

  1255.        )

  1256.     {

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

  1258.         {

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

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

  1261.             return true;

  1262.         }

  1263.         return false;

  1264.     }

  1265. 

  1266.     // -------------------------------------------------------------------

  1267. 

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

  1269.     {

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

  1271.         {

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

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

  1274.             return true;

  1275.         }

  1276.         return false;

  1277.     }

  1278. 

  1279.     // -------------------------------------------------------------------

  1280.     // ZynAddSubFX

  1281. 

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

  1283.     {

  1284. #ifdef HAVE_ZYN_DEPS

  1285.         CarlaString nicerName("Zyn - ");

  1286. 

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

  1288. 

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

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

  1291.         else

  1292.             nicerName += baseName;

  1293. 

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

  1295.         {

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

  1297. 

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

  1299.             {

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

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

  1302.             }

  1303. 

  1304.             return true;

  1305.         }

  1306.         return false;

  1307. #else

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

  1309.         return false;

  1310. #endif

  1311.     }

  1312. 

  1313.     // -------------------------------------------------------------------

  1314.     // Direct plugin binaries

  1315. 

  1316. #ifdef CARLA_OS_MAC

  1317.     if (extension == "vst")

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

  1319. #else

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

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

  1322. #endif

  1323. 

  1324. #ifdef USING_JUCE

  1325.     if (extension == "vst3")

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

  1327. #endif

  1328. 

  1329.     // -------------------------------------------------------------------

  1330. 

  1331.     setLastError("Unknown file extension");

  1332.     return false;

  1333. }

  1334. 

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

  1336. {

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

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

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

  1340. 

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

  1342.     const File file(jfilename);

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

  1344. 

  1345.     if (setAsCurrentProject)

  1346.     {

  1347. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  1349.         {

  1350.             pData->currentProjectFilename = filename;

  1351. 

  1352.             bool found;

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

  1354. 

  1355.             if (found)

  1356.             {

  1357.                 pData->currentProjectFolder = filename;

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

  1359.             }

  1360.             else

  1361.             {

  1362.                 pData->currentProjectFolder.clear();

  1363.             }

  1364.         }

  1365. #endif

  1366.     }

  1367. 

  1368.     XmlDocument xml(file);

  1369.     return loadProjectInternal(xml, !setAsCurrentProject);

  1370. }

  1371. 

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

  1373. {

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

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

  1376. 

  1377.     if (setAsCurrentProject)

  1378.     {

  1379. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  1381.         {

  1382.             pData->currentProjectFilename = filename;

  1383. 

  1384.             bool found;

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

  1386. 

  1387.             if (found)

  1388.             {

  1389.                 pData->currentProjectFolder = filename;

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

  1391.             }

  1392.             else

  1393.             {

  1394.                 pData->currentProjectFolder.clear();

  1395.             }

  1396.         }

  1397. #endif

  1398.     }

  1399. 

  1400.     MemoryOutputStream out;

  1401.     saveProjectInternal(out);

  1402. 

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

  1404.     File file(jfilename);

  1405. 

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

  1407.         return true;

  1408. 

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

  1410.     return false;

  1411. }

  1412. 

  1413. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  1415. {

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

  1417.                                                     : nullptr;

  1418. }

  1419. 

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

  1421. {

  1422.     return pData->currentProjectFilename;

  1423. }

  1424. 

  1425. void CarlaEngine::clearCurrentProjectFilename() noexcept

  1426. {

  1427.     pData->currentProjectFilename.clear();

  1428.     pData->currentProjectFolder.clear();

  1429. }

  1430. #endif

  1431. 

  1432. // -----------------------------------------------------------------------

  1433. // Information (base)

  1434. 

  1435. uint32_t CarlaEngine::getBufferSize() const noexcept

  1436. {

  1437.     return pData->bufferSize;

  1438. }

  1439. 

  1440. double CarlaEngine::getSampleRate() const noexcept

  1441. {

  1442.     return pData->sampleRate;

  1443. }

  1444. 

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

  1446. {

  1447.     return pData->name;

  1448. }

  1449. 

  1450. EngineProcessMode CarlaEngine::getProccessMode() const noexcept

  1451. {

  1452.     return pData->options.processMode;

  1453. }

  1454. 

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

  1456. {

  1457.     return pData->options;

  1458. }

  1459. 

  1460. EngineTimeInfo CarlaEngine::getTimeInfo() const noexcept

  1461. {

  1462.     return pData->timeInfo;

  1463. }

  1464. 

  1465. // -----------------------------------------------------------------------

  1466. // Information (peaks)

  1467. 

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

  1469. {

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

  1471. 

  1472.     if (pluginId == MAIN_CARLA_PLUGIN_ID)

  1473.     {

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

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

  1476.         {

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

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

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

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

  1481.         }

  1482.         else

  1483.         {

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

  1485.         }

  1486. 

  1487.         return pData->peaks;

  1488.     }

  1489. 

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

  1491. 

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

  1493. }

  1494. 

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

  1496. {

  1497.     if (pluginId == MAIN_CARLA_PLUGIN_ID)

  1498.     {

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

  1500.         if (pData->curPluginCount > 0)

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

  1502.         return 0.0f;

  1503.     }

  1504. 

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

  1506. 

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

  1508. }

  1509. 

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

  1511. {

  1512.     if (pluginId == MAIN_CARLA_PLUGIN_ID)

  1513.     {

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

  1515.         if (pData->curPluginCount > 0)

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

  1517.         return 0.0f;

  1518.     }

  1519. 

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

  1521. 

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

  1523. }

  1524. 

  1525. // -----------------------------------------------------------------------

  1526. // Callback

  1527. 

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

  1529.                            const EngineCallbackOpcode action, const uint pluginId,

  1530.                            const int value1, const int value2, const int value3,

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

  1532. {

  1533. #ifdef DEBUG

  1534.     if (pData->isIdling)

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

  1536.                      bool2str(sendHost), bool2str(sendOSC),

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

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

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

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

  1541.                     bool2str(sendHost), bool2str(sendOSC),

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

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

  1544. #endif

  1545. 

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

  1547.     {

  1548.         if (action == ENGINE_CALLBACK_IDLE)

  1549.             ++pData->isIdling;

  1550. 

  1551.         try {

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

  1553.         } CARLA_SAFE_EXCEPTION("callback")

  1554. 

  1555.         if (action == ENGINE_CALLBACK_IDLE)

  1556.             --pData->isIdling;

  1557.     }

  1558. 

  1559.     if (sendOSC)

  1560.     {

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

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

  1563.         {

  1564.             switch (action)

  1565.             {

  1566.             case ENGINE_CALLBACK_RELOAD_INFO:

  1567.             {

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

  1569.                 CARLA_SAFE_ASSERT_BREAK(plugin != nullptr);

  1570. 

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

  1572.                 break;

  1573.             }

  1574. 

  1575.             case ENGINE_CALLBACK_RELOAD_PARAMETERS:

  1576.             {

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

  1578.                 CARLA_SAFE_ASSERT_BREAK(plugin != nullptr);

  1579. 

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

  1581. 

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

  1583.                 {

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

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

  1586.                 }

  1587.                 break;

  1588.             }

  1589. 

  1590.             case ENGINE_CALLBACK_RELOAD_PROGRAMS:

  1591.             {

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

  1593.                 CARLA_SAFE_ASSERT_BREAK(plugin != nullptr);

  1594. 

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

  1596. 

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

  1598.                 {

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

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

  1601.                 }

  1602. 

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

  1604.                 {

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

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

  1607.                 }

  1608.                 break;

  1609.             }

  1610. 

  1611.             case ENGINE_CALLBACK_PLUGIN_ADDED:

  1612.             case ENGINE_CALLBACK_RELOAD_ALL:

  1613.             {

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

  1615.                 CARLA_SAFE_ASSERT_BREAK(plugin != nullptr);

  1616. 

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

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

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

  1620. 

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

  1622.                 {

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

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

  1625.                 }

  1626. 

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

  1628.                 {

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

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

  1631.                 }

  1632. 

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

  1634.                 {

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

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

  1637.                 }

  1638. 

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

  1640.                 {

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

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

  1643.                 }

  1644. 

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

  1646.                 break;

  1647.             }

  1648. 

  1649.             case ENGINE_CALLBACK_IDLE:

  1650.                 return;

  1651. 

  1652.             default:

  1653.                 break;

  1654.             }

  1655. 

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

  1657.         }

  1658. #endif

  1659.     }

  1660. }

  1661. 

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

  1663. {

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

  1665. 

  1666.     pData->callback    = func;

  1667.     pData->callbackPtr = ptr;

  1668. }

  1669. 

  1670. // -----------------------------------------------------------------------

  1671. // File Callback

  1672. 

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

  1674. {

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

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

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

  1678. 

  1679.     const char* ret = nullptr;

  1680. 

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

  1682.     {

  1683.         try {

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

  1685.         } CARLA_SAFE_EXCEPTION("runFileCallback");

  1686.     }

  1687. 

  1688.     return ret;

  1689. }

  1690. 

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

  1692. {

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

  1694. 

  1695.     pData->fileCallback    = func;

  1696.     pData->fileCallbackPtr = ptr;

  1697. }

  1698. 

  1699. // -----------------------------------------------------------------------

  1700. // Transport

  1701. 

  1702. void CarlaEngine::transportPlay() noexcept

  1703. {

  1704.     pData->timeInfo.playing = true;

  1705.     pData->time.setNeedsReset();

  1706. }

  1707. 

  1708. void CarlaEngine::transportPause() noexcept

  1709. {

  1710.     if (pData->timeInfo.playing)

  1711.         pData->time.pause();

  1712.     else

  1713.         pData->time.setNeedsReset();

  1714. }

  1715. 

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

  1717. {

  1718.     CARLA_SAFE_ASSERT_RETURN(bpm >= 20.0,)

  1719. 

  1720.     try {

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

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

  1723. }

  1724. 

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

  1726. {

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

  1728. }

  1729. 

  1730. // -----------------------------------------------------------------------

  1731. // Error handling

  1732. 

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

  1734. {

  1735.     return pData->lastError;

  1736. }

  1737. 

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

  1739. {

  1740.     pData->lastError = error;

  1741. }

  1742. 

  1743. // -----------------------------------------------------------------------

  1744. // Misc

  1745. 

  1746. bool CarlaEngine::isAboutToClose() const noexcept

  1747. {

  1748.     return pData->aboutToClose;

  1749. }

  1750. 

  1751. bool CarlaEngine::setAboutToClose() noexcept

  1752. {

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

  1754. 

  1755.     pData->aboutToClose = true;

  1756. 

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

  1758. }

  1759. 

  1760. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1761. bool CarlaEngine::isLoadingProject() const noexcept

  1762. {

  1763.     return pData->loadingProject;

  1764. }

  1765. #endif

  1766. 

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

  1768. {

  1769.     pData->actionCanceled = canceled;

  1770. }

  1771. 

  1772. bool CarlaEngine::wasActionCanceled() const noexcept

  1773. {

  1774.     return pData->actionCanceled;

  1775. }

  1776. 

  1777. // -----------------------------------------------------------------------

  1778. // Global options

  1779. 

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

  1781. {

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

  1783. 

  1784.     if (isRunning())

  1785.     {

  1786.         switch (option)

  1787.         {

  1788.         case ENGINE_OPTION_PROCESS_MODE:

  1789.         case ENGINE_OPTION_AUDIO_TRIPLE_BUFFER:

  1790.         case ENGINE_OPTION_AUDIO_DRIVER:

  1791.         case ENGINE_OPTION_AUDIO_DEVICE:

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

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

  1794.         default:

  1795.             break;

  1796.         }

  1797.     }

  1798. 

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

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

  1801.         return;

  1802. 

  1803.     switch (option)

  1804.     {

  1805.     case ENGINE_OPTION_DEBUG:

  1806.         break;

  1807. 

  1808.     case ENGINE_OPTION_PROCESS_MODE:

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

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

  1811.         break;

  1812. 

  1813.     case ENGINE_OPTION_TRANSPORT_MODE:

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

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

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

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

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

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

  1820.         else

  1821.             pData->options.transportExtra = nullptr;

  1822. 

  1823.         pData->time.setNeedsReset();

  1824. 

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

  1826.         // enable link now if needed

  1827.         {

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

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

  1830.         }

  1831. #endif

  1832.         break;

  1833. 

  1834.     case ENGINE_OPTION_FORCE_STEREO:

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

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

  1837.         break;

  1838. 

  1839.     case ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

  1840. #ifdef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1841.         CARLA_SAFE_ASSERT_RETURN(value == 0,);

  1842. #else

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

  1844. #endif

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

  1846.         break;

  1847. 

  1848.     case ENGINE_OPTION_PREFER_UI_BRIDGES:

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

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

  1851.         break;

  1852. 

  1853.     case ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

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

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

  1856.         break;

  1857. 

  1858.     case ENGINE_OPTION_MAX_PARAMETERS:

  1859.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  1861.         break;

  1862. 

  1863.     case ENGINE_OPTION_RESET_XRUNS:

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

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

  1866.         break;

  1867. 

  1868.     case ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  1869.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  1871.         break;

  1872. 

  1873.     case ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  1874.         CARLA_SAFE_ASSERT_RETURN(value >= 8,);

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

  1876.         break;

  1877. 

  1878.     case ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  1879.         CARLA_SAFE_ASSERT_RETURN(value >= 22050,);

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

  1881.         break;

  1882. 

  1883.     case ENGINE_OPTION_AUDIO_TRIPLE_BUFFER:

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

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

  1886.         break;

  1887. 

  1888.     case ENGINE_OPTION_AUDIO_DRIVER:

  1889.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  1890. 

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

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

  1893. 

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

  1895.         break;

  1896. 

  1897.     case ENGINE_OPTION_AUDIO_DEVICE:

  1898.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  1899. 

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

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

  1902. 

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

  1904.         break;

  1905. 

  1906. #ifndef BUILD_BRIDGE

  1907.     case ENGINE_OPTION_OSC_ENABLED:

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

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

  1910.         break;

  1911. 

  1912.     case ENGINE_OPTION_OSC_PORT_TCP:

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

  1914.         pData->options.oscPortTCP = value;

  1915.         break;

  1916. 

  1917.     case ENGINE_OPTION_OSC_PORT_UDP:

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

  1919.         pData->options.oscPortUDP = value;

  1920.         break;

  1921. #endif

  1922. 

  1923.     case ENGINE_OPTION_FILE_PATH:

  1924.         CARLA_SAFE_ASSERT_RETURN(value > FILE_NONE,);

  1925.         CARLA_SAFE_ASSERT_RETURN(value <= FILE_MIDI,);

  1926. 

  1927.         switch (value)

  1928.         {

  1929.         case FILE_AUDIO:

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

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

  1932.             if (valueStr != nullptr)

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

  1934.             else

  1935.                 pData->options.pathAudio = nullptr;

  1936.             break;

  1937.         case FILE_MIDI:

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

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

  1940.             if (valueStr != nullptr)

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

  1942.             else

  1943.                 pData->options.pathMIDI = nullptr;

  1944.             break;

  1945.         default:

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

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

  1948.             break;

  1949.         }

  1950.         break;

  1951.     case ENGINE_OPTION_PLUGIN_PATH:

  1952.         CARLA_SAFE_ASSERT_RETURN(value > PLUGIN_NONE,);

  1953.         CARLA_SAFE_ASSERT_RETURN(value <= PLUGIN_SFZ,);

  1954. 

  1955.         switch (value)

  1956.         {

  1957.         case PLUGIN_LADSPA:

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

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

  1960.             if (valueStr != nullptr)

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

  1962.             else

  1963.                 pData->options.pathLADSPA = nullptr;

  1964.             break;

  1965.         case PLUGIN_DSSI:

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

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

  1968.             if (valueStr != nullptr)

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

  1970.             else

  1971.                 pData->options.pathDSSI = nullptr;

  1972.             break;

  1973.         case PLUGIN_LV2:

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

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

  1976.             if (valueStr != nullptr)

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

  1978.             else

  1979.                 pData->options.pathLV2 = nullptr;

  1980.             break;

  1981.         case PLUGIN_VST2:

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

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

  1984.             if (valueStr != nullptr)

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

  1986.             else

  1987.                 pData->options.pathVST2 = nullptr;

  1988.             break;

  1989.         case PLUGIN_VST3:

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

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

  1992.             if (valueStr != nullptr)

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

  1994.             else

  1995.                 pData->options.pathVST3 = nullptr;

  1996.             break;

  1997.         case PLUGIN_SF2:

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

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

  2000.             if (valueStr != nullptr)

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

  2002.             else

  2003.                 pData->options.pathSF2 = nullptr;

  2004.             break;

  2005.         case PLUGIN_SFZ:

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

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

  2008.             if (valueStr != nullptr)

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

  2010.             else

  2011.                 pData->options.pathSFZ = nullptr;

  2012.             break;

  2013.         default:

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

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

  2016.             break;

  2017.         }

  2018.         break;

  2019. 

  2020.     case ENGINE_OPTION_PATH_BINARIES:

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

  2022. 

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

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

  2025. 

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

  2027.         break;

  2028. 

  2029.     case ENGINE_OPTION_PATH_RESOURCES:

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

  2031. 

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

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

  2034. 

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

  2036.         break;

  2037. 

  2038.     case ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR: {

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

  2040. 

  2041. #ifdef CARLA_OS_LINUX

  2042.         const ScopedEngineEnvironmentLocker _seel(this);

  2043. 

  2044.         if (value != 0)

  2045.         {

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

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

  2048.         }

  2049.         else

  2050.         {

  2051.             ::unsetenv("LD_PRELOAD");

  2052.         }

  2053. #endif

  2054.     }   break;

  2055. 

  2056.     case ENGINE_OPTION_FRONTEND_BACKGROUND_COLOR:

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

  2058.         break;

  2059. 

  2060.     case ENGINE_OPTION_FRONTEND_FOREGROUND_COLOR:

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

  2062.         break;

  2063. 

  2064.     case ENGINE_OPTION_FRONTEND_UI_SCALE:

  2065.         CARLA_SAFE_ASSERT_RETURN(value > 0,);

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

  2067.         break;

  2068. 

  2069.     case ENGINE_OPTION_FRONTEND_WIN_ID: {

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

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

  2072.         CARLA_SAFE_ASSERT_RETURN(winId >= 0,);

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

  2074.     }   break;

  2075. 

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

  2077.     case ENGINE_OPTION_WINE_EXECUTABLE:

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

  2079. 

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

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

  2082. 

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

  2084.         break;

  2085. 

  2086.     case ENGINE_OPTION_WINE_AUTO_PREFIX:

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

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

  2089.         break;

  2090. 

  2091.     case ENGINE_OPTION_WINE_FALLBACK_PREFIX:

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

  2093. 

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

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

  2096. 

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

  2098.         break;

  2099. 

  2100.     case ENGINE_OPTION_WINE_RT_PRIO_ENABLED:

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

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

  2103.         break;

  2104. 

  2105.     case ENGINE_OPTION_WINE_BASE_RT_PRIO:

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

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

  2108.         break;

  2109. 

  2110.     case ENGINE_OPTION_WINE_SERVER_RT_PRIO:

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

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

  2113.         break;

  2114. #endif

  2115. 

  2116. #ifndef BUILD_BRIDGE

  2117.     case ENGINE_OPTION_DEBUG_CONSOLE_OUTPUT:

  2118.         break;

  2119. #endif

  2120. 

  2121.     case ENGINE_OPTION_CLIENT_NAME_PREFIX:

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

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

  2124. 

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

  2126.                                         ? carla_strdup_safe(valueStr)

  2127.                                         : nullptr;

  2128.         break;

  2129. 

  2130.     case ENGINE_OPTION_PLUGINS_ARE_STANDALONE:

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

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

  2133.         break;

  2134.     }

  2135. }

  2136. 

  2137. #ifndef BUILD_BRIDGE

  2138. // -----------------------------------------------------------------------

  2139. // OSC Stuff

  2140. 

  2141. bool CarlaEngine::isOscControlRegistered() const noexcept

  2142. {

  2143. # ifdef HAVE_LIBLO

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

  2145. # else

  2146.     return false;

  2147. # endif

  2148. }

  2149. 

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

  2151. {

  2152. # ifdef HAVE_LIBLO

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

  2154. # else

  2155.     return nullptr;

  2156. # endif

  2157. }

  2158. 

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

  2160. {

  2161. # ifdef HAVE_LIBLO

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

  2163. # else

  2164.     return nullptr;

  2165. # endif

  2166. }

  2167. #endif

  2168. 

  2169. // -----------------------------------------------------------------------

  2170. // Internal stuff

  2171. 

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

  2173. {

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

  2175. 

  2176. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

  2179.     {

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

  2181.     }

  2182. #endif

  2183. 

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

  2185. 

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

  2187.     {

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

  2189.         {

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

  2191.             {

  2192.                 plugin->bufferSizeChanged(newBufferSize);

  2193.                 plugin->unlock();

  2194.             }

  2195.         }

  2196.     }

  2197. 

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

  2199. }

  2200. 

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

  2202. {

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

  2204. 

  2205. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

  2208.     {

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

  2210.     }

  2211. #endif

  2212. 

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

  2214. 

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

  2216.     {

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

  2218.         {

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

  2220.             {

  2221.                 plugin->sampleRateChanged(newSampleRate);

  2222.                 plugin->unlock();

  2223.             }

  2224.         }

  2225.     }

  2226. 

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

  2228. }

  2229. 

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

  2231. {

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

  2233. 

  2234. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

  2237.     {

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

  2239.     }

  2240. #endif

  2241. 

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

  2243.     {

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

  2245.             if (plugin->isEnabled())

  2246.                 plugin->offlineModeChanged(isOfflineNow);

  2247.     }

  2248. }

  2249. 

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

  2251. {

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

  2253. 

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

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

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

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

  2258. }

  2259. 

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

  2261. {

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

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

  2264.     {

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

  2266.         {

  2267.             if (plugin->isEnabled())

  2268.             {

  2269. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

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

  2273. #endif

  2274.                 plugin->prepareForSave(false);

  2275.             }

  2276.         }

  2277.     }

  2278. 

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

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

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

  2282. 

  2283. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2284.     if (pData->ignoreClientPrefix)

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

  2286. #endif

  2287. 

  2288.     outStream << ">\n";

  2289. 

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

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

  2292. 

  2293.     {

  2294.         MemoryOutputStream outSettings(1024);

  2295. 

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

  2297. 

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

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

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

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

  2302. 

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

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

  2305. 

  2306.         if (isPlugin)

  2307.         {

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

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

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

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

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

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

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

  2315.         }

  2316. 

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

  2318.         outStream << outSettings;

  2319.     }

  2320. 

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

  2322.     {

  2323.         MemoryOutputStream outTransport(128);

  2324. 

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

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

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

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

  2329.         outStream << outTransport;

  2330.     }

  2331. 

  2332.     char strBuf[STR_MAX+1];

  2333.     carla_zeroChars(strBuf, STR_MAX+1);

  2334. 

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

  2336.     {

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

  2338.         {

  2339.             if (plugin->isEnabled())

  2340.             {

  2341.                 MemoryOutputStream outPlugin(4096), streamPlugin;

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

  2343. 

  2344.                 outPlugin << "\n";

  2345. 

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

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

  2348. 

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

  2350.                 outPlugin << streamPlugin;

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

  2352.                 outStream << outPlugin;

  2353.             }

  2354.         }

  2355.     }

  2356. 

  2357. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2358.     // tell bridges we're done saving

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

  2360.     {

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

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

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

  2364.     }

  2365. 

  2366.     // save internal connections

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

  2368.     {

  2369.         uint posCount = 0;

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

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

  2372. 

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

  2374.         {

  2375.             MemoryOutputStream outPatchbay(2048);

  2376. 

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

  2378. 

  2379.             if (patchbayConns != nullptr)

  2380.             {

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

  2382.                 {

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

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

  2385. 

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

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

  2388. 

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

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

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

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

  2393.                 }

  2394.             }

  2395. 

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

  2397.             {

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

  2399. 

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

  2401.                 {

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

  2403. 

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

  2405. 

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

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

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

  2409.                     if (ppos.pluginId >= 0)

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

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

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

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

  2414. 

  2415.                     if (ppos.dealloc)

  2416.                         delete[] ppos.name;

  2417.                 }

  2418. 

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

  2420.             }

  2421. 

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

  2423.             outStream << outPatchbay;

  2424. 

  2425.             delete[] patchbayPos;

  2426.         }

  2427. 

  2428.     }

  2429. 

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

  2431.     bool saveExternalConnections, saveExternalPositions = true;

  2432. 

  2433.     /**/ if (isPlugin)

  2434.     {

  2435.         saveExternalConnections = false;

  2436.         saveExternalPositions = false;

  2437.     }

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

  2439.     {

  2440.         saveExternalConnections = true;

  2441.     }

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

  2443.     {

  2444.         saveExternalConnections = false;

  2445.     }

  2446.     else

  2447.     {

  2448.         saveExternalConnections = true;

  2449.     }

  2450. 

  2451.     if (saveExternalConnections || saveExternalPositions)

  2452.     {

  2453.         uint posCount = 0;

  2454.         const char* const* const patchbayConns = saveExternalConnections

  2455.                                                ? getPatchbayConnections(true)

  2456.                                                : nullptr;

  2457.         const PatchbayPosition* const patchbayPos = saveExternalPositions

  2458.                                                   ? getPatchbayPositions(true, posCount)

  2459.                                                   : nullptr;

  2460. 

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

  2462.         {

  2463.             MemoryOutputStream outPatchbay(2048);

  2464. 

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

  2466. 

  2467.             if (patchbayConns != nullptr)

  2468.             {

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

  2470.                 {

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

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

  2473. 

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

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

  2476. 

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

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

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

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

  2481.                 }

  2482.             }

  2483. 

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

  2485.             {

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

  2487. 

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

  2489.                 {

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

  2491. 

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

  2493. 

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

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

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

  2497.                     if (ppos.pluginId >= 0)

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

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

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

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

  2502. 

  2503.                     if (ppos.dealloc)

  2504.                         delete[] ppos.name;

  2505.                 }

  2506. 

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

  2508.             }

  2509. 

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

  2511.             outStream << outPatchbay;

  2512.         }

  2513.     }

  2514. #endif

  2515. 

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

  2517. }

  2518. 

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

  2520. {

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

  2522. 

  2523.     // try direct filename first

  2524.     String jbinary(binary);

  2525. 

  2526.     // adjust for current platform

  2527. #ifdef CARLA_OS_WIN

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

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

  2530. #else

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

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

  2533. #endif

  2534. 

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

  2536. 

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

  2538. #ifdef CARLA_OS_MAC

  2539.     if (filename.endsWithIgnoreCase(".vst") || filename.endsWithIgnoreCase(".vst3"))

  2540.         searchFlags |= File::findDirectories;

  2541. #endif

  2542. 

  2543.     Array<File> results;

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

  2545.     {

  2546.         const File path(*it);

  2547. 

  2548.         results.clear();

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

  2550. 

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

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

  2553.     }

  2554. 

  2555.     // try changing extension

  2556. #if defined(CARLA_OS_MAC)

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

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

  2559. #elif defined(CARLA_OS_WIN)

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

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

  2562. #else

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

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

  2565. #endif

  2566.     else

  2567.         return String();

  2568. 

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

  2570.     {

  2571.         const File path(*it);

  2572. 

  2573.         results.clear();

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

  2575. 

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

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

  2578.     }

  2579. 

  2580.     return String();

  2581. }

  2582. 

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

  2584. {

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

  2586. 

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

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

  2589. 

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

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

  2592. 

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

  2594.     {

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

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

  2597.         return false;

  2598.     }

  2599. 

  2600.     pData->actionCanceled = false;

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

  2602. 

  2603. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  2605.     {

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

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

  2608.         {

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

  2610.             pData->ignoreClientPrefix = true;

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

  2612.         }

  2613.     }

  2614. 

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

  2616. #endif

  2617. 

  2618.     // completely load file

  2619.     xmlElement = xmlDoc.getDocumentElement(false);

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

  2621. 

  2622.     if (pData->aboutToClose)

  2623.         return true;

  2624. 

  2625.     if (pData->actionCanceled)

  2626.     {

  2627.         setLastError("Project load canceled");

  2628.         return false;

  2629.     }

  2630. 

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

  2632. 

  2633. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

  2636. #endif

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

  2638. 

  2639.     // load engine settings first of all

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

  2641.     {

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

  2643.         {

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

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

  2646. 

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

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

  2649. 

  2650.             int option = -1;

  2651.             int value  = 0;

  2652.             const char* valueStr = nullptr;

  2653. 

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

  2655.             {

  2656.                 option = ENGINE_OPTION_FORCE_STEREO;

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

  2658.             }

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

  2660.             {

  2661.                 option = ENGINE_OPTION_PREFER_PLUGIN_BRIDGES;

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

  2663.             }

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

  2665.             {

  2666.                 option = ENGINE_OPTION_PREFER_UI_BRIDGES;

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

  2668.             }

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

  2670.             {

  2671.                 option = ENGINE_OPTION_UIS_ALWAYS_ON_TOP;

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

  2673.             }

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

  2675.             {

  2676.                 option = ENGINE_OPTION_MAX_PARAMETERS;

  2677.                 value  = text.getIntValue();

  2678.             }

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

  2680.             {

  2681.                 option = ENGINE_OPTION_UI_BRIDGES_TIMEOUT;

  2682.                 value  = text.getIntValue();

  2683.             }

  2684.             else if (isPlugin)

  2685.             {

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

  2687.                 {

  2688.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2689.                     value    = PLUGIN_LADSPA;

  2690.                     valueStr = text.toRawUTF8();

  2691.                 }

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

  2693.                 {

  2694.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2695.                     value    = PLUGIN_DSSI;

  2696.                     valueStr = text.toRawUTF8();

  2697.                 }

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

  2699.                 {

  2700.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2701.                     value    = PLUGIN_LV2;

  2702.                     valueStr = text.toRawUTF8();

  2703.                 }

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

  2705.                 {

  2706.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2707.                     value    = PLUGIN_VST2;

  2708.                     valueStr = text.toRawUTF8();

  2709.                 }

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

  2711.                 {

  2712.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2713.                     value    = PLUGIN_VST3;

  2714.                     valueStr = text.toRawUTF8();

  2715.                 }

  2716.                 else if (tag == "SF2_PATH")

  2717.                 {

  2718.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2719.                     value    = PLUGIN_SF2;

  2720.                     valueStr = text.toRawUTF8();

  2721.                 }

  2722.                 else if (tag == "SFZ_PATH")

  2723.                 {

  2724.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2725.                     value    = PLUGIN_SFZ;

  2726.                     valueStr = text.toRawUTF8();

  2727.                 }

  2728.             }

  2729. 

  2730.             if (option == -1)

  2731.             {

  2732.                 // check old stuff, unhandled now

  2733.                 if (tag == "GIG_PATH")

  2734.                     continue;

  2735.                 // ignored tags

  2736.                 if (tag == "LADSPA_PATH" || tag == "DSSI_PATH" || tag == "LV2_PATH" || tag == "VST2_PATH")

  2737.                     continue;

  2738.                 if (tag == "VST3_PATH" || tag == "AU_PATH")

  2739.                     continue;

  2740.                 if (tag == "SF2_PATH" || tag == "SFZ_PATH")

  2741.                     continue;

  2742. 

  2743.                 // hmm something is wrong..

  2744.                 carla_stderr2("CarlaEngine::loadProjectInternal() - Unhandled option '%s'", tag.toRawUTF8());

  2745.                 continue;

  2746.             }

  2747. 

  2748.             setOption(static_cast<EngineOption>(option), value, valueStr);

  2749.         }

  2750. 

  2751.         if (pData->aboutToClose)

  2752.             return true;

  2753. 

  2754.         if (pData->actionCanceled)

  2755.         {

  2756.             setLastError("Project load canceled");

  2757.             return false;

  2758.         }

  2759.     }

  2760. 

  2761.     // now setup transport

  2762.     if (XmlElement* const elem = (isPreset || isPlugin) ? nullptr : xmlElement->getChildByName("Transport"))

  2763.     {

  2764.         if (XmlElement* const bpmElem = elem->getChildByName("BeatsPerMinute"))

  2765.         {

  2766.             const String bpmText(bpmElem->getAllSubText().trim());

  2767.             const double bpm = bpmText.getDoubleValue();

  2768. 

  2769.             // some sane limits

  2770.             if (bpm >= 20.0 && bpm < 400.0)

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

  2772. 

  2773.             if (pData->aboutToClose)

  2774.                 return true;

  2775. 

  2776.             if (pData->actionCanceled)

  2777.             {

  2778.                 setLastError("Project load canceled");

  2779.                 return false;

  2780.             }

  2781.         }

  2782.     }

  2783. 

  2784.     // and we handle plugins

  2785.     for (XmlElement* elem = xmlElement->getFirstChildElement(); elem != nullptr; elem = elem->getNextElement())

  2786.     {

  2787.         const String& tagName(elem->getTagName());

  2788. 

  2789.         if (isPreset || tagName == "Plugin")

  2790.         {

  2791.             CarlaStateSave stateSave;

  2792.             stateSave.fillFromXmlElement(isPreset ? xmlElement.get() : elem);

  2793. 

  2794.             if (pData->aboutToClose)

  2795.                 return true;

  2796. 

  2797.             if (pData->actionCanceled)

  2798.             {

  2799.                 setLastError("Project load canceled");

  2800.                 return false;

  2801.             }

  2802. 

  2803.             CARLA_SAFE_ASSERT_CONTINUE(stateSave.type != nullptr);

  2804. 

  2805. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2806.             // compatibility code to load projects with GIG files

  2807.             // FIXME Remove on 2.1 release

  2808.             if (std::strcmp(stateSave.type, "GIG") == 0)

  2809.             {

  2810.                 if (addPlugin(PLUGIN_LV2, "", stateSave.name, "http://linuxsampler.org/plugins/linuxsampler", 0, nullptr))

  2811.                 {

  2812.                     const uint pluginId = pData->curPluginCount;

  2813. 

  2814.                     if (const CarlaPluginPtr plugin = pData->plugins[pluginId].plugin)

  2815.                     {

  2816.                         if (pData->aboutToClose)

  2817.                             return true;

  2818. 

  2819.                         if (pData->actionCanceled)

  2820.                         {

  2821.                             setLastError("Project load canceled");

  2822.                             return false;

  2823.                         }

  2824. 

  2825.                         String lsState;

  2826.                         lsState << "0.35\n";

  2827.                         lsState << "18 0 Chromatic\n";

  2828.                         lsState << "18 1 Drum Kits\n";

  2829.                         lsState << "20 0\n";

  2830.                         lsState << "0 1 " << stateSave.binary << "\n";

  2831.                         lsState << "0 0 0 0 1 0 GIG\n";

  2832. 

  2833.                         plugin->setCustomData(LV2_ATOM__String, "http://linuxsampler.org/schema#state-string", lsState.toRawUTF8(), true);

  2834.                         plugin->restoreLV2State(true);

  2835. 

  2836.                         plugin->setDryWet(stateSave.dryWet, true, true);

  2837.                         plugin->setVolume(stateSave.volume, true, true);

  2838.                         plugin->setBalanceLeft(stateSave.balanceLeft, true, true);

  2839.                         plugin->setBalanceRight(stateSave.balanceRight, true, true);

  2840.                         plugin->setPanning(stateSave.panning, true, true);

  2841.                         plugin->setCtrlChannel(stateSave.ctrlChannel, true, true);

  2842.                         plugin->setActive(stateSave.active, true, true);

  2843.                         plugin->setEnabled(true);

  2844. 

  2845.                         ++pData->curPluginCount;

  2846.                         callback(true, true, ENGINE_CALLBACK_PLUGIN_ADDED, pluginId, 0, 0, 0, 0.0f, plugin->getName());

  2847. 

  2848.                         if (isPatchbay)

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

  2850.                     }

  2851.                     else

  2852.                     {

  2853.                         carla_stderr2("Failed to get new plugin, state will not be restored correctly\n");

  2854.                     }

  2855.                 }

  2856.                 else

  2857.                 {

  2858.                     carla_stderr2("Failed to load a linuxsampler LV2 plugin, GIG file won't be loaded");

  2859.                 }

  2860. 

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

  2862.                 continue;

  2863.             }

  2864. # ifdef SFZ_FILES_USING_SFIZZ

  2865.             if (std::strcmp(stateSave.type, "SFZ") == 0)

  2866.             {

  2867.                 if (addPlugin(PLUGIN_LV2, "", stateSave.name, "http://sfztools.github.io/sfizz", 0, nullptr))

  2868.                 {

  2869.                     const uint pluginId = pData->curPluginCount;

  2870. 

  2871.                     if (const CarlaPluginPtr plugin = pData->plugins[pluginId].plugin)

  2872.                     {

  2873.                         if (pData->aboutToClose)

  2874.                             return true;

  2875. 

  2876.                         if (pData->actionCanceled)

  2877.                         {

  2878.                             setLastError("Project load canceled");

  2879.                             return false;

  2880.                         }

  2881. 

  2882.                         plugin->setCustomData(LV2_ATOM__Path,

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

  2884.                                               stateSave.binary,

  2885.                                               false);

  2886. 

  2887.                         plugin->restoreLV2State(true);

  2888. 

  2889.                         plugin->setDryWet(stateSave.dryWet, true, true);

  2890.                         plugin->setVolume(stateSave.volume, true, true);

  2891.                         plugin->setBalanceLeft(stateSave.balanceLeft, true, true);

  2892.                         plugin->setBalanceRight(stateSave.balanceRight, true, true);

  2893.                         plugin->setPanning(stateSave.panning, true, true);

  2894.                         plugin->setCtrlChannel(stateSave.ctrlChannel, true, true);

  2895.                         plugin->setActive(stateSave.active, true, true);

  2896.                         plugin->setEnabled(true);

  2897. 

  2898.                         ++pData->curPluginCount;

  2899.                         callback(true, true, ENGINE_CALLBACK_PLUGIN_ADDED, pluginId, 0, 0, 0, 0.0f, plugin->getName());

  2900. 

  2901.                         if (isPatchbay)

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

  2903.                     }

  2904.                     else

  2905.                     {

  2906.                         carla_stderr2("Failed to get new plugin, state will not be restored correctly\n");

  2907.                     }

  2908.                 }

  2909.                 else

  2910.                 {

  2911.                     carla_stderr2("Failed to load a sfizz LV2 plugin, SFZ file won't be loaded");

  2912.                 }

  2913. 

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

  2915.                 continue;

  2916.             }

  2917. # endif

  2918. #endif

  2919. 

  2920.             const void* extraStuff    = nullptr;

  2921.             static const char kTrue[] = "true";

  2922. 

  2923.             const PluginType ptype(getPluginTypeFromString(stateSave.type));

  2924. 

  2925.             switch (ptype)

  2926.             {

  2927.             case PLUGIN_SF2:

  2928.                 if (CarlaString(stateSave.label).endsWith(" (16 outs)"))

  2929.                     extraStuff = kTrue;

  2930.                 // fall through

  2931.             case PLUGIN_LADSPA:

  2932.             case PLUGIN_DSSI:

  2933.             case PLUGIN_VST2:

  2934.             case PLUGIN_VST3:

  2935.             case PLUGIN_SFZ:

  2936.                 if (stateSave.binary != nullptr && stateSave.binary[0] != '\0' &&

  2937.                     ! (File::isAbsolutePath(stateSave.binary) && File(stateSave.binary).exists()))

  2938.                 {

  2939.                     const char* searchPath;

  2940. 

  2941.                     switch (ptype)

  2942.                     {

  2943.                     case PLUGIN_LADSPA: searchPath = pData->options.pathLADSPA; break;

  2944.                     case PLUGIN_DSSI:   searchPath = pData->options.pathDSSI;   break;

  2945.                     case PLUGIN_VST2:   searchPath = pData->options.pathVST2;   break;

  2946.                     case PLUGIN_VST3:   searchPath = pData->options.pathVST3;   break;

  2947.                     case PLUGIN_SF2:    searchPath = pData->options.pathSF2;    break;

  2948.                     case PLUGIN_SFZ:    searchPath = pData->options.pathSFZ;    break;

  2949.                     default:            searchPath = nullptr;                   break;

  2950.                     }

  2951. 

  2952.                     if (searchPath != nullptr && searchPath[0] != '\0')

  2953.                     {

  2954.                         carla_stderr("Plugin binary '%s' doesn't exist on this filesystem, let's look for it...",

  2955.                                      stateSave.binary);

  2956. 

  2957.                         String result = findBinaryInCustomPath(searchPath, stateSave.binary);

  2958. 

  2959.                         if (result.isEmpty())

  2960.                         {

  2961.                             switch (ptype)

  2962.                             {

  2963.                             case PLUGIN_LADSPA: searchPath = std::getenv("LADSPA_PATH"); break;

  2964.                             case PLUGIN_DSSI:   searchPath = std::getenv("DSSI_PATH");   break;

  2965.                             case PLUGIN_VST2:   searchPath = std::getenv("VST_PATH");    break;

  2966.                             case PLUGIN_VST3:   searchPath = std::getenv("VST3_PATH");   break;

  2967.                             case PLUGIN_SF2:    searchPath = std::getenv("SF2_PATH");    break;

  2968.                             case PLUGIN_SFZ:    searchPath = std::getenv("SFZ_PATH");    break;

  2969.                             default:            searchPath = nullptr;                    break;

  2970.                             }

  2971. 

  2972.                             if (searchPath != nullptr && searchPath[0] != '\0')

  2973.                                 result = findBinaryInCustomPath(searchPath, stateSave.binary);

  2974.                         }

  2975. 

  2976.                         if (result.isNotEmpty())

  2977.                         {

  2978.                             delete[] stateSave.binary;

  2979.                             stateSave.binary = carla_strdup(result.toRawUTF8());

  2980.                             carla_stderr("Found it! :)");

  2981.                         }

  2982.                         else

  2983.                         {

  2984.                             carla_stderr("Damn, we failed... :(");

  2985.                         }

  2986. 

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

  2988.                     }

  2989.                 }

  2990.                 break;

  2991.             default:

  2992.                 break;

  2993.             }

  2994. 

  2995.             BinaryType btype;

  2996. 

  2997.             switch (ptype)

  2998.             {

  2999.             case PLUGIN_LADSPA:

  3000.             case PLUGIN_DSSI:

  3001.             case PLUGIN_LV2:

  3002.             case PLUGIN_VST2:

  3003.             case PLUGIN_VST3:

  3004.                 btype = getBinaryTypeFromFile(stateSave.binary);

  3005.                 break;

  3006.             default:

  3007.                 btype = BINARY_NATIVE;

  3008.                 break;

  3009.             }

  3010. 

  3011.             if (addPlugin(btype, ptype, stateSave.binary,

  3012.                           stateSave.name, stateSave.label, stateSave.uniqueId, extraStuff, stateSave.options))

  3013.             {

  3014. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  3015.                 const uint pluginId = pData->curPluginCount;

  3016. #else

  3017.                 const uint pluginId = 0;

  3018. #endif

  3019. 

  3020.                 if (const CarlaPluginPtr plugin = pData->plugins[pluginId].plugin)

  3021.                 {

  3022.                     if (pData->aboutToClose)

  3023.                         return true;

  3024. 

  3025.                     if (pData->actionCanceled)

  3026.                     {

  3027.                         setLastError("Project load canceled");

  3028.                         return false;

  3029.                     }

  3030. 

  3031.                     // deactivate bridge client-side ping check, since some plugins block during load

  3032.                     if ((plugin->getHints() & PLUGIN_IS_BRIDGE) != 0 && ! isPreset)

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

  3034. 

  3035.                     plugin->loadStateSave(stateSave);

  3036. 

  3037.                     /* NOTE: The following code is the same as the end of addPlugin().

  3038.                      *       When project is loading we do not enable the plugin right away,

  3039.                      *        as we want to load state first.

  3040.                      */

  3041.                     plugin->setEnabled(true);

  3042. 

  3043.                     ++pData->curPluginCount;

  3044.                     callback(true, true, ENGINE_CALLBACK_PLUGIN_ADDED, pluginId, 0, 0, 0, 0.0f, plugin->getName());

  3045. 

  3046. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  3047.                     if (isPatchbay)

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

  3049. #endif

  3050.                 }

  3051.                 else

  3052.                 {

  3053.                     carla_stderr2("Failed to get new plugin, state will not be restored correctly\n");

  3054.                 }

  3055.             }

  3056.             else

  3057.             {

  3058.                 carla_stderr2("Failed to load a plugin '%s', error was:\n%s", stateSave.name, getLastError());

  3059.             }

  3060. 

  3061.             if (! isPreset)

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

  3063.         }

  3064. 

  3065.         if (isPreset)

  3066.         {

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

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

  3069.             return true;

  3070.         }

  3071.     }

  3072. 

  3073. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  3074.     // tell bridges we're done loading

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

  3076.     {

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

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

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

  3080.     }

  3081. 

  3082.     if (pData->aboutToClose)

  3083.         return true;

  3084. 

  3085.     if (pData->actionCanceled)

  3086.     {

  3087.         setLastError("Project load canceled");

  3088.         return false;

  3089.     }

  3090. 

  3091.     // now we handle positions

  3092.     bool loadingAsExternal;

  3093.     std::map<water::String, water::String> mapGroupNamesInternal, mapGroupNamesExternal;

  3094. 

  3095.     bool hasInternalPositions = false;

  3096. 

  3097.     if (XmlElement* const elemPatchbay = xmlElement->getChildByName("Patchbay"))

  3098.     {

  3099.         hasInternalPositions = true;

  3100. 

  3101.         if (XmlElement* const elemPositions = elemPatchbay->getChildByName("Positions"))

  3102.         {

  3103.             String name;

  3104.             PatchbayPosition ppos = { nullptr, -1, 0, 0, 0, 0, false };

  3105. 

  3106.             for (XmlElement* patchElem = elemPositions->getFirstChildElement(); patchElem != nullptr; patchElem = patchElem->getNextElement())

  3107.             {

  3108.                 const String& patchTag(patchElem->getTagName());

  3109. 

  3110.                 if (patchTag != "Position")

  3111.                     continue;

  3112. 

  3113.                 XmlElement* const patchName = patchElem->getChildByName("Name");

  3114.                 CARLA_SAFE_ASSERT_CONTINUE(patchName != nullptr);

  3115. 

  3116.                 const String nameText(patchName->getAllSubText().trim());

  3117.                 name = xmlSafeString(nameText, false);

  3118. 

  3119.                 ppos.name = name.toRawUTF8();

  3120.                 ppos.x1 = patchElem->getIntAttribute("x1");

  3121.                 ppos.y1 = patchElem->getIntAttribute("y1");

  3122.                 ppos.x2 = patchElem->getIntAttribute("x2");

  3123.                 ppos.y2 = patchElem->getIntAttribute("y2");

  3124.                 ppos.pluginId = patchElem->getIntAttribute("pluginId", -1);

  3125.                 ppos.dealloc = false;

  3126. 

  3127.                 loadingAsExternal = ppos.pluginId >= 0 && isMultiClient;

  3128. 

  3129.                 if (name.isNotEmpty() && restorePatchbayGroupPosition(loadingAsExternal, ppos))

  3130.                 {

  3131.                     if (name != ppos.name)

  3132.                     {

  3133.                         carla_stdout("Converted client name '%s' to '%s' for this session",

  3134.                                      name.toRawUTF8(), ppos.name);

  3135.                         if (loadingAsExternal)

  3136.                             mapGroupNamesExternal[name] = ppos.name;

  3137.                         else

  3138.                             mapGroupNamesInternal[name] = ppos.name;

  3139.                     }

  3140. 

  3141.                     if (ppos.dealloc)

  3142.                         std::free(const_cast<char*>(ppos.name));

  3143.                 }

  3144.             }

  3145. 

  3146.             if (pData->aboutToClose)

  3147.                 return true;

  3148. 

  3149.             if (pData->actionCanceled)

  3150.             {

  3151.                 setLastError("Project load canceled");

  3152.                 return false;

  3153.             }

  3154.         }

  3155.     }

  3156. 

  3157.     if (XmlElement* const elemPatchbay = xmlElement->getChildByName("ExternalPatchbay"))

  3158.     {

  3159.         if (XmlElement* const elemPositions = elemPatchbay->getChildByName("Positions"))

  3160.         {

  3161.             String name;

  3162.             PatchbayPosition ppos = { nullptr, -1, 0, 0, 0, 0, false };

  3163. 

  3164.             for (XmlElement* patchElem = elemPositions->getFirstChildElement(); patchElem != nullptr; patchElem = patchElem->getNextElement())

  3165.             {

  3166.                 const String& patchTag(patchElem->getTagName());

  3167. 

  3168.                 if (patchTag != "Position")

  3169.                     continue;

  3170. 

  3171.                 XmlElement* const patchName = patchElem->getChildByName("Name");

  3172.                 CARLA_SAFE_ASSERT_CONTINUE(patchName != nullptr);

  3173. 

  3174.                 const String nameText(patchName->getAllSubText().trim());

  3175.                 name = xmlSafeString(nameText, false);

  3176. 

  3177.                 ppos.name = name.toRawUTF8();

  3178.                 ppos.x1 = patchElem->getIntAttribute("x1");

  3179.                 ppos.y1 = patchElem->getIntAttribute("y1");

  3180.                 ppos.x2 = patchElem->getIntAttribute("x2");

  3181.                 ppos.y2 = patchElem->getIntAttribute("y2");

  3182.                 ppos.pluginId = patchElem->getIntAttribute("pluginId", -1);

  3183.                 ppos.dealloc = false;

  3184. 

  3185.                 loadingAsExternal = ppos.pluginId < 0 || hasInternalPositions || !isPatchbay;

  3186. 

  3187.                 carla_debug("loadingAsExternal: %i because %i %i %i",

  3188.                             loadingAsExternal, ppos.pluginId < 0, hasInternalPositions, !isPatchbay);

  3189. 

  3190.                 if (name.isNotEmpty() && restorePatchbayGroupPosition(loadingAsExternal, ppos))

  3191.                 {

  3192.                     if (name != ppos.name)

  3193.                     {

  3194.                         carla_stdout("Converted client name '%s' to '%s' for this session",

  3195.                                      name.toRawUTF8(), ppos.name);

  3196. 

  3197.                         if (loadingAsExternal)

  3198.                             mapGroupNamesExternal[name] = ppos.name;

  3199.                         else

  3200.                             mapGroupNamesInternal[name] = ppos.name;

  3201.                     }

  3202. 

  3203.                     if (ppos.dealloc)

  3204.                         std::free(const_cast<char*>(ppos.name));

  3205.                 }

  3206.             }

  3207. 

  3208.             if (pData->aboutToClose)

  3209.                 return true;

  3210. 

  3211.             if (pData->actionCanceled)

  3212.             {

  3213.                 setLastError("Project load canceled");

  3214.                 return false;

  3215.             }

  3216.         }

  3217.     }

  3218. 

  3219.     bool hasInternalConnections = false;

  3220. 

  3221.     // and now we handle connections (internal)

  3222.     if (XmlElement* const elem = xmlElement->getChildByName("Patchbay"))

  3223.     {

  3224.         hasInternalConnections = true;

  3225. 

  3226.         if (isPatchbay)

  3227.         {

  3228.             water::String sourcePort, targetPort;

  3229. 

  3230.             for (XmlElement* patchElem = elem->getFirstChildElement(); patchElem != nullptr; patchElem = patchElem->getNextElement())

  3231.             {

  3232.                 const String& patchTag(patchElem->getTagName());

  3233. 

  3234.                 if (patchTag != "Connection")

  3235.                     continue;

  3236. 

  3237.                 sourcePort.clear();

  3238.                 targetPort.clear();

  3239. 

  3240.                 for (XmlElement* connElem = patchElem->getFirstChildElement(); connElem != nullptr; connElem = connElem->getNextElement())

  3241.                 {

  3242.                     const String& tag(connElem->getTagName());

  3243.                     const String  text(connElem->getAllSubText().trim());

  3244. 

  3245.                     /**/ if (tag == "Source")

  3246.                         sourcePort = xmlSafeString(text, false);

  3247.                     else if (tag == "Target")

  3248.                         targetPort = xmlSafeString(text, false);

  3249.                 }

  3250. 

  3251.                 if (sourcePort.isNotEmpty() && targetPort.isNotEmpty())

  3252.                 {

  3253.                     std::map<water::String, water::String>& map(mapGroupNamesInternal);

  3254.                     std::map<water::String, water::String>::iterator it;

  3255. 

  3256.                     if ((it = map.find(sourcePort.upToFirstOccurrenceOf(":", false, false))) != map.end())

  3257.                         sourcePort = it->second + sourcePort.fromFirstOccurrenceOf(":", true, false);

  3258.                     if ((it = map.find(targetPort.upToFirstOccurrenceOf(":", false, false))) != map.end())

  3259.                         targetPort = it->second + targetPort.fromFirstOccurrenceOf(":", true, false);

  3260. 

  3261.                     restorePatchbayConnection(false, sourcePort.toRawUTF8(), targetPort.toRawUTF8());

  3262.                 }

  3263.             }

  3264. 

  3265.             if (pData->aboutToClose)

  3266.                 return true;

  3267. 

  3268.             if (pData->actionCanceled)

  3269.             {

  3270.                 setLastError("Project load canceled");

  3271.                 return false;

  3272.             }

  3273.         }

  3274.     }

  3275. 

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

  3277.     bool loadExternalConnections;

  3278. 

  3279.     if (alwaysLoadConnections)

  3280.     {

  3281.         loadExternalConnections = true;

  3282.     }

  3283.     else

  3284.     {

  3285.         /**/ if (std::strcmp(getCurrentDriverName(), "JACK") != 0)

  3286.             loadExternalConnections = true;

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

  3288.             loadExternalConnections = false;

  3289.         else if (std::getenv("LADISH_APP_NAME") != nullptr)

  3290.             loadExternalConnections = false;

  3291.         else if (std::getenv("NSM_URL") != nullptr)

  3292.             loadExternalConnections = false;

  3293.         else

  3294.             loadExternalConnections = true;

  3295.     }

  3296. 

  3297.     // plus external connections too

  3298.     if (loadExternalConnections)

  3299.     {

  3300.         bool isExternal;

  3301.         loadingAsExternal = hasInternalConnections &&

  3302.             (pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK || isPatchbay);

  3303. 

  3304.         for (XmlElement* elem = xmlElement->getFirstChildElement(); elem != nullptr; elem = elem->getNextElement())

  3305.         {

  3306.             const String& tagName(elem->getTagName());

  3307. 

  3308.             // check if we want to load patchbay-mode connections into an external (multi-client) graph

  3309.             if (tagName == "Patchbay")

  3310.             {

  3311.                 if (isPatchbay)

  3312.                     continue;

  3313.                 isExternal = false;

  3314.                 loadingAsExternal = true;

  3315.             }

  3316.             // or load external patchbay connections

  3317.             else if (tagName == "ExternalPatchbay")

  3318.             {

  3319.                 if (! isPatchbay)

  3320.                     loadingAsExternal = true;

  3321.                 isExternal = true;

  3322.             }

  3323.             else

  3324.             {

  3325.                 continue;

  3326.             }

  3327. 

  3328.             water::String sourcePort, targetPort;

  3329. 

  3330.             for (XmlElement* patchElem = elem->getFirstChildElement(); patchElem != nullptr; patchElem = patchElem->getNextElement())

  3331.             {

  3332.                 const String& patchTag(patchElem->getTagName());

  3333. 

  3334.                 if (patchTag != "Connection")

  3335.                     continue;

  3336. 

  3337.                 sourcePort.clear();

  3338.                 targetPort.clear();

  3339. 

  3340.                 for (XmlElement* connElem = patchElem->getFirstChildElement(); connElem != nullptr; connElem = connElem->getNextElement())

  3341.                 {

  3342.                     const String& tag(connElem->getTagName());

  3343.                     const String  text(connElem->getAllSubText().trim());

  3344. 

  3345.                     /**/ if (tag == "Source")

  3346.                         sourcePort = xmlSafeString(text, false);

  3347.                     else if (tag == "Target")

  3348.                         targetPort = xmlSafeString(text, false);

  3349.                 }

  3350. 

  3351.                 if (sourcePort.isNotEmpty() && targetPort.isNotEmpty())

  3352.                 {

  3353.                     std::map<water::String, water::String>& map(loadingAsExternal ? mapGroupNamesExternal

  3354.                                                                                   : mapGroupNamesInternal);

  3355.                     std::map<water::String, water::String>::iterator it;

  3356. 

  3357.                     if (isExternal && isPatchbay && !loadingAsExternal && sourcePort.startsWith("system:capture_"))

  3358.                     {

  3359.                         water::String internalPort = sourcePort.trimCharactersAtStart("system:capture_");

  3360. 

  3361.                         if (pData->graph.getNumAudioOuts() < 3)

  3362.                         {

  3363.                             /**/ if (internalPort == "1")

  3364.                                 internalPort = "Audio Input:Left";

  3365.                             else if (internalPort == "2")

  3366.                                 internalPort = "Audio Input:Right";

  3367.                             else if (internalPort == "3")

  3368.                                 internalPort = "Audio Input:Sidechain";

  3369.                             else

  3370.                                 continue;

  3371.                         }

  3372.                         else

  3373.                         {

  3374.                             internalPort = "Audio Input:Capture " + internalPort;

  3375.                         }

  3376. 

  3377.                         carla_stdout("Converted port name '%s' to '%s' for this session",

  3378.                                      sourcePort.toRawUTF8(), internalPort.toRawUTF8());

  3379.                         sourcePort = internalPort;

  3380.                     }

  3381.                     else if (!isExternal && isMultiClient && sourcePort.startsWith("Audio Input:"))

  3382.                     {

  3383.                         water::String externalPort = sourcePort.trimCharactersAtStart("Audio Input:");

  3384. 

  3385.                         /**/ if (externalPort == "Left")

  3386.                             externalPort = "system:capture_1";

  3387.                         else if (externalPort == "Right")

  3388.                             externalPort = "system:capture_2";

  3389.                         else if (externalPort == "Sidechain")

  3390.                             externalPort = "system:capture_3";

  3391.                         else

  3392.                             externalPort = "system:capture_ " + externalPort.trimCharactersAtStart("Capture ");

  3393. 

  3394.                         carla_stdout("Converted port name '%s' to '%s' for this session",

  3395.                                      sourcePort.toRawUTF8(), externalPort.toRawUTF8());

  3396.                         sourcePort = externalPort;

  3397.                     }

  3398.                     else if ((it = map.find(sourcePort.upToFirstOccurrenceOf(":", false, false))) != map.end())

  3399.                     {

  3400.                         sourcePort = it->second + sourcePort.fromFirstOccurrenceOf(":", true, false);

  3401.                     }

  3402. 

  3403.                     if (isExternal && isPatchbay && !loadingAsExternal && targetPort.startsWith("system:playback_"))

  3404.                     {

  3405.                         water::String internalPort = targetPort.trimCharactersAtStart("system:playback_");

  3406. 

  3407.                         if (pData->graph.getNumAudioOuts() < 3)

  3408.                         {

  3409.                             /**/ if (internalPort == "1")

  3410.                                 internalPort = "Audio Output:Left";

  3411.                             else if (internalPort == "2")

  3412.                                 internalPort = "Audio Output:Right";

  3413.                             else

  3414.                                 continue;

  3415.                         }

  3416.                         else

  3417.                         {

  3418.                             internalPort = "Audio Input:Playback " + internalPort;

  3419.                         }

  3420. 

  3421.                         carla_stdout("Converted port name '%s' to '%s' for this session",

  3422.                                      targetPort.toRawUTF8(), internalPort.toRawUTF8());

  3423.                         targetPort = internalPort;

  3424.                     }

  3425.                     else if (!isExternal && isMultiClient && targetPort.startsWith("Audio Output:"))

  3426.                     {

  3427.                         water::String externalPort = targetPort.trimCharactersAtStart("Audio Output:");

  3428. 

  3429.                         /**/ if (externalPort == "Left")

  3430.                             externalPort = "system:playback_1";

  3431.                         else if (externalPort == "Right")

  3432.                             externalPort = "system:playback_2";

  3433.                         else

  3434.                             externalPort = "system:playback_ " + externalPort.trimCharactersAtStart("Playback ");

  3435. 

  3436.                         carla_stdout("Converted port name '%s' to '%s' for this session",

  3437.                                      targetPort.toRawUTF8(), externalPort.toRawUTF8());

  3438.                         targetPort = externalPort;

  3439.                     }

  3440.                     else if ((it = map.find(targetPort.upToFirstOccurrenceOf(":", false, false))) != map.end())

  3441.                     {

  3442.                         targetPort = it->second + targetPort.fromFirstOccurrenceOf(":", true, false);

  3443.                     }

  3444. 

  3445.                     restorePatchbayConnection(loadingAsExternal, sourcePort.toRawUTF8(), targetPort.toRawUTF8());

  3446.                 }

  3447.             }

  3448.             break;

  3449.         }

  3450.     }

  3451. #endif

  3452. 

  3453.     if (pData->options.resetXruns)

  3454.         clearXruns();

  3455. 

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

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

  3458. 

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

  3460.     return true;

  3461. 

  3462. #ifdef BUILD_BRIDGE_ALTERNATIVE_ARCH

  3463.     // unused

  3464.     (void)alwaysLoadConnections;

  3465. #endif

  3466. }

  3467. 

  3468. // -----------------------------------------------------------------------

  3469. 

  3470. CARLA_BACKEND_END_NAMESPACE