falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 43 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.
7005 Commits
17 Branches
243MB
Tree: 83f0bc98c1
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '83f0bc98c1'
${ noResults }
Carla/source/backend/plugin/CarlaPlugin.cpp

2742 lines
90KB
Raw Blame History 

  1. // SPDX-FileCopyrightText: 2011-2025 Filipe Coelho <falktx@falktx.com>

  2. // SPDX-License-Identifier: GPL-2.0-or-later

  3. 

  4. #include "CarlaPluginInternal.hpp"

  5. #include "CarlaEngine.hpp"

  6. 

  7. #include "CarlaBackendUtils.hpp"

  8. #include "CarlaMathUtils.hpp"

  9. #include "CarlaMIDI.h"

  10. #include "CarlaPluginUI.hpp"

  11. #include "CarlaScopeUtils.hpp"

  12. #include "CarlaStringList.hpp"

  13. 

  14. #include <ctime>

  15. 

  16. #include "distrho/extra/Base64.hpp"

  17. 

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

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

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

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

  22. 

  23. using water::CharPointer_UTF8;

  24. using water::File;

  25. using water::MemoryOutputStream;

  26. using water::Result;

  27. using water::String;

  28. using water::XmlDocument;

  29. using water::XmlElement;

  30. 

  31. CARLA_BACKEND_START_NAMESPACE

  32. 

  33. // -------------------------------------------------------------------------------------------------------------------

  34. // Fallback data

  35. 

  36. static const ParameterData   kParameterDataNull   = { PARAMETER_UNKNOWN, 0x0, PARAMETER_NULL, -1, 0, CONTROL_INDEX_NONE, 0.0f, 1.0f, 0x0 };

  37. static const ParameterRanges kParameterRangesNull = { 0.0f, 0.0f, 1.0f, 0.01f, 0.0001f, 0.1f };

  38. static const MidiProgramData kMidiProgramDataNull = { 0, 0, nullptr };

  39. 

  40. static const CustomData        kCustomDataFallback        = { nullptr, nullptr, nullptr };

  41. static /* */ CustomData        kCustomDataFallbackNC      = { nullptr, nullptr, nullptr };

  42. static const PluginPostRtEvent kPluginPostRtEventFallback = { kPluginPostRtEventNull, false, {} };

  43. 

  44. // -------------------------------------------------------------------------------------------------------------------

  45. // ParamSymbol struct, needed for CarlaPlugin::loadStateSave()

  46. 

  47. struct ParamSymbol {

  48.     int32_t index;

  49.     const char* symbol;

  50. 

  51.     ParamSymbol(const uint32_t i, const char* const s)

  52.         : index(static_cast<int32_t>(i)),

  53.           symbol(carla_strdup(s)) {}

  54. 

  55.     ~ParamSymbol() noexcept

  56.     {

  57.         CARLA_SAFE_ASSERT_RETURN(symbol != nullptr,)

  58. 

  59.         delete[] symbol;

  60.         symbol = nullptr;

  61.     }

  62. 

  63. #ifdef CARLA_PROPER_CPP11_SUPPORT

  64.     ParamSymbol() = delete;

  65.     CARLA_DECLARE_NON_COPYABLE(ParamSymbol)

  66. #endif

  67. };

  68. 

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

  70. // Constructor and destructor

  71. 

  72. CarlaPlugin::CarlaPlugin(CarlaEngine* const engine, const uint id)

  73.     : pData(new ProtectedData(engine, id))

  74. {

  75.     CARLA_SAFE_ASSERT_RETURN(engine != nullptr,);

  76.     CARLA_SAFE_ASSERT(id < engine->getMaxPluginNumber());

  77.     carla_debug("CarlaPlugin::CarlaPlugin(%p, %i)", engine, id);

  78. 

  79.     switch (engine->getProccessMode())

  80.     {

  81.     case ENGINE_PROCESS_MODE_SINGLE_CLIENT:

  82.     case ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS:

  83.         CARLA_SAFE_ASSERT(id < MAX_DEFAULT_PLUGINS);

  84.         break;

  85. 

  86.     case ENGINE_PROCESS_MODE_CONTINUOUS_RACK:

  87.         CARLA_SAFE_ASSERT(id < MAX_RACK_PLUGINS);

  88.         break;

  89. 

  90.     case ENGINE_PROCESS_MODE_PATCHBAY:

  91.         CARLA_SAFE_ASSERT(id < MAX_PATCHBAY_PLUGINS);

  92.         break;

  93. 

  94.     case ENGINE_PROCESS_MODE_BRIDGE:

  95.         CARLA_SAFE_ASSERT(id == 0);

  96.         break;

  97.     }

  98. }

  99. 

  100. CarlaPlugin::~CarlaPlugin()

  101. {

  102.     carla_debug("CarlaPlugin::~CarlaPlugin()");

  103. 

  104.     delete pData;

  105. }

  106. 

  107. // -------------------------------------------------------------------

  108. // Information (base)

  109. 

  110. uint CarlaPlugin::getId() const noexcept

  111. {

  112.     return pData->id;

  113. }

  114. 

  115. uint CarlaPlugin::getHints() const noexcept

  116. {

  117.     return pData->hints;

  118. }

  119. 

  120. uint CarlaPlugin::getOptionsEnabled() const noexcept

  121. {

  122.     return pData->options;

  123. }

  124. 

  125. bool CarlaPlugin::isEnabled() const noexcept

  126. {

  127.     return pData->enabled;

  128. }

  129. 

  130. const char* CarlaPlugin::getName() const noexcept

  131. {

  132.     return pData->name;

  133. }

  134. 

  135. const char* CarlaPlugin::getFilename() const noexcept

  136. {

  137.     return pData->filename;

  138. }

  139. 

  140. const char* CarlaPlugin::getIconName() const noexcept

  141. {

  142.     return pData->iconName;

  143. }

  144. 

  145. PluginCategory CarlaPlugin::getCategory() const noexcept

  146. {

  147.     return getPluginCategoryFromName(pData->name);

  148. }

  149. 

  150. int64_t CarlaPlugin::getUniqueId() const noexcept

  151. {

  152.     return 0;

  153. }

  154. 

  155. uint32_t CarlaPlugin::getLatencyInFrames() const noexcept

  156. {

  157.     return 0;

  158. }

  159. 

  160. // -------------------------------------------------------------------

  161. // Information (count)

  162. 

  163. uint32_t CarlaPlugin::getAudioInCount() const noexcept

  164. {

  165.     return pData->audioIn.count;

  166. }

  167. 

  168. uint32_t CarlaPlugin::getAudioOutCount() const noexcept

  169. {

  170.     return pData->audioOut.count;

  171. }

  172. 

  173. uint32_t CarlaPlugin::getCVInCount() const noexcept

  174. {

  175.     return pData->cvIn.count;

  176. }

  177. 

  178. uint32_t CarlaPlugin::getCVOutCount() const noexcept

  179. {

  180.     return pData->cvOut.count;

  181. }

  182. 

  183. uint32_t CarlaPlugin::getMidiInCount() const noexcept

  184. {

  185.     return (pData->extraHints & PLUGIN_EXTRA_HINT_HAS_MIDI_IN) ? 1 : 0;

  186. }

  187. 

  188. uint32_t CarlaPlugin::getMidiOutCount() const noexcept

  189. {

  190.     return (pData->extraHints & PLUGIN_EXTRA_HINT_HAS_MIDI_OUT) ? 1 : 0;

  191. }

  192. 

  193. uint32_t CarlaPlugin::getParameterCount() const noexcept

  194. {

  195.     return pData->param.count;

  196. }

  197. 

  198. uint32_t CarlaPlugin::getParameterScalePointCount(const uint32_t parameterId) const noexcept

  199. {

  200.     CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, 0);

  201.     return 0;

  202. }

  203. 

  204. uint32_t CarlaPlugin::getProgramCount() const noexcept

  205. {

  206.     return pData->prog.count;

  207. }

  208. 

  209. uint32_t CarlaPlugin::getMidiProgramCount() const noexcept

  210. {

  211.     return pData->midiprog.count;

  212. }

  213. 

  214. uint32_t CarlaPlugin::getCustomDataCount() const noexcept

  215. {

  216.     return static_cast<uint32_t>(pData->custom.count());

  217. }

  218. 

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

  220. // Information (current data)

  221. 

  222. int32_t CarlaPlugin::getCurrentProgram() const noexcept

  223. {

  224.     return pData->prog.current;

  225. }

  226. 

  227. int32_t CarlaPlugin::getCurrentMidiProgram() const noexcept

  228. {

  229.     return pData->midiprog.current;

  230. }

  231. 

  232. uint CarlaPlugin::getAudioPortHints(bool, uint32_t) const noexcept

  233. {

  234.     return 0x0;

  235. }

  236. 

  237. const ParameterData& CarlaPlugin::getParameterData(const uint32_t parameterId) const noexcept

  238. {

  239.     CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, kParameterDataNull);

  240.     return pData->param.data[parameterId];

  241. }

  242. 

  243. const ParameterRanges& CarlaPlugin::getParameterRanges(const uint32_t parameterId) const noexcept

  244. {

  245.     CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, kParameterRangesNull);

  246.     return pData->param.ranges[parameterId];

  247. }

  248. 

  249. bool CarlaPlugin::isParameterOutput(const uint32_t parameterId) const noexcept

  250. {

  251.     CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, false);

  252.     return (pData->param.data[parameterId].type == PARAMETER_OUTPUT);

  253. }

  254. 

  255. const MidiProgramData& CarlaPlugin::getMidiProgramData(const uint32_t index) const noexcept

  256. {

  257.     CARLA_SAFE_ASSERT_RETURN(index < pData->midiprog.count, kMidiProgramDataNull);

  258.     return pData->midiprog.data[index];

  259. }

  260. 

  261. const CustomData& CarlaPlugin::getCustomData(const uint32_t index) const noexcept

  262. {

  263.     return pData->custom.getAt(index, kCustomDataFallback);

  264. }

  265. 

  266. std::size_t CarlaPlugin::getChunkData(void** const dataPtr) noexcept

  267. {

  268.     CARLA_SAFE_ASSERT_RETURN(dataPtr != nullptr, 0);

  269.     CARLA_SAFE_ASSERT(false); // this should never happen

  270.     return 0;

  271. }

  272. 

  273. // -------------------------------------------------------------------

  274. // Information (per-plugin data)

  275. 

  276. uint CarlaPlugin::getOptionsAvailable() const noexcept

  277. {

  278.     CARLA_SAFE_ASSERT(false); // this should never happen

  279.     return 0x0;

  280. }

  281. 

  282. float CarlaPlugin::getParameterValue(const uint32_t parameterId) const noexcept

  283. {

  284.     CARLA_SAFE_ASSERT_RETURN(parameterId < getParameterCount(), 0.0f);

  285.     CARLA_SAFE_ASSERT(false); // this should never happen

  286.     return 0.0f;

  287. }

  288. 

  289. float CarlaPlugin::getParameterScalePointValue(const uint32_t parameterId, const uint32_t scalePointId) const noexcept

  290. {

  291.     CARLA_SAFE_ASSERT_RETURN(parameterId < getParameterCount(), 0.0f);

  292.     CARLA_SAFE_ASSERT_RETURN(scalePointId < getParameterScalePointCount(parameterId), 0.0f);

  293.     CARLA_SAFE_ASSERT(false); // this should never happen

  294.     return 0.0f;

  295. }

  296. 

  297. bool CarlaPlugin::getLabel(char* const strBuf) const noexcept

  298. {

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

  300.     return false;

  301. }

  302. 

  303. bool CarlaPlugin::getMaker(char* const strBuf) const noexcept

  304. {

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

  306.     return false;

  307. }

  308. 

  309. bool CarlaPlugin::getCopyright(char* const strBuf) const noexcept

  310. {

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

  312.     return false;

  313. }

  314. 

  315. bool CarlaPlugin::getRealName(char* const strBuf) const noexcept

  316. {

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

  318.     return false;

  319. }

  320. 

  321. bool CarlaPlugin::getParameterName(const uint32_t parameterId, char* const strBuf) const noexcept

  322. {

  323.     CARLA_SAFE_ASSERT_RETURN(parameterId < getParameterCount(), false);

  324.     CARLA_SAFE_ASSERT(false); // this should never happen

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

  326.     return false;

  327. }

  328. 

  329. bool CarlaPlugin::getParameterSymbol(const uint32_t parameterId, char* const strBuf) const noexcept

  330. {

  331.     CARLA_SAFE_ASSERT_RETURN(parameterId < getParameterCount(), false);

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

  333.     return false;

  334. }

  335. 

  336. bool CarlaPlugin::getParameterText(const uint32_t parameterId, char* const strBuf) noexcept

  337. {

  338.     CARLA_SAFE_ASSERT_RETURN(parameterId < getParameterCount(), false);

  339.     CARLA_SAFE_ASSERT(false); // this should never happen

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

  341.     return false;

  342. }

  343. 

  344. bool CarlaPlugin::getParameterUnit(const uint32_t parameterId, char* const strBuf) const noexcept

  345. {

  346.     CARLA_SAFE_ASSERT_RETURN(parameterId < getParameterCount(), false);

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

  348.     return false;

  349. }

  350. 

  351. bool CarlaPlugin::getParameterComment(const uint32_t parameterId, char* const strBuf) const noexcept

  352. {

  353.     CARLA_SAFE_ASSERT_RETURN(parameterId < getParameterCount(), false);

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

  355.     return false;

  356. }

  357. 

  358. bool CarlaPlugin::getParameterGroupName(const uint32_t parameterId, char* const strBuf) const noexcept

  359. {

  360.     CARLA_SAFE_ASSERT_RETURN(parameterId < getParameterCount(), false);

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

  362.     return false;

  363. }

  364. 

  365. bool CarlaPlugin::getParameterScalePointLabel(const uint32_t parameterId, const uint32_t scalePointId, char* const strBuf) const noexcept

  366. {

  367.     CARLA_SAFE_ASSERT_RETURN(parameterId < getParameterCount(), false);

  368.     CARLA_SAFE_ASSERT_RETURN(scalePointId < getParameterScalePointCount(parameterId), false);

  369.     CARLA_SAFE_ASSERT(false); // this should never happen

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

  371.     return false;

  372. }

  373. 

  374. float CarlaPlugin::getInternalParameterValue(const int32_t parameterId) const noexcept

  375. {

  376. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  377.     CARLA_SAFE_ASSERT_RETURN(parameterId != PARAMETER_NULL && parameterId > PARAMETER_MAX, 0.0f);

  378. 

  379.     switch (parameterId)

  380.     {

  381.     case PARAMETER_ACTIVE:

  382.         return pData->active;

  383.     case PARAMETER_CTRL_CHANNEL:

  384.         return pData->ctrlChannel;

  385.     case PARAMETER_DRYWET:

  386.         return pData->postProc.dryWet;

  387.     case PARAMETER_VOLUME:

  388.         return pData->postProc.volume;

  389.     case PARAMETER_BALANCE_LEFT:

  390.         return pData->postProc.balanceLeft;

  391.     case PARAMETER_BALANCE_RIGHT:

  392.         return pData->postProc.balanceRight;

  393.     case PARAMETER_PANNING:

  394.         return pData->postProc.panning;

  395.     };

  396. #endif

  397.     CARLA_SAFE_ASSERT_RETURN(parameterId >= 0, 0.0f);

  398. 

  399.     return getParameterValue(static_cast<uint32_t>(parameterId));

  400. }

  401. 

  402. bool CarlaPlugin::getProgramName(const uint32_t index, char* const strBuf) const noexcept

  403. {

  404.     CARLA_SAFE_ASSERT_RETURN(index < pData->prog.count, false);

  405.     CARLA_SAFE_ASSERT_RETURN(pData->prog.names[index] != nullptr, false);

  406.     std::strncpy(strBuf, pData->prog.names[index], STR_MAX);

  407.     return true;

  408. }

  409. 

  410. bool CarlaPlugin::getMidiProgramName(const uint32_t index, char* const strBuf) const noexcept

  411. {

  412.     CARLA_SAFE_ASSERT_RETURN(index < pData->midiprog.count, false);

  413.     CARLA_SAFE_ASSERT_RETURN(pData->midiprog.data[index].name != nullptr, false);

  414.     std::strncpy(strBuf, pData->midiprog.data[index].name, STR_MAX);

  415.     return true;

  416. }

  417. 

  418. void CarlaPlugin::getParameterCountInfo(uint32_t& ins, uint32_t& outs) const noexcept

  419. {

  420.     ins  = 0;

  421.     outs = 0;

  422. 

  423.     for (uint32_t i=0; i < pData->param.count; ++i)

  424.     {

  425.         if (pData->param.data[i].type == PARAMETER_INPUT)

  426.             ++ins;

  427.         else if (pData->param.data[i].type == PARAMETER_OUTPUT)

  428.             ++outs;

  429.     }

  430. }

  431. 

  432. // -------------------------------------------------------------------

  433. // Set data (state)

  434. 

  435. void CarlaPlugin::prepareForSave(bool)

  436. {

  437. }

  438. 

  439. void CarlaPlugin::resetParameters() noexcept

  440. {

  441.     for (uint i=0; i < pData->param.count; ++i)

  442.     {

  443.         const ParameterData&   paramData(pData->param.data[i]);

  444.         const ParameterRanges& paramRanges(pData->param.ranges[i]);

  445. 

  446.         if (paramData.type != PARAMETER_INPUT)

  447.             continue;

  448.         if ((paramData.hints & PARAMETER_IS_ENABLED) == 0)

  449.             continue;

  450. 

  451.         setParameterValue(i, paramRanges.def, true, true, true);

  452.     }

  453. }

  454. 

  455. void CarlaPlugin::randomizeParameters() noexcept

  456. {

  457.     float value, random;

  458. 

  459.     char strBuf[STR_MAX+1];

  460.     strBuf[STR_MAX] = '\0';

  461. 

  462.     std::srand(static_cast<uint>(std::time(nullptr)));

  463. 

  464.     for (uint i=0; i < pData->param.count; ++i)

  465.     {

  466.         const ParameterData& paramData(pData->param.data[i]);

  467. 

  468.         if (paramData.type != PARAMETER_INPUT)

  469.             continue;

  470.         if ((paramData.hints & PARAMETER_IS_ENABLED) == 0)

  471.             continue;

  472. 

  473.         if (! getParameterName(i, strBuf))

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

  475. 

  476.         if (std::strstr(strBuf, "olume") != nullptr)

  477.             continue;

  478.         if (std::strstr(strBuf, "Master") != nullptr)

  479.             continue;

  480. 

  481.         const ParameterRanges& paramRanges(pData->param.ranges[i]);

  482. 

  483.         if (paramData.hints & PARAMETER_IS_BOOLEAN)

  484.         {

  485.             random = static_cast<float>(std::rand()) / static_cast<float>(RAND_MAX);

  486.             value  = random > 0.5f ? paramRanges.max : paramRanges.min;

  487.         }

  488.         else

  489.         {

  490.             random = static_cast<float>(std::rand()) / static_cast<float>(RAND_MAX);

  491.             value  = random * (paramRanges.max - paramRanges.min) + paramRanges.min;

  492. 

  493.             if (paramData.hints & PARAMETER_IS_INTEGER)

  494.                 value = std::rint(value);

  495.         }

  496. 

  497.         setParameterValue(i, value, true, true, true);

  498.     }

  499. }

  500. 

  501. const CarlaStateSave& CarlaPlugin::getStateSave(const bool callPrepareForSave)

  502. {

  503.     pData->stateSave.clear();

  504. 

  505.     if (callPrepareForSave)

  506.     {

  507.         pData->stateSave.temporary = true;

  508.         prepareForSave(true);

  509.     }

  510. 

  511.     const PluginType pluginType = getType();

  512. 

  513.     char strBuf[STR_MAX+1];

  514.     carla_zeroChars(strBuf, STR_MAX+1);

  515. 

  516.     // ---------------------------------------------------------------

  517.     // Basic info

  518. 

  519.     if (! getLabel(strBuf))

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

  521. 

  522.     pData->stateSave.type     = carla_strdup(getPluginTypeAsString(pluginType));

  523.     pData->stateSave.name     = carla_strdup(pData->name);

  524.     pData->stateSave.label    = carla_strdup(strBuf);

  525.     pData->stateSave.uniqueId = getUniqueId();

  526. // #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  527.     pData->stateSave.options  = pData->options;

  528. // #endif

  529. 

  530.     if (pData->filename != nullptr)

  531.         pData->stateSave.binary = carla_strdup(pData->filename);

  532. 

  533.    #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  534.     // ---------------------------------------------------------------

  535.     // Internals

  536. 

  537.     pData->stateSave.active       = pData->active;

  538.     pData->stateSave.dryWet       = pData->postProc.dryWet;

  539.     pData->stateSave.volume       = pData->postProc.volume;

  540.     pData->stateSave.balanceLeft  = pData->postProc.balanceLeft;

  541.     pData->stateSave.balanceRight = pData->postProc.balanceRight;

  542.     pData->stateSave.panning      = pData->postProc.panning;

  543.     pData->stateSave.ctrlChannel  = pData->ctrlChannel;

  544.    #endif

  545. 

  546.     if (pData->hints & PLUGIN_IS_BRIDGE)

  547.         waitForBridgeSaveSignal();

  548. 

  549.     // ---------------------------------------------------------------

  550.     // Chunk

  551. 

  552.     bool usingChunk = false;

  553. 

  554.     if (pData->options & PLUGIN_OPTION_USE_CHUNKS)

  555.     {

  556.         void* data = nullptr;

  557.         const std::size_t dataSize = getChunkData(&data);

  558. 

  559.         if (data != nullptr && dataSize > 0)

  560.         {

  561.             pData->stateSave.chunk = CarlaString::asBase64(data, dataSize).dup();

  562. 

  563.             if (pluginType != PLUGIN_INTERNAL && pluginType != PLUGIN_JSFX)

  564.                 usingChunk = true;

  565.         }

  566.     }

  567. 

  568.     // ---------------------------------------------------------------

  569.     // Current Program

  570. 

  571.     if (pData->prog.current >= 0 && pluginType != PLUGIN_LV2)

  572.     {

  573.         pData->stateSave.currentProgramIndex = pData->prog.current;

  574.         pData->stateSave.currentProgramName  = carla_strdup(pData->prog.names[pData->prog.current]);

  575.     }

  576. 

  577.     // ---------------------------------------------------------------

  578.     // Current MIDI Program

  579. 

  580.     if (pData->midiprog.current >= 0 && pluginType != PLUGIN_LV2 && pluginType != PLUGIN_SF2)

  581.     {

  582.         const MidiProgramData& mpData(pData->midiprog.getCurrent());

  583. 

  584.         pData->stateSave.currentMidiBank    = static_cast<int32_t>(mpData.bank);

  585.         pData->stateSave.currentMidiProgram = static_cast<int32_t>(mpData.program);

  586.     }

  587. 

  588.     // ---------------------------------------------------------------

  589.     // Parameters

  590. 

  591.     const float sampleRate = static_cast<float>(pData->engine->getSampleRate());

  592. 

  593.     for (uint32_t i=0; i < pData->param.count; ++i)

  594.     {

  595.         const ParameterData& paramData(pData->param.data[i]);

  596. 

  597.         if ((paramData.hints & PARAMETER_IS_ENABLED) == 0)

  598.             continue;

  599.         if (paramData.hints & PARAMETER_IS_NOT_SAVED)

  600.             continue;

  601. 

  602.         const bool dummy = paramData.type != PARAMETER_INPUT || usingChunk;

  603. 

  604.         if (dummy && paramData.mappedControlIndex <= CONTROL_INDEX_NONE)

  605.             continue;

  606. 

  607.         CarlaStateSave::Parameter* const stateParameter(new CarlaStateSave::Parameter());

  608. 

  609.         stateParameter->dummy = dummy;

  610.         stateParameter->index = paramData.index;

  611.        #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  612.         if (paramData.mappedControlIndex != CONTROL_INDEX_MIDI_LEARN)

  613.         {

  614.             stateParameter->mappedControlIndex = paramData.mappedControlIndex;

  615.             stateParameter->midiChannel        = paramData.midiChannel;

  616. 

  617.             if (paramData.hints & PARAMETER_MAPPED_RANGES_SET)

  618.             {

  619.                 stateParameter->mappedMinimum = paramData.mappedMinimum;

  620.                 stateParameter->mappedMaximum = paramData.mappedMaximum;

  621.                 stateParameter->mappedRangeValid = true;

  622. 

  623.                 if (paramData.hints & PARAMETER_USES_SAMPLERATE)

  624.                 {

  625.                     stateParameter->mappedMinimum /= sampleRate;

  626.                     stateParameter->mappedMaximum /= sampleRate;

  627.                 }

  628.             }

  629.         }

  630.        #endif

  631. 

  632.         if (! getParameterName(i, strBuf))

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

  634.         stateParameter->name = carla_strdup(strBuf);

  635. 

  636.         if (! getParameterSymbol(i, strBuf))

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

  638.         stateParameter->symbol = carla_strdup(strBuf);;

  639. 

  640.         if (! dummy)

  641.         {

  642.             stateParameter->value = getParameterValue(i);

  643. 

  644.             if (paramData.hints & PARAMETER_USES_SAMPLERATE)

  645.                 stateParameter->value /= sampleRate;

  646.         }

  647. 

  648.         pData->stateSave.parameters.append(stateParameter);

  649.     }

  650. 

  651.     // ---------------------------------------------------------------

  652.     // Custom Data

  653. 

  654.     for (LinkedList<CustomData>::Itenerator it = pData->custom.begin2(); it.valid(); it.next())

  655.     {

  656.         const CustomData& cData(it.getValue(kCustomDataFallback));

  657.         CARLA_SAFE_ASSERT_CONTINUE(cData.isValid());

  658. 

  659.         CarlaStateSave::CustomData* stateCustomData(new CarlaStateSave::CustomData());

  660. 

  661.         stateCustomData->type  = carla_strdup(cData.type);

  662.         stateCustomData->key   = carla_strdup(cData.key);

  663.         stateCustomData->value = carla_strdup(cData.value);

  664. 

  665.         pData->stateSave.customData.append(stateCustomData);

  666.     }

  667. 

  668.     return pData->stateSave;

  669. }

  670. 

  671. void CarlaPlugin::loadStateSave(const CarlaStateSave& stateSave)

  672. {

  673.     const bool usesMultiProgs = pData->hints & PLUGIN_USES_MULTI_PROGS;

  674.     const PluginType pluginType = getType();

  675. 

  676.     char strBuf[STR_MAX+1];

  677.     carla_zeroChars(strBuf, STR_MAX+1);

  678. 

  679.     // ---------------------------------------------------------------

  680.     // Part 1 - PRE-set custom data (only those which reload programs)

  681. 

  682.     for (CarlaStateSave::CustomDataItenerator it = stateSave.customData.begin2(); it.valid(); it.next())

  683.     {

  684.         const CarlaStateSave::CustomData* const stateCustomData(it.getValue(nullptr));

  685.         CARLA_SAFE_ASSERT_CONTINUE(stateCustomData != nullptr);

  686.         CARLA_SAFE_ASSERT_CONTINUE(stateCustomData->isValid());

  687. 

  688.         const char* const key(stateCustomData->key);

  689. 

  690.         /**/ if (pluginType == PLUGIN_DSSI && (std::strcmp (key, "reloadprograms") == 0 ||

  691.                                                std::strcmp (key, "load"          ) == 0 ||

  692.                                                std::strncmp(key, "patches",     7) == 0 ))

  693.             pass();

  694.         else if (usesMultiProgs && std::strcmp(key, "midiPrograms") == 0)

  695.             pass();

  696.         else

  697.             continue;

  698. 

  699.         setCustomData(stateCustomData->type, key, stateCustomData->value, true);

  700.     }

  701. 

  702.     // ---------------------------------------------------------------

  703.     // Part 2 - set program

  704. 

  705.     if (stateSave.currentProgramIndex >= 0 && stateSave.currentProgramName != nullptr)

  706.     {

  707.         int32_t programId = -1;

  708. 

  709.         // index < count

  710.         if (stateSave.currentProgramIndex < static_cast<int32_t>(pData->prog.count))

  711.         {

  712.             programId = stateSave.currentProgramIndex;

  713.         }

  714.         // index not valid, try to find by name

  715.         else

  716.         {

  717.             for (uint32_t i=0; i < pData->prog.count; ++i)

  718.             {

  719.                 if (getProgramName(i, strBuf) && std::strcmp(stateSave.currentProgramName, strBuf) == 0)

  720.                 {

  721.                     programId = static_cast<int32_t>(i);

  722.                     break;

  723.                 }

  724.             }

  725.         }

  726. 

  727.         // set program now, if valid

  728.         if (programId >= 0)

  729.             setProgram(programId, true, true, true);

  730.     }

  731. 

  732.     // ---------------------------------------------------------------

  733.     // Part 3 - set midi program

  734. 

  735.     if (stateSave.currentMidiBank >= 0 && stateSave.currentMidiProgram >= 0 && ! usesMultiProgs)

  736.         setMidiProgramById(static_cast<uint32_t>(stateSave.currentMidiBank), static_cast<uint32_t>(stateSave.currentMidiProgram), true, true, true);

  737. 

  738.     // ---------------------------------------------------------------

  739.     // Part 4a - get plugin parameter symbols

  740. 

  741.     LinkedList<ParamSymbol*> paramSymbols;

  742. 

  743.     if (pluginType == PLUGIN_LADSPA || pluginType == PLUGIN_LV2 || pluginType == PLUGIN_CLAP)

  744.     {

  745.         for (uint32_t i=0; i < pData->param.count; ++i)

  746.         {

  747.             if (pData->param.data[i].hints & PARAMETER_IS_NOT_SAVED)

  748.                 continue;

  749. 

  750.             if (getParameterSymbol(i, strBuf))

  751.             {

  752.                 ParamSymbol* const paramSymbol(new ParamSymbol(i, strBuf));

  753.                 paramSymbols.append(paramSymbol);

  754.             }

  755.         }

  756.     }

  757. 

  758.     // ---------------------------------------------------------------

  759.     // Part 4b - set parameter values (carefully)

  760. 

  761.     const float sampleRate = static_cast<float>(pData->engine->getSampleRate());

  762. 

  763.     for (CarlaStateSave::ParameterItenerator it = stateSave.parameters.begin2(); it.valid(); it.next())

  764.     {

  765.         CarlaStateSave::Parameter* const stateParameter(it.getValue(nullptr));

  766.         CARLA_SAFE_ASSERT_CONTINUE(stateParameter != nullptr);

  767. 

  768.         int32_t index = -1;

  769. 

  770.         if (pluginType == PLUGIN_LADSPA)

  771.         {

  772.             // Try to set by symbol, otherwise use index

  773.             if (stateParameter->symbol != nullptr && stateParameter->symbol[0] != '\0')

  774.             {

  775.                 for (LinkedList<ParamSymbol*>::Itenerator it2 = paramSymbols.begin2(); it2.valid(); it2.next())

  776.                 {

  777.                     ParamSymbol* const paramSymbol(it2.getValue(nullptr));

  778.                     CARLA_SAFE_ASSERT_CONTINUE(paramSymbol != nullptr);

  779.                     CARLA_SAFE_ASSERT_CONTINUE(paramSymbol->symbol != nullptr);

  780. 

  781.                     if (std::strcmp(stateParameter->symbol, paramSymbol->symbol) == 0)

  782.                     {

  783.                         index = paramSymbol->index;

  784.                         break;

  785.                     }

  786.                 }

  787.                 if (index == -1)

  788.                     index = stateParameter->index;

  789.             }

  790.             else

  791.             {

  792.                 index = stateParameter->index;

  793.             }

  794.         }

  795.         else if (pluginType == PLUGIN_LV2 || pluginType == PLUGIN_CLAP)

  796.         {

  797.             // Symbol only

  798.             if (stateParameter->symbol != nullptr && stateParameter->symbol[0] != '\0')

  799.             {

  800.                 for (LinkedList<ParamSymbol*>::Itenerator it2 = paramSymbols.begin2(); it2.valid(); it2.next())

  801.                 {

  802.                     ParamSymbol* const paramSymbol(it2.getValue(nullptr));

  803.                     CARLA_SAFE_ASSERT_CONTINUE(paramSymbol != nullptr);

  804.                     CARLA_SAFE_ASSERT_CONTINUE(paramSymbol->symbol != nullptr);

  805. 

  806.                     if (std::strcmp(stateParameter->symbol, paramSymbol->symbol) == 0)

  807.                     {

  808.                         index = paramSymbol->index;

  809.                         break;

  810.                     }

  811.                 }

  812.                 if (index == -1)

  813.                 {

  814.                     if (pluginType == PLUGIN_LV2)

  815.                         carla_stderr("Failed to find LV2 parameter symbol '%s' for '%s'",

  816.                                     stateParameter->symbol, pData->name);

  817.                     else

  818.                         carla_stderr("Failed to find CLAP parameter id '%s' for '%s'",

  819.                                     stateParameter->symbol, pData->name);

  820.                 }

  821.             }

  822.             else

  823.             {

  824.                 if (pluginType == PLUGIN_LV2)

  825.                     carla_stderr("LV2 Plugin parameter '%s' has no symbol", stateParameter->name);

  826.                 else

  827.                     carla_stderr("CLAP Plugin parameter '%s' has no id", stateParameter->name);

  828.             }

  829.         }

  830.         else

  831.         {

  832.             // Index only

  833.             index = stateParameter->index;

  834.         }

  835. 

  836.         // Now set parameter

  837.         if (index >= 0 && index < static_cast<int32_t>(pData->param.count))

  838.         {

  839.             //CARLA_SAFE_ASSERT(stateParameter->isInput == (pData

  840. 

  841.             if (! stateParameter->dummy)

  842.             {

  843.                 if (pData->param.data[index].hints & PARAMETER_USES_SAMPLERATE)

  844.                     stateParameter->value *= sampleRate;

  845. 

  846.                 setParameterValue(static_cast<uint32_t>(index), stateParameter->value, true, true, true);

  847.             }

  848. 

  849.            #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  850.             if (stateParameter->mappedRangeValid)

  851.             {

  852.                 if (pData->param.data[index].hints & PARAMETER_USES_SAMPLERATE)

  853.                 {

  854.                     stateParameter->mappedMinimum *= sampleRate;

  855.                     stateParameter->mappedMaximum *= sampleRate;

  856.                 }

  857. 

  858.                 setParameterMappedRange(static_cast<uint32_t>(index),

  859.                                         stateParameter->mappedMinimum,

  860.                                         stateParameter->mappedMaximum, true, true);

  861.             }

  862. 

  863.             setParameterMappedControlIndex(static_cast<uint32_t>(index),

  864.                                            stateParameter->mappedControlIndex, true, true, false);

  865.             setParameterMidiChannel(static_cast<uint32_t>(index), stateParameter->midiChannel, true, true);

  866.            #endif

  867.         }

  868.         else

  869.             carla_stderr("Could not set parameter '%s' value for '%s'",

  870.                          stateParameter->name, pData->name);

  871.     }

  872. 

  873.     // ---------------------------------------------------------------

  874.     // Part 4c - clear

  875. 

  876.     for (LinkedList<ParamSymbol*>::Itenerator it = paramSymbols.begin2(); it.valid(); it.next())

  877.     {

  878.         ParamSymbol* const paramSymbol(it.getValue(nullptr));

  879.         delete paramSymbol;

  880.     }

  881. 

  882.     paramSymbols.clear();

  883. 

  884.     // ---------------------------------------------------------------

  885.     // Part 5 - set custom data

  886. 

  887.     for (CarlaStateSave::CustomDataItenerator it = stateSave.customData.begin2(); it.valid(); it.next())

  888.     {

  889.         const CarlaStateSave::CustomData* const stateCustomData(it.getValue(nullptr));

  890.         CARLA_SAFE_ASSERT_CONTINUE(stateCustomData != nullptr);

  891.         CARLA_SAFE_ASSERT_CONTINUE(stateCustomData->isValid());

  892. 

  893.         const char* const key(stateCustomData->key);

  894. 

  895.         if (pluginType == PLUGIN_DSSI && (std::strcmp (key, "reloadprograms") == 0 ||

  896.                                           std::strcmp (key, "load"          ) == 0 ||

  897.                                           std::strncmp(key, "patches",     7) == 0 ))

  898.             continue;

  899.         if (usesMultiProgs && std::strcmp(key, "midiPrograms") == 0)

  900.             continue;

  901. 

  902.         setCustomData(stateCustomData->type, key, stateCustomData->value, true);

  903.     }

  904. 

  905.     // ---------------------------------------------------------------

  906.     // Part 5x - set lv2 state

  907. 

  908.     if (pluginType == PLUGIN_LV2)

  909.     {

  910.         for (LinkedList<CustomData>::Itenerator it = pData->custom.begin2(); it.valid(); it.next())

  911.         {

  912.             const CustomData& customData(it.getValue(kCustomDataFallback));

  913.             CARLA_SAFE_ASSERT_CONTINUE(customData.isValid());

  914. 

  915.             if (std::strcmp(customData.type, CUSTOM_DATA_TYPE_PROPERTY) == 0)

  916.                 continue;

  917. 

  918.             restoreLV2State(stateSave.temporary);

  919.             break;

  920.         }

  921.     }

  922. 

  923.     // ---------------------------------------------------------------

  924.     // Part 6 - set chunk

  925. 

  926.     if (stateSave.chunk != nullptr && (pData->options & PLUGIN_OPTION_USE_CHUNKS) != 0)

  927.     {

  928.         std::vector<uint8_t> chunk;

  929.         d_getChunkFromBase64String_impl(chunk, stateSave.chunk);

  930.        #ifdef CARLA_PROPER_CPP11_SUPPORT

  931.         setChunkData(chunk.data(), chunk.size());

  932.        #else

  933.         setChunkData(&chunk.front(), chunk.size());

  934.        #endif

  935.     }

  936. 

  937.    #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  938.     // ---------------------------------------------------------------

  939.     // Part 6 - set internal stuff

  940. 

  941.     const uint availOptions = getOptionsAvailable();

  942. 

  943.     for (uint i=0; i<10; ++i) // FIXME - get this value somehow...

  944.     {

  945.         const uint option(1u << i);

  946. 

  947.         if (availOptions & option)

  948.             setOption(option, (stateSave.options & option) != 0, true);

  949.     }

  950. 

  951.     setDryWet(stateSave.dryWet, true, true);

  952.     setVolume(stateSave.volume, true, true);

  953.     setBalanceLeft(stateSave.balanceLeft, true, true);

  954.     setBalanceRight(stateSave.balanceRight, true, true);

  955.     setPanning(stateSave.panning, true, true);

  956.     setCtrlChannel(stateSave.ctrlChannel, true, true);

  957.     setActive(stateSave.active, true, true);

  958. 

  959.     if (! pData->engine->isLoadingProject())

  960.         pData->engine->callback(true, true, ENGINE_CALLBACK_UPDATE, pData->id, 0, 0, 0, 0.0f, nullptr);

  961.    #endif

  962. }

  963. 

  964. bool CarlaPlugin::saveStateToFile(const char* const filename)

  965. {

  966.     CARLA_SAFE_ASSERT_RETURN(filename != nullptr && filename[0] != '\0', false);

  967.     carla_debug("CarlaPlugin::saveStateToFile(\"%s\")", filename);

  968. 

  969.     MemoryOutputStream out, streamState;

  970.     getStateSave().dumpToMemoryStream(streamState);

  971. 

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

  973.     out << "<!DOCTYPE CARLA-PRESET>\n";

  974.     out << "<CARLA-PRESET VERSION='2.0'>\n";

  975.     out << streamState;

  976.     out << "</CARLA-PRESET>\n";

  977. 

  978.     File file(filename);

  979. 

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

  981.         return true;

  982. 

  983.     pData->engine->setLastError("Failed to write file");

  984.     return false;

  985. }

  986. 

  987. bool CarlaPlugin::loadStateFromFile(const char* const filename)

  988. {

  989.     // TODO set errors

  990. 

  991.     CARLA_SAFE_ASSERT_RETURN(filename != nullptr && filename[0] != '\0', false);

  992.     carla_debug("CarlaPlugin::loadStateFromFile(\"%s\")", filename);

  993. 

  994.     File file(filename);

  995.     CARLA_SAFE_ASSERT_RETURN(file.existsAsFile(), false);

  996. 

  997.     XmlDocument xml(file);

  998.     CarlaScopedPointer<XmlElement> xmlElement(xml.getDocumentElement(true));

  999.     CARLA_SAFE_ASSERT_RETURN(xmlElement != nullptr, false);

  1000.     CARLA_SAFE_ASSERT_RETURN(xmlElement->getTagName().equalsIgnoreCase("carla-preset"), false);

  1001. 

  1002.     // completely load file

  1003.     xmlElement = xml.getDocumentElement(false);

  1004.     CARLA_SAFE_ASSERT_RETURN(xmlElement != nullptr, false);

  1005. 

  1006.     if (pData->stateSave.fillFromXmlElement(xmlElement))

  1007.     {

  1008.         loadStateSave(pData->stateSave);

  1009.         return true;

  1010.     }

  1011. 

  1012.     return false;

  1013. }

  1014. 

  1015. #ifndef CARLA_PLUGIN_ONLY_BRIDGE

  1016. bool CarlaPlugin::exportAsLV2(const char* const lv2path)

  1017. {

  1018.     CARLA_SAFE_ASSERT_RETURN(lv2path != nullptr && lv2path[0] != '\0', false);

  1019.     carla_debug("CarlaPlugin::exportAsLV2(\"%s\")", lv2path);

  1020. 

  1021.     CarlaString bundlepath(lv2path);

  1022. 

  1023.     if (! bundlepath.endsWith(".lv2"))

  1024.         bundlepath += ".lv2";

  1025. 

  1026.     const File bundlefolder(bundlepath.buffer());

  1027. 

  1028.     if (bundlefolder.existsAsFile())

  1029.     {

  1030.         pData->engine->setLastError("Requested filename already exists as file, use a folder instead");

  1031.         return false;

  1032.     }

  1033. 

  1034.     if (! bundlefolder.exists())

  1035.     {

  1036.         const Result res(bundlefolder.createDirectory());

  1037. 

  1038.         if (res.failed())

  1039.         {

  1040.             pData->engine->setLastError(res.getErrorMessage().c_str());

  1041.             return false;

  1042.         }

  1043.     }

  1044. 

  1045.     CarlaString symbol(pData->name);

  1046.     symbol.toBasic();

  1047. 

  1048.     {

  1049.         const CarlaString pluginFilename(bundlepath + CARLA_OS_SEP_STR + symbol + ".xml");

  1050. 

  1051.         if (! saveStateToFile(pluginFilename))

  1052.             return false;

  1053.     }

  1054. 

  1055.     {

  1056.         MemoryOutputStream manifestStream;

  1057. 

  1058.         manifestStream << "@prefix lv2:  <http://lv2plug.in/ns/lv2core#> .\n";

  1059.         manifestStream << "@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .\n";

  1060.         manifestStream << "@prefix ui:   <http://lv2plug.in/ns/extensions/ui#> .\n";

  1061.         manifestStream << "\n";

  1062.         manifestStream << "<" << symbol.buffer() << ".ttl>\n";

  1063.         manifestStream << "    a lv2:Plugin ;\n";

  1064.         manifestStream << "    lv2:binary <" << symbol.buffer() << CARLA_LIB_EXT "> ;\n";

  1065.         manifestStream << "    rdfs:seeAlso <" << symbol.buffer() << ".ttl> .\n";

  1066.         manifestStream << "\n";

  1067.         manifestStream << "<ext-ui>\n";

  1068.         manifestStream << "    a <http://kxstudio.sf.net/ns/lv2ext/external-ui#Widget> ;\n";

  1069.         manifestStream << "    ui:binary <" << symbol.buffer() << CARLA_LIB_EXT "> ;\n";

  1070.         manifestStream << "    lv2:extensionData <http://lv2plug.in/ns/extensions/ui#idleInterface> ,\n";

  1071.         manifestStream << "                      <http://lv2plug.in/ns/extensions/ui#showInterface> ;\n";

  1072.         manifestStream << "    lv2:requiredFeature <http://lv2plug.in/ns/ext/instance-access> .\n";

  1073.         manifestStream << "\n";

  1074. 

  1075.         const CarlaString manifestFilename(bundlepath + CARLA_OS_SEP_STR "manifest.ttl");

  1076.         const File manifestFile(manifestFilename.buffer());

  1077. 

  1078.         if (! manifestFile.replaceWithData(manifestStream.getData(), manifestStream.getDataSize()))

  1079.         {

  1080.             pData->engine->setLastError("Failed to write manifest.ttl file");

  1081.             return false;

  1082.         }

  1083.     }

  1084. 

  1085.     {

  1086.         MemoryOutputStream mainStream;

  1087. 

  1088.         mainStream << "@prefix atom: <http://lv2plug.in/ns/ext/atom#> .\n";

  1089.         mainStream << "@prefix doap: <http://usefulinc.com/ns/doap#> .\n";

  1090.         mainStream << "@prefix foaf: <http://xmlns.com/foaf/0.1/> .\n";

  1091.         mainStream << "@prefix lv2:  <http://lv2plug.in/ns/lv2core#> .\n";

  1092.         mainStream << "@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .\n";

  1093.         mainStream << "@prefix ui:   <http://lv2plug.in/ns/extensions/ui#> .\n";

  1094.         mainStream << "\n";

  1095.         mainStream << "<>\n";

  1096.         mainStream << "    a lv2:Plugin ;\n";

  1097.         mainStream << "\n";

  1098.         mainStream << "    lv2:requiredFeature <http://lv2plug.in/ns/ext/buf-size#boundedBlockLength> ,\n";

  1099.         mainStream << "                        <http://lv2plug.in/ns/ext/options#options> ,\n";

  1100.         mainStream << "                        <http://lv2plug.in/ns/ext/urid#map> ;\n";

  1101.         mainStream << "\n";

  1102. 

  1103.         if (pData->hints & PLUGIN_HAS_CUSTOM_UI)

  1104.         {

  1105.             mainStream << "    ui:ui <ext-ui> ;\n";

  1106.             mainStream << "\n";

  1107.         }

  1108. 

  1109.         const uint32_t midiIns  = getMidiInCount();

  1110.         const uint32_t midiOuts = getMidiOutCount();

  1111. 

  1112.         int portIndex = 0;

  1113. 

  1114.         if (midiIns > 0)

  1115.         {

  1116.             mainStream << "    lv2:port [\n";

  1117.             mainStream << "        a lv2:InputPort, atom:AtomPort ;\n";

  1118.             mainStream << "        lv2:index 0 ;\n";

  1119.             mainStream << "        lv2:symbol \"clv2_events_in\" ;\n";

  1120.             mainStream << "        lv2:name \"Events Input\" ;\n";

  1121.             mainStream << "        atom:bufferType atom:Sequence ;\n";

  1122.             mainStream << "        atom:supports <http://lv2plug.in/ns/ext/midi#MidiEvent> ,\n";

  1123.             mainStream << "                      <http://lv2plug.in/ns/ext/time#Position> ;\n";

  1124.             mainStream << "    ] ;\n";

  1125.             ++portIndex;

  1126. 

  1127.             for (uint32_t i=1; i<midiIns; ++i)

  1128.             {

  1129.                 const String portIndexNum(portIndex++);

  1130.                 const String portIndexLabel(portIndex);

  1131. 

  1132.                 mainStream << "    lv2:port [\n";

  1133.                 mainStream << "        a lv2:InputPort, atom:AtomPort ;\n";

  1134.                 mainStream << "        lv2:index " << portIndexNum << " ;\n";

  1135.                 mainStream << "        lv2:symbol \"clv2_midi_in_" << portIndexLabel << "\" ;\n";

  1136.                 mainStream << "        lv2:name \"MIDI Input " << portIndexLabel << "\" ;\n";

  1137.                 mainStream << "    ] ;\n";

  1138.             }

  1139.         }

  1140.         else

  1141.         {

  1142.             mainStream << "    lv2:port [\n";

  1143.             mainStream << "        a lv2:InputPort, atom:AtomPort ;\n";

  1144.             mainStream << "        lv2:index 0 ;\n";

  1145.             mainStream << "        lv2:symbol \"clv2_time_info\" ;\n";

  1146.             mainStream << "        lv2:name \"Time Info\" ;\n";

  1147.             mainStream << "        atom:bufferType atom:Sequence ;\n";

  1148.             mainStream << "        atom:supports <http://lv2plug.in/ns/ext/time#Position> ;\n";

  1149.             mainStream << "    ] ;\n";

  1150.             ++portIndex;

  1151.         }

  1152. 

  1153.         for (uint32_t i=0; i<midiOuts; ++i)

  1154.         {

  1155.             const String portIndexNum(portIndex++);

  1156.             const String portIndexLabel(portIndex);

  1157. 

  1158.             mainStream << "    lv2:port [\n";

  1159.             mainStream << "        a lv2:InputPort, atom:AtomPort ;\n";

  1160.             mainStream << "        lv2:index " << portIndexNum << " ;\n";

  1161.             mainStream << "        lv2:symbol \"clv2_midi_out_" << portIndexLabel << "\" ;\n";

  1162.             mainStream << "        lv2:name \"MIDI Output " << portIndexLabel << "\" ;\n";

  1163.             mainStream << "        atom:bufferType atom:Sequence ;\n";

  1164.             mainStream << "        atom:supports <http://lv2plug.in/ns/ext/midi#MidiEvent> ;\n";

  1165.             mainStream << "    ] ;\n";

  1166.         }

  1167. 

  1168.         mainStream << "    lv2:port [\n";

  1169.         mainStream << "        a lv2:InputPort, lv2:ControlPort ;\n";

  1170.         mainStream << "        lv2:index " << String(portIndex++) << " ;\n";

  1171.         mainStream << "        lv2:name \"freewheel\" ;\n";

  1172.         mainStream << "        lv2:symbol \"clv2_freewheel\" ;\n";

  1173.         mainStream << "        lv2:default 0 ;\n";

  1174.         mainStream << "        lv2:minimum 0 ;\n";

  1175.         mainStream << "        lv2:maximum 1 ;\n";

  1176.         mainStream << "        lv2:designation lv2:freeWheeling ;\n";

  1177.         mainStream << "        lv2:portProperty lv2:toggled , lv2:integer ;\n";

  1178.         mainStream << "        lv2:portProperty <http://lv2plug.in/ns/ext/port-props#notOnGUI> ;\n";

  1179.         mainStream << "    ] ;\n";

  1180. 

  1181.         for (uint32_t i=0; i<pData->audioIn.count; ++i)

  1182.         {

  1183.             const String portIndexNum(portIndex++);

  1184.             const String portIndexLabel(i+1);

  1185. 

  1186.             mainStream << "    lv2:port [\n";

  1187.             mainStream << "        a lv2:InputPort, lv2:AudioPort ;\n";

  1188.             mainStream << "        lv2:index " << portIndexNum << " ;\n";

  1189.             mainStream << "        lv2:symbol \"clv2_audio_in_" << portIndexLabel << "\" ;\n";

  1190.             mainStream << "        lv2:name \"Audio Input " << portIndexLabel << "\" ;\n";

  1191.             mainStream << "    ] ;\n";

  1192.         }

  1193. 

  1194.         for (uint32_t i=0; i<pData->audioOut.count; ++i)

  1195.         {

  1196.             const String portIndexNum(portIndex++);

  1197.             const String portIndexLabel(i+1);

  1198. 

  1199.             mainStream << "    lv2:port [\n";

  1200.             mainStream << "        a lv2:OutputPort, lv2:AudioPort ;\n";

  1201.             mainStream << "        lv2:index " << portIndexNum << " ;\n";

  1202.             mainStream << "        lv2:symbol \"clv2_audio_out_" << portIndexLabel << "\" ;\n";

  1203.             mainStream << "        lv2:name \"Audio Output " << portIndexLabel << "\" ;\n";

  1204.             mainStream << "    ] ;\n";

  1205.         }

  1206. 

  1207.         CarlaStringList uniqueSymbolNames;

  1208. 

  1209.         char strBufName[STR_MAX+1];

  1210.         char strBufSymbol[STR_MAX+1];

  1211.         carla_zeroChars(strBufName, STR_MAX+1);

  1212.         carla_zeroChars(strBufSymbol, STR_MAX+1);

  1213. 

  1214.         for (uint32_t i=0; i<pData->param.count; ++i)

  1215.         {

  1216.             const ParameterData&   paramData(pData->param.data[i]);

  1217.             const ParameterRanges& paramRanges(pData->param.ranges[i]);

  1218. 

  1219.             const String portIndexNum(portIndex++);

  1220. 

  1221.             mainStream << "    lv2:port [\n";

  1222. 

  1223.             if (paramData.type == PARAMETER_INPUT)

  1224.                 mainStream << "        a lv2:InputPort, lv2:ControlPort ;\n";

  1225.             else

  1226.                 mainStream << "        a lv2:OutputPort, lv2:ControlPort ;\n";

  1227. 

  1228.             if (paramData.hints & PARAMETER_IS_BOOLEAN)

  1229.                 mainStream << "        lv2:portProperty lv2:toggled ;\n";

  1230. 

  1231.             if (paramData.hints & PARAMETER_IS_INTEGER)

  1232.                 mainStream << "        lv2:portProperty lv2:integer ;\n";

  1233. 

  1234.             // TODO logarithmic, enabled (not on gui), automatable, samplerate, scalepoints

  1235. 

  1236.             if (! getParameterName(i, strBufName))

  1237.                 strBufName[0] = '\0';

  1238.             if (! getParameterSymbol(i, strBufSymbol))

  1239.                 strBufSymbol[0] = '\0';

  1240. 

  1241.             if (strBufSymbol[0] == '\0')

  1242.             {

  1243.                 CarlaString s(strBufName);

  1244.                 s.toBasic();

  1245.                 std::memcpy(strBufSymbol, s.buffer(), s.length()+1);

  1246. 

  1247.                 if (strBufSymbol[0] >= '0' && strBufSymbol[0] <= '9')

  1248.                 {

  1249.                     const size_t len(std::strlen(strBufSymbol));

  1250.                     std::memmove(strBufSymbol+1, strBufSymbol, len);

  1251.                     strBufSymbol[0]   = '_';

  1252.                     strBufSymbol[len+1] = '\0';

  1253.                 }

  1254.             }

  1255. 

  1256.             if (uniqueSymbolNames.contains(strBufSymbol))

  1257.                 std::snprintf(strBufSymbol, STR_MAX, "clv2_param_%d", i+1);

  1258. 

  1259.             mainStream << "        lv2:index " << portIndexNum << " ;\n";

  1260.             mainStream << "        lv2:symbol \"" << strBufSymbol << "\" ;\n";

  1261.             mainStream << "        lv2:name \"\"\"" << strBufName << "\"\"\" ;\n";

  1262.             mainStream << "        lv2:default " << String(paramRanges.def) << " ;\n";

  1263.             mainStream << "        lv2:minimum " << String(paramRanges.min) << " ;\n";

  1264.             mainStream << "        lv2:maximum " << String(paramRanges.max) << " ;\n";

  1265. 

  1266.             // TODO midiCC, midiChannel

  1267. 

  1268.             mainStream << "    ] ;\n";

  1269.         }

  1270. 

  1271.         char strBuf[STR_MAX+1];

  1272.         carla_zeroChars(strBuf, STR_MAX+1);

  1273. 

  1274.         if (! getMaker(strBuf))

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

  1276. 

  1277.         mainStream << "    rdfs:comment \"Plugin generated using Carla LV2 export.\" ;\n";

  1278.         mainStream << "    doap:name \"\"\"" << getName() << "\"\"\" ;\n";

  1279.         mainStream << "    doap:maintainer [ foaf:name \"\"\"" << strBuf << "\"\"\" ] .\n";

  1280.         mainStream << "\n";

  1281. 

  1282.         const CarlaString mainFilename(bundlepath + CARLA_OS_SEP_STR + symbol + ".ttl");

  1283.         const File mainFile(mainFilename.buffer());

  1284. 

  1285.         if (! mainFile.replaceWithData(mainStream.getData(), mainStream.getDataSize()))

  1286.         {

  1287.             pData->engine->setLastError("Failed to write main plugin ttl file");

  1288.             return false;

  1289.         }

  1290.     }

  1291. 

  1292.     const CarlaString binaryFilename(bundlepath + CARLA_OS_SEP_STR + symbol + CARLA_LIB_EXT);

  1293. 

  1294.     const File binaryFileSource(File::getSpecialLocation(File::currentExecutableFile).getSiblingFile("carla-bridge-lv2" CARLA_LIB_EXT));

  1295.     const File binaryFileTarget(binaryFilename.buffer());

  1296. 

  1297.     const EngineOptions& opts(pData->engine->getOptions());

  1298. 

  1299.     const CarlaString binFolderTarget(bundlepath + CARLA_OS_SEP_STR + "bin");

  1300.     const CarlaString resFolderTarget(bundlepath + CARLA_OS_SEP_STR + "res");

  1301. 

  1302.     if (! binaryFileSource.copyFileTo(binaryFileTarget))

  1303.     {

  1304.         pData->engine->setLastError("Failed to copy plugin binary");

  1305.         return false;

  1306.     }

  1307. 

  1308. #ifdef CARLA_OS_WIN

  1309.     File(opts.resourceDir).copyDirectoryTo(File(resFolderTarget.buffer()));

  1310. 

  1311.     // Copying all the binaries is pointless, just go through the expected needed bits

  1312.     const File binFolder1(opts.binaryDir);

  1313.     const File binFolder2(binFolderTarget.buffer());

  1314.     binFolder2.createDirectory();

  1315. 

  1316.     static const char* files[] = {

  1317.       "carla-bridge-native.exe",

  1318.       "carla-bridge-win32.exe",

  1319.       "carla-discovery-win32.exe",

  1320.       "carla-discovery-win64.exe",

  1321.       "libcarla_utils.dll"

  1322.     };

  1323. 

  1324.     for (int i=0; i<5; ++i)

  1325.         binFolder1.getChildFile(files[i]).copyFileTo(binFolder2.getChildFile(files[i]));;

  1326. #else

  1327.     File(opts.binaryDir).createSymbolicLink(File(binFolderTarget.buffer()), true);

  1328.     File(opts.resourceDir).createSymbolicLink(File(resFolderTarget.buffer()), true);

  1329. #endif

  1330. 

  1331.     return true;

  1332. }

  1333. #endif

  1334. 

  1335. // -------------------------------------------------------------------

  1336. // Set data (internal stuff)

  1337. 

  1338. void CarlaPlugin::setId(const uint newId) noexcept

  1339. {

  1340.     pData->id = newId;

  1341. }

  1342. 

  1343. void CarlaPlugin::setName(const char* const newName)

  1344. {

  1345.     CARLA_SAFE_ASSERT_RETURN(newName != nullptr && newName[0] != '\0',);

  1346. 

  1347.     if (pData->name != nullptr)

  1348.         delete[] pData->name;

  1349. 

  1350.     pData->name = carla_strdup(newName);

  1351. }

  1352. 

  1353. void CarlaPlugin::setOption(const uint option, const bool yesNo, const bool sendCallback)

  1354. {

  1355.     CARLA_SAFE_ASSERT_UINT2_RETURN(getOptionsAvailable() & option, getOptionsAvailable(), option,);

  1356. 

  1357.     if (yesNo)

  1358.         pData->options |= option;

  1359.     else

  1360.         pData->options &= ~option;

  1361. 

  1362. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1363.     if (sendCallback)

  1364.         pData->engine->callback(true, true,

  1365.                                 ENGINE_CALLBACK_OPTION_CHANGED,

  1366.                                 pData->id,

  1367.                                 static_cast<int>(option),

  1368.                                 yesNo ? 1 : 0,

  1369.                                 0, 0.0f, nullptr);

  1370. #else

  1371.     // unused

  1372.     return; (void)sendCallback;

  1373. #endif

  1374. }

  1375. 

  1376. void CarlaPlugin::setEnabled(const bool yesNo) noexcept

  1377. {

  1378.     if (pData->enabled == yesNo)

  1379.         return;

  1380. 

  1381.     pData->masterMutex.lock();

  1382.     pData->enabled = yesNo;

  1383. 

  1384.     if (yesNo && ! pData->client->isActive())

  1385.         pData->client->activate();

  1386. 

  1387.     pData->masterMutex.unlock();

  1388. }

  1389. 

  1390. void CarlaPlugin::setActive(const bool active, const bool sendOsc, const bool sendCallback) noexcept

  1391. {

  1392.     if (pData->engineBridged) {

  1393.         CARLA_SAFE_ASSERT_RETURN(!sendOsc && !sendCallback,);

  1394.     } else if (pData->enginePlugin) {

  1395.         // nothing here

  1396.     } else {

  1397.         CARLA_SAFE_ASSERT_RETURN(sendOsc || sendCallback,); // never call this from RT

  1398.     }

  1399. 

  1400.     if (pData->active == active)

  1401.         return;

  1402. 

  1403.     {

  1404.         const ScopedSingleProcessLocker spl(this, true);

  1405. 

  1406.         if (active)

  1407.             activate();

  1408.         else

  1409.             deactivate();

  1410.     }

  1411. 

  1412.     pData->active = active;

  1413. 

  1414. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1415.     const float value = active ? 1.0f : 0.0f;

  1416. 

  1417.     pData->engine->callback(sendCallback, sendOsc,

  1418.                             ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  1419.                             pData->id,

  1420.                             PARAMETER_ACTIVE,

  1421.                             0, 0,

  1422.                             value,

  1423.                             nullptr);

  1424. #endif

  1425. }

  1426. 

  1427. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1428. void CarlaPlugin::setDryWet(const float value, const bool sendOsc, const bool sendCallback) noexcept

  1429. {

  1430.     if (pData->engineBridged) {

  1431.         CARLA_SAFE_ASSERT_RETURN(!sendOsc && !sendCallback,);

  1432.     } else {

  1433.         CARLA_SAFE_ASSERT_RETURN(sendOsc || sendCallback,); // never call this from RT

  1434.     }

  1435.     CARLA_SAFE_ASSERT(value >= 0.0f && value <= 1.0f);

  1436. 

  1437.     const float fixedValue(carla_fixedValue<float>(0.0f, 1.0f, value));

  1438. 

  1439.     if (carla_isEqual(pData->postProc.dryWet, fixedValue))

  1440.         return;

  1441. 

  1442.     pData->postProc.dryWet = fixedValue;

  1443. 

  1444.     pData->engine->callback(sendCallback, sendOsc,

  1445.                             ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  1446.                             pData->id,

  1447.                             PARAMETER_DRYWET,

  1448.                             0, 0,

  1449.                             fixedValue,

  1450.                             nullptr);

  1451. }

  1452. 

  1453. void CarlaPlugin::setVolume(const float value, const bool sendOsc, const bool sendCallback) noexcept

  1454. {

  1455.     if (pData->engineBridged) {

  1456.         CARLA_SAFE_ASSERT_RETURN(!sendOsc && !sendCallback,);

  1457.     } else {

  1458.         CARLA_SAFE_ASSERT_RETURN(sendOsc || sendCallback,); // never call this from RT

  1459.     }

  1460.     CARLA_SAFE_ASSERT(value >= 0.0f && value <= 1.27f);

  1461. 

  1462.     const float fixedValue(carla_fixedValue<float>(0.0f, 1.27f, value));

  1463. 

  1464.     if (carla_isEqual(pData->postProc.volume, fixedValue))

  1465.         return;

  1466. 

  1467.     pData->postProc.volume = fixedValue;

  1468. 

  1469.     pData->engine->callback(sendCallback, sendOsc,

  1470.                             ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  1471.                             pData->id,

  1472.                             PARAMETER_VOLUME,

  1473.                             0, 0,

  1474.                             fixedValue,

  1475.                             nullptr);

  1476. }

  1477. 

  1478. void CarlaPlugin::setBalanceLeft(const float value, const bool sendOsc, const bool sendCallback) noexcept

  1479. {

  1480.     if (pData->engineBridged) {

  1481.         CARLA_SAFE_ASSERT_RETURN(!sendOsc && !sendCallback,);

  1482.     } else {

  1483.         CARLA_SAFE_ASSERT_RETURN(sendOsc || sendCallback,); // never call this from RT

  1484.     }

  1485.     CARLA_SAFE_ASSERT(value >= -1.0f && value <= 1.0f);

  1486. 

  1487.     const float fixedValue(carla_fixedValue<float>(-1.0f, 1.0f, value));

  1488. 

  1489.     if (carla_isEqual(pData->postProc.balanceLeft, fixedValue))

  1490.         return;

  1491. 

  1492.     pData->postProc.balanceLeft = fixedValue;

  1493. 

  1494.     pData->engine->callback(sendCallback, sendOsc,

  1495.                             ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  1496.                             pData->id,

  1497.                             PARAMETER_BALANCE_LEFT,

  1498.                             0, 0,

  1499.                             fixedValue,

  1500.                             nullptr);

  1501. }

  1502. 

  1503. void CarlaPlugin::setBalanceRight(const float value, const bool sendOsc, const bool sendCallback) noexcept

  1504. {

  1505.     if (pData->engineBridged) {

  1506.         CARLA_SAFE_ASSERT_RETURN(!sendOsc && !sendCallback,);

  1507.     } else {

  1508.         CARLA_SAFE_ASSERT_RETURN(sendOsc || sendCallback,); // never call this from RT

  1509.     }

  1510.     CARLA_SAFE_ASSERT(value >= -1.0f && value <= 1.0f);

  1511. 

  1512.     const float fixedValue(carla_fixedValue<float>(-1.0f, 1.0f, value));

  1513. 

  1514.     if (carla_isEqual(pData->postProc.balanceRight, fixedValue))

  1515.         return;

  1516. 

  1517.     pData->postProc.balanceRight = fixedValue;

  1518. 

  1519.     pData->engine->callback(sendCallback, sendOsc,

  1520.                             ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  1521.                             pData->id,

  1522.                             PARAMETER_BALANCE_RIGHT,

  1523.                             0, 0,

  1524.                             fixedValue,

  1525.                             nullptr);

  1526. }

  1527. 

  1528. void CarlaPlugin::setPanning(const float value, const bool sendOsc, const bool sendCallback) noexcept

  1529. {

  1530.     if (pData->engineBridged) {

  1531.         CARLA_SAFE_ASSERT_RETURN(!sendOsc && !sendCallback,);

  1532.     } else {

  1533.         CARLA_SAFE_ASSERT_RETURN(sendOsc || sendCallback,); // never call this from RT

  1534.     }

  1535.     CARLA_SAFE_ASSERT(value >= -1.0f && value <= 1.0f);

  1536. 

  1537.     const float fixedValue(carla_fixedValue<float>(-1.0f, 1.0f, value));

  1538. 

  1539.     if (carla_isEqual(pData->postProc.panning, fixedValue))

  1540.         return;

  1541. 

  1542.     pData->postProc.panning = fixedValue;

  1543. 

  1544.     pData->engine->callback(sendCallback, sendOsc,

  1545.                             ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  1546.                             pData->id,

  1547.                             PARAMETER_PANNING,

  1548.                             0, 0,

  1549.                             fixedValue,

  1550.                             nullptr);

  1551. }

  1552. 

  1553. void CarlaPlugin::setDryWetRT(const float value, const bool sendCallbackLater) noexcept

  1554. {

  1555.     CARLA_SAFE_ASSERT(value >= 0.0f && value <= 1.0f);

  1556. 

  1557.     const float fixedValue(carla_fixedValue<float>(0.0f, 1.0f, value));

  1558. 

  1559.     if (carla_isEqual(pData->postProc.dryWet, fixedValue))

  1560.         return;

  1561. 

  1562.     pData->postProc.dryWet = fixedValue;

  1563.     pData->postponeParameterChangeRtEvent(sendCallbackLater, PARAMETER_DRYWET, fixedValue);

  1564. }

  1565. 

  1566. void CarlaPlugin::setVolumeRT(const float value, const bool sendCallbackLater) noexcept

  1567. {

  1568.     CARLA_SAFE_ASSERT(value >= 0.0f && value <= 1.27f);

  1569. 

  1570.     const float fixedValue(carla_fixedValue<float>(0.0f, 1.27f, value));

  1571. 

  1572.     if (carla_isEqual(pData->postProc.volume, fixedValue))

  1573.         return;

  1574. 

  1575.     pData->postProc.volume = fixedValue;

  1576.     pData->postponeParameterChangeRtEvent(sendCallbackLater, PARAMETER_VOLUME, fixedValue);

  1577. }

  1578. 

  1579. void CarlaPlugin::setBalanceLeftRT(const float value, const bool sendCallbackLater) noexcept

  1580. {

  1581.     CARLA_SAFE_ASSERT(value >= -1.0f && value <= 1.0f);

  1582. 

  1583.     const float fixedValue(carla_fixedValue<float>(-1.0f, 1.0f, value));

  1584. 

  1585.     if (carla_isEqual(pData->postProc.balanceLeft, fixedValue))

  1586.         return;

  1587. 

  1588.     pData->postProc.balanceLeft = fixedValue;

  1589.     pData->postponeParameterChangeRtEvent(sendCallbackLater, PARAMETER_BALANCE_LEFT, fixedValue);

  1590. }

  1591. 

  1592. void CarlaPlugin::setBalanceRightRT(const float value, const bool sendCallbackLater) noexcept

  1593. {

  1594.     CARLA_SAFE_ASSERT(value >= -1.0f && value <= 1.0f);

  1595. 

  1596.     const float fixedValue(carla_fixedValue<float>(-1.0f, 1.0f, value));

  1597. 

  1598.     if (carla_isEqual(pData->postProc.balanceRight, fixedValue))

  1599.         return;

  1600. 

  1601.     pData->postProc.balanceRight = fixedValue;

  1602.     pData->postponeParameterChangeRtEvent(sendCallbackLater, PARAMETER_BALANCE_RIGHT, fixedValue);

  1603. }

  1604. 

  1605. void CarlaPlugin::setPanningRT(const float value, const bool sendCallbackLater) noexcept

  1606. {

  1607.     CARLA_SAFE_ASSERT(value >= -1.0f && value <= 1.0f);

  1608. 

  1609.     const float fixedValue(carla_fixedValue<float>(-1.0f, 1.0f, value));

  1610. 

  1611.     if (carla_isEqual(pData->postProc.panning, fixedValue))

  1612.         return;

  1613. 

  1614.     pData->postProc.panning = fixedValue;

  1615.     pData->postponeParameterChangeRtEvent(sendCallbackLater, PARAMETER_PANNING, fixedValue);

  1616. }

  1617. #endif // ! BUILD_BRIDGE_ALTERNATIVE_ARCH

  1618. 

  1619. void CarlaPlugin::setCtrlChannel(const int8_t channel, const bool sendOsc, const bool sendCallback) noexcept

  1620. {

  1621.     if (pData->engineBridged) {

  1622.         CARLA_SAFE_ASSERT_RETURN(!sendOsc && !sendCallback,);

  1623.     } else {

  1624.         CARLA_SAFE_ASSERT_RETURN(sendOsc || sendCallback,); // never call this from RT

  1625.     }

  1626.     CARLA_SAFE_ASSERT_RETURN(channel >= -1 && channel < MAX_MIDI_CHANNELS,);

  1627. 

  1628.     if (pData->ctrlChannel == channel)

  1629.         return;

  1630. 

  1631.     pData->ctrlChannel = channel;

  1632. 

  1633. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1634.     const float channelf = static_cast<float>(channel);

  1635. 

  1636.     pData->engine->callback(sendCallback, sendOsc,

  1637.                             ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  1638.                             pData->id,

  1639.                             PARAMETER_CTRL_CHANNEL,

  1640.                             0, 0,

  1641.                             channelf, nullptr);

  1642. #endif

  1643. }

  1644. 

  1645. // -------------------------------------------------------------------

  1646. // Set data (plugin-specific stuff)

  1647. 

  1648. void CarlaPlugin::setParameterValue(const uint32_t parameterId, const float value, const bool sendGui, const bool sendOsc, const bool sendCallback) noexcept

  1649. {

  1650.     if (pData->engineBridged) {

  1651.         // NOTE: some LV2 plugins feedback messages to UI on purpose

  1652.         CARLA_SAFE_ASSERT_RETURN(getType() == PLUGIN_LV2 || !sendGui,);

  1653.     } else if (pData->enginePlugin) {

  1654.         // nothing here

  1655.     } else {

  1656.         CARLA_SAFE_ASSERT_RETURN(sendGui || sendOsc || sendCallback,); // never call this from RT

  1657.     }

  1658.     CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count,);

  1659. 

  1660.     if (sendGui && (pData->hints & PLUGIN_HAS_CUSTOM_UI) != 0)

  1661.         uiParameterChange(parameterId, value);

  1662. 

  1663.     pData->engine->callback(sendCallback, sendOsc,

  1664.                             ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  1665.                             pData->id,

  1666.                             static_cast<int>(parameterId),

  1667.                             0, 0,

  1668.                             value,

  1669.                             nullptr);

  1670. }

  1671. 

  1672. void CarlaPlugin::setParameterValueRT(const uint32_t parameterId, const float value, uint32_t, const bool sendCallbackLater) noexcept

  1673. {

  1674.     pData->postponeParameterChangeRtEvent(sendCallbackLater, static_cast<int32_t>(parameterId), value);

  1675. }

  1676. 

  1677. void CarlaPlugin::setParameterValueByRealIndex(const int32_t rindex, const float value, const bool sendGui, const bool sendOsc, const bool sendCallback) noexcept

  1678. {

  1679. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1680.     CARLA_SAFE_ASSERT_RETURN(rindex > PARAMETER_MAX && rindex != PARAMETER_NULL,);

  1681. 

  1682.     switch (rindex)

  1683.     {

  1684.     case PARAMETER_ACTIVE:

  1685.         return setActive((value > 0.0f), sendOsc, sendCallback);

  1686.     case PARAMETER_CTRL_CHANNEL:

  1687.         return setCtrlChannel(int8_t(value), sendOsc, sendCallback);

  1688.     case PARAMETER_DRYWET:

  1689.         return setDryWet(value, sendOsc, sendCallback);

  1690.     case PARAMETER_VOLUME:

  1691.         return setVolume(value, sendOsc, sendCallback);

  1692.     case PARAMETER_BALANCE_LEFT:

  1693.         return setBalanceLeft(value, sendOsc, sendCallback);

  1694.     case PARAMETER_BALANCE_RIGHT:

  1695.         return setBalanceRight(value, sendOsc, sendCallback);

  1696.     case PARAMETER_PANNING:

  1697.         return setPanning(value, sendOsc, sendCallback);

  1698.     }

  1699. #endif

  1700.     CARLA_SAFE_ASSERT_RETURN(rindex >= 0,);

  1701. 

  1702.     for (uint32_t i=0; i < pData->param.count; ++i)

  1703.     {

  1704.         if (pData->param.data[i].rindex == rindex)

  1705.         {

  1706.             //if (carla_isNotEqual(getParameterValue(i), value))

  1707.             setParameterValue(i, value, sendGui, sendOsc, sendCallback);

  1708.             break;

  1709.         }

  1710.     }

  1711. }

  1712. 

  1713. void CarlaPlugin::setParameterMidiChannel(const uint32_t parameterId, const uint8_t channel, const bool sendOsc, const bool sendCallback) noexcept

  1714. {

  1715.     if (pData->engineBridged) {

  1716.         CARLA_SAFE_ASSERT_RETURN(!sendOsc && !sendCallback,);

  1717.     } else {

  1718.         CARLA_SAFE_ASSERT_RETURN(sendOsc || sendCallback,); // never call this from RT

  1719.     }

  1720.     CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count,);

  1721.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  1722. 

  1723.     if (pData->param.data[parameterId].midiChannel == channel)

  1724.         return;

  1725. 

  1726.     pData->param.data[parameterId].midiChannel = channel;

  1727. 

  1728. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1729.     pData->engine->callback(sendCallback, sendOsc,

  1730.                             ENGINE_CALLBACK_PARAMETER_MIDI_CHANNEL_CHANGED,

  1731.                             pData->id,

  1732.                             static_cast<int>(parameterId),

  1733.                             channel,

  1734.                             0, 0.0f, nullptr);

  1735. #endif

  1736. }

  1737. 

  1738. void CarlaPlugin::setParameterMappedControlIndex(const uint32_t parameterId, const int16_t index,

  1739.                                                  const bool sendOsc, const bool sendCallback,

  1740.                                                  const bool reconfigureNow) noexcept

  1741. {

  1742.     if (pData->engineBridged) {

  1743.         CARLA_SAFE_ASSERT_RETURN(!sendOsc && !sendCallback,);

  1744.     } else {

  1745.         CARLA_SAFE_ASSERT_RETURN(sendOsc || sendCallback,); // never call this from RT

  1746.     }

  1747.     CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count,);

  1748.     CARLA_SAFE_ASSERT_RETURN(index >= CONTROL_INDEX_NONE && index <= CONTROL_INDEX_MAX_ALLOWED,);

  1749. 

  1750.     ParameterData& paramData(pData->param.data[parameterId]);

  1751. 

  1752.     if (paramData.mappedControlIndex == index)

  1753.         return;

  1754. 

  1755.     const ParameterRanges& paramRanges(pData->param.ranges[parameterId]);

  1756. 

  1757.     if ((paramData.hints & PARAMETER_MAPPED_RANGES_SET) == 0x0)

  1758.         setParameterMappedRange(parameterId, paramRanges.min, paramRanges.max, true, true);

  1759. 

  1760. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1761.     char strBuf[STR_MAX+1];

  1762.     carla_zeroChars(strBuf, STR_MAX+1);

  1763.     if (! getParameterName(parameterId, strBuf))

  1764.         std::snprintf(strBuf, STR_MAX, "Param %u", parameterId);

  1765. 

  1766.     const uint portNameSize = pData->engine->getMaxPortNameSize();

  1767.     if (portNameSize < STR_MAX)

  1768.         strBuf[portNameSize] = '\0';

  1769. 

  1770.     // was learning something else before, stop that first

  1771.     if (pData->midiLearnParameterIndex >= 0 && pData->midiLearnParameterIndex != static_cast<int32_t>(parameterId))

  1772.     {

  1773.         const int32_t oldParameterId = pData->midiLearnParameterIndex;

  1774.         pData->midiLearnParameterIndex = -1;

  1775. 

  1776.         CARLA_SAFE_ASSERT_RETURN(oldParameterId < static_cast<int32_t>(pData->param.count),);

  1777. 

  1778.         pData->param.data[oldParameterId].mappedControlIndex = CONTROL_INDEX_NONE;

  1779.         pData->engine->callback(true, true,

  1780.                                 ENGINE_CALLBACK_PARAMETER_MAPPED_CONTROL_INDEX_CHANGED,

  1781.                                 pData->id,

  1782.                                 oldParameterId,

  1783.                                 CONTROL_INDEX_NONE,

  1784.                                 0, 0.0f, nullptr);

  1785.     }

  1786. 

  1787.     // mapping new parameter to CV

  1788.     if (index == CONTROL_INDEX_CV)

  1789.     {

  1790.         CARLA_SAFE_ASSERT_RETURN(pData->event.cvSourcePorts != nullptr,);

  1791.         CARLA_SAFE_ASSERT_RETURN(paramData.type == PARAMETER_INPUT,);

  1792.         CARLA_SAFE_ASSERT_RETURN(paramData.hints & PARAMETER_CAN_BE_CV_CONTROLLED,);

  1793. 

  1794.         CarlaEngineCVPort* const cvPort =

  1795.             (CarlaEngineCVPort*)pData->client->addPort(kEnginePortTypeCV, strBuf, true, parameterId);

  1796.         cvPort->setRange(paramData.mappedMinimum, paramData.mappedMaximum);

  1797.         pData->event.cvSourcePorts->addCVSource(cvPort, parameterId, reconfigureNow);

  1798.     }

  1799.     // unmapping from CV

  1800.     else if (paramData.mappedControlIndex == CONTROL_INDEX_CV)

  1801.     {

  1802.         CARLA_SAFE_ASSERT_RETURN(pData->event.cvSourcePorts != nullptr,);

  1803. 

  1804.         CARLA_SAFE_ASSERT(pData->client->removePort(kEnginePortTypeCV, strBuf, true));

  1805.         CARLA_SAFE_ASSERT(pData->event.cvSourcePorts->removeCVSource(parameterId));

  1806.     }

  1807.     // mapping to something new

  1808.     else if (paramData.mappedControlIndex == CONTROL_INDEX_NONE)

  1809.     {

  1810.         // when doing MIDI CC mapping, ensure ranges are within bounds

  1811.         if (paramData.mappedMinimum < paramRanges.min || paramData.mappedMaximum > paramRanges.max)

  1812.             setParameterMappedRange(parameterId,

  1813.                                     std::max(paramData.mappedMinimum, paramRanges.min),

  1814.                                     std::min(paramData.mappedMaximum, paramRanges.max),

  1815.                                     true, true);

  1816.     }

  1817. #endif

  1818. 

  1819.     paramData.mappedControlIndex = index;

  1820. 

  1821. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1822.     if (index == CONTROL_INDEX_MIDI_LEARN)

  1823.         pData->midiLearnParameterIndex = static_cast<int32_t>(parameterId);

  1824.     else

  1825.         pData->midiLearnParameterIndex = -1;

  1826. 

  1827.     pData->engine->callback(sendCallback, sendOsc,

  1828.                             ENGINE_CALLBACK_PARAMETER_MAPPED_CONTROL_INDEX_CHANGED,

  1829.                             pData->id,

  1830.                             static_cast<int>(parameterId),

  1831.                             index,

  1832.                             0, 0.0f, nullptr);

  1833. #else

  1834.     return;

  1835.     // unused

  1836.     (void)reconfigureNow;

  1837. #endif

  1838. }

  1839. 

  1840. void CarlaPlugin::setParameterMappedRange(const uint32_t parameterId, const float minimum, const float maximum,

  1841.                                           const bool sendOsc, const bool sendCallback) noexcept

  1842. {

  1843.     if (pData->engineBridged) {

  1844.         CARLA_SAFE_ASSERT_RETURN(!sendOsc && !sendCallback,);

  1845.     } else {

  1846.         CARLA_SAFE_ASSERT_RETURN(sendOsc || sendCallback,); // never call this from RT

  1847.     }

  1848.     CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count,);

  1849. 

  1850.     ParameterData& paramData(pData->param.data[parameterId]);

  1851. 

  1852.     if (carla_isEqual(paramData.mappedMinimum, minimum) &&

  1853.         carla_isEqual(paramData.mappedMaximum, maximum) &&

  1854.         (paramData.hints & PARAMETER_MAPPED_RANGES_SET) != 0x0)

  1855.         return;

  1856. 

  1857.     if (paramData.mappedControlIndex != CONTROL_INDEX_NONE && paramData.mappedControlIndex != CONTROL_INDEX_CV)

  1858.     {

  1859.         const ParameterRanges& paramRanges(pData->param.ranges[parameterId]);

  1860.         CARLA_SAFE_ASSERT_RETURN(minimum >= paramRanges.min,);

  1861.         CARLA_SAFE_ASSERT_RETURN(maximum <= paramRanges.max,);

  1862.     }

  1863. 

  1864.     paramData.hints |= PARAMETER_MAPPED_RANGES_SET;

  1865.     paramData.mappedMinimum = minimum;

  1866.     paramData.mappedMaximum = maximum;

  1867. 

  1868. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1869.     if (pData->event.cvSourcePorts != nullptr && paramData.mappedControlIndex == CONTROL_INDEX_CV)

  1870.         pData->event.cvSourcePorts->setCVSourceRange(parameterId, minimum, maximum);

  1871. 

  1872.     char strBuf[STR_MAX+1];

  1873.     carla_zeroChars(strBuf, STR_MAX+1);

  1874.     std::snprintf(strBuf, STR_MAX, "%.12g:%.12g", static_cast<double>(minimum), static_cast<double>(maximum));

  1875. 

  1876.     pData->engine->callback(sendCallback, sendOsc,

  1877.                             ENGINE_CALLBACK_PARAMETER_MAPPED_RANGE_CHANGED,

  1878.                             pData->id,

  1879.                             static_cast<int>(parameterId),

  1880.                             0, 0, 0.0f,

  1881.                             strBuf);

  1882. #endif

  1883. }

  1884. 

  1885. void CarlaPlugin::setCustomData(const char* const type, const char* const key, const char* const value, const bool)

  1886. {

  1887.     CARLA_SAFE_ASSERT_RETURN(type != nullptr && type[0] != '\0',);

  1888.     CARLA_SAFE_ASSERT_RETURN(key != nullptr && key[0] != '\0',);

  1889.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

  1890. 

  1891.     // Ignore some keys

  1892.     if (std::strcmp(type, CUSTOM_DATA_TYPE_STRING) == 0)

  1893.     {

  1894.         const PluginType ptype = getType();

  1895. 

  1896.         if ((ptype == PLUGIN_INTERNAL && std::strncmp(key, "CarlaAlternateFile", 18) == 0) ||

  1897.             (ptype == PLUGIN_DSSI     && std::strcmp (key, "guiVisible") == 0) ||

  1898.             (ptype == PLUGIN_LV2      && std::strncmp(key, "OSC:", 4) == 0))

  1899.             return;

  1900.     }

  1901. 

  1902.     // Check if we already have this key

  1903.     for (LinkedList<CustomData>::Itenerator it = pData->custom.begin2(); it.valid(); it.next())

  1904.     {

  1905.         CustomData& customData(it.getValue(kCustomDataFallbackNC));

  1906.         CARLA_SAFE_ASSERT_CONTINUE(customData.isValid());

  1907. 

  1908.         if (std::strcmp(customData.key, key) == 0)

  1909.         {

  1910.             if (customData.value != nullptr)

  1911.                 delete[] customData.value;

  1912. 

  1913.             customData.value = carla_strdup(value);

  1914.             return;

  1915.         }

  1916.     }

  1917. 

  1918.     // Otherwise store it

  1919.     CustomData customData;

  1920.     customData.type  = carla_strdup(type);

  1921.     customData.key   = carla_strdup(key);

  1922.     customData.value = carla_strdup(value);

  1923.     pData->custom.append(customData);

  1924. }

  1925. 

  1926. void CarlaPlugin::setChunkData(const void* const data, const std::size_t dataSize)

  1927. {

  1928.     CARLA_SAFE_ASSERT_RETURN(data != nullptr,);

  1929.     CARLA_SAFE_ASSERT_RETURN(dataSize > 0,);

  1930.     CARLA_SAFE_ASSERT(false); // this should never happen

  1931. }

  1932. 

  1933. void CarlaPlugin::setProgram(const int32_t index,

  1934.                              const bool sendGui, const bool sendOsc, const bool sendCallback, const bool) noexcept

  1935. {

  1936.     CARLA_SAFE_ASSERT_RETURN(index >= -1 && index < static_cast<int32_t>(pData->prog.count),);

  1937. 

  1938.     pData->prog.current = index;

  1939. 

  1940.     pData->engine->callback(sendCallback, sendOsc,

  1941.                             ENGINE_CALLBACK_PROGRAM_CHANGED,

  1942.                             pData->id,

  1943.                             index,

  1944.                             0, 0, 0.0f, nullptr);

  1945. 

  1946.     // Change default parameter values

  1947.     if (index >= 0)

  1948.     {

  1949.         if (sendGui && (pData->hints & PLUGIN_HAS_CUSTOM_UI) != 0)

  1950.             uiProgramChange(static_cast<uint32_t>(index));

  1951. 

  1952.         switch (getType())

  1953.         {

  1954.         case PLUGIN_SF2:

  1955.         case PLUGIN_SFZ:

  1956.             break;

  1957. 

  1958.         default:

  1959.             pData->updateParameterValues(this, sendCallback, sendOsc, true);

  1960.             break;

  1961.         }

  1962.     }

  1963. }

  1964. 

  1965. void CarlaPlugin::setMidiProgram(const int32_t index,

  1966.                                  const bool sendGui, const bool sendOsc, const bool sendCallback, const bool) noexcept

  1967. {

  1968.     CARLA_SAFE_ASSERT_RETURN(index >= -1 && index < static_cast<int32_t>(pData->midiprog.count),);

  1969. 

  1970.     pData->midiprog.current = index;

  1971. 

  1972.     pData->engine->callback(sendCallback, sendOsc,

  1973.                             ENGINE_CALLBACK_MIDI_PROGRAM_CHANGED,

  1974.                             pData->id,

  1975.                             index,

  1976.                             0, 0, 0.0f, nullptr);

  1977. 

  1978.     // Change default parameter values

  1979.     if (index >= 0)

  1980.     {

  1981.         if (sendGui && (pData->hints & PLUGIN_HAS_CUSTOM_UI) != 0)

  1982.             uiMidiProgramChange(static_cast<uint32_t>(index));

  1983. 

  1984.         switch (getType())

  1985.         {

  1986.         case PLUGIN_SF2:

  1987.         case PLUGIN_SFZ:

  1988.             break;

  1989. 

  1990.         default:

  1991.             pData->updateParameterValues(this, sendCallback, sendOsc, true);

  1992.             break;

  1993.         }

  1994.     }

  1995. }

  1996. 

  1997. void CarlaPlugin::setMidiProgramById(const uint32_t bank, const uint32_t program, const bool sendGui, const bool sendOsc, const bool sendCallback) noexcept

  1998. {

  1999.     for (uint32_t i=0; i < pData->midiprog.count; ++i)

  2000.     {

  2001.         if (pData->midiprog.data[i].bank == bank && pData->midiprog.data[i].program == program)

  2002.             return setMidiProgram(static_cast<int32_t>(i), sendGui, sendOsc, sendCallback);

  2003.     }

  2004. }

  2005. 

  2006. void CarlaPlugin::setProgramRT(const uint32_t uindex, const bool sendCallbackLater) noexcept

  2007. {

  2008.     CARLA_SAFE_ASSERT_RETURN(uindex < pData->prog.count,);

  2009. 

  2010.     const int32_t index = static_cast<int32_t>(uindex);

  2011.     pData->prog.current = index;

  2012. 

  2013.     // Change default parameter values

  2014.     switch (getType())

  2015.     {

  2016.     case PLUGIN_SF2:

  2017.     case PLUGIN_SFZ:

  2018.         break;

  2019. 

  2020.     default:

  2021.         pData->updateDefaultParameterValues(this);

  2022.         break;

  2023.     }

  2024. 

  2025.     pData->postponeProgramChangeRtEvent(sendCallbackLater, uindex);

  2026. }

  2027. 

  2028. void CarlaPlugin::setMidiProgramRT(const uint32_t uindex, const bool sendCallbackLater) noexcept

  2029. {

  2030.     CARLA_SAFE_ASSERT_RETURN(uindex < pData->midiprog.count,);

  2031. 

  2032.     const int32_t index = static_cast<int32_t>(uindex);

  2033.     pData->midiprog.current = index;

  2034. 

  2035.     // Change default parameter values

  2036.     switch (getType())

  2037.     {

  2038.     case PLUGIN_SF2:

  2039.     case PLUGIN_SFZ:

  2040.         break;

  2041. 

  2042.     default:

  2043.         pData->updateDefaultParameterValues(this);

  2044.         break;

  2045.     }

  2046. 

  2047.     pData->postponeMidiProgramChangeRtEvent(sendCallbackLater, uindex);

  2048. }

  2049. 

  2050. // -------------------------------------------------------------------

  2051. // Plugin state

  2052. 

  2053. void CarlaPlugin::reloadPrograms(const bool)

  2054. {

  2055. }

  2056. 

  2057. // -------------------------------------------------------------------

  2058. // Plugin processing

  2059. 

  2060. void CarlaPlugin::activate() noexcept

  2061. {

  2062.     CARLA_SAFE_ASSERT(! pData->active);

  2063. }

  2064. 

  2065. void CarlaPlugin::deactivate() noexcept

  2066. {

  2067.     CARLA_SAFE_ASSERT(pData->active);

  2068. }

  2069. 

  2070. void CarlaPlugin::bufferSizeChanged(const uint32_t newBufferSize)

  2071. {

  2072.    #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2073.     delete[] pData->postProc.extraBuffer;

  2074.     pData->postProc.extraBuffer = new float[newBufferSize];

  2075.    #else

  2076.     // unused

  2077.     (void)newBufferSize;

  2078.    #endif

  2079. }

  2080. 

  2081. void CarlaPlugin::sampleRateChanged(const double)

  2082. {

  2083. }

  2084. 

  2085. void CarlaPlugin::offlineModeChanged(const bool)

  2086. {

  2087. }

  2088. 

  2089. // -------------------------------------------------------------------

  2090. // Misc

  2091. 

  2092. void CarlaPlugin::idle()

  2093. {

  2094.     if (! pData->enabled)

  2095.         return;

  2096. 

  2097.     const bool hasUI = pData->hints & PLUGIN_HAS_CUSTOM_UI;

  2098.     const bool needsUiMainThread = pData->hints & PLUGIN_NEEDS_UI_MAIN_THREAD;

  2099.     const uint32_t latency = getLatencyInFrames();

  2100. 

  2101.     if (pData->latency.frames != latency)

  2102.     {

  2103.         carla_stdout("latency changed to %i samples", latency);

  2104. 

  2105.         const ScopedSingleProcessLocker sspl(this, true);

  2106. 

  2107.         pData->client->setLatency(latency);

  2108. #ifndef BUILD_BRIDGE

  2109.         pData->latency.recreateBuffers(pData->latency.channels, latency);

  2110. #else

  2111.         pData->latency.frames = latency;

  2112. #endif

  2113.     }

  2114. 

  2115.     ProtectedData::PostRtEvents::Access rtEvents(pData->postRtEvents);

  2116. 

  2117.     if (rtEvents.isEmpty())

  2118.         return;

  2119. 

  2120.     for (RtLinkedList<PluginPostRtEvent>::Itenerator it = rtEvents.getDataIterator(); it.valid(); it.next())

  2121.     {

  2122.         const PluginPostRtEvent& event(it.getValue(kPluginPostRtEventFallback));

  2123.         CARLA_SAFE_ASSERT_CONTINUE(event.type != kPluginPostRtEventNull);

  2124. 

  2125.         switch (event.type)

  2126.         {

  2127.         case kPluginPostRtEventNull: {

  2128.         } break;

  2129. 

  2130.         case kPluginPostRtEventParameterChange: {

  2131.             // Update UI

  2132.             if (event.parameter.index >= 0 && hasUI)

  2133.             {

  2134.                 if (needsUiMainThread)

  2135.                     pData->postUiEvents.append(event);

  2136.                 else

  2137.                     uiParameterChange(static_cast<uint32_t>(event.parameter.index), event.parameter.value);

  2138.             }

  2139. 

  2140.             if (event.sendCallback)

  2141.             {

  2142.                 // Update Host

  2143.                 pData->engine->callback(true, true,

  2144.                                         ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  2145.                                         pData->id,

  2146.                                         event.parameter.index,

  2147.                                         0, 0,

  2148.                                         event.parameter.value,

  2149.                                         nullptr);

  2150.             }

  2151.         } break;

  2152. 

  2153.         case kPluginPostRtEventProgramChange: {

  2154.             // Update UI

  2155.             if (hasUI)

  2156.             {

  2157.                 if (needsUiMainThread)

  2158.                     pData->postUiEvents.append(event);

  2159.                 else

  2160.                     uiProgramChange(event.program.index);

  2161.             }

  2162. 

  2163.             // Update param values

  2164.             for (uint32_t j=0; j < pData->param.count; ++j)

  2165.             {

  2166.                 const float paramDefault(pData->param.ranges[j].def);

  2167.                 const float paramValue(getParameterValue(j));

  2168. 

  2169.                 pData->engine->callback(true, true,

  2170.                                         ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  2171.                                         pData->id,

  2172.                                         static_cast<int>(j),

  2173.                                         0, 0,

  2174.                                         paramValue,

  2175.                                         nullptr);

  2176.                 pData->engine->callback(true, true,

  2177.                                         ENGINE_CALLBACK_PARAMETER_DEFAULT_CHANGED,

  2178.                                         pData->id,

  2179.                                         static_cast<int>(j),

  2180.                                         0, 0,

  2181.                                         paramDefault,

  2182.                                         nullptr);

  2183.             }

  2184. 

  2185.             if (event.sendCallback)

  2186.             {

  2187.                 // Update Host

  2188.                 pData->engine->callback(true, true,

  2189.                                         ENGINE_CALLBACK_PROGRAM_CHANGED,

  2190.                                         pData->id,

  2191.                                         static_cast<int>(event.program.index),

  2192.                                         0, 0, 0.0f, nullptr);

  2193.             }

  2194.         } break;

  2195. 

  2196.         case kPluginPostRtEventMidiProgramChange: {

  2197.             // Update UI

  2198.             if (hasUI)

  2199.             {

  2200.                 if (needsUiMainThread)

  2201.                     pData->postUiEvents.append(event);

  2202.                 else

  2203.                     uiMidiProgramChange(event.program.index);

  2204.             }

  2205. 

  2206.             // Update param values

  2207.             for (uint32_t j=0; j < pData->param.count; ++j)

  2208.             {

  2209.                 const float paramDefault(pData->param.ranges[j].def);

  2210.                 const float paramValue(getParameterValue(j));

  2211. 

  2212.                 pData->engine->callback(true, true,

  2213.                                         ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  2214.                                         pData->id,

  2215.                                         static_cast<int>(j),

  2216.                                         0, 0,

  2217.                                         paramValue,

  2218.                                         nullptr);

  2219.                 pData->engine->callback(true, true,

  2220.                                         ENGINE_CALLBACK_PARAMETER_DEFAULT_CHANGED,

  2221.                                         pData->id,

  2222.                                         static_cast<int>(j),

  2223.                                         0, 0,

  2224.                                         paramDefault,

  2225.                                         nullptr);

  2226.             }

  2227. 

  2228.             if (event.sendCallback)

  2229.             {

  2230.                 // Update Host

  2231.                 pData->engine->callback(true, true,

  2232.                                         ENGINE_CALLBACK_MIDI_PROGRAM_CHANGED,

  2233.                                         pData->id,

  2234.                                         static_cast<int>(event.program.index),

  2235.                                         0, 0, 0.0f, nullptr);

  2236.             }

  2237.         } break;

  2238. 

  2239.         case kPluginPostRtEventNoteOn: {

  2240.             CARLA_SAFE_ASSERT_BREAK(event.note.channel  < MAX_MIDI_CHANNELS);

  2241.             CARLA_SAFE_ASSERT_BREAK(event.note.note     < MAX_MIDI_NOTE);

  2242.             CARLA_SAFE_ASSERT_BREAK(event.note.velocity < MAX_MIDI_VALUE);

  2243. 

  2244.             // Update UI

  2245.             if (hasUI)

  2246.             {

  2247.                 if (needsUiMainThread)

  2248.                     pData->postUiEvents.append(event);

  2249.                 else

  2250.                     uiNoteOn(event.note.channel, event.note.note, event.note.velocity);

  2251.             }

  2252. 

  2253.             if (event.sendCallback)

  2254.             {

  2255.                 // Update Host

  2256.                 pData->engine->callback(true, true,

  2257.                                         ENGINE_CALLBACK_NOTE_ON,

  2258.                                         pData->id,

  2259.                                         static_cast<int>(event.note.channel),

  2260.                                         static_cast<int>(event.note.note),

  2261.                                         static_cast<int>(event.note.velocity),

  2262.                                         0.0f, nullptr);

  2263.             }

  2264.         } break;

  2265. 

  2266.         case kPluginPostRtEventNoteOff: {

  2267.             CARLA_SAFE_ASSERT_BREAK(event.note.channel  < MAX_MIDI_CHANNELS);

  2268.             CARLA_SAFE_ASSERT_BREAK(event.note.note     < MAX_MIDI_NOTE);

  2269. 

  2270.             // Update UI

  2271.             if (hasUI)

  2272.             {

  2273.                 if (needsUiMainThread)

  2274.                     pData->postUiEvents.append(event);

  2275.                 else

  2276.                     uiNoteOff(event.note.channel, event.note.note);

  2277.             }

  2278. 

  2279.             if (event.sendCallback)

  2280.             {

  2281.                 // Update Host

  2282.                 pData->engine->callback(true, true,

  2283.                                         ENGINE_CALLBACK_NOTE_OFF,

  2284.                                         pData->id,

  2285.                                         static_cast<int>(event.note.channel),

  2286.                                         static_cast<int>(event.note.note),

  2287.                                         0, 0.0f, nullptr);

  2288.             }

  2289.         } break;

  2290. 

  2291.         case kPluginPostRtEventMidiLearn: {

  2292.             CARLA_SAFE_ASSERT_BREAK(event.midiLearn.cc      < MAX_MIDI_VALUE);

  2293.             CARLA_SAFE_ASSERT_BREAK(event.midiLearn.channel < MAX_MIDI_CHANNELS);

  2294. 

  2295. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2296.             if (event.sendCallback)

  2297.             {

  2298.                 pData->engine->callback(true, true,

  2299.                                         ENGINE_CALLBACK_PARAMETER_MAPPED_CONTROL_INDEX_CHANGED,

  2300.                                         pData->id,

  2301.                                         static_cast<int>(event.midiLearn.parameter),

  2302.                                         static_cast<int>(event.midiLearn.cc),

  2303.                                         0, 0.0f, nullptr);

  2304. 

  2305.                 pData->engine->callback(true, true,

  2306.                                         ENGINE_CALLBACK_PARAMETER_MIDI_CHANNEL_CHANGED,

  2307.                                         pData->id,

  2308.                                         static_cast<int>(event.midiLearn.parameter),

  2309.                                         static_cast<int>(event.midiLearn.channel),

  2310.                                         0, 0.0f, nullptr);

  2311.             }

  2312. #endif

  2313.         } break;

  2314.         }

  2315.     }

  2316. }

  2317. 

  2318. bool CarlaPlugin::tryLock(const bool forcedOffline) noexcept

  2319. {

  2320.     if (forcedOffline)

  2321.     {

  2322. #ifndef STOAT_TEST_BUILD

  2323.         pData->masterMutex.lock();

  2324.         return true;

  2325. #endif

  2326.     }

  2327. 

  2328.     return pData->masterMutex.tryLock();

  2329. }

  2330. 

  2331. void CarlaPlugin::unlock() noexcept

  2332. {

  2333.     pData->masterMutex.unlock();

  2334. }

  2335. 

  2336. // -------------------------------------------------------------------

  2337. // Plugin buffers

  2338. 

  2339. void CarlaPlugin::initBuffers() const noexcept

  2340. {

  2341.     pData->audioIn.initBuffers();

  2342.     pData->audioOut.initBuffers();

  2343.     pData->cvIn.initBuffers();

  2344.     pData->cvOut.initBuffers();

  2345.     pData->event.initBuffers();

  2346. }

  2347. 

  2348. void CarlaPlugin::clearBuffers() noexcept

  2349. {

  2350.     pData->clearBuffers();

  2351. }

  2352. 

  2353. // -------------------------------------------------------------------

  2354. // OSC stuff

  2355. 

  2356. // FIXME

  2357. void CarlaPlugin::handleOscMessage(const char*, int, const void*, const char*, void*)

  2358. {

  2359.     // do nothing

  2360. }

  2361. 

  2362. // -------------------------------------------------------------------

  2363. // MIDI events

  2364. 

  2365. void CarlaPlugin::sendMidiSingleNote(const uint8_t channel, const uint8_t note, const uint8_t velo, const bool sendGui, const bool sendOsc, const bool sendCallback)

  2366. {

  2367.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2368.     CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

  2369.     CARLA_SAFE_ASSERT_RETURN(velo < MAX_MIDI_VALUE,);

  2370. 

  2371.     if (! pData->active)

  2372.         return;

  2373. 

  2374.     ExternalMidiNote extNote;

  2375.     extNote.channel = static_cast<int8_t>(channel);

  2376.     extNote.note    = note;

  2377.     extNote.velo    = velo;

  2378. 

  2379.     pData->extNotes.appendNonRT(extNote);

  2380. 

  2381.     if (sendGui && (pData->hints & PLUGIN_HAS_CUSTOM_UI) != 0)

  2382.     {

  2383.         if (velo > 0)

  2384.             uiNoteOn(channel, note, velo);

  2385.         else

  2386.             uiNoteOff(channel, note);

  2387.     }

  2388. 

  2389.     pData->engine->callback(sendCallback, sendOsc,

  2390.                             (velo > 0) ? ENGINE_CALLBACK_NOTE_ON : ENGINE_CALLBACK_NOTE_OFF,

  2391.                             pData->id,

  2392.                             channel,

  2393.                             note,

  2394.                             velo,

  2395.                             0.0f, nullptr);

  2396. }

  2397. 

  2398. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2399. void CarlaPlugin::postponeRtAllNotesOff()

  2400. {

  2401.     if (pData->ctrlChannel < 0 || pData->ctrlChannel >= MAX_MIDI_CHANNELS)

  2402.         return;

  2403. 

  2404.     PluginPostRtEvent postEvent = { kPluginPostRtEventNoteOff, true, {} };

  2405.     postEvent.note.channel = static_cast<uint8_t>(pData->ctrlChannel);

  2406. 

  2407.     for (uint8_t i=0; i < MAX_MIDI_NOTE; ++i)

  2408.     {

  2409.         postEvent.note.note = i;

  2410.         pData->postRtEvents.appendRT(postEvent);

  2411.     }

  2412. }

  2413. #endif

  2414. 

  2415. // -------------------------------------------------------------------

  2416. // UI Stuff

  2417. 

  2418. void CarlaPlugin::setCustomUITitle(const char* const title) noexcept

  2419. {

  2420.     pData->uiTitle = title;

  2421. }

  2422. 

  2423. void CarlaPlugin::showCustomUI(const bool yesNo)

  2424. {

  2425.     if (yesNo) {

  2426.         CARLA_SAFE_ASSERT(false);

  2427.     }

  2428. }

  2429. 

  2430. void* CarlaPlugin::embedCustomUI(void*)

  2431. {

  2432.     return nullptr;

  2433. }

  2434. 

  2435. void CarlaPlugin::uiIdle()

  2436. {

  2437.     if (pData->hints & PLUGIN_NEEDS_UI_MAIN_THREAD)

  2438.     {

  2439.         // Update parameter outputs

  2440.         for (uint32_t i=0; i < pData->param.count; ++i)

  2441.         {

  2442.             if (pData->param.data[i].type == PARAMETER_OUTPUT)

  2443.                 uiParameterChange(i, getParameterValue(i));

  2444.         }

  2445. 

  2446.         const CarlaMutexLocker sl(pData->postUiEvents.mutex);

  2447. 

  2448.         for (LinkedList<PluginPostRtEvent>::Itenerator it = pData->postUiEvents.data.begin2(); it.valid(); it.next())

  2449.         {

  2450.             const PluginPostRtEvent& event(it.getValue(kPluginPostRtEventFallback));

  2451.             CARLA_SAFE_ASSERT_CONTINUE(event.type != kPluginPostRtEventNull);

  2452. 

  2453.             switch (event.type)

  2454.             {

  2455.             case kPluginPostRtEventNull:

  2456.             case kPluginPostRtEventMidiLearn:

  2457.                 break;

  2458. 

  2459.             case kPluginPostRtEventParameterChange:

  2460.                 uiParameterChange(static_cast<uint32_t>(event.parameter.index), event.parameter.value);

  2461.                 break;

  2462. 

  2463.             case kPluginPostRtEventProgramChange:

  2464.                 uiProgramChange(event.program.index);

  2465.                 break;

  2466. 

  2467.             case kPluginPostRtEventMidiProgramChange:

  2468.                 uiMidiProgramChange(event.program.index);

  2469.                 break;

  2470. 

  2471.             case kPluginPostRtEventNoteOn:

  2472.                 uiNoteOn(event.note.channel, event.note.note, event.note.velocity);

  2473.                 break;

  2474. 

  2475.             case kPluginPostRtEventNoteOff:

  2476.                 uiNoteOff(event.note.channel, event.note.note);

  2477.                 break;

  2478.             }

  2479.         }

  2480. 

  2481.         pData->postUiEvents.data.clear();

  2482.     }

  2483. 

  2484. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2485.     if (pData->transientTryCounter == 0)

  2486.         return;

  2487.     if (++pData->transientTryCounter % 10 != 0)

  2488.         return;

  2489.     if (pData->transientTryCounter >= 200)

  2490.         return;

  2491. 

  2492.     carla_stdout("Trying to get window...");

  2493. 

  2494.     CarlaString uiTitle;

  2495. 

  2496.     if (pData->uiTitle.isNotEmpty())

  2497.     {

  2498.         uiTitle = pData->uiTitle;

  2499.     }

  2500.     else

  2501.     {

  2502.         uiTitle  = pData->name;

  2503.         uiTitle += " (GUI)";

  2504.     }

  2505. 

  2506.     if (CarlaPluginUI::tryTransientWinIdMatch(getUiBridgeProcessId(), uiTitle,

  2507.                                               pData->engine->getOptions().frontendWinId, pData->transientFirstTry))

  2508.     {

  2509.         pData->transientTryCounter = 0;

  2510.         pData->transientFirstTry = false;

  2511.     }

  2512. #endif

  2513. }

  2514. 

  2515. void CarlaPlugin::uiParameterChange(const uint32_t index, const float value) noexcept

  2516. {

  2517.     CARLA_SAFE_ASSERT_RETURN(index < getParameterCount(),);

  2518.     return;

  2519. 

  2520.     // unused

  2521.     (void)value;

  2522. }

  2523. 

  2524. void CarlaPlugin::uiProgramChange(const uint32_t index) noexcept

  2525. {

  2526.     CARLA_SAFE_ASSERT_RETURN(index < getProgramCount(),);

  2527. }

  2528. 

  2529. void CarlaPlugin::uiMidiProgramChange(const uint32_t index) noexcept

  2530. {

  2531.     CARLA_SAFE_ASSERT_RETURN(index < getMidiProgramCount(),);

  2532. }

  2533. 

  2534. void CarlaPlugin::uiNoteOn(const uint8_t channel, const uint8_t note, const uint8_t velo) noexcept

  2535. {

  2536.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2537.     CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

  2538.     CARLA_SAFE_ASSERT_RETURN(velo > 0 && velo < MAX_MIDI_VALUE,);

  2539. }

  2540. 

  2541. void CarlaPlugin::uiNoteOff(const uint8_t channel, const uint8_t note) noexcept

  2542. {

  2543.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2544.     CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

  2545. }

  2546. 

  2547. CarlaEngine* CarlaPlugin::getEngine() const noexcept

  2548. {

  2549.     return pData->engine;

  2550. }

  2551. 

  2552. CarlaEngineClient* CarlaPlugin::getEngineClient() const noexcept

  2553. {

  2554.     return pData->client;

  2555. }

  2556. 

  2557. CarlaEngineAudioPort* CarlaPlugin::getAudioInPort(const uint32_t index) const noexcept

  2558. {

  2559.     return pData->audioIn.ports[index].port;

  2560. }

  2561. 

  2562. CarlaEngineAudioPort* CarlaPlugin::getAudioOutPort(const uint32_t index) const noexcept

  2563. {

  2564.     return pData->audioOut.ports[index].port;

  2565. }

  2566. 

  2567. CarlaEngineCVPort* CarlaPlugin::getCVInPort(const uint32_t index) const noexcept

  2568. {

  2569.     return pData->cvIn.ports[index].port;

  2570. }

  2571. 

  2572. CarlaEngineCVPort* CarlaPlugin::getCVOutPort(const uint32_t index) const noexcept

  2573. {

  2574.     return pData->cvOut.ports[index].port;

  2575. }

  2576. 

  2577. CarlaEngineEventPort* CarlaPlugin::getDefaultEventInPort() const noexcept

  2578. {

  2579.     return pData->event.portIn;

  2580. }

  2581. 

  2582. CarlaEngineEventPort* CarlaPlugin::getDefaultEventOutPort() const noexcept

  2583. {

  2584.     return pData->event.portOut;

  2585. }

  2586. 

  2587. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2588. void CarlaPlugin::checkForMidiLearn(EngineEvent& event) noexcept

  2589. {

  2590.     if (pData->midiLearnParameterIndex < 0)

  2591.         return;

  2592.     if (event.ctrl.param == MIDI_CONTROL_BANK_SELECT || event.ctrl.param == MIDI_CONTROL_BANK_SELECT__LSB)

  2593.         return;

  2594.     if (event.ctrl.param >= MAX_MIDI_CONTROL)

  2595.         return;

  2596. 

  2597.     const uint32_t parameterId = static_cast<uint32_t>(pData->midiLearnParameterIndex);

  2598.     CARLA_SAFE_ASSERT_UINT2_RETURN(parameterId < pData->param.count, parameterId, pData->param.count,);

  2599. 

  2600.     ParameterData& paramData(pData->param.data[parameterId]);

  2601.     CARLA_SAFE_ASSERT_INT_RETURN(paramData.mappedControlIndex == CONTROL_INDEX_MIDI_LEARN,

  2602.                                  paramData.mappedControlIndex,);

  2603. 

  2604.     event.ctrl.handled = true;

  2605.     paramData.mappedControlIndex = static_cast<int16_t>(event.ctrl.param);

  2606.     paramData.midiChannel = event.channel;

  2607. 

  2608.     pData->postponeMidiLearnRtEvent(true, parameterId, static_cast<uint8_t>(event.ctrl.param), event.channel);

  2609.     pData->midiLearnParameterIndex = -1;

  2610. }

  2611. #endif

  2612. 

  2613. void* CarlaPlugin::getNativeHandle() const noexcept

  2614. {

  2615.     return nullptr;

  2616. }

  2617. 

  2618. const void* CarlaPlugin::getNativeDescriptor() const noexcept

  2619. {

  2620.     return nullptr;

  2621. }

  2622. 

  2623. uintptr_t CarlaPlugin::getUiBridgeProcessId() const noexcept

  2624. {

  2625.     return 0;

  2626. }

  2627. 

  2628. // -------------------------------------------------------------------

  2629. 

  2630. uint32_t CarlaPlugin::getPatchbayNodeId() const noexcept

  2631. {

  2632.     return pData->nodeId;

  2633. }

  2634. 

  2635. void CarlaPlugin::setPatchbayNodeId(const uint32_t nodeId) noexcept

  2636. {

  2637.     pData->nodeId = nodeId;

  2638. }

  2639. 

  2640. // -------------------------------------------------------------------

  2641. 

  2642. void CarlaPlugin::cloneLV2Files(const CarlaPlugin&)

  2643. {

  2644.     carla_stderr2("Warning: cloneLV2Files() called for non-implemented type");

  2645. }

  2646. 

  2647. void CarlaPlugin::restoreLV2State(const bool temporary) noexcept

  2648. {

  2649.     carla_stderr2("Warning: restoreLV2State(%s) called for non-implemented type", bool2str(temporary));

  2650. }

  2651. 

  2652. void CarlaPlugin::prepareForDeletion() noexcept

  2653. {

  2654.     carla_debug("CarlaPlugin::prepareForDeletion");

  2655. 

  2656.     const CarlaMutexLocker cml(pData->masterMutex);

  2657. 

  2658.     pData->client->deactivate(true);

  2659. }

  2660. 

  2661. void CarlaPlugin::waitForBridgeSaveSignal() noexcept

  2662. {

  2663. }

  2664. 

  2665. // -------------------------------------------------------------------

  2666. // Scoped Disabler

  2667. 

  2668. CarlaPlugin::ScopedDisabler::ScopedDisabler(CarlaPlugin* const plugin) noexcept

  2669.     : fPlugin(plugin),

  2670.       fWasEnabled(false)

  2671. {

  2672.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2673.     CARLA_SAFE_ASSERT_RETURN(plugin->pData != nullptr,);

  2674.     CARLA_SAFE_ASSERT_RETURN(plugin->pData->client != nullptr,);

  2675.     carla_debug("CarlaPlugin::ScopedDisabler(%p)", plugin);

  2676. 

  2677.     plugin->pData->masterMutex.lock();

  2678. 

  2679.     if (plugin->pData->enabled)

  2680.     {

  2681.         fWasEnabled = true;

  2682.         plugin->pData->enabled = false;

  2683. 

  2684.         if (plugin->pData->client->isActive())

  2685.             plugin->pData->client->deactivate(false);

  2686.     }

  2687. }

  2688. 

  2689. CarlaPlugin::ScopedDisabler::~ScopedDisabler() noexcept

  2690. {

  2691.     CARLA_SAFE_ASSERT_RETURN(fPlugin != nullptr,);

  2692.     CARLA_SAFE_ASSERT_RETURN(fPlugin->pData != nullptr,);

  2693.     CARLA_SAFE_ASSERT_RETURN(fPlugin->pData->client != nullptr,);

  2694.     carla_debug("CarlaPlugin::~ScopedDisabler()");

  2695. 

  2696.     if (fWasEnabled)

  2697.     {

  2698.         fPlugin->pData->enabled = true;

  2699.         fPlugin->pData->client->activate();

  2700.     }

  2701. 

  2702.     fPlugin->pData->masterMutex.unlock();

  2703. }

  2704. 

  2705. // -------------------------------------------------------------------

  2706. // Scoped Process Locker

  2707. 

  2708. CarlaPlugin::ScopedSingleProcessLocker::ScopedSingleProcessLocker(CarlaPlugin* const plugin, const bool block) noexcept

  2709.     : fPlugin(plugin),

  2710.       fBlock(block)

  2711. {

  2712.     CARLA_SAFE_ASSERT_RETURN(fPlugin != nullptr,);

  2713.     CARLA_SAFE_ASSERT_RETURN(fPlugin->pData != nullptr,);

  2714.     carla_debug("CarlaPlugin::ScopedSingleProcessLocker(%p, %s)", plugin, bool2str(block));

  2715. 

  2716.     if (! fBlock)

  2717.         return;

  2718. 

  2719.     plugin->pData->singleMutex.lock();

  2720. }

  2721. 

  2722. CarlaPlugin::ScopedSingleProcessLocker::~ScopedSingleProcessLocker() noexcept

  2723. {

  2724.     CARLA_SAFE_ASSERT_RETURN(fPlugin != nullptr,);

  2725.     CARLA_SAFE_ASSERT_RETURN(fPlugin->pData != nullptr,);

  2726.     carla_debug("CarlaPlugin::~ScopedSingleProcessLocker()");

  2727. 

  2728.     if (! fBlock)

  2729.         return;

  2730. 

  2731. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2732.     if (fPlugin->pData->singleMutex.wasTryLockCalled())

  2733.         fPlugin->pData->needsReset = true;

  2734. #endif

  2735. 

  2736.     fPlugin->pData->singleMutex.unlock();

  2737. }

  2738. 

  2739. // -------------------------------------------------------------------

  2740. 

  2741. CARLA_BACKEND_END_NAMESPACE