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.
3470 Commits
16 Branches
447MB
Tree: 11e7814b3b
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '11e7814b3b'
${ noResults }
Carla/source/backend/engine/CarlaEngine.cpp

2333 lines
80KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Host

  3.  * Copyright (C) 2011-2014 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 "CarlaEngineInternal.hpp"

  26. #include "CarlaPlugin.hpp"

  27. 

  28. #include "CarlaBackendUtils.hpp"

  29. #include "CarlaBinaryUtils.hpp"

  30. #include "CarlaEngineUtils.hpp"

  31. #include "CarlaMathUtils.hpp"

  32. #include "CarlaPipeUtils.hpp"

  33. #include "CarlaStateUtils.hpp"

  34. #include "CarlaMIDI.h"

  35. 

  36. #include "jackbridge/JackBridge.hpp"

  37. #include "juce_core/juce_core.h"

  38. 

  39. using juce::Array;

  40. using juce::CharPointer_UTF8;

  41. using juce::File;

  42. using juce::MemoryOutputStream;

  43. using juce::ScopedPointer;

  44. using juce::String;

  45. using juce::StringArray;

  46. using juce::XmlDocument;

  47. using juce::XmlElement;

  48. 

  49. CARLA_BACKEND_START_NAMESPACE

  50. 

  51. // -----------------------------------------------------------------------

  52. // Carla Engine

  53. 

  54. CarlaEngine::CarlaEngine()

  55.     : pData(new ProtectedData(this))

  56. {

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

  58. }

  59. 

  60. CarlaEngine::~CarlaEngine()

  61. {

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

  63. 

  64.     delete pData;

  65. }

  66. 

  67. // -----------------------------------------------------------------------

  68. // Static calls

  69. 

  70. uint CarlaEngine::getDriverCount()

  71. {

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

  73. 

  74.     uint count = 0;

  75. 

  76.     if (jackbridge_is_ok())

  77.         count += 1;

  78. 

  79. #ifndef BUILD_BRIDGE

  80. # if defined(CARLA_OS_MAC) || defined(CARLA_OS_WIN)

  81.     count += getJuceApiCount();

  82. # else

  83.     count += getRtAudioApiCount();

  84. # endif

  85. #endif

  86. 

  87.     return count;

  88. }

  89. 

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

  91. {

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

  93. 

  94.     uint index(index2);

  95. 

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

  97.         return "JACK";

  98. 

  99. #ifndef BUILD_BRIDGE

  100. # if defined(CARLA_OS_MAC) || defined(CARLA_OS_WIN)

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

  102.     {

  103.         if (index < count)

  104.             return getJuceApiName(index);

  105.         index -= count;

  106.     }

  107. # else

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

  109.     {

  110.         if (index < count)

  111.             return getRtAudioApiName(index);

  112.         index -= count;

  113.     }

  114. # endif

  115. #endif

  116. 

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

  118.     return nullptr;

  119. }

  120. 

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

  122. {

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

  124. 

  125.     uint index(index2);

  126. 

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

  128.     {

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

  130.         return ret;

  131.     }

  132. 

  133. #ifndef BUILD_BRIDGE

  134. # if defined(CARLA_OS_MAC) || defined(CARLA_OS_WIN)

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

  136.     {

  137.         if (index < count)

  138.             return getJuceApiDeviceNames(index);

  139.         index -= count;

  140.     }

  141. # else

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

  143.     {

  144.         if (index < count)

  145.             return getRtAudioApiDeviceNames(index);

  146.         index -= count;

  147.     }

  148. # endif

  149. #endif

  150. 

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

  152.     return nullptr;

  153. }

  154. 

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

  156. {

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

  158. 

  159.     uint index(index2);

  160. 

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

  162.     {

  163.         static uint32_t bufSizes[11] = { 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 0 };

  164.         static EngineDriverDeviceInfo devInfo;

  165.         devInfo.hints       = ENGINE_DRIVER_DEVICE_VARIABLE_BUFFER_SIZE;

  166.         devInfo.bufferSizes = bufSizes;

  167.         devInfo.sampleRates = nullptr;

  168.         return &devInfo;

  169.     }

  170. 

  171. #ifndef BUILD_BRIDGE

  172. # if defined(CARLA_OS_MAC) || defined(CARLA_OS_WIN)

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

  174.     {

  175.         if (index < count)

  176.             return getJuceDeviceInfo(index, deviceName);

  177.         index -= count;

  178.     }

  179. # else

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

  181.     {

  182.         if (index < count)

  183.             return getRtAudioDeviceInfo(index, deviceName);

  184.         index -= count;

  185.     }

  186. # endif

  187. #endif

  188. 

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

  190.     return nullptr;

  191. }

  192. 

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

  194. {

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

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

  197. 

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

  199.         return newJack();

  200. 

  201. #ifndef BUILD_BRIDGE

  202. # if defined(CARLA_OS_MAC) || defined(CARLA_OS_WIN)

  203.     // -------------------------------------------------------------------

  204.     // macos

  205. 

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

  207.         return newJuce(AUDIO_API_CORE);

  208. 

  209.     // -------------------------------------------------------------------

  210.     // windows

  211. 

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

  213.         return newJuce(AUDIO_API_ASIO);

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

  215.         return newJuce(AUDIO_API_DS);

  216. #else

  217.     // -------------------------------------------------------------------

  218.     // common

  219. 

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

  221.         return newRtAudio(AUDIO_API_JACK);

  222. 

  223.     // -------------------------------------------------------------------

  224.     // linux

  225. 

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

  227.         return newRtAudio(AUDIO_API_ALSA);

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

  229.         return newRtAudio(AUDIO_API_OSS);

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

  231.         return newRtAudio(AUDIO_API_PULSE);

  232. # endif

  233. #endif

  234. 

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

  236.     return nullptr;

  237. }

  238. 

  239. // -----------------------------------------------------------------------

  240. // Constant values

  241. 

  242. uint CarlaEngine::getMaxClientNameSize() const noexcept

  243. {

  244.     return STR_MAX/2;

  245. }

  246. 

  247. uint CarlaEngine::getMaxPortNameSize() const noexcept

  248. {

  249.     return STR_MAX;

  250. }

  251. 

  252. uint CarlaEngine::getCurrentPluginCount() const noexcept

  253. {

  254.     return pData->curPluginCount;

  255. }

  256. 

  257. uint CarlaEngine::getMaxPluginNumber() const noexcept

  258. {

  259.     return pData->maxPluginNumber;

  260. }

  261. 

  262. // -----------------------------------------------------------------------

  263. // Virtual, per-engine type calls

  264. 

  265. bool CarlaEngine::close()

  266. {

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

  268. 

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

  270.     {

  271.         pData->aboutToClose = true;

  272.         removeAllPlugins();

  273.     }

  274. 

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

  276.     if (pData->osc.isControlRegistered())

  277.         oscSend_control_exit();

  278. #endif

  279. 

  280.     pData->close();

  281. 

  282.     callback(ENGINE_CALLBACK_ENGINE_STOPPED, 0, 0, 0, 0.0f, nullptr);

  283.     return true;

  284. }

  285. 

  286. bool CarlaEngine::usesConstantBufferSize() const noexcept

  287. {

  288.     return true;

  289. }

  290. 

  291. void CarlaEngine::idle() noexcept

  292. {

  293.     CARLA_SAFE_ASSERT_RETURN(pData->nextAction.opcode == kEnginePostActionNull,); // FIXME REMOVE

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

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

  296. 

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

  298.     {

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

  300. 

  301.         if (plugin != nullptr && plugin->isEnabled())

  302.         {

  303.             const uint hints(plugin->getHints());

  304. 

  305.             if ((hints & PLUGIN_HAS_CUSTOM_UI) != 0 && (hints & PLUGIN_NEEDS_UI_MAIN_THREAD) != 0)

  306.             {

  307.                 try {

  308.                     plugin->uiIdle();

  309.                 } CARLA_SAFE_EXCEPTION_CONTINUE("Plugin uiIdle");

  310.             }

  311.         }

  312.     }

  313. 

  314. #ifdef HAVE_LIBLO

  315.     pData->osc.idle();

  316. #endif

  317. }

  318. 

  319. CarlaEngineClient* CarlaEngine::addClient(CarlaPlugin* const)

  320. {

  321.     return new CarlaEngineClient(*this);

  322. }

  323. 

  324. // -----------------------------------------------------------------------

  325. // Plugin management

  326. 

  327. bool CarlaEngine::addPlugin(const BinaryType btype, const PluginType ptype,

  328.                             const char* const filename, const char* const name, const char* const label, const int64_t uniqueId,

  329.                             const void* const extra, const uint options)

  330. {

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

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

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

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

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

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

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

  338.     carla_debug("CarlaEngine::addPlugin(%i:%s, %i:%s, \"%s\", \"%s\", \"%s\", " P_INT64 ", %p, %u)", btype, BinaryType2Str(btype), ptype, PluginType2Str(ptype), filename, name, label, uniqueId, extra, options);

  339. 

  340.     uint id;

  341. 

  342. #ifndef BUILD_BRIDGE

  343.     CarlaPlugin* oldPlugin = nullptr;

  344. 

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

  346.     {

  347.         id = pData->nextPluginId;

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

  349. 

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

  351. 

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

  353.     }

  354.     else

  355. #endif

  356.     {

  357.         id = pData->curPluginCount;

  358. 

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

  360.         {

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

  362.             return false;

  363.         }

  364. 

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

  366.     }

  367. 

  368.     CarlaPlugin::Initializer initializer = {

  369.         this,

  370.         id,

  371.         filename,

  372.         name,

  373.         label,

  374.         uniqueId,

  375.         options

  376.     };

  377. 

  378.     CarlaPlugin* plugin = nullptr;

  379. 

  380. #ifndef BUILD_BRIDGE

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

  382. 

  383.     if (bridgeBinary.isNotEmpty())

  384.     {

  385.         if (btype == BINARY_NATIVE)

  386.         {

  387. # ifdef CARLA_OS_WIN

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

  389. # else

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

  391. # endif

  392.         }

  393.         else

  394.         {

  395.             switch (btype)

  396.             {

  397.             case BINARY_POSIX32:

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

  399.                 break;

  400.             case BINARY_POSIX64:

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

  402.                 break;

  403.             case BINARY_WIN32:

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

  405.                 break;

  406.             case BINARY_WIN64:

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

  408.                 break;

  409.             default:

  410.                 bridgeBinary.clear();

  411.                 break;

  412.             }

  413.         }

  414. 

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

  416.             bridgeBinary.clear();

  417.     }

  418. 

  419.     // Prefer bridges for some specific plugins

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

  421. 

  422. # ifdef CARLA_OS_LINUX

  423.     if (! preferBridges)

  424.     {

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

  426.         {

  427.             if (std::strcmp(label, "http://calf.sourceforge.net/plugins/Analyzer") == 0)

  428.                 preferBridges = true;

  429.             if (std::strcmp(label, "http://calf.sourceforge.net/plugins/Fluidsynth") == 0)

  430.                 preferBridges = true;

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

  432.                 preferBridges = true;

  433.         }

  434. #if 0

  435.         else if (ptype == PLUGIN_VST2)

  436.         {

  437.             /*

  438.             char uniqueIdChars[5] = {

  439.                 static_cast<char>((uniqueId & 0xFF000000) >> 24),

  440.                 static_cast<char>((uniqueId & 0x00FF0000) >> 16),

  441.                 static_cast<char>((uniqueId & 0x0000FF00) >>  8),

  442.                 static_cast<char>((uniqueId & 0x000000FF) >>  1),

  443.                 0

  444.             };

  445.             */

  446. 

  447.             /**/ if (uniqueId == 1633895765 && std::strstr(filename, "/ACE.") != nullptr)

  448.                 preferBridges = true;

  449.             else if (uniqueId == 1433421876 && std::strstr(filename, "/Bazille.") != nullptr)

  450.                 preferBridges = true;

  451.             else if (uniqueId == 1147754081 && std::strstr(filename, "/Diva.") != nullptr)

  452.                 preferBridges = true;

  453.             else if (uniqueId == 1095583057 && std::strstr(filename, "/Filterscape.") != nullptr)

  454.                 preferBridges = true;

  455.             else if (uniqueId == 1179866689 && std::strstr(filename, "/Filterscape.") != nullptr)

  456.                 preferBridges = true;

  457.             else if (uniqueId == 1179865398 && std::strstr(filename, "/Filterscape.") != nullptr)

  458.                 preferBridges = true;

  459.             else if (uniqueId == 1749636677 && std::strstr(filename, "/Hive.") != nullptr)

  460.                 preferBridges = true;

  461.             else if (uniqueId == 1296452914 && std::strstr(filename, "/MFM2.") != nullptr)

  462.                 preferBridges = true;

  463.             else if (uniqueId == 1349477487 && std::strstr(filename, "/Podolski.") != nullptr)

  464.                 preferBridges = true;

  465.             else if (uniqueId == 1886548821 && std::strstr(filename, "/Presswerk.") != nullptr)

  466.                 preferBridges = true;

  467.             else if (uniqueId == 1969770582 && std::strstr(filename, "/Protoverb.") != nullptr)

  468.                 preferBridges = true;

  469.             else if (uniqueId == 1969771348 && std::strstr(filename, "/Satin.") != nullptr)

  470.                 preferBridges = true;

  471.             else if (uniqueId == 1667388281 && std::strstr(filename, "/TripleCheese.") != nullptr)

  472.                 preferBridges = true;

  473.             else if (uniqueId == 1952017974 && std::strstr(filename, "/TyrellN6.") != nullptr)

  474.                 preferBridges = true;

  475.             else if (uniqueId == 1432568113 && std::strstr(filename, "/Uhbik.") != nullptr)

  476.                 preferBridges = true;

  477.             else if (uniqueId == 1432568881 && std::strstr(filename, "/Uhbik.") != nullptr)

  478.                 preferBridges = true;

  479.             else if (uniqueId == 1432572209 && std::strstr(filename, "/Uhbik.") != nullptr)

  480.                 preferBridges = true;

  481.             else if (uniqueId == 1432569393 && std::strstr(filename, "/Uhbik.") != nullptr)

  482.                 preferBridges = true;

  483.             else if (uniqueId == 1432569649 && std::strstr(filename, "/Uhbik.") != nullptr)

  484.                 preferBridges = true;

  485.             else if (uniqueId == 1432571953 && std::strstr(filename, "/Uhbik.") != nullptr)

  486.                 preferBridges = true;

  487.             else if (uniqueId == 1382232375 && std::strstr(filename, "/Uhbik.") != nullptr)

  488.                 preferBridges = true;

  489.             else if (uniqueId == 1432572721 && std::strstr(filename, "/Uhbik.") != nullptr)

  490.                 preferBridges = true;

  491.             else if (uniqueId == 1432572977 && std::strstr(filename, "/Uhbik.") != nullptr)

  492.                 preferBridges = true;

  493.             else if (uniqueId == 1397572658 && std::strstr(filename, "/Zebra2.") != nullptr)

  494.                 preferBridges = true;

  495.             else if (uniqueId == 1397572659 && std::strstr(filename, "/Zebra2.") != nullptr)

  496.                 preferBridges = true;

  497.             else if (uniqueId == 1919243824 && std::strstr(filename, "/Zebra2.") != nullptr)

  498.                 preferBridges = true;

  499.             else if (uniqueId == 1397578034 && std::strstr(filename, "/Zebra2.") != nullptr)

  500.                 preferBridges = true;

  501.             else if (uniqueId == 1397573722 && std::strstr(filename, "/ZebraHZ.") != nullptr)

  502.                 preferBridges = true;

  503.         }

  504. #endif

  505.         // FIXME: linuxsampler inside carla-rack/patchbay plugin has some issues (only last kit makes noise)

  506.         else if (getType() == kEngineTypePlugin && (ptype == PLUGIN_GIG || ptype == PLUGIN_SFZ))

  507.         {

  508.             // if we're not loading a project consider all is ok

  509.             if (! pData->loadingProject)

  510.                 pData->firstLinuxSamplerInstance = true;

  511. 

  512.             // loading a project, revert first status if set

  513.             else if (pData->firstLinuxSamplerInstance)

  514.                 pData->firstLinuxSamplerInstance = false;

  515. 

  516.             // now check if bridge is needed

  517.             if (! pData->firstLinuxSamplerInstance)

  518.                 preferBridges = true;

  519.         }

  520.     }

  521. # endif

  522. 

  523.     if (ptype != PLUGIN_INTERNAL && (btype != BINARY_NATIVE || (preferBridges && bridgeBinary.isNotEmpty())))

  524.     {

  525.         if (bridgeBinary.isNotEmpty())

  526.         {

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

  528.         }

  529. # ifdef CARLA_OS_LINUX

  530.         // fallback to dssi-vst if possible

  531.         else if (btype == BINARY_WIN32 && File("/usr/lib/dssi/dssi-vst.so").existsAsFile())

  532.         {

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

  534.             File file(jfilename);

  535. 

  536.             CarlaString label2(file.getFileName().toRawUTF8());

  537.             label2.replace(' ', '*');

  538. 

  539.             CarlaPlugin::Initializer init2 = {

  540.                 this,

  541.                 id,

  542.                 "/usr/lib/dssi/dssi-vst.so",

  543.                 name,

  544.                 label2,

  545.                 uniqueId,

  546.                 options

  547.             };

  548. 

  549.             ScopedEnvVar sev("VST_PATH", file.getParentDirectory().getFullPathName().toRawUTF8());

  550. 

  551.             plugin = CarlaPlugin::newDSSI(init2);

  552.         }

  553. # endif

  554.         else

  555.         {

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

  557.             return false;

  558.         }

  559.     }

  560.     else

  561. #endif // ! BUILD_BRIDGE

  562.     {

  563.         bool use16Outs;

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

  565. 

  566.         switch (ptype)

  567.         {

  568.         case PLUGIN_NONE:

  569.             break;

  570. 

  571.         case PLUGIN_INTERNAL:

  572.             /*if (std::strcmp(label, "FluidSynth") == 0)

  573.             {

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

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

  576.             }

  577.             else if (std::strcmp(label, "LinuxSampler (GIG)") == 0)

  578.             {

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

  580.                 plugin = CarlaPlugin::newLinuxSampler(initializer, "GIG", use16Outs);

  581.             }

  582.             else if (std::strcmp(label, "LinuxSampler (SF2)") == 0)

  583.             {

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

  585.                 plugin = CarlaPlugin::newLinuxSampler(initializer, "SF2", use16Outs);

  586.             }

  587.             else if (std::strcmp(label, "LinuxSampler (SFZ)") == 0)

  588.             {

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

  590.                 plugin = CarlaPlugin::newLinuxSampler(initializer, "SFZ", use16Outs);

  591.             }*/

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

  593.             break;

  594. 

  595.         case PLUGIN_LADSPA:

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

  597.             break;

  598. 

  599.         case PLUGIN_DSSI:

  600.             if (CarlaString(filename).contains("dssi-vst", true))

  601.             {

  602.                 const ScopedEngineEnvironmentLocker _seel(this);

  603.                 const ScopedEnvVar _sev("VST_PATH", pData->options.pathVST2);

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

  605.             }

  606.             else

  607.             {

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

  609.             }

  610.             break;

  611. 

  612.         case PLUGIN_LV2:

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

  614.             break;

  615. 

  616.         case PLUGIN_VST2:

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

  618.             break;

  619. 

  620.         case PLUGIN_VST3:

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

  622.             break;

  623. 

  624.         case PLUGIN_AU:

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

  626.             break;

  627. 

  628.         case PLUGIN_GIG:

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

  630.             plugin = CarlaPlugin::newFileGIG(initializer, use16Outs);

  631.             break;

  632. 

  633.         case PLUGIN_SF2:

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

  635.             plugin = CarlaPlugin::newFileSF2(initializer, use16Outs);

  636.             break;

  637. 

  638.         case PLUGIN_SFZ:

  639.             plugin = CarlaPlugin::newFileSFZ(initializer);

  640.             break;

  641. 

  642.         case PLUGIN_JACK:

  643. #ifndef BUILD_BRIDGE

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

  645. #endif

  646.             break;

  647.         }

  648.     }

  649. 

  650.     if (plugin == nullptr)

  651.         return false;

  652. 

  653.     plugin->reload();

  654. 

  655.     bool canRun = true;

  656. 

  657.     /**/ if (pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK)

  658.     {

  659.         /**/ if (! plugin->canRunInRack())

  660.         {

  661.             setLastError("Carla's rack mode can only work with Mono or Stereo plugins, sorry!");

  662.             canRun = false;

  663.         }

  664.         else if (plugin->getCVInCount() > 0 || plugin->getCVInCount() > 0)

  665.         {

  666.             setLastError("Carla's rack mode cannot work with plugins that have CV ports, sorry!");

  667.             canRun = false;

  668.         }

  669.     }

  670.     else if (pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY)

  671.     {

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

  673.         {

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

  675.             canRun = false;

  676.         }

  677.         else if (plugin->getCVInCount() > 0 || plugin->getCVInCount() > 0)

  678.         {

  679.             setLastError("CV ports in patchbay mode is still TODO");

  680.             canRun = false;

  681.         }

  682.     }

  683. 

  684.     if (! canRun)

  685.     {

  686.         delete plugin;

  687.         return false;

  688.     }

  689. 

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

  691.     plugin->registerToOscClient();

  692. #endif

  693. 

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

  695.     pluginData.plugin      = plugin;

  696.     pluginData.insPeak[0]  = 0.0f;

  697.     pluginData.insPeak[1]  = 0.0f;

  698.     pluginData.outsPeak[0] = 0.0f;

  699.     pluginData.outsPeak[1] = 0.0f;

  700. 

  701. #ifndef BUILD_BRIDGE

  702.     if (oldPlugin != nullptr)

  703.     {

  704.         CARLA_SAFE_ASSERT(! pData->loadingProject);

  705. 

  706.         const ScopedThreadStopper sts(this);

  707. 

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

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

  710. 

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

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

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

  714. 

  715.         delete oldPlugin;

  716. 

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

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

  719. 

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

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

  722. 

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

  724. 

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

  726.     }

  727.     else if (! pData->loadingProject)

  728. #endif

  729.     {

  730.         plugin->setActive(true, true, false);

  731.         plugin->setEnabled(true);

  732. 

  733.         ++pData->curPluginCount;

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

  735. 

  736. #ifndef BUILD_BRIDGE

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

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

  739. #endif

  740.     }

  741. 

  742.     return true;

  743. }

  744. 

  745. bool CarlaEngine::addPlugin(const PluginType ptype, const char* const filename, const char* const name, const char* const label, const int64_t uniqueId, const void* const extra)

  746. {

  747.     return addPlugin(BINARY_NATIVE, ptype, filename, name, label, uniqueId, extra, 0x0);

  748. }

  749. 

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

  751. {

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

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

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

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

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

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

  758. 

  759.     CarlaPlugin* const plugin(pData->plugins[id].plugin);

  760. 

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

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

  763. 

  764.     const ScopedThreadStopper sts(this);

  765. 

  766. #ifndef BUILD_BRIDGE

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

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

  769. 

  770.     const bool lockWait(isRunning() /*&& pData->options.processMode != ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS*/);

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

  772. 

  773.     /*

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

  775.     {

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

  777.         CARLA_SAFE_ASSERT_BREAK(plugin2 != nullptr);

  778.         plugin2->updateOscURL();

  779.     }

  780.     */

  781. 

  782. # ifdef HAVE_LIBLO

  783.     if (isOscControlRegistered())

  784.         oscSend_control_remove_plugin(id);

  785. # endif

  786. #else

  787.     pData->curPluginCount = 0;

  788.     carla_zeroStructs(pData->plugins, 1);

  789. #endif

  790. 

  791.     delete plugin;

  792. 

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

  794.     return true;

  795. }

  796. 

  797. bool CarlaEngine::removeAllPlugins()

  798. {

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

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

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

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

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

  804. 

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

  806.         return true;

  807. 

  808.     const ScopedThreadStopper sts(this);

  809. 

  810.     const uint curPluginCount(pData->curPluginCount);

  811. 

  812. #ifndef BUILD_BRIDGE

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

  814.         pData->graph.removeAllPlugins();

  815. 

  816. # ifdef HAVE_LIBLO

  817.     if (isOscControlRegistered())

  818.     {

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

  820.             oscSend_control_remove_plugin(curPluginCount-i-1);

  821.     }

  822. # endif

  823. #endif

  824. 

  825.     const bool lockWait(isRunning());

  826.     const ScopedActionLock sal(this, kEnginePostActionZeroCount, 0, 0, lockWait);

  827. 

  828.     callback(ENGINE_CALLBACK_IDLE, 0, 0, 0, 0.0f, nullptr);

  829. 

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

  831.     {

  832.         EnginePluginData& pluginData(pData->plugins[i]);

  833. 

  834.         if (pluginData.plugin != nullptr)

  835.         {

  836.             delete pluginData.plugin;

  837.             pluginData.plugin = nullptr;

  838.         }

  839. 

  840.         pluginData.insPeak[0]  = 0.0f;

  841.         pluginData.insPeak[1]  = 0.0f;

  842.         pluginData.outsPeak[0] = 0.0f;

  843.         pluginData.outsPeak[1] = 0.0f;

  844. 

  845.         callback(ENGINE_CALLBACK_IDLE, 0, 0, 0, 0.0f, nullptr);

  846.     }

  847. 

  848.     return true;

  849. }

  850. 

  851. #ifndef BUILD_BRIDGE

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

  853. {

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

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

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

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

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

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

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

  861. 

  862.     CarlaPlugin* const plugin(pData->plugins[id].plugin);

  863.     CARLA_SAFE_ASSERT_RETURN_ERRN(plugin != nullptr, "Could not find plugin to rename");

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

  865. 

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

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

  868. 

  869.     plugin->setName(uniqueName);

  870. 

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

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

  873. 

  874.     delete[] uniqueName;

  875.     return plugin->getName();

  876. }

  877. 

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

  879. {

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

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

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

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

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

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

  886. 

  887.     CarlaPlugin* const plugin(pData->plugins[id].plugin);

  888. 

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

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

  891. 

  892.     char label[STR_MAX+1];

  893.     carla_zeroChars(label, STR_MAX+1);

  894.     plugin->getLabel(label);

  895. 

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

  897. 

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

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

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

  901.         return false;

  902. 

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

  904. 

  905.     if (CarlaPlugin* const newPlugin = pData->plugins[pluginCountBefore].plugin)

  906.         newPlugin->loadStateSave(plugin->getStateSave());

  907. 

  908.     return true;

  909. }

  910. 

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

  912. {

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

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

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

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

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

  918. 

  919.     // might use this to reset

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

  921.     {

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

  923.         return true;

  924.     }

  925. 

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

  927. 

  928.     CarlaPlugin* const plugin(pData->plugins[id].plugin);

  929. 

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

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

  932. 

  933.     pData->nextPluginId = id;

  934. 

  935.     return true;

  936. }

  937. 

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

  939. {

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

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

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

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

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

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

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

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

  948. 

  949.     CarlaPlugin* const pluginA(pData->plugins[idA].plugin);

  950.     CarlaPlugin* const pluginB(pData->plugins[idB].plugin);

  951. 

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

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

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

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

  956. 

  957.     const ScopedThreadStopper sts(this);

  958. 

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

  960.         pData->graph.replacePlugin(pluginA, pluginB);

  961. 

  962.     const bool lockWait(isRunning() /*&& pData->options.processMode != ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS*/);

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

  964. 

  965.     // TODO

  966.     /*

  967.     pluginA->updateOscURL();

  968.     pluginB->updateOscURL();

  969. 

  970.     if (isOscControlRegistered())

  971.         oscSend_control_switch_plugins(idA, idB);

  972.     */

  973. 

  974.     return true;

  975. }

  976. #endif

  977. 

  978. CarlaPlugin* CarlaEngine::getPlugin(const uint id) const noexcept

  979. {

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

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

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

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

  984. 

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

  986. }

  987. 

  988. CarlaPlugin* CarlaEngine::getPluginUnchecked(const uint id) const noexcept

  989. {

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

  991. }

  992. 

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

  994. {

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

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

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

  998. 

  999.     CarlaString sname;

  1000.     sname = name;

  1001. 

  1002.     if (sname.isEmpty())

  1003.     {

  1004.         sname = "(No name)";

  1005.         return sname.dup();

  1006.     }

  1007. 

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

  1009. 

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

  1011.         return sname.dup();

  1012. 

  1013.     sname.truncate(maxNameSize);

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

  1015. 

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

  1017.     {

  1018.         CARLA_SAFE_ASSERT_BREAK(pData->plugins[i].plugin != nullptr);

  1019. 

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

  1021.         if (const char* const pluginName = pData->plugins[i].plugin->getName())

  1022.         {

  1023.             if (sname != pluginName)

  1024.                 continue;

  1025.         }

  1026. 

  1027.         // Check if string has already been modified

  1028.         {

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

  1030. 

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

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

  1033.             {

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

  1035. 

  1036.                 if (number == 9)

  1037.                 {

  1038.                     // next number is 10, 2 digits

  1039.                     sname.truncate(len-4);

  1040.                     sname += " (10)";

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

  1042.                 }

  1043.                 else

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

  1045. 

  1046.                 continue;

  1047.             }

  1048. 

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

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

  1051.             {

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

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

  1054. 

  1055.                 if (n2 == '9')

  1056.                 {

  1057.                     n2 = '0';

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

  1059.                 }

  1060.                 else

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

  1062. 

  1063.                 sname[len-2] = n2;

  1064.                 sname[len-3] = n3;

  1065. 

  1066.                 continue;

  1067.             }

  1068.         }

  1069. 

  1070.         // Modify string if not

  1071.         sname += " (2)";

  1072.     }

  1073. 

  1074.     return sname.dup();

  1075. }

  1076. 

  1077. // -----------------------------------------------------------------------

  1078. // Project management

  1079. 

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

  1081. {

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

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

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

  1085. 

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

  1087.     File file(jfilename);

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

  1089. 

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

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

  1092. 

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

  1094. 

  1095.     // -------------------------------------------------------------------

  1096. 

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

  1098.         return loadProject(filename);

  1099. 

  1100.     // -------------------------------------------------------------------

  1101. 

  1102.     if (extension == "gig")

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

  1104. 

  1105.     if (extension == "sf2")

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

  1107. 

  1108.     if (extension == "sfz")

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

  1110. 

  1111.     // -------------------------------------------------------------------

  1112. 

  1113.     if (extension == "aif" || extension == "aiff" || extension == "bwf" || extension == "flac" || extension == "ogg" || extension == "wav")

  1114.     {

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

  1116.         {

  1117.             if (CarlaPlugin* const plugin = getPlugin(curPluginId))

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

  1119.             return true;

  1120.         }

  1121.         return false;

  1122.     }

  1123. 

  1124.     // -------------------------------------------------------------------

  1125. 

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

  1127.     {

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

  1129.         {

  1130.             if (CarlaPlugin* const plugin = getPlugin(curPluginId))

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

  1132.             return true;

  1133.         }

  1134.         return false;

  1135.     }

  1136. 

  1137.     // -------------------------------------------------------------------

  1138.     // ZynAddSubFX

  1139. 

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

  1141.     {

  1142. #ifdef HAVE_ZYN_DEPS

  1143.         CarlaString nicerName("Zyn - ");

  1144. 

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

  1146. 

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

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

  1149.         else

  1150.             nicerName += baseName;

  1151. 

  1152.         //nicerName

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

  1154.         {

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

  1156. 

  1157.             if (CarlaPlugin* const plugin = getPlugin(curPluginId))

  1158.                 plugin->setCustomData(CUSTOM_DATA_TYPE_STRING, (extension == "xmz") ? "CarlaAlternateFile1" : "CarlaAlternateFile2", filename, true);

  1159.             return true;

  1160.         }

  1161.         return false;

  1162. #else

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

  1164.         return false;

  1165. #endif

  1166.     }

  1167. 

  1168.     // -------------------------------------------------------------------

  1169. 

  1170.     setLastError("Unknown file extension");

  1171.     return false;

  1172. }

  1173. 

  1174. bool CarlaEngine::loadProject(const char* const filename)

  1175. {

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

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

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

  1179. 

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

  1181.     File file(jfilename);

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

  1183. 

  1184.     XmlDocument xml(file);

  1185.     return loadProjectInternal(xml);

  1186. }

  1187. 

  1188. bool CarlaEngine::saveProject(const char* const filename)

  1189. {

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

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

  1192. 

  1193.     MemoryOutputStream out;

  1194.     saveProjectInternal(out);

  1195. 

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

  1197.     File file(jfilename);

  1198. 

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

  1200.         return true;

  1201. 

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

  1203.     return false;

  1204. }

  1205. 

  1206. // -----------------------------------------------------------------------

  1207. // Information (base)

  1208. 

  1209. uint CarlaEngine::getHints() const noexcept

  1210. {

  1211.     return pData->hints;

  1212. }

  1213. 

  1214. uint32_t CarlaEngine::getBufferSize() const noexcept

  1215. {

  1216.     return pData->bufferSize;

  1217. }

  1218. 

  1219. double CarlaEngine::getSampleRate() const noexcept

  1220. {

  1221.     return pData->sampleRate;

  1222. }

  1223. 

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

  1225. {

  1226.     return pData->name;

  1227. }

  1228. 

  1229. EngineProcessMode CarlaEngine::getProccessMode() const noexcept

  1230. {

  1231.     return pData->options.processMode;

  1232. }

  1233. 

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

  1235. {

  1236.     return pData->options;

  1237. }

  1238. 

  1239. const EngineTimeInfo& CarlaEngine::getTimeInfo() const noexcept

  1240. {

  1241.     return pData->timeInfo;

  1242. }

  1243. 

  1244. // -----------------------------------------------------------------------

  1245. // Information (peaks)

  1246. 

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

  1248. {

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

  1250. 

  1251.     return pData->plugins[pluginId].insPeak[isLeft ? 0 : 1];

  1252. }

  1253. 

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

  1255. {

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

  1257. 

  1258.     return pData->plugins[pluginId].outsPeak[isLeft ? 0 : 1];

  1259. }

  1260. 

  1261. // -----------------------------------------------------------------------

  1262. // Callback

  1263. 

  1264. void CarlaEngine::callback(const EngineCallbackOpcode action, const uint pluginId, const int value1, const int value2, const float value3, const char* const valueStr) noexcept

  1265. {

  1266. #ifdef DEBUG

  1267.     if (action != ENGINE_CALLBACK_IDLE)

  1268.         carla_debug("CarlaEngine::callback(%i:%s, %i, %i, %i, %f, \"%s\")", action, EngineCallbackOpcode2Str(action), pluginId, value1, value2, value3, valueStr);

  1269. #endif

  1270. 

  1271. #ifdef BUILD_BRIDGE

  1272.     if (pData->isIdling)

  1273. #else

  1274.     if (pData->isIdling && action != ENGINE_CALLBACK_PATCHBAY_CLIENT_DATA_CHANGED)

  1275. #endif

  1276.     {

  1277.         carla_stdout("callback while idling (%i:%s, %i, %i, %i, %f, \"%s\")", action, EngineCallbackOpcode2Str(action), pluginId, value1, value2, value3, valueStr);

  1278.     }

  1279. 

  1280.     if (pData->callback != nullptr)

  1281.     {

  1282.         if (action == ENGINE_CALLBACK_IDLE)

  1283.             ++pData->isIdling;

  1284. 

  1285.         try {

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

  1287. #if defined(CARLA_OS_LINUX) && defined(__arm__)

  1288.         } catch (__cxxabiv1::__forced_unwind&) {

  1289.             carla_stderr2("Caught forced unwind exception in callback");

  1290.             throw;

  1291. #endif

  1292.         } catch (...) {

  1293.             carla_safe_exception("callback", __FILE__, __LINE__);

  1294.         }

  1295. 

  1296.         if (action == ENGINE_CALLBACK_IDLE)

  1297.             --pData->isIdling;

  1298.     }

  1299. }

  1300. 

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

  1302. {

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

  1304. 

  1305.     pData->callback    = func;

  1306.     pData->callbackPtr = ptr;

  1307. }

  1308. 

  1309. // -----------------------------------------------------------------------

  1310. // File Callback

  1311. 

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

  1313. {

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

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

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

  1317. 

  1318.     const char* ret = nullptr;

  1319. 

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

  1321.     {

  1322.         try {

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

  1324.         } CARLA_SAFE_EXCEPTION("runFileCallback");

  1325.     }

  1326. 

  1327.     return ret;

  1328. }

  1329. 

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

  1331. {

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

  1333. 

  1334.     pData->fileCallback    = func;

  1335.     pData->fileCallbackPtr = ptr;

  1336. }

  1337. 

  1338. // -----------------------------------------------------------------------

  1339. // Transport

  1340. 

  1341. void CarlaEngine::transportPlay() noexcept

  1342. {

  1343.     pData->time.playing = true;

  1344. }

  1345. 

  1346. void CarlaEngine::transportPause() noexcept

  1347. {

  1348.     pData->time.playing = false;

  1349. }

  1350. 

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

  1352. {

  1353.     pData->time.frame = frame;

  1354. }

  1355. 

  1356. // -----------------------------------------------------------------------

  1357. // Error handling

  1358. 

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

  1360. {

  1361.     return pData->lastError;

  1362. }

  1363. 

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

  1365. {

  1366.     pData->lastError = error;

  1367. }

  1368. 

  1369. // -----------------------------------------------------------------------

  1370. // Misc

  1371. 

  1372. bool CarlaEngine::isAboutToClose() const noexcept

  1373. {

  1374.     return pData->aboutToClose;

  1375. }

  1376. 

  1377. bool CarlaEngine::setAboutToClose() noexcept

  1378. {

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

  1380. 

  1381.     pData->aboutToClose = true;

  1382. 

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

  1384. }

  1385. 

  1386. // -----------------------------------------------------------------------

  1387. // Global options

  1388. 

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

  1390. {

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

  1392. 

  1393.     if (isRunning() && (option == ENGINE_OPTION_PROCESS_MODE || option == ENGINE_OPTION_AUDIO_NUM_PERIODS || option == ENGINE_OPTION_AUDIO_DEVICE))

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

  1395. 

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

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

  1398.         return;

  1399. 

  1400.     switch (option)

  1401.     {

  1402.     case ENGINE_OPTION_DEBUG:

  1403.         break;

  1404. 

  1405.     case ENGINE_OPTION_PROCESS_MODE:

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

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

  1408.         break;

  1409. 

  1410.     case ENGINE_OPTION_TRANSPORT_MODE:

  1411.         CARLA_SAFE_ASSERT_RETURN(value >= ENGINE_TRANSPORT_MODE_INTERNAL && value <= ENGINE_TRANSPORT_MODE_BRIDGE,);

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

  1413.         break;

  1414. 

  1415.     case ENGINE_OPTION_FORCE_STEREO:

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

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

  1418.         break;

  1419. 

  1420.     case ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

  1421. #ifdef BUILD_BRIDGE

  1422.         CARLA_SAFE_ASSERT_RETURN(value == 0,);

  1423. #else

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

  1425. #endif

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

  1427.         break;

  1428. 

  1429.     case ENGINE_OPTION_PREFER_UI_BRIDGES:

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

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

  1432.         break;

  1433. 

  1434.     case ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

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

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

  1437.         break;

  1438. 

  1439.     case ENGINE_OPTION_MAX_PARAMETERS:

  1440.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  1442.         break;

  1443. 

  1444.     case ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  1445.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  1447.         break;

  1448. 

  1449.     case ENGINE_OPTION_AUDIO_NUM_PERIODS:

  1450.         CARLA_SAFE_ASSERT_RETURN(value >= 2 && value <= 3,);

  1451.         pData->options.audioNumPeriods = static_cast<uint>(value);

  1452.         break;

  1453. 

  1454.     case ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  1455.         CARLA_SAFE_ASSERT_RETURN(value >= 8,);

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

  1457.         break;

  1458. 

  1459.     case ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  1460.         CARLA_SAFE_ASSERT_RETURN(value >= 22050,);

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

  1462.         break;

  1463. 

  1464.     case ENGINE_OPTION_AUDIO_DEVICE:

  1465.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  1466. 

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

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

  1469. 

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

  1471.         break;

  1472. 

  1473.     case ENGINE_OPTION_PLUGIN_PATH:

  1474.         CARLA_SAFE_ASSERT_RETURN(value > PLUGIN_NONE,);

  1475.         CARLA_SAFE_ASSERT_RETURN(value <= PLUGIN_SFZ,);

  1476. 

  1477.         switch (value)

  1478.         {

  1479.         case PLUGIN_LADSPA:

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

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

  1482.             if (valueStr != nullptr)

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

  1484.             else

  1485.                 pData->options.pathLADSPA = nullptr;

  1486.             break;

  1487.         case PLUGIN_DSSI:

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

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

  1490.             if (valueStr != nullptr)

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

  1492.             else

  1493.                 pData->options.pathDSSI = nullptr;

  1494.             break;

  1495.         case PLUGIN_LV2:

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

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

  1498.             if (valueStr != nullptr)

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

  1500.             else

  1501.                 pData->options.pathLV2 = nullptr;

  1502.             break;

  1503.         case PLUGIN_VST2:

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

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

  1506.             if (valueStr != nullptr)

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

  1508.             else

  1509.                 pData->options.pathVST2 = nullptr;

  1510.             break;

  1511.         case PLUGIN_VST3:

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

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

  1514.             if (valueStr != nullptr)

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

  1516.             else

  1517.                 pData->options.pathVST3 = nullptr;

  1518.             break;

  1519.         case PLUGIN_GIG:

  1520.             if (pData->options.pathGIG != nullptr)

  1521.                 delete[] pData->options.pathGIG;

  1522.             if (valueStr != nullptr)

  1523.                 pData->options.pathGIG = carla_strdup_safe(valueStr);

  1524.             else

  1525.                 pData->options.pathGIG = nullptr;

  1526.             break;

  1527.         case PLUGIN_SF2:

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

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

  1530.             if (valueStr != nullptr)

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

  1532.             else

  1533.                 pData->options.pathSF2 = nullptr;

  1534.             break;

  1535.         case PLUGIN_SFZ:

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

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

  1538.             if (valueStr != nullptr)

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

  1540.             else

  1541.                 pData->options.pathSFZ = nullptr;

  1542.             break;

  1543.         default:

  1544.             return carla_stderr("CarlaEngine::setOption(%i:%s, %i, \"%s\") - Invalid plugin type", option, EngineOption2Str(option), value, valueStr);

  1545.             break;

  1546.         }

  1547.         break;

  1548. 

  1549.     case ENGINE_OPTION_PATH_BINARIES:

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

  1551. 

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

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

  1554. 

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

  1556.         break;

  1557. 

  1558.     case ENGINE_OPTION_PATH_RESOURCES:

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

  1560. 

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

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

  1563. 

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

  1565.         break;

  1566. 

  1567.     case ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR:

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

  1569. #ifdef CARLA_OS_LINUX

  1570.         if (value != 0)

  1571.         {

  1572.             CarlaString interposerPath(CarlaString(pData->options.binaryDir) + CARLA_OS_SEP_STR "libcarla_interposer.so");

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

  1574.         }

  1575.         else

  1576.         {

  1577.             ::unsetenv("LD_PRELOAD");

  1578.         }

  1579. #endif

  1580.         break;

  1581. 

  1582.     case ENGINE_OPTION_FRONTEND_WIN_ID: {

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

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

  1585.         CARLA_SAFE_ASSERT_RETURN(winId >= 0,);

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

  1587.     }   break;

  1588. 

  1589.     case ENGINE_OPTION_DEBUG_CONSOLE_OUTPUT:

  1590.         break;

  1591.     }

  1592. }

  1593. 

  1594. #ifdef HAVE_LIBLO

  1595. // -----------------------------------------------------------------------

  1596. // OSC Stuff

  1597. 

  1598. # ifndef BUILD_BRIDGE

  1599. bool CarlaEngine::isOscControlRegistered() const noexcept

  1600. {

  1601.     return pData->osc.isControlRegistered();

  1602. }

  1603. # endif

  1604. 

  1605. void CarlaEngine::idleOsc() const noexcept

  1606. {

  1607.     pData->osc.idle();

  1608. }

  1609. 

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

  1611. {

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

  1613. }

  1614. 

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

  1616. {

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

  1618. }

  1619. #endif

  1620. 

  1621. // -----------------------------------------------------------------------

  1622. // Helper functions

  1623. 

  1624. EngineEvent* CarlaEngine::getInternalEventBuffer(const bool isInput) const noexcept

  1625. {

  1626.     return isInput ? pData->events.in : pData->events.out;

  1627. }

  1628. 

  1629. // -----------------------------------------------------------------------

  1630. // Internal stuff

  1631. 

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

  1633. {

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

  1635. 

  1636. #ifndef BUILD_BRIDGE

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

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

  1639.     {

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

  1641.     }

  1642. #endif

  1643. 

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

  1645.     {

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

  1647. 

  1648.         if (plugin != nullptr && plugin->isEnabled())

  1649.             plugin->bufferSizeChanged(newBufferSize);

  1650.     }

  1651. 

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

  1653. }

  1654. 

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

  1656. {

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

  1658. 

  1659. #ifndef BUILD_BRIDGE

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

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

  1662.     {

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

  1664.     }

  1665. #endif

  1666. 

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

  1668.     {

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

  1670. 

  1671.         if (plugin != nullptr && plugin->isEnabled())

  1672.             plugin->sampleRateChanged(newSampleRate);

  1673.     }

  1674. 

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

  1676. }

  1677. 

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

  1679. {

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

  1681. 

  1682. #ifndef BUILD_BRIDGE

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

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

  1685.     {

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

  1687.     }

  1688. #endif

  1689. 

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

  1691.     {

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

  1693. 

  1694.         if (plugin != nullptr && plugin->isEnabled())

  1695.             plugin->offlineModeChanged(isOfflineNow);

  1696.     }

  1697. }

  1698. 

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

  1700. {

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

  1702. 

  1703.     pluginData.insPeak[0]  = inPeaks[0];

  1704.     pluginData.insPeak[1]  = inPeaks[1];

  1705.     pluginData.outsPeak[0] = outPeaks[0];

  1706.     pluginData.outsPeak[1] = outPeaks[1];

  1707. }

  1708. 

  1709. void CarlaEngine::saveProjectInternal(juce::MemoryOutputStream& outStream) const

  1710. {

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

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

  1713.     {

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

  1715. 

  1716.         if (plugin != nullptr && plugin->isEnabled())

  1717.         {

  1718. #ifndef BUILD_BRIDGE

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

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

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

  1722. #endif

  1723.             plugin->prepareForSave();

  1724.         }

  1725.     }

  1726. 

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

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

  1729.     outStream << "<CARLA-PROJECT VERSION='2.0'>\n";

  1730. 

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

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

  1733. 

  1734.     MemoryOutputStream outSettings(1024);

  1735. 

  1736.     // save appropriate engine settings

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

  1738. 

  1739.     //processMode

  1740.     //transportMode

  1741. 

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

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

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

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

  1746. 

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

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

  1749. 

  1750.     if (isPlugin)

  1751.     {

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

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

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

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

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

  1757.         outSettings << "  <GIG_PATH>"    << xmlSafeString(options.pathGIG,    true) << "</GIG_PATH>\n";

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

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

  1760.     }

  1761. 

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

  1763.     outStream << outSettings;

  1764. 

  1765.     char strBuf[STR_MAX+1];

  1766. 

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

  1768.     {

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

  1770. 

  1771.         if (plugin != nullptr && plugin->isEnabled())

  1772.         {

  1773.             MemoryOutputStream outPlugin(4096), streamPlugin;

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

  1775. 

  1776.             outPlugin << "\n";

  1777. 

  1778.             strBuf[0] = '\0';

  1779.             plugin->getRealName(strBuf);

  1780. 

  1781.             if (strBuf[0] != '\0')

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

  1783. 

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

  1785.             outPlugin << streamPlugin;

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

  1787.             outStream << outPlugin;

  1788.         }

  1789.     }

  1790. 

  1791. #ifndef BUILD_BRIDGE

  1792.     // tell bridges we're done saving

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

  1794.     {

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

  1796. 

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

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

  1799.     }

  1800. 

  1801.     // save internal connections

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

  1803.     {

  1804.         if (const char* const* const patchbayConns = getPatchbayConnections(false))

  1805.         {

  1806.             MemoryOutputStream outPatchbay(2048);

  1807. 

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

  1809. 

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

  1811.             {

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

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

  1814. 

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

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

  1817. 

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

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

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

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

  1822.             }

  1823. 

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

  1825.             outStream << outPatchbay;

  1826.         }

  1827.     }

  1828. 

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

  1830.     bool saveExternalConnections;

  1831. 

  1832.     /**/ if (isPlugin)

  1833.         saveExternalConnections = false;

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

  1835.         saveExternalConnections = true;

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

  1837.         saveExternalConnections = false;

  1838.     else if (std::getenv("LADISH_APP_NAME") != nullptr)

  1839.         saveExternalConnections = false;

  1840.     else if (std::getenv("NSM_URL") != nullptr)

  1841.         saveExternalConnections = false;

  1842.     else

  1843.         saveExternalConnections = true;

  1844. 

  1845.     if (saveExternalConnections)

  1846.     {

  1847.         if (const char* const* const patchbayConns = getPatchbayConnections(true))

  1848.         {

  1849.             MemoryOutputStream outPatchbay(2048);

  1850. 

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

  1852. 

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

  1854.             {

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

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

  1857. 

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

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

  1860. 

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

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

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

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

  1865.             }

  1866. 

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

  1868.             outStream << outPatchbay;

  1869.         }

  1870.     }

  1871. #endif

  1872. 

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

  1874. }

  1875. 

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

  1877. {

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

  1879. 

  1880.     // try direct filename first

  1881.     String jbinary(binary);

  1882. 

  1883.     // adjust for current platform

  1884. #ifdef CARLA_OS_WIN

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

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

  1887. #else

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

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

  1890. #endif

  1891. 

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

  1893. 

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

  1895. #ifdef CARLA_OS_MAC

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

  1897.         searchFlags |= File::findDirectories;

  1898. #endif

  1899. 

  1900.     Array<File> results;

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

  1902.     {

  1903.         const File path(*it);

  1904. 

  1905.         results.clear();

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

  1907. 

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

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

  1910.     }

  1911. 

  1912.     // try changing extension

  1913. #if defined(CARLA_OS_MAC)

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

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

  1916. #elif defined(CARLA_OS_WIN)

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

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

  1919. #else

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

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

  1922. #endif

  1923.     else

  1924.         return String();

  1925. 

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

  1927.     {

  1928.         const File path(*it);

  1929. 

  1930.         results.clear();

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

  1932. 

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

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

  1935.     }

  1936. 

  1937.     return String();

  1938. }

  1939. 

  1940. bool CarlaEngine::loadProjectInternal(juce::XmlDocument& xmlDoc)

  1941. {

  1942.     ScopedPointer<XmlElement> xmlElement(xmlDoc.getDocumentElement(true));

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

  1944. 

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

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

  1947. 

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

  1949.     {

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

  1951.         return false;

  1952.     }

  1953. 

  1954. #ifndef BUILD_BRIDGE

  1955.     const ScopedValueSetter<bool> _svs(pData->loadingProject, true, false);

  1956. #endif

  1957. 

  1958.     // completely load file

  1959.     xmlElement = xmlDoc.getDocumentElement(false);

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

  1961. 

  1962.     if (pData->aboutToClose)

  1963.         return true;

  1964. 

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

  1966. 

  1967.     // engine settings

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

  1969.     {

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

  1971. 

  1972.         if (! tagName.equalsIgnoreCase("enginesettings"))

  1973.             continue;

  1974. 

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

  1976.         {

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

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

  1979. 

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

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

  1982. 

  1983.            int option = -1;

  1984.            int value  = 0;

  1985.            const char* valueStr = nullptr;

  1986. 

  1987.             /**/ if (tag.equalsIgnoreCase("forcestereo"))

  1988.             {

  1989.                 option = ENGINE_OPTION_FORCE_STEREO;

  1990.                 value  = text.equalsIgnoreCase("true") ? 1 : 0;

  1991.             }

  1992.             else if (tag.equalsIgnoreCase("preferpluginbridges"))

  1993.             {

  1994.                 option = ENGINE_OPTION_PREFER_PLUGIN_BRIDGES;

  1995.                 value  = text.equalsIgnoreCase("true") ? 1 : 0;

  1996.             }

  1997.             else if (tag.equalsIgnoreCase("preferuibridges"))

  1998.             {

  1999.                 option = ENGINE_OPTION_PREFER_UI_BRIDGES;

  2000.                 value  = text.equalsIgnoreCase("true") ? 1 : 0;

  2001.             }

  2002.             else if (tag.equalsIgnoreCase("uisalwaysontop"))

  2003.             {

  2004.                 option = ENGINE_OPTION_UIS_ALWAYS_ON_TOP;

  2005.                 value  = text.equalsIgnoreCase("true") ? 1 : 0;

  2006.             }

  2007.             else if (tag.equalsIgnoreCase("maxparameters"))

  2008.             {

  2009.                 option = ENGINE_OPTION_MAX_PARAMETERS;

  2010.                 value  = text.getIntValue();

  2011.             }

  2012.             else if (tag.equalsIgnoreCase("uibridgestimeout"))

  2013.             {

  2014.                 option = ENGINE_OPTION_UI_BRIDGES_TIMEOUT;

  2015.                 value  = text.getIntValue();

  2016.             }

  2017.             else if (isPlugin)

  2018.             {

  2019.                 /**/ if (tag.equalsIgnoreCase("LADSPA_PATH"))

  2020.                 {

  2021.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2022.                     value    = PLUGIN_LADSPA;

  2023.                     valueStr = text.toRawUTF8();

  2024.                 }

  2025.                 else if (tag.equalsIgnoreCase("DSSI_PATH"))

  2026.                 {

  2027.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2028.                     value    = PLUGIN_DSSI;

  2029.                     valueStr = text.toRawUTF8();

  2030.                 }

  2031.                 else if (tag.equalsIgnoreCase("LV2_PATH"))

  2032.                 {

  2033.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2034.                     value    = PLUGIN_LV2;

  2035.                     valueStr = text.toRawUTF8();

  2036.                 }

  2037.                 else if (tag.equalsIgnoreCase("VST2_PATH"))

  2038.                 {

  2039.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2040.                     value    = PLUGIN_VST2;

  2041.                     valueStr = text.toRawUTF8();

  2042.                 }

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

  2044.                 {

  2045.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2046.                     value    = PLUGIN_VST3;

  2047.                     valueStr = text.toRawUTF8();

  2048.                 }

  2049.                 else if (tag.equalsIgnoreCase("GIG_PATH"))

  2050.                 {

  2051.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2052.                     value    = PLUGIN_GIG;

  2053.                     valueStr = text.toRawUTF8();

  2054.                 }

  2055.                 else if (tag.equalsIgnoreCase("SF2_PATH"))

  2056.                 {

  2057.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2058.                     value    = PLUGIN_SF2;

  2059.                     valueStr = text.toRawUTF8();

  2060.                 }

  2061.                 else if (tag.equalsIgnoreCase("SFZ_PATH"))

  2062.                 {

  2063.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2064.                     value    = PLUGIN_SFZ;

  2065.                     valueStr = text.toRawUTF8();

  2066.                 }

  2067.             }

  2068. 

  2069.             CARLA_SAFE_ASSERT_CONTINUE(option != -1);

  2070. 

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

  2072.         }

  2073. 

  2074.         break;

  2075.     }

  2076. 

  2077.     if (pData->aboutToClose)

  2078.         return true;

  2079. 

  2080.     // handle plugins first

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

  2082.     {

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

  2084. 

  2085.         if (isPreset || tagName.equalsIgnoreCase("plugin"))

  2086.         {

  2087.             CarlaStateSave stateSave;

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

  2089. 

  2090.             callback(ENGINE_CALLBACK_IDLE, 0, 0, 0, 0.0f, nullptr);

  2091. 

  2092.             if (pData->aboutToClose)

  2093.                 return true;

  2094. 

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

  2096. 

  2097.             const void* extraStuff    = nullptr;

  2098.             static const char kTrue[] = "true";

  2099. 

  2100.             const PluginType ptype(getPluginTypeFromString(stateSave.type));

  2101. 

  2102.             switch (ptype)

  2103.             {

  2104.             case PLUGIN_GIG:

  2105.             case PLUGIN_SF2:

  2106.                 if (CarlaString(stateSave.label).endsWith(" (16 outs)"))

  2107.                     extraStuff = kTrue;

  2108.                 // nobreak

  2109.             case PLUGIN_LADSPA:

  2110.             case PLUGIN_DSSI:

  2111.             case PLUGIN_VST2:

  2112.             case PLUGIN_VST3:

  2113.             case PLUGIN_SFZ:

  2114.                 if (stateSave.binary != nullptr && stateSave.binary[0] != '\0' &&

  2115.                     ! (File::isAbsolutePath(stateSave.binary) && File(stateSave.binary).exists()))

  2116.                 {

  2117.                     const char* searchPath;

  2118. 

  2119.                     switch (ptype)

  2120.                     {

  2121.                     case PLUGIN_LADSPA: searchPath = pData->options.pathLADSPA; break;

  2122.                     case PLUGIN_DSSI:   searchPath = pData->options.pathDSSI;   break;

  2123.                     case PLUGIN_VST2:   searchPath = pData->options.pathVST2;   break;

  2124.                     case PLUGIN_VST3:   searchPath = pData->options.pathVST3;   break;

  2125.                     case PLUGIN_GIG:    searchPath = pData->options.pathGIG;    break;

  2126.                     case PLUGIN_SF2:    searchPath = pData->options.pathSF2;    break;

  2127.                     case PLUGIN_SFZ:    searchPath = pData->options.pathSFZ;    break;

  2128.                     default:            searchPath = nullptr;                   break;

  2129.                     }

  2130. 

  2131.                     if (searchPath != nullptr && searchPath[0] != '\0')

  2132.                     {

  2133.                         carla_stderr("Plugin binary '%s' doesn't exist on this filesystem, let's look for it...",

  2134.                                      stateSave.binary);

  2135. 

  2136.                         const String result(findBinaryInCustomPath(searchPath, stateSave.binary));

  2137. 

  2138.                         if (result.isNotEmpty())

  2139.                         {

  2140.                             delete[] stateSave.binary;

  2141.                             stateSave.binary = carla_strdup(result.toRawUTF8());

  2142.                             carla_stderr("Found it! :)");

  2143.                         }

  2144.                         else

  2145.                         {

  2146.                             carla_stderr("Damn, we failed... :(");

  2147.                         }

  2148.                     }

  2149.                 }

  2150.                 break;

  2151.             default:

  2152.                 break;

  2153.             }

  2154. 

  2155.             if (addPlugin(getBinaryTypeFromFile(stateSave.binary), ptype, stateSave.binary,

  2156.                           stateSave.name, stateSave.label, stateSave.uniqueId, extraStuff, stateSave.options))

  2157.             {

  2158.                 const uint pluginId = pData->curPluginCount;

  2159. 

  2160.                 if (CarlaPlugin* const plugin = pData->plugins[pluginId].plugin)

  2161.                 {

  2162.                     callback(ENGINE_CALLBACK_IDLE, 0, 0, 0, 0.0f, nullptr);

  2163. 

  2164.                     if (pData->aboutToClose)

  2165.                         return true;

  2166. 

  2167. #ifndef BUILD_BRIDGE

  2168.                     // deactivate bridge client-side ping check, since some plugins block during load

  2169.                     if ((plugin->getHints() & PLUGIN_IS_BRIDGE) != 0 && ! isPreset)

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

  2171. #endif

  2172.                     plugin->loadStateSave(stateSave);

  2173. 

  2174.                     /* NOTE: The following code is the same as the end of addPlugin().

  2175.                      *       When project is loading we do not enable the plugin right away,

  2176.                      *        as we want to load state first.

  2177.                      */

  2178. #ifdef BUILD_BRIDGE

  2179.                     plugin->setActive(true, true, false);

  2180. #endif

  2181.                     plugin->setEnabled(true);

  2182. 

  2183.                     ++pData->curPluginCount;

  2184.                     callback(ENGINE_CALLBACK_PLUGIN_ADDED, pluginId, 0, 0, 0.0f, plugin->getName());

  2185. 

  2186. #ifndef BUILD_BRIDGE

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

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

  2189. #endif

  2190.                 }

  2191.                 else

  2192.                 {

  2193.                     carla_stderr2("Failed to get new plugin, state will not be restored correctly\n");

  2194.                 }

  2195.             }

  2196.             else

  2197.             {

  2198.                 carla_stderr2("Failed to load a plugin, error was:\n%s", getLastError());

  2199.             }

  2200.         }

  2201. 

  2202.         if (isPreset)

  2203.             return true;

  2204.     }

  2205. 

  2206. #ifndef BUILD_BRIDGE

  2207.     // tell bridges we're done loading

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

  2209.     {

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

  2211. 

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

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

  2214.     }

  2215. 

  2216.     callback(ENGINE_CALLBACK_IDLE, 0, 0, 0, 0.0f, nullptr);

  2217. 

  2218.     if (pData->aboutToClose)

  2219.         return true;

  2220. 

  2221.     // handle connections (internal)

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

  2223.     {

  2224.         const bool isUsingExternal(pData->graph.isUsingExternal());

  2225. 

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

  2227.         {

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

  2229. 

  2230.             if (! tagName.equalsIgnoreCase("patchbay"))

  2231.                 continue;

  2232. 

  2233.             CarlaString sourcePort, targetPort;

  2234. 

  2235.             for (XmlElement* patchElem = elem->getFirstChildElement(); patchElem != nullptr; patchElem = patchElem->getNextElement())

  2236.             {

  2237.                 const String& patchTag(patchElem->getTagName());

  2238. 

  2239.                 sourcePort.clear();

  2240.                 targetPort.clear();

  2241. 

  2242.                 if (! patchTag.equalsIgnoreCase("connection"))

  2243.                     continue;

  2244. 

  2245.                 for (XmlElement* connElem = patchElem->getFirstChildElement(); connElem != nullptr; connElem = connElem->getNextElement())

  2246.                 {

  2247.                     const String& tag(connElem->getTagName());

  2248.                     const String  text(connElem->getAllSubText().trim());

  2249. 

  2250.                     /**/ if (tag.equalsIgnoreCase("source"))

  2251.                         sourcePort = xmlSafeString(text, false).toRawUTF8();

  2252.                     else if (tag.equalsIgnoreCase("target"))

  2253.                         targetPort = xmlSafeString(text, false).toRawUTF8();

  2254.                 }

  2255. 

  2256.                 if (sourcePort.isNotEmpty() && targetPort.isNotEmpty())

  2257.                     restorePatchbayConnection(false, sourcePort, targetPort, !isUsingExternal);

  2258.             }

  2259.             break;

  2260.         }

  2261. 

  2262.         callback(ENGINE_CALLBACK_IDLE, 0, 0, 0, 0.0f, nullptr);

  2263. 

  2264.         if (pData->aboutToClose)

  2265.             return true;

  2266.     }

  2267. 

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

  2269.     bool loadExternalConnections;

  2270. 

  2271.     /**/ if (isPlugin)

  2272.         loadExternalConnections = false;

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

  2274.         loadExternalConnections = true;

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

  2276.         loadExternalConnections = false;

  2277.     else if (std::getenv("LADISH_APP_NAME") != nullptr)

  2278.         loadExternalConnections = false;

  2279.     else if (std::getenv("NSM_URL") != nullptr)

  2280.         loadExternalConnections = false;

  2281.     else

  2282.         loadExternalConnections = true;

  2283. 

  2284.     // handle connections (external)

  2285.     if (loadExternalConnections)

  2286.     {

  2287.         const bool isUsingExternal(pData->graph.isUsingExternal());

  2288. 

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

  2290.         {

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

  2292. 

  2293.             if (! tagName.equalsIgnoreCase("externalpatchbay"))

  2294.                 continue;

  2295. 

  2296.             CarlaString sourcePort, targetPort;

  2297. 

  2298.             for (XmlElement* patchElem = elem->getFirstChildElement(); patchElem != nullptr; patchElem = patchElem->getNextElement())

  2299.             {

  2300.                 const String& patchTag(patchElem->getTagName());

  2301. 

  2302.                 sourcePort.clear();

  2303.                 targetPort.clear();

  2304. 

  2305.                 if (! patchTag.equalsIgnoreCase("connection"))

  2306.                     continue;

  2307. 

  2308.                 for (XmlElement* connElem = patchElem->getFirstChildElement(); connElem != nullptr; connElem = connElem->getNextElement())

  2309.                 {

  2310.                     const String& tag(connElem->getTagName());

  2311.                     const String  text(connElem->getAllSubText().trim());

  2312. 

  2313.                     /**/ if (tag.equalsIgnoreCase("source"))

  2314.                         sourcePort = xmlSafeString(text, false).toRawUTF8();

  2315.                     else if (tag.equalsIgnoreCase("target"))

  2316.                         targetPort = xmlSafeString(text, false).toRawUTF8();

  2317.                 }

  2318. 

  2319.                 if (sourcePort.isNotEmpty() && targetPort.isNotEmpty())

  2320.                     restorePatchbayConnection(true, sourcePort, targetPort, isUsingExternal);

  2321.             }

  2322.             break;

  2323.         }

  2324.     }

  2325. #endif

  2326. 

  2327.     return true;

  2328. }

  2329. 

  2330. // -----------------------------------------------------------------------

  2331. 

  2332. CARLA_BACKEND_END_NAMESPACE