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

2667 lines
88KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Host

  3.  * Copyright (C) 2011-2019 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 "water/files/File.h"

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

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

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

  42. 

  43. // FIXME Remove on 2.1 release

  44. #include "lv2/atom.h"

  45. 

  46. using water::Array;

  47. using water::CharPointer_UTF8;

  48. using water::File;

  49. using water::MemoryOutputStream;

  50. using water::String;

  51. using water::StringArray;

  52. using water::XmlDocument;

  53. using water::XmlElement;

  54. 

  55. CARLA_BACKEND_START_NAMESPACE

  56. 

  57. // -----------------------------------------------------------------------

  58. // Carla Engine

  59. 

  60. CarlaEngine::CarlaEngine()

  61.     : pData(new ProtectedData(this))

  62. {

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

  64. }

  65. 

  66. CarlaEngine::~CarlaEngine()

  67. {

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

  69. 

  70.     delete pData;

  71. }

  72. 

  73. // -----------------------------------------------------------------------

  74. // Static calls

  75. 

  76. uint CarlaEngine::getDriverCount()

  77. {

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

  79. 

  80.     uint count = 0;

  81. 

  82.     if (jackbridge_is_ok())

  83.         count += 1;

  84. 

  85. #ifndef BUILD_BRIDGE

  86. # ifdef USING_JUCE

  87.     count += getJuceApiCount();

  88. # else

  89.     count += getRtAudioApiCount();

  90. # endif

  91. #endif

  92. 

  93.     return count;

  94. }

  95. 

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

  97. {

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

  99. 

  100.     uint index = index2;

  101. 

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

  103.         return "JACK";

  104. 

  105. #ifndef BUILD_BRIDGE

  106. # ifdef USING_JUCE

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

  108.     {

  109.         if (index < count)

  110.             return getJuceApiName(index);

  111.         index -= count;

  112.     }

  113. # else

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

  115.     {

  116.         if (index < count)

  117.             return getRtAudioApiName(index);

  118.     }

  119. # endif

  120. #endif

  121. 

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

  123.     return nullptr;

  124. }

  125. 

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

  127. {

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

  129. 

  130.     uint index = index2;

  131. 

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

  133.     {

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

  135.         return ret;

  136.     }

  137. 

  138. #ifndef BUILD_BRIDGE

  139. # ifdef USING_JUCE

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

  141.     {

  142.         if (index < count)

  143.             return getJuceApiDeviceNames(index);

  144.         index -= count;

  145.     }

  146. # else

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

  148.     {

  149.         if (index < count)

  150.             return getRtAudioApiDeviceNames(index);

  151.     }

  152. # endif

  153. #endif

  154. 

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

  156.     return nullptr;

  157. }

  158. 

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

  160. {

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

  162. 

  163.     uint index = index2;

  164. 

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

  166.     {

  167.         static EngineDriverDeviceInfo devInfo;

  168.         devInfo.hints       = ENGINE_DRIVER_DEVICE_VARIABLE_BUFFER_SIZE;

  169.         devInfo.bufferSizes = nullptr;

  170.         devInfo.sampleRates = nullptr;

  171.         return &devInfo;

  172.     }

  173. 

  174. #ifndef BUILD_BRIDGE

  175. # ifdef USING_JUCE

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

  177.     {

  178.         if (index < count)

  179.             return getJuceDeviceInfo(index, deviceName);

  180.         index -= count;

  181.     }

  182. # else

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

  184.     {

  185.         if (index < count)

  186.             return getRtAudioDeviceInfo(index, deviceName);

  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. # ifdef USING_JUCE

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

  206.     // linux

  207. 

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

  209.         return newJuce(AUDIO_API_ALSA);

  210. 

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

  212.     // macos

  213. 

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

  215.         return newJuce(AUDIO_API_COREAUDIO);

  216. 

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

  218.     // windows

  219. 

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

  221.         return newJuce(AUDIO_API_ASIO);

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

  223.         return newJuce(AUDIO_API_DIRECTSOUND);

  224. # else

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

  226.     // common

  227. 

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

  229.         return newRtAudio(AUDIO_API_NULL);

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

  231.         return newRtAudio(AUDIO_API_JACK);

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

  233.         return newRtAudio(AUDIO_API_OSS);

  234. 

  235.     // -------------------------------------------------------------------

  236.     // linux

  237. 

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

  239.         return newRtAudio(AUDIO_API_ALSA);

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

  241.         return newRtAudio(AUDIO_API_PULSEAUDIO);

  242. 

  243.     // -------------------------------------------------------------------

  244.     // macos

  245. 

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

  247.         return newRtAudio(AUDIO_API_COREAUDIO);

  248. 

  249.     // -------------------------------------------------------------------

  250.     // windows

  251. 

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

  253.         return newRtAudio(AUDIO_API_ASIO);

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

  255.         return newRtAudio(AUDIO_API_DIRECTSOUND);

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

  257.         return newRtAudio(AUDIO_API_WASAPI);

  258. # endif

  259. #endif

  260. 

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

  262.     return nullptr;

  263. }

  264. 

  265. // -----------------------------------------------------------------------

  266. // Constant values

  267. 

  268. uint CarlaEngine::getMaxClientNameSize() const noexcept

  269. {

  270.     return STR_MAX/2;

  271. }

  272. 

  273. uint CarlaEngine::getMaxPortNameSize() const noexcept

  274. {

  275.     return STR_MAX;

  276. }

  277. 

  278. uint CarlaEngine::getCurrentPluginCount() const noexcept

  279. {

  280.     return pData->curPluginCount;

  281. }

  282. 

  283. uint CarlaEngine::getMaxPluginNumber() const noexcept

  284. {

  285.     return pData->maxPluginNumber;

  286. }

  287. 

  288. // -----------------------------------------------------------------------

  289. // Virtual, per-engine type calls

  290. 

  291. bool CarlaEngine::close()

  292. {

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

  294. 

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

  296.     {

  297.         pData->aboutToClose = true;

  298.         removeAllPlugins();

  299.     }

  300. 

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

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

  303.         oscSend_control_exit();

  304. #endif

  305. 

  306.     pData->close();

  307. 

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

  309.     return true;

  310. }

  311. 

  312. bool CarlaEngine::usesConstantBufferSize() const noexcept

  313. {

  314.     return true;

  315. }

  316. 

  317. void CarlaEngine::idle() noexcept

  318. {

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

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

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

  322. 

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

  324.     {

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

  326. 

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

  328.         {

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

  330. 

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

  332.             {

  333.                 try {

  334.                     plugin->uiIdle();

  335.                 } CARLA_SAFE_EXCEPTION_CONTINUE("Plugin uiIdle");

  336.             }

  337.         }

  338.     }

  339. 

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

  341.     pData->osc.idle();

  342. #endif

  343. }

  344. 

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

  346. {

  347.     return new CarlaEngineClient(*this);

  348. }

  349. 

  350. float CarlaEngine::getDSPLoad() const noexcept

  351. {

  352.     return 0.0f;

  353. }

  354. 

  355. uint32_t CarlaEngine::getTotalXruns() const noexcept

  356. {

  357. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  358.     return pData->xruns;

  359. #else

  360.     return 0;

  361. #endif

  362. }

  363. 

  364. // -----------------------------------------------------------------------

  365. // Plugin management

  366. 

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

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

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

  370. {

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

  372. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

  375. #endif

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

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

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

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

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

  381. 

  382. #ifndef CARLA_OS_WIN

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

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

  385.     }

  386. #endif

  387. 

  388.     uint id;

  389. 

  390. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  391.     CarlaPlugin* oldPlugin = nullptr;

  392. 

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

  394.     {

  395.         id = pData->nextPluginId;

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

  397. 

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

  399. 

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

  401.     }

  402.     else

  403. #endif

  404.     {

  405.         id = pData->curPluginCount;

  406. 

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

  408.         {

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

  410.             return false;

  411.         }

  412. 

  413. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  415. #endif

  416.     }

  417. 

  418.     CarlaPlugin::Initializer initializer = {

  419.         this,

  420.         id,

  421.         filename,

  422.         name,

  423.         label,

  424.         uniqueId,

  425.         options

  426.     };

  427. 

  428.     CarlaPlugin* plugin = nullptr;

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

  430. 

  431.     if (bridgeBinary.isNotEmpty())

  432.     {

  433. #ifndef CARLA_OS_WIN

  434.         if (btype == BINARY_NATIVE)

  435.         {

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

  437.         }

  438.         else

  439. #endif

  440.         {

  441.             switch (btype)

  442.             {

  443.             case BINARY_POSIX32:

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

  445.                 break;

  446.             case BINARY_POSIX64:

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

  448.                 break;

  449.             case BINARY_WIN32:

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

  451.                 break;

  452.             case BINARY_WIN64:

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

  454.                 break;

  455.             default:

  456.                 bridgeBinary.clear();

  457.                 break;

  458.             }

  459.         }

  460. 

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

  462.             bridgeBinary.clear();

  463.     }

  464. 

  465.     // Prefer bridges for some specific plugins

  466.     const bool preferBridges = pData->options.preferPluginBridges;

  467. 

  468. #if 0 // ndef BUILD_BRIDGE

  469.     if (! preferBridges)

  470.     {

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

  472.         {

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

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

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

  476.             {

  477.                 preferBridges = true;

  478.             }

  479.         }

  480.     }

  481. #endif // ! BUILD_BRIDGE

  482. 

  483.     const bool canBeBridged = ptype != PLUGIN_INTERNAL

  484.                            && ptype != PLUGIN_SF2

  485.                            && ptype != PLUGIN_SFZ

  486.                            && ptype != PLUGIN_JACK;

  487. 

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

  489.     {

  490.         if (bridgeBinary.isNotEmpty())

  491.         {

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

  493.         }

  494.         else

  495.         {

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

  497.             return false;

  498.         }

  499.     }

  500.     else

  501.     {

  502. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  503.         bool use16Outs;

  504. #endif

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

  506. 

  507.         switch (ptype)

  508.         {

  509.         case PLUGIN_NONE:

  510.             break;

  511. 

  512.         case PLUGIN_LADSPA:

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

  514.             break;

  515. 

  516.         case PLUGIN_DSSI:

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

  518.             break;

  519. 

  520.         case PLUGIN_LV2:

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

  522.             break;

  523. 

  524.         case PLUGIN_VST2:

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

  526.             break;

  527. 

  528.         case PLUGIN_VST3:

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

  530.             break;

  531. 

  532.         case PLUGIN_AU:

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

  534.             break;

  535. 

  536. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  537.         case PLUGIN_INTERNAL:

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

  539.             break;

  540. 

  541.         case PLUGIN_SF2:

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

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

  544.             break;

  545. 

  546.         case PLUGIN_SFZ:

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

  548.             break;

  549. 

  550.         case PLUGIN_JACK:

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

  552.             break;

  553. #else

  554.         case PLUGIN_INTERNAL:

  555.         case PLUGIN_SF2:

  556.         case PLUGIN_SFZ:

  557.         case PLUGIN_JACK:

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

  559.             break;

  560. #endif

  561.         }

  562.     }

  563. 

  564.     if (plugin == nullptr)

  565.         return false;

  566. 

  567.     plugin->reload();

  568. 

  569.     bool canRun = true;

  570. 

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

  572.     {

  573.         if (plugin->getCVInCount() > 0 || plugin->getCVInCount() > 0)

  574.         {

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

  576.             canRun = false;

  577.         }

  578.     }

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

  580.     {

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

  582.         {

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

  584.             canRun = false;

  585.         }

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

  587.         {

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

  589.             canRun = false;

  590.         }

  591.     }

  592. 

  593.     if (! canRun)

  594.     {

  595.         delete plugin;

  596.         return false;

  597.     }

  598. 

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

  600.     pluginData.plugin = plugin;

  601.     carla_zeroFloats(pluginData.peaks, 4);

  602. 

  603. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  604.     if (oldPlugin != nullptr)

  605.     {

  606.         CARLA_SAFE_ASSERT(! pData->loadingProject);

  607. 

  608.         const ScopedThreadStopper sts(this);

  609. 

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

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

  612. 

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

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

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

  616. 

  617.         delete oldPlugin;

  618. 

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

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

  621. 

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

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

  624. 

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

  626.         plugin->setEnabled(true);

  627. 

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

  629.     }

  630.     else if (! pData->loadingProject)

  631. #endif

  632.     {

  633.         plugin->setEnabled(true);

  634. 

  635.         ++pData->curPluginCount;

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

  637. 

  638.         if (getType() != kEngineTypeBridge)

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

  640. 

  641. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

  644. #endif

  645.     }

  646. 

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

  648.     plugin->registerToOscClient();

  649. #endif

  650. 

  651.     return true;

  652. }

  653. 

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

  655. {

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

  657. }

  658. 

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

  660. {

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

  662. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

  665. #endif

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

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

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

  669. 

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

  671. 

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

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

  674. 

  675.     const ScopedThreadStopper sts(this);

  676. 

  677. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

  680. 

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

  682. 

  683.     /*

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

  685.     {

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

  687.         CARLA_SAFE_ASSERT_BREAK(plugin2 != nullptr);

  688.         plugin2->updateOscURL();

  689.     }

  690.     */

  691. 

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

  693.     if (isOscControlRegistered())

  694.         oscSend_control_remove_plugin(id);

  695. # endif

  696. #else

  697.     pData->curPluginCount = 0;

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

  699. #endif

  700. 

  701.     delete plugin;

  702. 

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

  704.     return true;

  705. }

  706. 

  707. bool CarlaEngine::removeAllPlugins()

  708. {

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

  710. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

  713. #endif

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

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

  716. 

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

  718.         return true;

  719. 

  720.     const ScopedThreadStopper sts(this);

  721. 

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

  723. 

  724. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  726.         pData->graph.removeAllPlugins();

  727. 

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

  729.     if (isOscControlRegistered())

  730.     {

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

  732.             oscSend_control_remove_plugin(curPluginCount-i-1);

  733.     }

  734. # endif

  735. #endif

  736. 

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

  738. 

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

  740. 

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

  742.     {

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

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

  745. 

  746.         if (pluginData.plugin != nullptr)

  747.         {

  748.             delete pluginData.plugin;

  749.             pluginData.plugin = nullptr;

  750.         }

  751. 

  752.         carla_zeroFloats(pluginData.peaks, 4);

  753. 

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

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

  756.     }

  757. 

  758.     return true;

  759. }

  760. 

  761. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  763. {

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

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

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

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

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

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

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

  771. 

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

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

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

  775. 

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

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

  778. 

  779.     plugin->setName(uniqueName);

  780. 

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

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

  783. 

  784.     delete[] uniqueName;

  785.     return plugin->getName();

  786. }

  787. 

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

  789. {

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

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

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

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

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

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

  796. 

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

  798. 

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

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

  801. 

  802.     char label[STR_MAX+1];

  803.     carla_zeroChars(label, STR_MAX+1);

  804.     plugin->getLabel(label);

  805. 

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

  807. 

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

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

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

  811.         return false;

  812. 

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

  814. 

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

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

  817. 

  818.     return true;

  819. }

  820. 

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

  822. {

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

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

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

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

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

  828. 

  829.     // might use this to reset

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

  831.     {

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

  833.         return true;

  834.     }

  835. 

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

  837. 

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

  839. 

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

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

  842. 

  843.     pData->nextPluginId = id;

  844. 

  845.     return true;

  846. }

  847. 

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

  849. {

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

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

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

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

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

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

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

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

  858. 

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

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

  861. 

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

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

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

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

  866. 

  867.     const ScopedThreadStopper sts(this);

  868. 

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

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

  871. 

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

  873. 

  874.     // TODO

  875.     /*

  876.     pluginA->updateOscURL();

  877.     pluginB->updateOscURL();

  878. 

  879.     if (isOscControlRegistered())

  880.         oscSend_control_switch_plugins(idA, idB);

  881.     */

  882. 

  883.     return true;

  884. }

  885. #endif

  886. 

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

  888. {

  889. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

  892. #endif

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

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

  895. 

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

  897. }

  898. 

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

  900. {

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

  902. }

  903. 

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

  905. {

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

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

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

  909. 

  910.     CarlaString sname;

  911.     sname = name;

  912. 

  913.     if (sname.isEmpty())

  914.     {

  915.         sname = "(No name)";

  916.         return sname.dup();

  917.     }

  918. 

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

  920. 

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

  922.         return sname.dup();

  923. 

  924.     sname.truncate(maxNameSize);

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

  926. 

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

  928.     {

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

  930. 

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

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

  933.         {

  934.             if (sname != pluginName)

  935.                 continue;

  936.         }

  937. 

  938.         // Check if string has already been modified

  939.         {

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

  941. 

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

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

  944.             {

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

  946. 

  947.                 if (number == 9)

  948.                 {

  949.                     // next number is 10, 2 digits

  950.                     sname.truncate(len-4);

  951.                     sname += " (10)";

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

  953.                 }

  954.                 else

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

  956. 

  957.                 continue;

  958.             }

  959. 

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

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

  962.             {

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

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

  965. 

  966.                 if (n2 == '9')

  967.                 {

  968.                     n2 = '0';

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

  970.                 }

  971.                 else

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

  973. 

  974.                 sname[len-2] = n2;

  975.                 sname[len-3] = n3;

  976. 

  977.                 continue;

  978.             }

  979.         }

  980. 

  981.         // Modify string if not

  982.         sname += " (2)";

  983.     }

  984. 

  985.     return sname.dup();

  986. }

  987. 

  988. // -----------------------------------------------------------------------

  989. // Project management

  990. 

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

  992. {

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

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

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

  996. 

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

  998.     File file(jfilename);

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

  1000. 

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

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

  1003. 

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

  1005. 

  1006.     // -------------------------------------------------------------------

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

  1008. 

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

  1010.         return loadProject(filename, false);

  1011. 

  1012.     // -------------------------------------------------------------------

  1013. 

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

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

  1016. 

  1017.     if (extension == "sfz")

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

  1019. 

  1020.     // -------------------------------------------------------------------

  1021. 

  1022.     if (

  1023. #ifdef HAVE_SNDFILE

  1024.         extension == "aif"  ||

  1025.         extension == "aifc" ||

  1026.         extension == "aiff" ||

  1027.         extension == "au"   ||

  1028.         extension == "bwf"  ||

  1029.         extension == "flac" ||

  1030.         extension == "htk"  ||

  1031.         extension == "iff"  ||

  1032.         extension == "mat4" ||

  1033.         extension == "mat5" ||

  1034.         extension == "oga"  ||

  1035.         extension == "ogg"  ||

  1036.         extension == "paf"  ||

  1037.         extension == "pvf"  ||

  1038.         extension == "pvf5" ||

  1039.         extension == "sd2"  ||

  1040.         extension == "sf"   ||

  1041.         extension == "snd"  ||

  1042.         extension == "svx"  ||

  1043.         extension == "vcc"  ||

  1044.         extension == "w64"  ||

  1045.         extension == "wav"  ||

  1046.         extension == "xi"   ||

  1047. #endif

  1048. #ifdef HAVE_FFMPEG

  1049.         extension == "3g2" ||

  1050.         extension == "3gp" ||

  1051.         extension == "aac" ||

  1052.         extension == "ac3" ||

  1053.         extension == "amr" ||

  1054.         extension == "ape" ||

  1055.         extension == "mp2" ||

  1056.         extension == "mp3" ||

  1057.         extension == "mpc" ||

  1058.         extension == "wma" ||

  1059. # ifndef HAVE_SNDFILE

  1060.         // FFmpeg without sndfile

  1061.         extension == "flac" ||

  1062.         extension == "oga"  ||

  1063.         extension == "ogg"  ||

  1064.         extension == "w64"  ||

  1065.         extension == "wav"  ||

  1066. # endif

  1067. #endif

  1068.         false

  1069.        )

  1070.     {

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

  1072.         {

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

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

  1075.             return true;

  1076.         }

  1077.         return false;

  1078.     }

  1079. 

  1080.     // -------------------------------------------------------------------

  1081. 

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

  1083.     {

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

  1085.         {

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

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

  1088.             return true;

  1089.         }

  1090.         return false;

  1091.     }

  1092. 

  1093.     // -------------------------------------------------------------------

  1094.     // ZynAddSubFX

  1095. 

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

  1097.     {

  1098. #ifdef HAVE_ZYN_DEPS

  1099.         CarlaString nicerName("Zyn - ");

  1100. 

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

  1102. 

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

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

  1105.         else

  1106.             nicerName += baseName;

  1107. 

  1108.         //nicerName

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

  1110.         {

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

  1112. 

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

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

  1115.             return true;

  1116.         }

  1117.         return false;

  1118. #else

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

  1120.         return false;

  1121. #endif

  1122.     }

  1123. 

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

  1125.     // Direct plugin binaries

  1126. 

  1127. #ifdef CARLA_OS_MAC

  1128.     if (extension == "vst")

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

  1130. #else

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

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

  1133. #endif

  1134. 

  1135. #if defined(USING_JUCE) && (defined(CARLA_OS_MAC) || defined(CARLA_OS_WIN))

  1136.     if (extension == "vst3")

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

  1138. #endif

  1139. 

  1140.     // -------------------------------------------------------------------

  1141. 

  1142.     setLastError("Unknown file extension");

  1143.     return false;

  1144. }

  1145. 

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

  1147. {

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

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

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

  1151. 

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

  1153.     File file(jfilename);

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

  1155. 

  1156.     if (setAsCurrentProject)

  1157.     {

  1158. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1159.         pData->currentProjectFilename = filename;

  1160. #endif

  1161.     }

  1162. 

  1163.     XmlDocument xml(file);

  1164.     return loadProjectInternal(xml);

  1165. }

  1166. 

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

  1168. {

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

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

  1171. 

  1172.     MemoryOutputStream out;

  1173.     saveProjectInternal(out);

  1174. 

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

  1176.     File file(jfilename);

  1177. 

  1178.     if (setAsCurrentProject)

  1179.     {

  1180. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1181.         pData->currentProjectFilename = filename;

  1182. #endif

  1183.     }

  1184. 

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

  1186.         return true;

  1187. 

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

  1189.     return false;

  1190. }

  1191. 

  1192. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  1194. {

  1195.     return pData->currentProjectFilename;

  1196. }

  1197. 

  1198. void CarlaEngine::clearCurrentProjectFilename() noexcept

  1199. {

  1200.     pData->currentProjectFilename.clear();

  1201. }

  1202. #endif

  1203. 

  1204. // -----------------------------------------------------------------------

  1205. // Information (base)

  1206. 

  1207. uint CarlaEngine::getHints() const noexcept

  1208. {

  1209.     return pData->hints;

  1210. }

  1211. 

  1212. uint32_t CarlaEngine::getBufferSize() const noexcept

  1213. {

  1214.     return pData->bufferSize;

  1215. }

  1216. 

  1217. double CarlaEngine::getSampleRate() const noexcept

  1218. {

  1219.     return pData->sampleRate;

  1220. }

  1221. 

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

  1223. {

  1224.     return pData->name;

  1225. }

  1226. 

  1227. EngineProcessMode CarlaEngine::getProccessMode() const noexcept

  1228. {

  1229.     return pData->options.processMode;

  1230. }

  1231. 

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

  1233. {

  1234.     return pData->options;

  1235. }

  1236. 

  1237. EngineTimeInfo CarlaEngine::getTimeInfo() const noexcept

  1238. {

  1239.     return pData->timeInfo;

  1240. }

  1241. 

  1242. // -----------------------------------------------------------------------

  1243. // Information (peaks)

  1244. 

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

  1246. {

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

  1248. 

  1249.     if (pluginId == MAIN_CARLA_PLUGIN_ID)

  1250.     {

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

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

  1253.         {

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

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

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

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

  1258.         }

  1259. 

  1260.         return pData->peaks;

  1261.     }

  1262. 

  1263.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount, pData->peaks);

  1264. 

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

  1266. }

  1267. 

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

  1269. {

  1270.     if (pluginId == MAIN_CARLA_PLUGIN_ID)

  1271.     {

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

  1273.         if (pData->curPluginCount > 0)

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

  1275.         return 0.0f;

  1276.     }

  1277. 

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

  1279. 

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

  1281. }

  1282. 

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

  1284. {

  1285.     if (pluginId == MAIN_CARLA_PLUGIN_ID)

  1286.     {

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

  1288.         if (pData->curPluginCount > 0)

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

  1290.         return 0.0f;

  1291.     }

  1292. 

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

  1294. 

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

  1296. }

  1297. 

  1298. // -----------------------------------------------------------------------

  1299. // Callback

  1300. 

  1301. void CarlaEngine::callback(const EngineCallbackOpcode action, const uint pluginId,

  1302.                            const int value1, const int value2, const int value3,

  1303.                            const float valueF, const char* const valueStr) noexcept

  1304. {

  1305. #ifdef DEBUG

  1306.     if (pData->isIdling)

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

  1308.                      action, EngineCallbackOpcode2Str(action), pluginId, value1, value2, value3, valueF, valueStr);

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

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

  1311.                     action, EngineCallbackOpcode2Str(action), pluginId, value1, value2, value3, valueF. valueStr);

  1312. #endif

  1313. 

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

  1315.     {

  1316.         if (action == ENGINE_CALLBACK_IDLE)

  1317.             ++pData->isIdling;

  1318. 

  1319.         try {

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

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

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

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

  1324.             throw;

  1325. #endif

  1326.         } catch (...) {

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

  1328.         }

  1329. 

  1330.         if (action == ENGINE_CALLBACK_IDLE)

  1331.             --pData->isIdling;

  1332.     }

  1333. }

  1334. 

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

  1336. {

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

  1338. 

  1339.     pData->callback    = func;

  1340.     pData->callbackPtr = ptr;

  1341. }

  1342. 

  1343. // -----------------------------------------------------------------------

  1344. // File Callback

  1345. 

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

  1347. {

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

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

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

  1351. 

  1352.     const char* ret = nullptr;

  1353. 

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

  1355.     {

  1356.         try {

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

  1358.         } CARLA_SAFE_EXCEPTION("runFileCallback");

  1359.     }

  1360. 

  1361.     return ret;

  1362. }

  1363. 

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

  1365. {

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

  1367. 

  1368.     pData->fileCallback    = func;

  1369.     pData->fileCallbackPtr = ptr;

  1370. }

  1371. 

  1372. // -----------------------------------------------------------------------

  1373. // Transport

  1374. 

  1375. void CarlaEngine::transportPlay() noexcept

  1376. {

  1377.     pData->timeInfo.playing = true;

  1378.     pData->time.setNeedsReset();

  1379. }

  1380. 

  1381. void CarlaEngine::transportPause() noexcept

  1382. {

  1383.     if (pData->timeInfo.playing)

  1384.         pData->time.pause();

  1385.     else

  1386.         pData->time.setNeedsReset();

  1387. }

  1388. 

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

  1390. {

  1391.     try {

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

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

  1394. }

  1395. 

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

  1397. {

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

  1399. }

  1400. 

  1401. // -----------------------------------------------------------------------

  1402. // Error handling

  1403. 

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

  1405. {

  1406.     return pData->lastError;

  1407. }

  1408. 

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

  1410. {

  1411.     pData->lastError = error;

  1412. }

  1413. 

  1414. // -----------------------------------------------------------------------

  1415. // Misc

  1416. 

  1417. bool CarlaEngine::isAboutToClose() const noexcept

  1418. {

  1419.     return pData->aboutToClose;

  1420. }

  1421. 

  1422. bool CarlaEngine::setAboutToClose() noexcept

  1423. {

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

  1425. 

  1426.     pData->aboutToClose = true;

  1427. 

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

  1429. }

  1430. 

  1431. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1432. bool CarlaEngine::isLoadingProject() const noexcept

  1433. {

  1434.     return pData->loadingProject;

  1435. }

  1436. #endif

  1437. 

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

  1439. {

  1440.     pData->actionCanceled = canceled;

  1441. }

  1442. 

  1443. bool CarlaEngine::wasActionCanceled() const noexcept

  1444. {

  1445.     return pData->actionCanceled;

  1446. }

  1447. 

  1448. // -----------------------------------------------------------------------

  1449. // Global options

  1450. 

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

  1452. {

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

  1454. 

  1455.     if (isRunning())

  1456.     {

  1457.         switch (option)

  1458.         {

  1459.         case ENGINE_OPTION_PROCESS_MODE:

  1460.         case ENGINE_OPTION_AUDIO_TRIPLE_BUFFER:

  1461.         case ENGINE_OPTION_AUDIO_DEVICE:

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

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

  1464.         default:

  1465.             break;

  1466.         }

  1467.     }

  1468. 

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

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

  1471.         return;

  1472. 

  1473.     switch (option)

  1474.     {

  1475.     case ENGINE_OPTION_DEBUG:

  1476.         break;

  1477. 

  1478.     case ENGINE_OPTION_PROCESS_MODE:

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

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

  1481.         break;

  1482. 

  1483.     case ENGINE_OPTION_TRANSPORT_MODE:

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

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

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

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

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

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

  1490.         else

  1491.             pData->options.transportExtra = nullptr;

  1492. 

  1493.         pData->time.setNeedsReset();

  1494. 

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

  1496.         // enable link now if needed

  1497.         {

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

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

  1500.         }

  1501. #endif

  1502.         break;

  1503. 

  1504.     case ENGINE_OPTION_FORCE_STEREO:

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

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

  1507.         break;

  1508. 

  1509.     case ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

  1510. #ifdef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1511.         CARLA_SAFE_ASSERT_RETURN(value == 0,);

  1512. #else

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

  1514. #endif

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

  1516.         break;

  1517. 

  1518.     case ENGINE_OPTION_PREFER_UI_BRIDGES:

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

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

  1521.         break;

  1522. 

  1523.     case ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

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

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

  1526.         break;

  1527. 

  1528.     case ENGINE_OPTION_MAX_PARAMETERS:

  1529.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  1531.         break;

  1532. 

  1533.     case ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  1534.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  1536.         break;

  1537. 

  1538.     case ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  1539.         CARLA_SAFE_ASSERT_RETURN(value >= 8,);

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

  1541.         break;

  1542. 

  1543.     case ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  1544.         CARLA_SAFE_ASSERT_RETURN(value >= 22050,);

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

  1546.         break;

  1547. 

  1548.     case ENGINE_OPTION_AUDIO_TRIPLE_BUFFER:

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

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

  1551.         break;

  1552. 

  1553.     case ENGINE_OPTION_AUDIO_DEVICE:

  1554.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  1555. 

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

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

  1558. 

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

  1560.         break;

  1561. 

  1562.     case ENGINE_OPTION_PLUGIN_PATH:

  1563.         CARLA_SAFE_ASSERT_RETURN(value > PLUGIN_NONE,);

  1564.         CARLA_SAFE_ASSERT_RETURN(value <= PLUGIN_SFZ,);

  1565. 

  1566.         switch (value)

  1567.         {

  1568.         case PLUGIN_LADSPA:

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

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

  1571.             if (valueStr != nullptr)

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

  1573.             else

  1574.                 pData->options.pathLADSPA = nullptr;

  1575.             break;

  1576.         case PLUGIN_DSSI:

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

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

  1579.             if (valueStr != nullptr)

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

  1581.             else

  1582.                 pData->options.pathDSSI = nullptr;

  1583.             break;

  1584.         case PLUGIN_LV2:

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

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

  1587.             if (valueStr != nullptr)

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

  1589.             else

  1590.                 pData->options.pathLV2 = nullptr;

  1591.             break;

  1592.         case PLUGIN_VST2:

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

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

  1595.             if (valueStr != nullptr)

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

  1597.             else

  1598.                 pData->options.pathVST2 = nullptr;

  1599.             break;

  1600.         case PLUGIN_VST3:

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

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

  1603.             if (valueStr != nullptr)

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

  1605.             else

  1606.                 pData->options.pathVST3 = nullptr;

  1607.             break;

  1608.         case PLUGIN_SF2:

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

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

  1611.             if (valueStr != nullptr)

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

  1613.             else

  1614.                 pData->options.pathSF2 = nullptr;

  1615.             break;

  1616.         case PLUGIN_SFZ:

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

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

  1619.             if (valueStr != nullptr)

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

  1621.             else

  1622.                 pData->options.pathSFZ = nullptr;

  1623.             break;

  1624.         default:

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

  1626.             break;

  1627.         }

  1628.         break;

  1629. 

  1630.     case ENGINE_OPTION_PATH_BINARIES:

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

  1632. 

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

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

  1635. 

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

  1637.         break;

  1638. 

  1639.     case ENGINE_OPTION_PATH_RESOURCES:

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

  1641. 

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

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

  1644. 

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

  1646.         break;

  1647. 

  1648.     case ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR: {

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

  1650. 

  1651. #ifdef CARLA_OS_LINUX

  1652.         const ScopedEngineEnvironmentLocker _seel(this);

  1653. 

  1654.         if (value != 0)

  1655.         {

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

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

  1658.         }

  1659.         else

  1660.         {

  1661.             ::unsetenv("LD_PRELOAD");

  1662.         }

  1663. #endif

  1664.     }   break;

  1665. 

  1666.     case ENGINE_OPTION_FRONTEND_WIN_ID: {

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

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

  1669.         CARLA_SAFE_ASSERT_RETURN(winId >= 0,);

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

  1671.     }   break;

  1672. 

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

  1674.     case ENGINE_OPTION_WINE_EXECUTABLE:

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

  1676. 

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

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

  1679. 

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

  1681.         break;

  1682. 

  1683.     case ENGINE_OPTION_WINE_AUTO_PREFIX:

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

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

  1686.         break;

  1687. 

  1688.     case ENGINE_OPTION_WINE_FALLBACK_PREFIX:

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

  1690. 

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

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

  1693. 

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

  1695.         break;

  1696. 

  1697.     case ENGINE_OPTION_WINE_RT_PRIO_ENABLED:

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

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

  1700.         break;

  1701. 

  1702.     case ENGINE_OPTION_WINE_BASE_RT_PRIO:

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

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

  1705.         break;

  1706. 

  1707.     case ENGINE_OPTION_WINE_SERVER_RT_PRIO:

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

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

  1710.         break;

  1711. #endif

  1712. 

  1713.     case ENGINE_OPTION_DEBUG_CONSOLE_OUTPUT:

  1714.         break;

  1715.     }

  1716. }

  1717. 

  1718. #ifndef BUILD_BRIDGE

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

  1720. // OSC Stuff

  1721. 

  1722. bool CarlaEngine::isOscControlRegistered() const noexcept

  1723. {

  1724. # ifdef HAVE_LIBLO

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

  1726. # else

  1727.     return false;

  1728. # endif

  1729. }

  1730. 

  1731. void CarlaEngine::idleOsc() const noexcept

  1732. {

  1733. # ifdef HAVE_LIBLO

  1734.     pData->osc.idle();

  1735. # endif

  1736. }

  1737. 

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

  1739. {

  1740. # ifdef HAVE_LIBLO

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

  1742. # else

  1743.     return nullptr;

  1744. # endif

  1745. }

  1746. 

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

  1748. {

  1749. # ifdef HAVE_LIBLO

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

  1751. # else

  1752.     return nullptr;

  1753. # endif

  1754. }

  1755. #endif

  1756. 

  1757. // -----------------------------------------------------------------------

  1758. // Helper functions

  1759. 

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

  1761. {

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

  1763. }

  1764. 

  1765. // -----------------------------------------------------------------------

  1766. // Internal stuff

  1767. 

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

  1769. {

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

  1771. 

  1772. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

  1775.     {

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

  1777.     }

  1778. #endif

  1779. 

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

  1781. 

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

  1783.     {

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

  1785. 

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

  1787.         {

  1788.             plugin->tryLock(true);

  1789.             plugin->bufferSizeChanged(newBufferSize);

  1790.             plugin->unlock();

  1791.         }

  1792.     }

  1793. 

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

  1795. }

  1796. 

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

  1798. {

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

  1800. 

  1801. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

  1804.     {

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

  1806.     }

  1807. #endif

  1808. 

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

  1810. 

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

  1812.     {

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

  1814. 

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

  1816.         {

  1817.             plugin->tryLock(true);

  1818.             plugin->sampleRateChanged(newSampleRate);

  1819.             plugin->unlock();

  1820.         }

  1821.     }

  1822. 

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

  1824. }

  1825. 

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

  1827. {

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

  1829. 

  1830. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

  1833.     {

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

  1835.     }

  1836. #endif

  1837. 

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

  1839.     {

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

  1841. 

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

  1843.             plugin->offlineModeChanged(isOfflineNow);

  1844.     }

  1845. }

  1846. 

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

  1848. {

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

  1850. 

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

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

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

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

  1855. }

  1856. 

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

  1858. {

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

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

  1861.     {

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

  1863. 

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

  1865.         {

  1866. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

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

  1870. #endif

  1871.             plugin->prepareForSave();

  1872.         }

  1873.     }

  1874. 

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

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

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

  1878. 

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

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

  1881. 

  1882.     {

  1883.         MemoryOutputStream outSettings(1024);

  1884. 

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

  1886. 

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

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

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

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

  1891. 

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

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

  1894. 

  1895.         if (isPlugin)

  1896.         {

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

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

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

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

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

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

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

  1904.         }

  1905. 

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

  1907.         outStream << outSettings;

  1908.     }

  1909. 

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

  1911.     {

  1912.         MemoryOutputStream outTransport(128);

  1913. 

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

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

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

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

  1918.         outStream << outTransport;

  1919.     }

  1920. 

  1921.     char strBuf[STR_MAX+1];

  1922. 

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

  1924.     {

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

  1926. 

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

  1928.         {

  1929.             MemoryOutputStream outPlugin(4096), streamPlugin;

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

  1931. 

  1932.             outPlugin << "\n";

  1933. 

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

  1935.             plugin->getRealName(strBuf);

  1936. 

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

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

  1939. 

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

  1941.             outPlugin << streamPlugin;

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

  1943.             outStream << outPlugin;

  1944.         }

  1945.     }

  1946. 

  1947. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1948.     // tell bridges we're done saving

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

  1950.     {

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

  1952. 

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

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

  1955.     }

  1956. 

  1957.     // save internal connections

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

  1959.     {

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

  1961.         {

  1962.             MemoryOutputStream outPatchbay(2048);

  1963. 

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

  1965. 

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

  1967.             {

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

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

  1970. 

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

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

  1973. 

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

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

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

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

  1978.             }

  1979. 

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

  1981.             outStream << outPatchbay;

  1982.         }

  1983.     }

  1984. 

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

  1986.     bool saveExternalConnections;

  1987. 

  1988.     /**/ if (isPlugin)

  1989.         saveExternalConnections = false;

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

  1991.         saveExternalConnections = true;

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

  1993.         saveExternalConnections = false;

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

  1995.         saveExternalConnections = false;

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

  1997.         saveExternalConnections = false;

  1998.     else

  1999.         saveExternalConnections = true;

  2000. 

  2001.     if (saveExternalConnections)

  2002.     {

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

  2004.         {

  2005.             MemoryOutputStream outPatchbay(2048);

  2006. 

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

  2008. 

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

  2010.             {

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

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

  2013. 

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

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

  2016. 

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

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

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

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

  2021.             }

  2022. 

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

  2024.             outStream << outPatchbay;

  2025.         }

  2026.     }

  2027. #endif

  2028. 

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

  2030. }

  2031. 

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

  2033. {

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

  2035. 

  2036.     // try direct filename first

  2037.     String jbinary(binary);

  2038. 

  2039.     // adjust for current platform

  2040. #ifdef CARLA_OS_WIN

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

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

  2043. #else

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

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

  2046. #endif

  2047. 

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

  2049. 

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

  2051. #ifdef CARLA_OS_MAC

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

  2053.         searchFlags |= File::findDirectories;

  2054. #endif

  2055. 

  2056.     Array<File> results;

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

  2058.     {

  2059.         const File path(*it);

  2060. 

  2061.         results.clear();

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

  2063. 

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

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

  2066.     }

  2067. 

  2068.     // try changing extension

  2069. #if defined(CARLA_OS_MAC)

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

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

  2072. #elif defined(CARLA_OS_WIN)

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

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

  2075. #else

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

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

  2078. #endif

  2079.     else

  2080.         return String();

  2081. 

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

  2083.     {

  2084.         const File path(*it);

  2085. 

  2086.         results.clear();

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

  2088. 

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

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

  2091.     }

  2092. 

  2093.     return String();

  2094. }

  2095. 

  2096. bool CarlaEngine::loadProjectInternal(water::XmlDocument& xmlDoc)

  2097. {

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

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

  2100. 

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

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

  2103. 

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

  2105.     {

  2106.         callback(ENGINE_CALLBACK_PROJECT_LOAD_FINISHED, 0, 0, 0, 0, 0.0f, nullptr);

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

  2108.         return false;

  2109.     }

  2110. 

  2111.     pData->actionCanceled = false;

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

  2113. 

  2114. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2115.     const ScopedValueSetter<bool> _svs2(pData->loadingProject, true, false);

  2116. #endif

  2117. 

  2118.     // completely load file

  2119.     xmlElement = xmlDoc.getDocumentElement(false);

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

  2121. 

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

  2123. 

  2124.     if (pData->aboutToClose)

  2125.         return true;

  2126. 

  2127.     if (pData->actionCanceled)

  2128.     {

  2129.         setLastError("Project load canceled");

  2130.         return false;

  2131.     }

  2132. 

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

  2134. 

  2135.     // load engine settings first of all

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

  2137.     {

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

  2139.         {

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

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

  2142. 

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

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

  2145. 

  2146.             int option = -1;

  2147.             int value  = 0;

  2148.             const char* valueStr = nullptr;

  2149. 

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

  2151.             {

  2152.                 option = ENGINE_OPTION_FORCE_STEREO;

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

  2154.             }

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

  2156.             {

  2157.                 option = ENGINE_OPTION_PREFER_PLUGIN_BRIDGES;

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

  2159.             }

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

  2161.             {

  2162.                 option = ENGINE_OPTION_PREFER_UI_BRIDGES;

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

  2164.             }

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

  2166.             {

  2167.                 option = ENGINE_OPTION_UIS_ALWAYS_ON_TOP;

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

  2169.             }

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

  2171.             {

  2172.                 option = ENGINE_OPTION_MAX_PARAMETERS;

  2173.                 value  = text.getIntValue();

  2174.             }

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

  2176.             {

  2177.                 option = ENGINE_OPTION_UI_BRIDGES_TIMEOUT;

  2178.                 value  = text.getIntValue();

  2179.             }

  2180.             else if (isPlugin)

  2181.             {

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

  2183.                 {

  2184.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2185.                     value    = PLUGIN_LADSPA;

  2186.                     valueStr = text.toRawUTF8();

  2187.                 }

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

  2189.                 {

  2190.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2191.                     value    = PLUGIN_DSSI;

  2192.                     valueStr = text.toRawUTF8();

  2193.                 }

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

  2195.                 {

  2196.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2197.                     value    = PLUGIN_LV2;

  2198.                     valueStr = text.toRawUTF8();

  2199.                 }

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

  2201.                 {

  2202.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2203.                     value    = PLUGIN_VST2;

  2204.                     valueStr = text.toRawUTF8();

  2205.                 }

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

  2207.                 {

  2208.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2209.                     value    = PLUGIN_VST3;

  2210.                     valueStr = text.toRawUTF8();

  2211.                 }

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

  2213.                 {

  2214.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2215.                     value    = PLUGIN_SF2;

  2216.                     valueStr = text.toRawUTF8();

  2217.                 }

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

  2219.                 {

  2220.                     option   = ENGINE_OPTION_PLUGIN_PATH;

  2221.                     value    = PLUGIN_SFZ;

  2222.                     valueStr = text.toRawUTF8();

  2223.                 }

  2224.             }

  2225. 

  2226.             if (option == -1)

  2227.             {

  2228.                 // check old stuff, unhandled now

  2229.                 if (tag == "GIG_PATH")

  2230.                     continue;

  2231.                 // ignored tags

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

  2233.                     continue;

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

  2235.                     continue;

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

  2237.                     continue;

  2238. 

  2239.                 // hmm something is wrong..

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

  2241.                 continue;

  2242.             }

  2243. 

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

  2245.         }

  2246. 

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

  2248. 

  2249.         if (pData->aboutToClose)

  2250.             return true;

  2251. 

  2252.         if (pData->actionCanceled)

  2253.         {

  2254.             setLastError("Project load canceled");

  2255.             return false;

  2256.         }

  2257.     }

  2258. 

  2259.     // now setup transport

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

  2261.     {

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

  2263.         {

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

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

  2266. 

  2267.             // some sane limits

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

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

  2270. 

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

  2272. 

  2273.             if (pData->aboutToClose)

  2274.                 return true;

  2275. 

  2276.             if (pData->actionCanceled)

  2277.             {

  2278.                 setLastError("Project load canceled");

  2279.                 return false;

  2280.             }

  2281.         }

  2282.     }

  2283. 

  2284.     // and we handle plugins

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

  2286.     {

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

  2288. 

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

  2290.         {

  2291.             CarlaStateSave stateSave;

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

  2293. 

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

  2295. 

  2296.             if (pData->aboutToClose)

  2297.                 return true;

  2298. 

  2299.             if (pData->actionCanceled)

  2300.             {

  2301.                 setLastError("Project load canceled");

  2302.                 return false;

  2303.             }

  2304. 

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

  2306. 

  2307. #ifndef BUILD_BRIDGE

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

  2309.             // FIXME Remove on 2.1 release

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

  2311.             {

  2312.                 if (addPlugin(PLUGIN_LV2, "", stateSave.name, "http://linuxsampler.org/plugins/linuxsampler", 0, nullptr))

  2313.                 {

  2314.                     const uint pluginId = pData->curPluginCount;

  2315. 

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

  2317.                     {

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

  2319. 

  2320.                         if (pData->aboutToClose)

  2321.                             return true;

  2322. 

  2323.                         if (pData->actionCanceled)

  2324.                         {

  2325.                             setLastError("Project load canceled");

  2326.                             return false;

  2327.                         }

  2328. 

  2329.                         String lsState;

  2330.                         lsState << "0.35\n";

  2331.                         lsState << "18 0 Chromatic\n";

  2332.                         lsState << "18 1 Drum Kits\n";

  2333.                         lsState << "20 0\n";

  2334.                         lsState << "0 1 " << stateSave.binary << "\n";

  2335.                         lsState << "0 0 0 0 1 0 GIG\n";

  2336. 

  2337.                         plugin->setCustomData(LV2_ATOM__String, "http://linuxsampler.org/schema#state-string", lsState.toRawUTF8(), true);

  2338.                         plugin->restoreLV2State();

  2339. 

  2340.                         plugin->setDryWet(stateSave.dryWet, true, true);

  2341.                         plugin->setVolume(stateSave.volume, true, true);

  2342.                         plugin->setBalanceLeft(stateSave.balanceLeft, true, true);

  2343.                         plugin->setBalanceRight(stateSave.balanceRight, true, true);

  2344.                         plugin->setPanning(stateSave.panning, true, true);

  2345.                         plugin->setCtrlChannel(stateSave.ctrlChannel, true, true);

  2346.                         plugin->setActive(stateSave.active, true, true);

  2347. 

  2348.                         ++pData->curPluginCount;

  2349. 

  2350.                         plugin->setEnabled(true);

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

  2352. 

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

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

  2355.                     }

  2356.                     else

  2357.                     {

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

  2359.                     }

  2360.                 }

  2361.                 else

  2362.                 {

  2363.                     carla_stderr2("Failed to load a linuxsampler LV2 plugin, GIG file won't be loaded");

  2364.                 }

  2365. 

  2366.                 continue;

  2367.             }

  2368. #endif

  2369. 

  2370.             const void* extraStuff    = nullptr;

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

  2372. 

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

  2374. 

  2375.             switch (ptype)

  2376.             {

  2377.             case PLUGIN_SF2:

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

  2379.                     extraStuff = kTrue;

  2380.                 // fall through

  2381.             case PLUGIN_LADSPA:

  2382.             case PLUGIN_DSSI:

  2383.             case PLUGIN_VST2:

  2384.             case PLUGIN_VST3:

  2385.             case PLUGIN_SFZ:

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

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

  2388.                 {

  2389.                     const char* searchPath;

  2390. 

  2391.                     switch (ptype)

  2392.                     {

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

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

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

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

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

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

  2399.                     default:            searchPath = nullptr;                   break;

  2400.                     }

  2401. 

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

  2403.                     {

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

  2405.                                      stateSave.binary);

  2406. 

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

  2408. 

  2409.                         if (result.isEmpty())

  2410.                         {

  2411.                             switch (ptype)

  2412.                             {

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

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

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

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

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

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

  2419.                             default:            searchPath = nullptr;                    break;

  2420.                             }

  2421. 

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

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

  2424.                         }

  2425. 

  2426.                         if (result.isNotEmpty())

  2427.                         {

  2428.                             delete[] stateSave.binary;

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

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

  2431.                         }

  2432.                         else

  2433.                         {

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

  2435.                         }

  2436.                     }

  2437.                 }

  2438.                 break;

  2439.             default:

  2440.                 break;

  2441.             }

  2442. 

  2443.             BinaryType btype;

  2444. 

  2445.             switch (ptype)

  2446.             {

  2447.             case PLUGIN_LADSPA:

  2448.             case PLUGIN_DSSI:

  2449.             case PLUGIN_LV2:

  2450.             case PLUGIN_VST2:

  2451.                 btype = getBinaryTypeFromFile(stateSave.binary);

  2452.                 break;

  2453.             default:

  2454.                 btype = BINARY_NATIVE;

  2455.                 break;

  2456.             }

  2457. 

  2458.             if (addPlugin(btype, ptype, stateSave.binary,

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

  2460.             {

  2461. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2462.                 const uint pluginId = pData->curPluginCount;

  2463. #else

  2464.                 const uint pluginId = 0;

  2465. #endif

  2466. 

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

  2468.                 {

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

  2470. 

  2471.                     if (pData->aboutToClose)

  2472.                         return true;

  2473. 

  2474.                     if (pData->actionCanceled)

  2475.                     {

  2476.                         setLastError("Project load canceled");

  2477.                         return false;

  2478.                     }

  2479. 

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

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

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

  2483. 

  2484.                     plugin->loadStateSave(stateSave);

  2485. 

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

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

  2488.                      *        as we want to load state first.

  2489.                      */

  2490.                     plugin->setEnabled(true);

  2491. 

  2492.                     ++pData->curPluginCount;

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

  2494. 

  2495. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

  2498. #endif

  2499.                 }

  2500.                 else

  2501.                 {

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

  2503.                 }

  2504.             }

  2505.             else

  2506.             {

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

  2508.             }

  2509.         }

  2510. 

  2511.         if (isPreset)

  2512.         {

  2513.             callback(ENGINE_CALLBACK_PROJECT_LOAD_FINISHED, 0, 0, 0, 0, 0.0f, nullptr);

  2514.             callback(ENGINE_CALLBACK_CANCELABLE_ACTION, 0, 0, 0, 0, 0.0f, "Loading project");

  2515.             return true;

  2516.         }

  2517.     }

  2518. 

  2519. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2520.     // tell bridges we're done loading

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

  2522.     {

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

  2524. 

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

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

  2527.     }

  2528. 

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

  2530. 

  2531.     if (pData->aboutToClose)

  2532.         return true;

  2533. 

  2534.     if (pData->actionCanceled)

  2535.     {

  2536.         setLastError("Project load canceled");

  2537.         return false;

  2538.     }

  2539. 

  2540.     bool hasInternalConnections = false;

  2541. 

  2542.     // and now we handle connections (internal)

  2543.     if (XmlElement* const elem = xmlElement->getChildByName("Patchbay"))

  2544.     {

  2545.         hasInternalConnections = true;

  2546. 

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

  2548.         {

  2549.             CarlaString sourcePort, targetPort;

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

  2551. 

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

  2553.             {

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

  2555. 

  2556.                 if (patchTag != "Connection")

  2557.                     continue;

  2558. 

  2559.                 sourcePort.clear();

  2560.                 targetPort.clear();

  2561. 

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

  2563.                 {

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

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

  2566. 

  2567.                     /**/ if (tag == "Source")

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

  2569.                     else if (tag == "Target")

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

  2571.                 }

  2572. 

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

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

  2575.             }

  2576. 

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

  2578. 

  2579.             if (pData->aboutToClose)

  2580.                 return true;

  2581. 

  2582.             if (pData->actionCanceled)

  2583.             {

  2584.                 setLastError("Project load canceled");

  2585.                 return false;

  2586.             }

  2587.         }

  2588.     }

  2589. 

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

  2591.     bool loadExternalConnections;

  2592. 

  2593.     /**/ if (std::strcmp(getCurrentDriverName(), "JACK") != 0)

  2594.         loadExternalConnections = true;

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

  2596.         loadExternalConnections = false;

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

  2598.         loadExternalConnections = false;

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

  2600.         loadExternalConnections = false;

  2601.     else

  2602.         loadExternalConnections = true;

  2603. 

  2604.     // plus external connections too

  2605.     if (loadExternalConnections)

  2606.     {

  2607.         const bool isUsingExternal = pData->options.processMode != ENGINE_PROCESS_MODE_PATCHBAY ||

  2608.                                      pData->graph.isUsingExternal();

  2609.         const bool loadingAsExternal = pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY &&

  2610.                                        hasInternalConnections;

  2611. 

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

  2613.         {

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

  2615. 

  2616.             // check if we want to load patchbay-mode connections into an external (multi-client) graph

  2617.             if (tagName == "Patchbay")

  2618.             {

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

  2620.                     continue;

  2621.             }

  2622.             // or load external patchbay connections

  2623.             else if (tagName != "ExternalPatchbay")

  2624.             {

  2625.                 continue;

  2626.             }

  2627. 

  2628.             CarlaString sourcePort, targetPort;

  2629. 

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

  2631.             {

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

  2633. 

  2634.                 if (patchTag != "Connection")

  2635.                     continue;

  2636. 

  2637.                 sourcePort.clear();

  2638.                 targetPort.clear();

  2639. 

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

  2641.                 {

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

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

  2644. 

  2645.                     /**/ if (tag == "Source")

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

  2647.                     else if (tag == "Target")

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

  2649.                 }

  2650. 

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

  2652.                     restorePatchbayConnection(loadingAsExternal, sourcePort, targetPort, isUsingExternal);

  2653.             }

  2654.             break;

  2655.         }

  2656.     }

  2657. #endif

  2658. 

  2659.     callback(ENGINE_CALLBACK_PROJECT_LOAD_FINISHED, 0, 0, 0, 0, 0.0f, nullptr);

  2660.     callback(ENGINE_CALLBACK_CANCELABLE_ACTION, 0, 0, 0, 0, 0.0f, "Loading project");

  2661.     return true;

  2662. }

  2663. 

  2664. // -----------------------------------------------------------------------

  2665. 

  2666. CARLA_BACKEND_END_NAMESPACE