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

2374 lines
82KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Host

  3.  * Copyright (C) 2011-2017 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. 

  38. #include "AppConfig.h"

  39. #include "juce_core/juce_core.h"

  40. 

  41. using juce::Array;

  42. using juce::CharPointer_UTF8;

  43. using juce::File;

  44. using juce::MemoryOutputStream;

  45. using juce::ScopedPointer;

  46. using juce::String;

  47. using juce::StringArray;

  48. using juce::XmlDocument;

  49. using juce::XmlElement;

  50. 

  51. CARLA_BACKEND_START_NAMESPACE

  52. 

  53. // -----------------------------------------------------------------------

  54. // Carla Engine

  55. 

  56. CarlaEngine::CarlaEngine()

  57.     : pData(new ProtectedData(this))

  58. {

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

  60. }

  61. 

  62. CarlaEngine::~CarlaEngine()

  63. {

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

  65. 

  66.     delete pData;

  67. }

  68. 

  69. // -----------------------------------------------------------------------

  70. // Static calls

  71. 

  72. uint CarlaEngine::getDriverCount()

  73. {

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

  75. 

  76.     uint count = 0;

  77. 

  78.     if (jackbridge_is_ok())

  79.         count += 1;

  80. 

  81. #ifndef BUILD_BRIDGE

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

  83.     count += getJuceApiCount();

  84. # else

  85.     count += getRtAudioApiCount();

  86. # endif

  87. #endif

  88. 

  89.     return count;

  90. }

  91. 

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

  93. {

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

  95. 

  96.     uint index(index2);

  97. 

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

  99.         return "JACK";

  100. 

  101. #ifndef BUILD_BRIDGE

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

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

  104.     {

  105.         if (index < count)

  106.             return getJuceApiName(index);

  107.         index -= count;

  108.     }

  109. # else

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

  111.     {

  112.         if (index < count)

  113.             return getRtAudioApiName(index);

  114.         index -= count;

  115.     }

  116. # endif

  117. #endif

  118. 

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

  120.     return nullptr;

  121. }

  122. 

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

  124. {

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

  126. 

  127.     uint index(index2);

  128. 

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

  130.     {

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

  132.         return ret;

  133.     }

  134. 

  135. #ifndef BUILD_BRIDGE

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

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

  138.     {

  139.         if (index < count)

  140.             return getJuceApiDeviceNames(index);

  141.         index -= count;

  142.     }

  143. # else

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

  145.     {

  146.         if (index < count)

  147.             return getRtAudioApiDeviceNames(index);

  148.         index -= count;

  149.     }

  150. # endif

  151. #endif

  152. 

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

  154.     return nullptr;

  155. }

  156. 

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

  158. {

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

  160. 

  161.     uint index(index2);

  162. 

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

  164.     {

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

  166.         static EngineDriverDeviceInfo devInfo;

  167.         devInfo.hints       = ENGINE_DRIVER_DEVICE_VARIABLE_BUFFER_SIZE;

  168.         devInfo.bufferSizes = bufSizes;

  169.         devInfo.sampleRates = nullptr;

  170.         return &devInfo;

  171.     }

  172. 

  173. #ifndef BUILD_BRIDGE

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

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

  176.     {

  177.         if (index < count)

  178.             return getJuceDeviceInfo(index, deviceName);

  179.         index -= count;

  180.     }

  181. # else

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

  183.     {

  184.         if (index < count)

  185.             return getRtAudioDeviceInfo(index, deviceName);

  186.         index -= count;

  187.     }

  188. # endif

  189. #endif

  190. 

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

  192.     return nullptr;

  193. }

  194. 

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

  196. {

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

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

  199. 

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

  201.         return newJack();

  202. 

  203. #ifndef BUILD_BRIDGE

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

  205.     // -------------------------------------------------------------------

  206.     // macos

  207. 

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

  209.         return newJuce(AUDIO_API_CORE);

  210. 

  211.     // -------------------------------------------------------------------

  212.     // windows

  213. 

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

  215.         return newJuce(AUDIO_API_ASIO);

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

  217.         return newJuce(AUDIO_API_DS);

  218. #else

  219.     // -------------------------------------------------------------------

  220.     // common

  221. 

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

  223.         return newRtAudio(AUDIO_API_JACK);

  224. 

  225.     // -------------------------------------------------------------------

  226.     // linux

  227. 

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

  229.         return newRtAudio(AUDIO_API_ALSA);

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

  231.         return newRtAudio(AUDIO_API_OSS);

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

  233.         return newRtAudio(AUDIO_API_PULSE);

  234. # endif

  235. #endif

  236. 

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

  238.     return nullptr;

  239. }

  240. 

  241. // -----------------------------------------------------------------------

  242. // Constant values

  243. 

  244. uint CarlaEngine::getMaxClientNameSize() const noexcept

  245. {

  246.     return STR_MAX/2;

  247. }

  248. 

  249. uint CarlaEngine::getMaxPortNameSize() const noexcept

  250. {

  251.     return STR_MAX;

  252. }

  253. 

  254. uint CarlaEngine::getCurrentPluginCount() const noexcept

  255. {

  256.     return pData->curPluginCount;

  257. }

  258. 

  259. uint CarlaEngine::getMaxPluginNumber() const noexcept

  260. {

  261.     return pData->maxPluginNumber;

  262. }

  263. 

  264. // -----------------------------------------------------------------------

  265. // Virtual, per-engine type calls

  266. 

  267. bool CarlaEngine::close()

  268. {

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

  270. 

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

  272.     {

  273.         pData->aboutToClose = true;

  274.         removeAllPlugins();

  275.     }

  276. 

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

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

  279.         oscSend_control_exit();

  280. #endif

  281. 

  282.     pData->close();

  283. 

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

  285.     return true;

  286. }

  287. 

  288. bool CarlaEngine::usesConstantBufferSize() const noexcept

  289. {

  290.     return true;

  291. }

  292. 

  293. void CarlaEngine::idle() noexcept

  294. {

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

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

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

  298. 

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

  300.     {

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

  302. 

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

  304.         {

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

  306. 

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

  308.             {

  309.                 try {

  310.                     plugin->uiIdle();

  311.                 } CARLA_SAFE_EXCEPTION_CONTINUE("Plugin uiIdle");

  312.             }

  313.         }

  314.     }

  315. 

  316. #ifdef HAVE_LIBLO

  317.     pData->osc.idle();

  318. #endif

  319. }

  320. 

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

  322. {

  323.     return new CarlaEngineClient(*this);

  324. }

  325. 

  326. // -----------------------------------------------------------------------

  327. // Plugin management

  328. 

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

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

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

  332. {

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

  334. #ifndef BUILD_BRIDGE

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

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

  337. #endif

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

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

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

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

  342.     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);

  343. 

  344.     uint id;

  345. 

  346. #ifndef BUILD_BRIDGE

  347.     CarlaPlugin* oldPlugin = nullptr;

  348. 

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

  350.     {

  351.         id = pData->nextPluginId;

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

  353. 

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

  355. 

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

  357.     }

  358.     else

  359. #endif

  360.     {

  361.         id = pData->curPluginCount;

  362. 

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

  364.         {

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

  366.             return false;

  367.         }

  368. 

  369. #ifndef BUILD_BRIDGE

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

  371. #endif

  372.     }

  373. 

  374.     CarlaPlugin::Initializer initializer = {

  375.         this,

  376.         id,

  377.         filename,

  378.         name,

  379.         label,

  380.         uniqueId,

  381.         options

  382.     };

  383. 

  384.     CarlaPlugin* plugin = nullptr;

  385. 

  386. #ifndef BUILD_BRIDGE

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

  388. 

  389.     if (bridgeBinary.isNotEmpty())

  390.     {

  391.         if (btype == BINARY_NATIVE)

  392.         {

  393. # ifdef CARLA_OS_WIN

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

  395. # else

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

  397. # endif

  398.         }

  399.         else

  400.         {

  401.             switch (btype)

  402.             {

  403.             case BINARY_POSIX32:

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

  405.                 break;

  406.             case BINARY_POSIX64:

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

  408.                 break;

  409.             case BINARY_WIN32:

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

  411.                 break;

  412.             case BINARY_WIN64:

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

  414.                 break;

  415.             default:

  416.                 bridgeBinary.clear();

  417.                 break;

  418.             }

  419.         }

  420. 

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

  422.             bridgeBinary.clear();

  423.     }

  424. 

  425.     // Prefer bridges for some specific plugins

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

  427. 

  428. # ifdef CARLA_OS_LINUX

  429.     if (! preferBridges)

  430.     {

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

  432.         {

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

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

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

  436.             {

  437.                 preferBridges = true;

  438.             }

  439.         }

  440. #if 0

  441.         else if (ptype == PLUGIN_VST2)

  442.         {

  443.             /*

  444.             char uniqueIdChars[5] = {

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

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

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

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

  449.                 0

  450.             };

  451.             */

  452. 

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

  454.                 preferBridges = true;

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

  456.                 preferBridges = true;

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

  458.                 preferBridges = true;

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

  460.                 preferBridges = true;

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

  462.                 preferBridges = true;

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

  464.                 preferBridges = true;

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

  466.                 preferBridges = true;

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

  468.                 preferBridges = true;

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

  470.                 preferBridges = true;

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

  472.                 preferBridges = true;

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

  474.                 preferBridges = true;

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

  476.                 preferBridges = true;

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

  478.                 preferBridges = true;

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

  480.                 preferBridges = true;

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

  482.                 preferBridges = true;

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

  484.                 preferBridges = true;

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

  486.                 preferBridges = true;

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

  488.                 preferBridges = true;

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

  490.                 preferBridges = true;

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

  492.                 preferBridges = true;

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

  494.                 preferBridges = true;

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

  496.                 preferBridges = true;

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

  498.                 preferBridges = true;

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

  500.                 preferBridges = true;

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

  502.                 preferBridges = true;

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

  504.                 preferBridges = true;

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

  506.                 preferBridges = true;

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

  508.                 preferBridges = true;

  509.         }

  510. #endif

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

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

  513.         {

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

  515.             if (! pData->loadingProject)

  516.                 pData->firstLinuxSamplerInstance = true;

  517. 

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

  519.             else if (pData->firstLinuxSamplerInstance)

  520.                 pData->firstLinuxSamplerInstance = false;

  521. 

  522.             // now check if bridge is needed

  523.             if (! pData->firstLinuxSamplerInstance)

  524.                 preferBridges = true;

  525.         }

  526.     }

  527. # endif

  528. 

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

  530.     {

  531.         if (bridgeBinary.isNotEmpty())

  532.         {

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

  534.         }

  535.         else

  536.         {

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

  538.             return false;

  539.         }

  540.     }

  541.     else

  542. #endif // ! BUILD_BRIDGE

  543.     {

  544.         bool use16Outs;

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

  546. 

  547.         switch (ptype)

  548.         {

  549.         case PLUGIN_NONE:

  550.             break;

  551. 

  552.         case PLUGIN_INTERNAL:

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

  554.             {

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

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

  557.             }

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

  559.             {

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

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

  562.             }

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

  564.             {

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

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

  567.             }

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

  569.             {

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

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

  572.             }*/

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

  574.             break;

  575. 

  576.         case PLUGIN_LADSPA:

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

  578.             break;

  579. 

  580.         case PLUGIN_DSSI:

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

  582.             {

  583.                 const ScopedEngineEnvironmentLocker _seel(this);

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

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

  586.             }

  587.             else

  588.             {

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

  590.             }

  591.             break;

  592. 

  593.         case PLUGIN_LV2:

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

  595.             break;

  596. 

  597.         case PLUGIN_VST2:

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

  599.             break;

  600. 

  601.         case PLUGIN_VST3:

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

  603.             break;

  604. 

  605.         case PLUGIN_AU:

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

  607.             break;

  608. 

  609.         case PLUGIN_GIG:

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

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

  612.             break;

  613. 

  614.         case PLUGIN_SF2:

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

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

  617.             break;

  618. 

  619.         case PLUGIN_SFZ:

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

  621.             break;

  622. 

  623.         case PLUGIN_JACK:

  624. #ifndef BUILD_BRIDGE

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

  626. #endif

  627.             break;

  628.         }

  629.     }

  630. 

  631.     if (plugin == nullptr)

  632.         return false;

  633. 

  634.     plugin->reload();

  635. 

  636.     bool canRun = true;

  637. 

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

  639.     {

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

  641.         {

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

  643.             canRun = false;

  644.         }

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

  646.         {

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

  648.             canRun = false;

  649.         }

  650.     }

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

  652.     {

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

  654.         {

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

  656.             canRun = false;

  657.         }

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

  659.         {

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

  661.             canRun = false;

  662.         }

  663.     }

  664. 

  665.     if (! canRun)

  666.     {

  667.         delete plugin;

  668.         return false;

  669.     }

  670. 

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

  672.     plugin->registerToOscClient();

  673. #endif

  674. 

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

  676.     pluginData.plugin      = plugin;

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

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

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

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

  681. 

  682. #ifndef BUILD_BRIDGE

  683.     if (oldPlugin != nullptr)

  684.     {

  685.         CARLA_SAFE_ASSERT(! pData->loadingProject);

  686. 

  687.         const ScopedThreadStopper sts(this);

  688. 

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

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

  691. 

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

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

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

  695. 

  696.         delete oldPlugin;

  697. 

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

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

  700. 

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

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

  703. 

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

  705.         plugin->setEnabled(true);

  706. 

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

  708.     }

  709.     else if (! pData->loadingProject)

  710. #endif

  711.     {

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

  713.         plugin->setEnabled(true);

  714. 

  715.         ++pData->curPluginCount;

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

  717. 

  718. #ifndef BUILD_BRIDGE

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

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

  721. #endif

  722.     }

  723. 

  724.     return true;

  725. }

  726. 

  727. 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)

  728. {

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

  730. }

  731. 

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

  733. {

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

  735. #ifndef BUILD_BRIDGE

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

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

  738. #endif

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

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

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

  742. 

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

  744. 

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

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

  747. 

  748.     const ScopedThreadStopper sts(this);

  749. 

  750. #ifndef BUILD_BRIDGE

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

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

  753. 

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

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

  756. 

  757.     /*

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

  759.     {

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

  761.         CARLA_SAFE_ASSERT_BREAK(plugin2 != nullptr);

  762.         plugin2->updateOscURL();

  763.     }

  764.     */

  765. 

  766. # ifdef HAVE_LIBLO

  767.     if (isOscControlRegistered())

  768.         oscSend_control_remove_plugin(id);

  769. # endif

  770. #else

  771.     pData->curPluginCount = 0;

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

  773. #endif

  774. 

  775.     delete plugin;

  776. 

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

  778.     return true;

  779. }

  780. 

  781. bool CarlaEngine::removeAllPlugins()

  782. {

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

  784. #ifndef BUILD_BRIDGE

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

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

  787. #endif

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

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

  790. 

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

  792.         return true;

  793. 

  794.     const ScopedThreadStopper sts(this);

  795. 

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

  797. 

  798. #ifndef BUILD_BRIDGE

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

  800.         pData->graph.removeAllPlugins();

  801. 

  802. # ifdef HAVE_LIBLO

  803.     if (isOscControlRegistered())

  804.     {

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

  806.             oscSend_control_remove_plugin(curPluginCount-i-1);

  807.     }

  808. # endif

  809. #endif

  810. 

  811.     const bool lockWait(isRunning());

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

  813. 

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

  815. 

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

  817.     {

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

  819. 

  820.         if (pluginData.plugin != nullptr)

  821.         {

  822.             delete pluginData.plugin;

  823.             pluginData.plugin = nullptr;

  824.         }

  825. 

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

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

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

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

  830. 

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

  832.     }

  833. 

  834.     return true;

  835. }

  836. 

  837. #ifndef BUILD_BRIDGE

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

  839. {

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

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

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

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

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

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

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

  847. 

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

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

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

  851. 

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

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

  854. 

  855.     plugin->setName(uniqueName);

  856. 

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

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

  859. 

  860.     delete[] uniqueName;

  861.     return plugin->getName();

  862. }

  863. 

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

  865. {

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

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

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

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

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

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

  872. 

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

  874. 

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

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

  877. 

  878.     char label[STR_MAX+1];

  879.     carla_zeroChars(label, STR_MAX+1);

  880.     plugin->getLabel(label);

  881. 

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

  883. 

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

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

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

  887.         return false;

  888. 

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

  890. 

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

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

  893. 

  894.     return true;

  895. }

  896. 

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

  898. {

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

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

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

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

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

  904. 

  905.     // might use this to reset

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

  907.     {

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

  909.         return true;

  910.     }

  911. 

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

  913. 

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

  915. 

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

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

  918. 

  919.     pData->nextPluginId = id;

  920. 

  921.     return true;

  922. }

  923. 

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

  925. {

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

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

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

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

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

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

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

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

  934. 

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

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

  937. 

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

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

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

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

  942. 

  943.     const ScopedThreadStopper sts(this);

  944. 

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

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

  947. 

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

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

  950. 

  951.     // TODO

  952.     /*

  953.     pluginA->updateOscURL();

  954.     pluginB->updateOscURL();

  955. 

  956.     if (isOscControlRegistered())

  957.         oscSend_control_switch_plugins(idA, idB);

  958.     */

  959. 

  960.     return true;

  961. }

  962. #endif

  963. 

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

  965. {

  966. #ifndef BUILD_BRIDGE

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

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

  969. #endif

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

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

  972. 

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

  974. }

  975. 

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

  977. {

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

  979. }

  980. 

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

  982. {

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

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

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

  986. 

  987.     CarlaString sname;

  988.     sname = name;

  989. 

  990.     if (sname.isEmpty())

  991.     {

  992.         sname = "(No name)";

  993.         return sname.dup();

  994.     }

  995. 

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

  997. 

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

  999.         return sname.dup();

  1000. 

  1001.     sname.truncate(maxNameSize);

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

  1003. 

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

  1005.     {

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

  1007. 

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

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

  1010.         {

  1011.             if (sname != pluginName)

  1012.                 continue;

  1013.         }

  1014. 

  1015.         // Check if string has already been modified

  1016.         {

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

  1018. 

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

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

  1021.             {

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

  1023. 

  1024.                 if (number == 9)

  1025.                 {

  1026.                     // next number is 10, 2 digits

  1027.                     sname.truncate(len-4);

  1028.                     sname += " (10)";

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

  1030.                 }

  1031.                 else

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

  1033. 

  1034.                 continue;

  1035.             }

  1036. 

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

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

  1039.             {

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

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

  1042. 

  1043.                 if (n2 == '9')

  1044.                 {

  1045.                     n2 = '0';

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

  1047.                 }

  1048.                 else

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

  1050. 

  1051.                 sname[len-2] = n2;

  1052.                 sname[len-3] = n3;

  1053. 

  1054.                 continue;

  1055.             }

  1056.         }

  1057. 

  1058.         // Modify string if not

  1059.         sname += " (2)";

  1060.     }

  1061. 

  1062.     return sname.dup();

  1063. }

  1064. 

  1065. // -----------------------------------------------------------------------

  1066. // Project management

  1067. 

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

  1069. {

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

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

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

  1073. 

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

  1075.     File file(jfilename);

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

  1077. 

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

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

  1080. 

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

  1082. 

  1083.     // -------------------------------------------------------------------

  1084. 

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

  1086.         return loadProject(filename);

  1087. 

  1088.     // -------------------------------------------------------------------

  1089. 

  1090.     if (extension == "gig")

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

  1092. 

  1093.     if (extension == "sf2")

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

  1095. 

  1096.     if (extension == "sfz")

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

  1098. 

  1099.     // -------------------------------------------------------------------

  1100. 

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

  1102.     {

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

  1104.         {

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

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

  1107.             return true;

  1108.         }

  1109.         return false;

  1110.     }

  1111. 

  1112.     // -------------------------------------------------------------------

  1113. 

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

  1115.     {

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

  1117.         {

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

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

  1120.             return true;

  1121.         }

  1122.         return false;

  1123.     }

  1124. 

  1125.     // -------------------------------------------------------------------

  1126.     // ZynAddSubFX

  1127. 

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

  1129.     {

  1130. #ifdef HAVE_ZYN_DEPS

  1131.         CarlaString nicerName("Zyn - ");

  1132. 

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

  1134. 

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

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

  1137.         else

  1138.             nicerName += baseName;

  1139. 

  1140.         //nicerName

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

  1142.         {

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

  1144. 

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

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

  1147.             return true;

  1148.         }

  1149.         return false;

  1150. #else

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

  1152.         return false;

  1153. #endif

  1154.     }

  1155. 

  1156.     // -------------------------------------------------------------------

  1157.     // Direct plugin binaries

  1158. 

  1159. #ifdef CARLA_OS_MAC

  1160.     if (extension == "vst")

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

  1162. #else

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

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

  1165. #endif

  1166. 

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

  1168.     if (extension == "vst3")

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

  1170. #endif

  1171. 

  1172.     // -------------------------------------------------------------------

  1173. 

  1174.     setLastError("Unknown file extension");

  1175.     return false;

  1176. }

  1177. 

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

  1179. {

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

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

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

  1183. 

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

  1185.     File file(jfilename);

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

  1187. 

  1188.     XmlDocument xml(file);

  1189.     return loadProjectInternal(xml);

  1190. }

  1191. 

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

  1193. {

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

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

  1196. 

  1197.     MemoryOutputStream out;

  1198.     saveProjectInternal(out);

  1199. 

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

  1201.     File file(jfilename);

  1202. 

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

  1204.         return true;

  1205. 

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

  1207.     return false;

  1208. }

  1209. 

  1210. // -----------------------------------------------------------------------

  1211. // Information (base)

  1212. 

  1213. uint CarlaEngine::getHints() const noexcept

  1214. {

  1215.     return pData->hints;

  1216. }

  1217. 

  1218. uint32_t CarlaEngine::getBufferSize() const noexcept

  1219. {

  1220.     return pData->bufferSize;

  1221. }

  1222. 

  1223. double CarlaEngine::getSampleRate() const noexcept

  1224. {

  1225.     return pData->sampleRate;

  1226. }

  1227. 

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

  1229. {

  1230.     return pData->name;

  1231. }

  1232. 

  1233. EngineProcessMode CarlaEngine::getProccessMode() const noexcept

  1234. {

  1235.     return pData->options.processMode;

  1236. }

  1237. 

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

  1239. {

  1240.     return pData->options;

  1241. }

  1242. 

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

  1244. {

  1245.     return pData->timeInfo;

  1246. }

  1247. 

  1248. // -----------------------------------------------------------------------

  1249. // Information (peaks)

  1250. 

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

  1252. {

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

  1254. 

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

  1256. }

  1257. 

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

  1259. {

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

  1261. 

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

  1263. }

  1264. 

  1265. // -----------------------------------------------------------------------

  1266. // Callback

  1267. 

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

  1269. {

  1270. #ifdef DEBUG

  1271.     if (action != ENGINE_CALLBACK_IDLE)

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

  1273. #endif

  1274. 

  1275. #ifdef BUILD_BRIDGE

  1276.     if (pData->isIdling)

  1277. #else

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

  1279. #endif

  1280.     {

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

  1282.     }

  1283. 

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

  1285.     {

  1286.         if (action == ENGINE_CALLBACK_IDLE)

  1287.             ++pData->isIdling;

  1288. 

  1289.         try {

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

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

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

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

  1294.             throw;

  1295. #endif

  1296.         } catch (...) {

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

  1298.         }

  1299. 

  1300.         if (action == ENGINE_CALLBACK_IDLE)

  1301.             --pData->isIdling;

  1302.     }

  1303. }

  1304. 

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

  1306. {

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

  1308. 

  1309.     pData->callback    = func;

  1310.     pData->callbackPtr = ptr;

  1311. }

  1312. 

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

  1314. // File Callback

  1315. 

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

  1317. {

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

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

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

  1321. 

  1322.     const char* ret = nullptr;

  1323. 

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

  1325.     {

  1326.         try {

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

  1328.         } CARLA_SAFE_EXCEPTION("runFileCallback");

  1329.     }

  1330. 

  1331.     return ret;

  1332. }

  1333. 

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

  1335. {

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

  1337. 

  1338.     pData->fileCallback    = func;

  1339.     pData->fileCallbackPtr = ptr;

  1340. }

  1341. 

  1342. // -----------------------------------------------------------------------

  1343. // Transport

  1344. 

  1345. void CarlaEngine::transportPlay() noexcept

  1346. {

  1347.     pData->timeInfo.playing = true;

  1348.     pData->time.setNeedsReset();

  1349. }

  1350. 

  1351. void CarlaEngine::transportPause() noexcept

  1352. {

  1353.     pData->timeInfo.playing = false;

  1354.     pData->time.setNeedsReset();

  1355. }

  1356. 

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

  1358. {

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

  1360. }

  1361. 

  1362. // -----------------------------------------------------------------------

  1363. // Error handling

  1364. 

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

  1366. {

  1367.     return pData->lastError;

  1368. }

  1369. 

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

  1371. {

  1372.     pData->lastError = error;

  1373. }

  1374. 

  1375. // -----------------------------------------------------------------------

  1376. // Misc

  1377. 

  1378. bool CarlaEngine::isAboutToClose() const noexcept

  1379. {

  1380.     return pData->aboutToClose;

  1381. }

  1382. 

  1383. bool CarlaEngine::setAboutToClose() noexcept

  1384. {

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

  1386. 

  1387.     pData->aboutToClose = true;

  1388. 

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

  1390. }

  1391. 

  1392. // -----------------------------------------------------------------------

  1393. // Global options

  1394. 

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

  1396. {

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

  1398. 

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

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

  1401. 

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

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

  1404.         return;

  1405. 

  1406.     switch (option)

  1407.     {

  1408.     case ENGINE_OPTION_DEBUG:

  1409.         break;

  1410. 

  1411.     case ENGINE_OPTION_PROCESS_MODE:

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

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

  1414.         break;

  1415. 

  1416.     case ENGINE_OPTION_TRANSPORT_MODE:

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

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

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

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

  1421.         pData->options.transportExtra = (valueStr != nullptr) ? carla_strdup_safe(valueStr) : nullptr;

  1422. 

  1423.         pData->time.setNeedsReset();

  1424. 

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

  1426.         // enable link now if needed

  1427.         {

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

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

  1430.         }

  1431. #endif

  1432.         break;

  1433. 

  1434.     case ENGINE_OPTION_FORCE_STEREO:

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

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

  1437.         break;

  1438. 

  1439.     case ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

  1440. #ifdef BUILD_BRIDGE

  1441.         CARLA_SAFE_ASSERT_RETURN(value == 0,);

  1442. #else

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

  1444. #endif

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

  1446.         break;

  1447. 

  1448.     case ENGINE_OPTION_PREFER_UI_BRIDGES:

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

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

  1451.         break;

  1452. 

  1453.     case ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

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

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

  1456.         break;

  1457. 

  1458.     case ENGINE_OPTION_MAX_PARAMETERS:

  1459.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  1461.         break;

  1462. 

  1463.     case ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  1464.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  1466.         break;

  1467. 

  1468.     case ENGINE_OPTION_AUDIO_NUM_PERIODS:

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

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

  1471.         break;

  1472. 

  1473.     case ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  1474.         CARLA_SAFE_ASSERT_RETURN(value >= 8,);

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

  1476.         break;

  1477. 

  1478.     case ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  1479.         CARLA_SAFE_ASSERT_RETURN(value >= 22050,);

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

  1481.         break;

  1482. 

  1483.     case ENGINE_OPTION_AUDIO_DEVICE:

  1484.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  1485. 

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

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

  1488. 

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

  1490.         break;

  1491. 

  1492.     case ENGINE_OPTION_PLUGIN_PATH:

  1493.         CARLA_SAFE_ASSERT_RETURN(value > PLUGIN_NONE,);

  1494.         CARLA_SAFE_ASSERT_RETURN(value <= PLUGIN_SFZ,);

  1495. 

  1496.         switch (value)

  1497.         {

  1498.         case PLUGIN_LADSPA:

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

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

  1501.             if (valueStr != nullptr)

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

  1503.             else

  1504.                 pData->options.pathLADSPA = nullptr;

  1505.             break;

  1506.         case PLUGIN_DSSI:

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

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

  1509.             if (valueStr != nullptr)

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

  1511.             else

  1512.                 pData->options.pathDSSI = nullptr;

  1513.             break;

  1514.         case PLUGIN_LV2:

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

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

  1517.             if (valueStr != nullptr)

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

  1519.             else

  1520.                 pData->options.pathLV2 = nullptr;

  1521.             break;

  1522.         case PLUGIN_VST2:

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

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

  1525.             if (valueStr != nullptr)

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

  1527.             else

  1528.                 pData->options.pathVST2 = nullptr;

  1529.             break;

  1530.         case PLUGIN_VST3:

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

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

  1533.             if (valueStr != nullptr)

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

  1535.             else

  1536.                 pData->options.pathVST3 = nullptr;

  1537.             break;

  1538.         case PLUGIN_GIG:

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

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

  1541.             if (valueStr != nullptr)

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

  1543.             else

  1544.                 pData->options.pathGIG = nullptr;

  1545.             break;

  1546.         case PLUGIN_SF2:

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

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

  1549.             if (valueStr != nullptr)

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

  1551.             else

  1552.                 pData->options.pathSF2 = nullptr;

  1553.             break;

  1554.         case PLUGIN_SFZ:

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

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

  1557.             if (valueStr != nullptr)

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

  1559.             else

  1560.                 pData->options.pathSFZ = nullptr;

  1561.             break;

  1562.         default:

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

  1564.             break;

  1565.         }

  1566.         break;

  1567. 

  1568.     case ENGINE_OPTION_PATH_BINARIES:

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

  1570. 

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

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

  1573. 

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

  1575.         break;

  1576. 

  1577.     case ENGINE_OPTION_PATH_RESOURCES:

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

  1579. 

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

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

  1582. 

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

  1584.         break;

  1585. 

  1586.     case ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR:

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

  1588. #ifdef CARLA_OS_LINUX

  1589.         if (value != 0)

  1590.         {

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

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

  1593.         }

  1594.         else

  1595.         {

  1596.             ::unsetenv("LD_PRELOAD");

  1597.         }

  1598. #endif

  1599.         break;

  1600. 

  1601.     case ENGINE_OPTION_FRONTEND_WIN_ID: {

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

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

  1604.         CARLA_SAFE_ASSERT_RETURN(winId >= 0,);

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

  1606.     }   break;

  1607. 

  1608.     case ENGINE_OPTION_DEBUG_CONSOLE_OUTPUT:

  1609.         break;

  1610.     }

  1611. }

  1612. 

  1613. #ifdef HAVE_LIBLO

  1614. // -----------------------------------------------------------------------

  1615. // OSC Stuff

  1616. 

  1617. # ifndef BUILD_BRIDGE

  1618. bool CarlaEngine::isOscControlRegistered() const noexcept

  1619. {

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

  1621. }

  1622. # endif

  1623. 

  1624. void CarlaEngine::idleOsc() const noexcept

  1625. {

  1626.     pData->osc.idle();

  1627. }

  1628. 

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

  1630. {

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

  1632. }

  1633. 

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

  1635. {

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

  1637. }

  1638. #endif

  1639. 

  1640. // -----------------------------------------------------------------------

  1641. // Helper functions

  1642. 

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

  1644. {

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

  1646. }

  1647. 

  1648. // -----------------------------------------------------------------------

  1649. // Internal stuff

  1650. 

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

  1652. {

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

  1654. 

  1655. #ifndef BUILD_BRIDGE

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

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

  1658.     {

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

  1660.     }

  1661. #endif

  1662. 

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

  1664. 

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

  1666.     {

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

  1668. 

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

  1670.             plugin->bufferSizeChanged(newBufferSize);

  1671.     }

  1672. 

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

  1674. }

  1675. 

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

  1677. {

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

  1679. 

  1680. #ifndef BUILD_BRIDGE

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

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

  1683.     {

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

  1685.     }

  1686. #endif

  1687. 

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

  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->sampleRateChanged(newSampleRate);

  1696.     }

  1697. 

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

  1699. }

  1700. 

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

  1702. {

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

  1704. 

  1705. #ifndef BUILD_BRIDGE

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

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

  1708.     {

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

  1710.     }

  1711. #endif

  1712. 

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

  1714.     {

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

  1716. 

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

  1718.             plugin->offlineModeChanged(isOfflineNow);

  1719.     }

  1720. }

  1721. 

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

  1723. {

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

  1725. 

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

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

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

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

  1730. }

  1731. 

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

  1733. {

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

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

  1736.     {

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

  1738. 

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

  1740.         {

  1741. #ifndef BUILD_BRIDGE

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

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

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

  1745. #endif

  1746.             plugin->prepareForSave();

  1747.         }

  1748.     }

  1749. 

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

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

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

  1753. 

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

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

  1756. 

  1757.     MemoryOutputStream outSettings(1024);

  1758. 

  1759.     // save appropriate engine settings

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

  1761. 

  1762.     //processMode

  1763.     //transportMode

  1764. 

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

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

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

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

  1769. 

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

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

  1772. 

  1773.     if (isPlugin)

  1774.     {

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

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

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

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

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

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

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

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

  1783.     }

  1784. 

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

  1786.     outStream << outSettings;

  1787. 

  1788.     char strBuf[STR_MAX+1];

  1789. 

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

  1791.     {

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

  1793. 

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

  1795.         {

  1796.             MemoryOutputStream outPlugin(4096), streamPlugin;

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

  1798. 

  1799.             outPlugin << "\n";

  1800. 

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

  1802.             plugin->getRealName(strBuf);

  1803. 

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

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

  1806. 

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

  1808.             outPlugin << streamPlugin;

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

  1810.             outStream << outPlugin;

  1811.         }

  1812.     }

  1813. 

  1814. #ifndef BUILD_BRIDGE

  1815.     // tell bridges we're done saving

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

  1817.     {

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

  1819. 

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

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

  1822.     }

  1823. 

  1824.     // save internal connections

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

  1826.     {

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

  1828.         {

  1829.             MemoryOutputStream outPatchbay(2048);

  1830. 

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

  1832. 

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

  1834.             {

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

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

  1837. 

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

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

  1840. 

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

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

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

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

  1845.             }

  1846. 

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

  1848.             outStream << outPatchbay;

  1849.         }

  1850.     }

  1851. 

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

  1853.     bool saveExternalConnections;

  1854. 

  1855.     /**/ if (isPlugin)

  1856.         saveExternalConnections = false;

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

  1858.         saveExternalConnections = true;

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

  1860.         saveExternalConnections = false;

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

  1862.         saveExternalConnections = false;

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

  1864.         saveExternalConnections = false;

  1865.     else

  1866.         saveExternalConnections = true;

  1867. 

  1868.     if (saveExternalConnections)

  1869.     {

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

  1871.         {

  1872.             MemoryOutputStream outPatchbay(2048);

  1873. 

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

  1875. 

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

  1877.             {

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

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

  1880. 

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

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

  1883. 

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

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

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

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

  1888.             }

  1889. 

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

  1891.             outStream << outPatchbay;

  1892.         }

  1893.     }

  1894. #endif

  1895. 

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

  1897. }

  1898. 

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

  1900. {

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

  1902. 

  1903.     // try direct filename first

  1904.     String jbinary(binary);

  1905. 

  1906.     // adjust for current platform

  1907. #ifdef CARLA_OS_WIN

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

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

  1910. #else

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

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

  1913. #endif

  1914. 

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

  1916. 

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

  1918. #ifdef CARLA_OS_MAC

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

  1920.         searchFlags |= File::findDirectories;

  1921. #endif

  1922. 

  1923.     Array<File> results;

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

  1925.     {

  1926.         const File path(*it);

  1927. 

  1928.         results.clear();

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

  1930. 

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

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

  1933.     }

  1934. 

  1935.     // try changing extension

  1936. #if defined(CARLA_OS_MAC)

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

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

  1939. #elif defined(CARLA_OS_WIN)

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

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

  1942. #else

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

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

  1945. #endif

  1946.     else

  1947.         return String();

  1948. 

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

  1950.     {

  1951.         const File path(*it);

  1952. 

  1953.         results.clear();

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

  1955. 

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

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

  1958.     }

  1959. 

  1960.     return String();

  1961. }

  1962. 

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

  1964. {

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

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

  1967. 

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

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

  1970. 

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

  1972.     {

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

  1974.         return false;

  1975.     }

  1976. 

  1977. #ifndef BUILD_BRIDGE

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

  1979. #endif

  1980. 

  1981.     // completely load file

  1982.     xmlElement = xmlDoc.getDocumentElement(false);

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

  1984. 

  1985.     if (pData->aboutToClose)

  1986.         return true;

  1987. 

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

  1989. 

  1990.     // engine settings

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

  1992.     {

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

  1994. 

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

  1996.             continue;

  1997. 

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

  1999.         {

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

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

  2002. 

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

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

  2005. 

  2006.            int option = -1;

  2007.            int value  = 0;

  2008.            const char* valueStr = nullptr;

  2009. 

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

  2011.             {

  2012.                 option = ENGINE_OPTION_FORCE_STEREO;

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

  2014.             }

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

  2016.             {

  2017.                 option = ENGINE_OPTION_PREFER_PLUGIN_BRIDGES;

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

  2019.             }

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

  2021.             {

  2022.                 option = ENGINE_OPTION_PREFER_UI_BRIDGES;

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

  2024.             }

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

  2026.             {

  2027.                 option = ENGINE_OPTION_UIS_ALWAYS_ON_TOP;

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

  2029.             }

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

  2031.             {

  2032.                 option = ENGINE_OPTION_MAX_PARAMETERS;

  2033.                 value  = text.getIntValue();

  2034.             }

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

  2036.             {

  2037.                 option = ENGINE_OPTION_UI_BRIDGES_TIMEOUT;

  2038.                 value  = text.getIntValue();

  2039.             }

  2040.             else if (isPlugin)

  2041.             {

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

  2043.                 {

  2044.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2045.                     value    = PLUGIN_LADSPA;

  2046.                     valueStr = text.toRawUTF8();

  2047.                 }

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

  2049.                 {

  2050.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2051.                     value    = PLUGIN_DSSI;

  2052.                     valueStr = text.toRawUTF8();

  2053.                 }

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

  2055.                 {

  2056.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2057.                     value    = PLUGIN_LV2;

  2058.                     valueStr = text.toRawUTF8();

  2059.                 }

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

  2061.                 {

  2062.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2063.                     value    = PLUGIN_VST2;

  2064.                     valueStr = text.toRawUTF8();

  2065.                 }

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

  2067.                 {

  2068.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2069.                     value    = PLUGIN_VST3;

  2070.                     valueStr = text.toRawUTF8();

  2071.                 }

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

  2073.                 {

  2074.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2075.                     value    = PLUGIN_GIG;

  2076.                     valueStr = text.toRawUTF8();

  2077.                 }

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

  2079.                 {

  2080.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2081.                     value    = PLUGIN_SF2;

  2082.                     valueStr = text.toRawUTF8();

  2083.                 }

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

  2085.                 {

  2086.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2087.                     value    = PLUGIN_SFZ;

  2088.                     valueStr = text.toRawUTF8();

  2089.                 }

  2090.             }

  2091. 

  2092.             CARLA_SAFE_ASSERT_CONTINUE(option != -1);

  2093. 

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

  2095.         }

  2096. 

  2097.         break;

  2098.     }

  2099. 

  2100.     if (pData->aboutToClose)

  2101.         return true;

  2102. 

  2103.     // handle plugins first

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

  2105.     {

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

  2107. 

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

  2109.         {

  2110.             CarlaStateSave stateSave;

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

  2112. 

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

  2114. 

  2115.             if (pData->aboutToClose)

  2116.                 return true;

  2117. 

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

  2119. 

  2120.             const void* extraStuff    = nullptr;

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

  2122. 

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

  2124. 

  2125.             switch (ptype)

  2126.             {

  2127.             case PLUGIN_GIG:

  2128.             case PLUGIN_SF2:

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

  2130.                     extraStuff = kTrue;

  2131.                 // fall through

  2132.             case PLUGIN_LADSPA:

  2133.             case PLUGIN_DSSI:

  2134.             case PLUGIN_VST2:

  2135.             case PLUGIN_VST3:

  2136.             case PLUGIN_SFZ:

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

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

  2139.                 {

  2140.                     const char* searchPath;

  2141. 

  2142.                     switch (ptype)

  2143.                     {

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

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

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

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

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

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

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

  2151.                     default:            searchPath = nullptr;                   break;

  2152.                     }

  2153. 

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

  2155.                     {

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

  2157.                                      stateSave.binary);

  2158. 

  2159.                         String result = findBinaryInCustomPath(searchPath, stateSave.binary);

  2160. 

  2161.                         if (result.isEmpty())

  2162.                         {

  2163.                             switch (ptype)

  2164.                             {

  2165.                             case PLUGIN_LADSPA: searchPath = std::getenv("LADSPA_PATH"); break;

  2166.                             case PLUGIN_DSSI:   searchPath = std::getenv("DSSI_PATH");   break;

  2167.                             case PLUGIN_VST2:   searchPath = std::getenv("VST_PATH");    break;

  2168.                             case PLUGIN_VST3:   searchPath = std::getenv("VST3_PATH");   break;

  2169.                             case PLUGIN_GIG:    searchPath = std::getenv("GIG_PATH");    break;

  2170.                             case PLUGIN_SF2:    searchPath = std::getenv("SF2_PATH");    break;

  2171.                             case PLUGIN_SFZ:    searchPath = std::getenv("SFZ_PATH");    break;

  2172.                             default:            searchPath = nullptr;                    break;

  2173.                             }

  2174. 

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

  2176.                                 result = findBinaryInCustomPath(searchPath, stateSave.binary);

  2177.                         }

  2178. 

  2179.                         if (result.isNotEmpty())

  2180.                         {

  2181.                             delete[] stateSave.binary;

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

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

  2184.                         }

  2185.                         else

  2186.                         {

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

  2188.                         }

  2189.                     }

  2190.                 }

  2191.                 break;

  2192.             default:

  2193.                 break;

  2194.             }

  2195. 

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

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

  2198.             {

  2199.                 const uint pluginId = pData->curPluginCount;

  2200. 

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

  2202.                 {

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

  2204. 

  2205.                     if (pData->aboutToClose)

  2206.                         return true;

  2207. 

  2208. #ifndef BUILD_BRIDGE

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

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

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

  2212. #endif

  2213.                     plugin->loadStateSave(stateSave);

  2214. 

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

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

  2217.                      *        as we want to load state first.

  2218.                      */

  2219. #ifdef BUILD_BRIDGE

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

  2221. #endif

  2222.                     plugin->setEnabled(true);

  2223. 

  2224.                     ++pData->curPluginCount;

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

  2226. 

  2227. #ifndef BUILD_BRIDGE

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

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

  2230. #endif

  2231.                 }

  2232.                 else

  2233.                 {

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

  2235.                 }

  2236.             }

  2237.             else

  2238.             {

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

  2240.             }

  2241.         }

  2242. 

  2243.         if (isPreset)

  2244.             return true;

  2245.     }

  2246. 

  2247. #ifndef BUILD_BRIDGE

  2248.     // tell bridges we're done loading

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

  2250.     {

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

  2252. 

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

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

  2255.     }

  2256. 

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

  2258. 

  2259.     if (pData->aboutToClose)

  2260.         return true;

  2261. 

  2262.     // handle connections (internal)

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

  2264.     {

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

  2266. 

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

  2268.         {

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

  2270. 

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

  2272.                 continue;

  2273. 

  2274.             CarlaString sourcePort, targetPort;

  2275. 

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

  2277.             {

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

  2279. 

  2280.                 sourcePort.clear();

  2281.                 targetPort.clear();

  2282. 

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

  2284.                     continue;

  2285. 

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

  2287.                 {

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

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

  2290. 

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

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

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

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

  2295.                 }

  2296. 

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

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

  2299.             }

  2300.             break;

  2301.         }

  2302. 

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

  2304. 

  2305.         if (pData->aboutToClose)

  2306.             return true;

  2307.     }

  2308. 

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

  2310.     bool loadExternalConnections;

  2311. 

  2312.     /**/ if (isPlugin)

  2313.         loadExternalConnections = false;

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

  2315.         loadExternalConnections = true;

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

  2317.         loadExternalConnections = false;

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

  2319.         loadExternalConnections = false;

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

  2321.         loadExternalConnections = false;

  2322.     else

  2323.         loadExternalConnections = true;

  2324. 

  2325.     // handle connections (external)

  2326.     if (loadExternalConnections)

  2327.     {

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

  2329. 

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

  2331.         {

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

  2333. 

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

  2335.                 continue;

  2336. 

  2337.             CarlaString sourcePort, targetPort;

  2338. 

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

  2340.             {

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

  2342. 

  2343.                 sourcePort.clear();

  2344.                 targetPort.clear();

  2345. 

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

  2347.                     continue;

  2348. 

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

  2350.                 {

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

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

  2353. 

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

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

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

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

  2358.                 }

  2359. 

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

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

  2362.             }

  2363.             break;

  2364.         }

  2365.     }

  2366. #endif

  2367. 

  2368.     return true;

  2369. }

  2370. 

  2371. // -----------------------------------------------------------------------

  2372. 

  2373. CARLA_BACKEND_END_NAMESPACE