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.
7034 Commits
17 Branches
381MB
Tree: 6adfdf0374
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '6adfdf0374'
${ noResults }
Carla/source/backend/plugin/CarlaPlugin.cpp

2786 lines
92KB
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. #include "distrho/extra/ScopedPointer.hpp"

  18. 

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

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

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

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

  23. 

  24. using water::CharPointer_UTF8;

  25. using water::File;

  26. using water::MemoryOutputStream;

  27. using water::Result;

  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.     case PARAMETER_FORTH:

  396.         return pData->postProc.forth;

  397.     };

  398. #endif

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

  400. 

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

  402. }

  403. 

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

  405. {

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

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

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

  409.     return true;

  410. }

  411. 

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

  413. {

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

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

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

  417.     return true;

  418. }

  419. 

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

  421. {

  422.     ins  = 0;

  423.     outs = 0;

  424. 

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

  426.     {

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

  428.             ++ins;

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

  430.             ++outs;

  431.     }

  432. }

  433. 

  434. // -------------------------------------------------------------------

  435. // Set data (state)

  436. 

  437. void CarlaPlugin::prepareForSave(bool)

  438. {

  439. }

  440. 

  441. void CarlaPlugin::resetParameters() noexcept

  442. {

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

  444.     {

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

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

  447. 

  448.         if (paramData.type != PARAMETER_INPUT)

  449.             continue;

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

  451.             continue;

  452. 

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

  454.     }

  455. }

  456. 

  457. void CarlaPlugin::randomizeParameters() noexcept

  458. {

  459.     float value, random;

  460. 

  461.     char strBuf[STR_MAX+1];

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

  463. 

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

  465. 

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

  467.     {

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

  469. 

  470.         if (paramData.type != PARAMETER_INPUT)

  471.             continue;

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

  473.             continue;

  474. 

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

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

  477. 

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

  479.             continue;

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

  481.             continue;

  482. 

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

  484. 

  485.         if (paramData.hints & PARAMETER_IS_BOOLEAN)

  486.         {

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

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

  489.         }

  490.         else

  491.         {

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

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

  494. 

  495.             if (paramData.hints & PARAMETER_IS_INTEGER)

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

  497.         }

  498. 

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

  500.     }

  501. }

  502. 

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

  504. {

  505.     pData->stateSave.clear();

  506. 

  507.     if (callPrepareForSave)

  508.     {

  509.         pData->stateSave.temporary = true;

  510.         prepareForSave(true);

  511.     }

  512. 

  513.     const PluginType pluginType = getType();

  514. 

  515.     char strBuf[STR_MAX+1];

  516.     carla_zeroChars(strBuf, STR_MAX+1);

  517. 

  518.     // ---------------------------------------------------------------

  519.     // Basic info

  520. 

  521.     if (! getLabel(strBuf))

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

  523. 

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

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

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

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

  528. // #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  530. // #endif

  531. 

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

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

  534. 

  535.    #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  536.     // ---------------------------------------------------------------

  537.     // Internals

  538. 

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

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

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

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

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

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

  545.     pData->stateSave.forth        = pData->postProc.forth;

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

  547.    #endif

  548. 

  549.     if (pData->hints & PLUGIN_IS_BRIDGE)

  550.         waitForBridgeSaveSignal();

  551. 

  552.     // ---------------------------------------------------------------

  553.     // Chunk

  554. 

  555.     bool usingChunk = false;

  556. 

  557.     if (pData->options & PLUGIN_OPTION_USE_CHUNKS)

  558.     {

  559.         void* data = nullptr;

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

  561. 

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

  563.         {

  564.             pData->stateSave.chunk = carla_strdup(String::asBase64(data, dataSize));

  565. 

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

  567.                 usingChunk = true;

  568.         }

  569.     }

  570. 

  571.     // ---------------------------------------------------------------

  572.     // Current Program

  573. 

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

  575.     {

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

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

  578.     }

  579. 

  580.     // ---------------------------------------------------------------

  581.     // Current MIDI Program

  582. 

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

  584.     {

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

  586. 

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

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

  589.     }

  590. 

  591.     // ---------------------------------------------------------------

  592.     // Parameters

  593. 

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

  595. 

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

  597.     {

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

  599. 

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

  601.             continue;

  602.         if (paramData.hints & PARAMETER_IS_NOT_SAVED)

  603.             continue;

  604. 

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

  606. 

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

  608.             continue;

  609. 

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

  611. 

  612.         stateParameter->dummy = dummy;

  613.         stateParameter->index = paramData.index;

  614.        #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  615.         if (paramData.mappedControlIndex != CONTROL_INDEX_MIDI_LEARN)

  616.         {

  617.             stateParameter->mappedControlIndex = paramData.mappedControlIndex;

  618.             stateParameter->midiChannel        = paramData.midiChannel;

  619. 

  620.             if (paramData.hints & PARAMETER_MAPPED_RANGES_SET)

  621.             {

  622.                 stateParameter->mappedMinimum = paramData.mappedMinimum;

  623.                 stateParameter->mappedMaximum = paramData.mappedMaximum;

  624.                 stateParameter->mappedRangeValid = true;

  625. 

  626.                 if (paramData.hints & PARAMETER_USES_SAMPLERATE)

  627.                 {

  628.                     stateParameter->mappedMinimum /= sampleRate;

  629.                     stateParameter->mappedMaximum /= sampleRate;

  630.                 }

  631.             }

  632.         }

  633.        #endif

  634. 

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

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

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

  638. 

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

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

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

  642. 

  643.         if (! dummy)

  644.         {

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

  646. 

  647.             if (paramData.hints & PARAMETER_USES_SAMPLERATE)

  648.                 stateParameter->value /= sampleRate;

  649.         }

  650. 

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

  652.     }

  653. 

  654.     // ---------------------------------------------------------------

  655.     // Custom Data

  656. 

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

  658.     {

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

  660.         CARLA_SAFE_ASSERT_CONTINUE(cData.isValid());

  661. 

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

  663. 

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

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

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

  667. 

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

  669.     }

  670. 

  671.     return pData->stateSave;

  672. }

  673. 

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

  675. {

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

  677.     const PluginType pluginType = getType();

  678. 

  679.     char strBuf[STR_MAX+1];

  680.     carla_zeroChars(strBuf, STR_MAX+1);

  681. 

  682.     // ---------------------------------------------------------------

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

  684. 

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

  686.     {

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

  688.         CARLA_SAFE_ASSERT_CONTINUE(stateCustomData != nullptr);

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

  690. 

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

  692. 

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

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

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

  696.             pass();

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

  698.             pass();

  699.         else

  700.             continue;

  701. 

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

  703.     }

  704. 

  705.     // ---------------------------------------------------------------

  706.     // Part 2 - set program

  707. 

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

  709.     {

  710.         int32_t programId = -1;

  711. 

  712.         // index < count

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

  714.         {

  715.             programId = stateSave.currentProgramIndex;

  716.         }

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

  718.         else

  719.         {

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

  721.             {

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

  723.                 {

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

  725.                     break;

  726.                 }

  727.             }

  728.         }

  729. 

  730.         // set program now, if valid

  731.         if (programId >= 0)

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

  733.     }

  734. 

  735.     // ---------------------------------------------------------------

  736.     // Part 3 - set midi program

  737. 

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

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

  740. 

  741.     // ---------------------------------------------------------------

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

  743. 

  744.     LinkedList<ParamSymbol*> paramSymbols;

  745. 

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

  747.     {

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

  749.         {

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

  751.                 continue;

  752. 

  753.             if (getParameterSymbol(i, strBuf))

  754.             {

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

  756.                 paramSymbols.append(paramSymbol);

  757.             }

  758.         }

  759.     }

  760. 

  761.     // ---------------------------------------------------------------

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

  763. 

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

  765. 

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

  767.     {

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

  769.         CARLA_SAFE_ASSERT_CONTINUE(stateParameter != nullptr);

  770. 

  771.         int32_t index = -1;

  772. 

  773.         if (pluginType == PLUGIN_LADSPA)

  774.         {

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

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

  777.             {

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

  779.                 {

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

  781.                     CARLA_SAFE_ASSERT_CONTINUE(paramSymbol != nullptr);

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

  783. 

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

  785.                     {

  786.                         index = paramSymbol->index;

  787.                         break;

  788.                     }

  789.                 }

  790.                 if (index == -1)

  791.                     index = stateParameter->index;

  792.             }

  793.             else

  794.             {

  795.                 index = stateParameter->index;

  796.             }

  797.         }

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

  799.         {

  800.             // Symbol only

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

  802.             {

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

  804.                 {

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

  806.                     CARLA_SAFE_ASSERT_CONTINUE(paramSymbol != nullptr);

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

  808. 

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

  810.                     {

  811.                         index = paramSymbol->index;

  812.                         break;

  813.                     }

  814.                 }

  815.                 if (index == -1)

  816.                 {

  817.                     if (pluginType == PLUGIN_LV2)

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

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

  820.                     else

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

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

  823.                 }

  824.             }

  825.             else

  826.             {

  827.                 if (pluginType == PLUGIN_LV2)

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

  829.                 else

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

  831.             }

  832.         }

  833.         else

  834.         {

  835.             // Index only

  836.             index = stateParameter->index;

  837.         }

  838. 

  839.         // Now set parameter

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

  841.         {

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

  843. 

  844.             if (! stateParameter->dummy)

  845.             {

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

  847.                     stateParameter->value *= sampleRate;

  848. 

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

  850.             }

  851. 

  852.            #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  853.             if (stateParameter->mappedRangeValid)

  854.             {

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

  856.                 {

  857.                     stateParameter->mappedMinimum *= sampleRate;

  858.                     stateParameter->mappedMaximum *= sampleRate;

  859.                 }

  860. 

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

  862.                                         stateParameter->mappedMinimum,

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

  864.             }

  865. 

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

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

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

  869.            #endif

  870.         }

  871.         else

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

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

  874.     }

  875. 

  876.     // ---------------------------------------------------------------

  877.     // Part 4c - clear

  878. 

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

  880.     {

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

  882.         delete paramSymbol;

  883.     }

  884. 

  885.     paramSymbols.clear();

  886. 

  887.     // ---------------------------------------------------------------

  888.     // Part 5 - set custom data

  889. 

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

  891.     {

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

  893.         CARLA_SAFE_ASSERT_CONTINUE(stateCustomData != nullptr);

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

  895. 

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

  897. 

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

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

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

  901.             continue;

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

  903.             continue;

  904. 

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

  906.     }

  907. 

  908.     // ---------------------------------------------------------------

  909.     // Part 5x - set lv2 state

  910. 

  911.     if (pluginType == PLUGIN_LV2)

  912.     {

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

  914.         {

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

  916.             CARLA_SAFE_ASSERT_CONTINUE(customData.isValid());

  917. 

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

  919.                 continue;

  920. 

  921.             restoreLV2State(stateSave.temporary);

  922.             break;

  923.         }

  924.     }

  925. 

  926.     // ---------------------------------------------------------------

  927.     // Part 6 - set chunk

  928. 

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

  930.     {

  931.         std::vector<uint8_t> chunk;

  932.         d_getChunkFromBase64String_impl(chunk, stateSave.chunk);

  933.        #ifdef CARLA_PROPER_CPP11_SUPPORT

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

  935.        #else

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

  937.        #endif

  938.     }

  939. 

  940.    #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  941.     // ---------------------------------------------------------------

  942.     // Part 6 - set internal stuff

  943. 

  944.     const uint availOptions = getOptionsAvailable();

  945. 

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

  947.     {

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

  949. 

  950.         if (availOptions & option)

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

  952.     }

  953. 

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

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

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

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

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

  959.     setForth(stateSave.forth, true, true);

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

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

  962. 

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

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

  965.    #endif

  966. }

  967. 

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

  969. {

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

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

  972. 

  973.     MemoryOutputStream out, streamState;

  974.     getStateSave().dumpToMemoryStream(streamState);

  975. 

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

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

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

  979.     out << streamState;

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

  981. 

  982.     File file(filename);

  983. 

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

  985.         return true;

  986. 

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

  988.     return false;

  989. }

  990. 

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

  992. {

  993.     // TODO set errors

  994. 

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

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

  997. 

  998.     File file(filename);

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

  1000. 

  1001.     XmlDocument xml(file);

  1002.     ScopedPointer<XmlElement> xmlElement(xml.getDocumentElement(true));

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

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

  1005. 

  1006.     // completely load file

  1007.     xmlElement = xml.getDocumentElement(false);

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

  1009. 

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

  1011.     {

  1012.         loadStateSave(pData->stateSave);

  1013.         return true;

  1014.     }

  1015. 

  1016.     return false;

  1017. }

  1018. 

  1019. #ifndef CARLA_PLUGIN_ONLY_BRIDGE

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

  1021. {

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

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

  1024. 

  1025.     String bundlepath(lv2path);

  1026. 

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

  1028.         bundlepath += ".lv2";

  1029. 

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

  1031. 

  1032.     if (bundlefolder.existsAsFile())

  1033.     {

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

  1035.         return false;

  1036.     }

  1037. 

  1038.     if (! bundlefolder.exists())

  1039.     {

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

  1041. 

  1042.         if (res.failed())

  1043.         {

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

  1045.             return false;

  1046.         }

  1047.     }

  1048. 

  1049.     String symbol(pData->name);

  1050.     symbol.toBasic();

  1051. 

  1052.     {

  1053.         const String pluginFilename(bundlepath + CARLA_OS_SEP_STR + symbol + ".xml");

  1054. 

  1055.         if (! saveStateToFile(pluginFilename))

  1056.             return false;

  1057.     }

  1058. 

  1059.     {

  1060.         MemoryOutputStream manifestStream;

  1061. 

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

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

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

  1065.         manifestStream << "\n";

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

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

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

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

  1070.         manifestStream << "\n";

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

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

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

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

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

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

  1077.         manifestStream << "\n";

  1078. 

  1079.         const String manifestFilename(bundlepath + CARLA_OS_SEP_STR "manifest.ttl");

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

  1081. 

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

  1083.         {

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

  1085.             return false;

  1086.         }

  1087.     }

  1088. 

  1089.     {

  1090.         MemoryOutputStream mainStream;

  1091. 

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

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

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

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

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

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

  1098.         mainStream << "\n";

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

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

  1101.         mainStream << "\n";

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

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

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

  1105.         mainStream << "\n";

  1106. 

  1107.         if (pData->hints & PLUGIN_HAS_CUSTOM_UI)

  1108.         {

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

  1110.             mainStream << "\n";

  1111.         }

  1112. 

  1113.         const uint32_t midiIns  = getMidiInCount();

  1114.         const uint32_t midiOuts = getMidiOutCount();

  1115. 

  1116.         int portIndex = 0;

  1117. 

  1118.         if (midiIns > 0)

  1119.         {

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

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

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

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

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

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

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

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

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

  1129.             ++portIndex;

  1130. 

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

  1132.             {

  1133.                 const water::String portIndexNum(portIndex++);

  1134.                 const water::String portIndexLabel(portIndex);

  1135. 

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

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

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

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

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

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

  1142.             }

  1143.         }

  1144.         else

  1145.         {

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

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

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

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

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

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

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

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

  1154.             ++portIndex;

  1155.         }

  1156. 

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

  1158.         {

  1159.             const water::String portIndexNum(portIndex++);

  1160.             const water::String portIndexLabel(portIndex);

  1161. 

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

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

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

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

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

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

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

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

  1170.         }

  1171. 

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

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

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

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

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

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

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

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

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

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

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

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

  1184. 

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

  1186.         {

  1187.             const water::String portIndexNum(portIndex++);

  1188.             const water::String portIndexLabel(i+1);

  1189. 

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

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

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

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

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

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

  1196.         }

  1197. 

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

  1199.         {

  1200.             const water::String portIndexNum(portIndex++);

  1201.             const water::String portIndexLabel(i+1);

  1202. 

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

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

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

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

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

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

  1209.         }

  1210. 

  1211.         CarlaStringList uniqueSymbolNames;

  1212. 

  1213.         char strBufName[STR_MAX+1];

  1214.         char strBufSymbol[STR_MAX+1];

  1215.         carla_zeroChars(strBufName, STR_MAX+1);

  1216.         carla_zeroChars(strBufSymbol, STR_MAX+1);

  1217. 

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

  1219.         {

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

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

  1222. 

  1223.             const water::String portIndexNum(portIndex++);

  1224. 

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

  1226. 

  1227.             if (paramData.type == PARAMETER_INPUT)

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

  1229.             else

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

  1231. 

  1232.             if (paramData.hints & PARAMETER_IS_BOOLEAN)

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

  1234. 

  1235.             if (paramData.hints & PARAMETER_IS_INTEGER)

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

  1237. 

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

  1239. 

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

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

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

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

  1244. 

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

  1246.             {

  1247.                 String s(strBufName);

  1248.                 s.toBasic();

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

  1250. 

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

  1252.                 {

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

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

  1255.                     strBufSymbol[0]   = '_';

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

  1257.                 }

  1258.             }

  1259. 

  1260.             if (uniqueSymbolNames.contains(strBufSymbol))

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

  1262. 

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

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

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

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

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

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

  1269. 

  1270.             // TODO midiCC, midiChannel

  1271. 

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

  1273.         }

  1274. 

  1275.         char strBuf[STR_MAX+1];

  1276.         carla_zeroChars(strBuf, STR_MAX+1);

  1277. 

  1278.         if (! getMaker(strBuf))

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

  1280. 

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

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

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

  1284.         mainStream << "\n";

  1285. 

  1286.         const String mainFilename(bundlepath + CARLA_OS_SEP_STR + symbol + ".ttl");

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

  1288. 

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

  1290.         {

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

  1292.             return false;

  1293.         }

  1294.     }

  1295. 

  1296.     const String binaryFilename(bundlepath + CARLA_OS_SEP_STR + symbol + CARLA_LIB_EXT);

  1297. 

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

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

  1300. 

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

  1302. 

  1303.     const String binFolderTarget(bundlepath + CARLA_OS_SEP_STR + "bin");

  1304.     const String resFolderTarget(bundlepath + CARLA_OS_SEP_STR + "res");

  1305. 

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

  1307.     {

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

  1309.         return false;

  1310.     }

  1311. 

  1312. #ifdef CARLA_OS_WIN

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

  1314. 

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

  1316.     const File binFolder1(opts.binaryDir);

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

  1318.     binFolder2.createDirectory();

  1319. 

  1320.     static const char* files[] = {

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

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

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

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

  1325.       "libcarla_utils.dll"

  1326.     };

  1327. 

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

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

  1330. #else

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

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

  1333. #endif

  1334. 

  1335.     return true;

  1336. }

  1337. #endif

  1338. 

  1339. // -------------------------------------------------------------------

  1340. // Set data (internal stuff)

  1341. 

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

  1343. {

  1344.     pData->id = newId;

  1345. }

  1346. 

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

  1348. {

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

  1350. 

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

  1352.         delete[] pData->name;

  1353. 

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

  1355. }

  1356. 

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

  1358. {

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

  1360. 

  1361.     if (yesNo)

  1362.         pData->options |= option;

  1363.     else

  1364.         pData->options &= ~option;

  1365. 

  1366. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1367.     if (sendCallback)

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

  1369.                                 ENGINE_CALLBACK_OPTION_CHANGED,

  1370.                                 pData->id,

  1371.                                 static_cast<int>(option),

  1372.                                 yesNo ? 1 : 0,

  1373.                                 0, 0.0f, nullptr);

  1374. #else

  1375.     // unused

  1376.     return; (void)sendCallback;

  1377. #endif

  1378. }

  1379. 

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

  1381. {

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

  1383.         return;

  1384. 

  1385.     pData->masterMutex.lock();

  1386.     pData->enabled = yesNo;

  1387. 

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

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

  1390. 

  1391.     pData->masterMutex.unlock();

  1392. }

  1393. 

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

  1395. {

  1396.     if (pData->engineBridged) {

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

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

  1399.         // nothing here

  1400.     } else {

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

  1402.     }

  1403. 

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

  1405.         return;

  1406. 

  1407.     {

  1408.         const ScopedSingleProcessLocker spl(this, true);

  1409. 

  1410.         if (active)

  1411.             activate();

  1412.         else

  1413.             deactivate();

  1414.     }

  1415. 

  1416.     pData->active = active;

  1417. 

  1418. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  1420. 

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

  1422.                             ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  1423.                             pData->id,

  1424.                             PARAMETER_ACTIVE,

  1425.                             0, 0,

  1426.                             value,

  1427.                             nullptr);

  1428. #endif

  1429. }

  1430. 

  1431. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  1433. {

  1434.     if (pData->engineBridged) {

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

  1436.     } else {

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

  1438.     }

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

  1440. 

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

  1442. 

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

  1444.         return;

  1445. 

  1446.     pData->postProc.dryWet = fixedValue;

  1447. 

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

  1449.                             ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  1450.                             pData->id,

  1451.                             PARAMETER_DRYWET,

  1452.                             0, 0,

  1453.                             fixedValue,

  1454.                             nullptr);

  1455. }

  1456. 

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

  1458. {

  1459.     if (pData->engineBridged) {

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

  1461.     } else {

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

  1463.     }

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

  1465. 

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

  1467. 

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

  1469.         return;

  1470. 

  1471.     pData->postProc.volume = fixedValue;

  1472. 

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

  1474.                             ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  1475.                             pData->id,

  1476.                             PARAMETER_VOLUME,

  1477.                             0, 0,

  1478.                             fixedValue,

  1479.                             nullptr);

  1480. }

  1481. 

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

  1483. {

  1484.     if (pData->engineBridged) {

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

  1486.     } else {

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

  1488.     }

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

  1490. 

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

  1492. 

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

  1494.         return;

  1495. 

  1496.     pData->postProc.balanceLeft = fixedValue;

  1497. 

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

  1499.                             ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  1500.                             pData->id,

  1501.                             PARAMETER_BALANCE_LEFT,

  1502.                             0, 0,

  1503.                             fixedValue,

  1504.                             nullptr);

  1505. }

  1506. 

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

  1508. {

  1509.     if (pData->engineBridged) {

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

  1511.     } else {

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

  1513.     }

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

  1515. 

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

  1517. 

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

  1519.         return;

  1520. 

  1521.     pData->postProc.balanceRight = fixedValue;

  1522. 

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

  1524.                             ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  1525.                             pData->id,

  1526.                             PARAMETER_BALANCE_RIGHT,

  1527.                             0, 0,

  1528.                             fixedValue,

  1529.                             nullptr);

  1530. }

  1531. 

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

  1533. {

  1534.     if (pData->engineBridged) {

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

  1536.     } else {

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

  1538.     }

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

  1540. 

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

  1542. 

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

  1544.         return;

  1545. 

  1546.     pData->postProc.panning = fixedValue;

  1547. 

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

  1549.                             ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  1550.                             pData->id,

  1551.                             PARAMETER_PANNING,

  1552.                             0, 0,

  1553.                             fixedValue,

  1554.                             nullptr);

  1555. }

  1556. 

  1557. void CarlaPlugin::setForth(const float value, const bool sendOsc, const bool sendCallback) noexcept

  1558. {

  1559.     if (pData->engineBridged) {

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

  1561.     } else {

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

  1563.     }

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

  1565. 

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

  1567. 

  1568.     if (carla_isEqual(pData->postProc.forth, fixedValue))

  1569.         return;

  1570. 

  1571.     pData->postProc.forth = fixedValue;

  1572. 

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

  1574.                             ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  1575.                             pData->id,

  1576.                             PARAMETER_FORTH,

  1577.                             0, 0,

  1578.                             fixedValue,

  1579.                             nullptr);

  1580. }

  1581. 

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

  1583. {

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

  1585. 

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

  1587. 

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

  1589.         return;

  1590. 

  1591.     pData->postProc.dryWet = fixedValue;

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

  1593. }

  1594. 

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

  1596. {

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

  1598. 

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

  1600. 

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

  1602.         return;

  1603. 

  1604.     pData->postProc.volume = fixedValue;

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

  1606. }

  1607. 

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

  1609. {

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

  1611. 

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

  1613. 

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

  1615.         return;

  1616. 

  1617.     pData->postProc.balanceLeft = fixedValue;

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

  1619. }

  1620. 

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

  1622. {

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

  1624. 

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

  1626. 

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

  1628.         return;

  1629. 

  1630.     pData->postProc.balanceRight = fixedValue;

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

  1632. }

  1633. 

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

  1635. {

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

  1637. 

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

  1639. 

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

  1641.         return;

  1642. 

  1643.     pData->postProc.panning = fixedValue;

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

  1645. }

  1646. 

  1647. void CarlaPlugin::setForthRT(const float value, const bool sendCallbackLater) noexcept

  1648. {

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

  1650. 

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

  1652. 

  1653.     if (carla_isEqual(pData->postProc.forth, fixedValue))

  1654.         return;

  1655. 

  1656.     pData->postProc.forth = fixedValue;

  1657.     pData->postponeParameterChangeRtEvent(sendCallbackLater, PARAMETER_FORTH, fixedValue);

  1658. }

  1659. #endif // ! BUILD_BRIDGE_ALTERNATIVE_ARCH

  1660. 

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

  1662. {

  1663.     if (pData->engineBridged) {

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

  1665.     } else {

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

  1667.     }

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

  1669. 

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

  1671.         return;

  1672. 

  1673.     pData->ctrlChannel = channel;

  1674. 

  1675. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  1677. 

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

  1679.                             ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  1680.                             pData->id,

  1681.                             PARAMETER_CTRL_CHANNEL,

  1682.                             0, 0,

  1683.                             channelf, nullptr);

  1684. #endif

  1685. }

  1686. 

  1687. // -------------------------------------------------------------------

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

  1689. 

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

  1691. {

  1692.     if (pData->engineBridged) {

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

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

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

  1696.         // nothing here

  1697.     } else {

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

  1699.     }

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

  1701. 

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

  1703.         uiParameterChange(parameterId, value);

  1704. 

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

  1706.                             ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  1707.                             pData->id,

  1708.                             static_cast<int>(parameterId),

  1709.                             0, 0,

  1710.                             value,

  1711.                             nullptr);

  1712. }

  1713. 

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

  1715. {

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

  1717. }

  1718. 

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

  1720. {

  1721. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  1723. 

  1724.     switch (rindex)

  1725.     {

  1726.     case PARAMETER_ACTIVE:

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

  1728.     case PARAMETER_CTRL_CHANNEL:

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

  1730.     case PARAMETER_DRYWET:

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

  1732.     case PARAMETER_VOLUME:

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

  1734.     case PARAMETER_BALANCE_LEFT:

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

  1736.     case PARAMETER_BALANCE_RIGHT:

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

  1738.     case PARAMETER_PANNING:

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

  1740.     case PARAMETER_FORTH:

  1741.         return setForth(value, sendOsc, sendCallback);

  1742.     }

  1743. #endif

  1744.     CARLA_SAFE_ASSERT_RETURN(rindex >= 0,);

  1745. 

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

  1747.     {

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

  1749.         {

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

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

  1752.             break;

  1753.         }

  1754.     }

  1755. }

  1756. 

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

  1758. {

  1759.     if (pData->engineBridged) {

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

  1761.     } else {

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

  1763.     }

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

  1765.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  1766. 

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

  1768.         return;

  1769. 

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

  1771. 

  1772. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  1774.                             ENGINE_CALLBACK_PARAMETER_MIDI_CHANNEL_CHANGED,

  1775.                             pData->id,

  1776.                             static_cast<int>(parameterId),

  1777.                             channel,

  1778.                             0, 0.0f, nullptr);

  1779. #endif

  1780. }

  1781. 

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

  1783.                                                  const bool sendOsc, const bool sendCallback,

  1784.                                                  const bool reconfigureNow) noexcept

  1785. {

  1786.     if (pData->engineBridged) {

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

  1788.     } else {

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

  1790.     }

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

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

  1793. 

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

  1795. 

  1796.     if (paramData.mappedControlIndex == index)

  1797.         return;

  1798. 

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

  1800. 

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

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

  1803. 

  1804. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1805.     char strBuf[STR_MAX+1];

  1806.     carla_zeroChars(strBuf, STR_MAX+1);

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

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

  1809. 

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

  1811.     if (portNameSize < STR_MAX)

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

  1813. 

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

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

  1816.     {

  1817.         const int32_t oldParameterId = pData->midiLearnParameterIndex;

  1818.         pData->midiLearnParameterIndex = -1;

  1819. 

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

  1821. 

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

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

  1824.                                 ENGINE_CALLBACK_PARAMETER_MAPPED_CONTROL_INDEX_CHANGED,

  1825.                                 pData->id,

  1826.                                 oldParameterId,

  1827.                                 CONTROL_INDEX_NONE,

  1828.                                 0, 0.0f, nullptr);

  1829.     }

  1830. 

  1831.     // mapping new parameter to CV

  1832.     if (index == CONTROL_INDEX_CV)

  1833.     {

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

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

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

  1837. 

  1838.         CarlaEngineCVPort* const cvPort =

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

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

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

  1842.     }

  1843.     // unmapping from CV

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

  1845.     {

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

  1847. 

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

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

  1850.     }

  1851.     // mapping to something new

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

  1853.     {

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

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

  1856.             setParameterMappedRange(parameterId,

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

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

  1859.                                     true, true);

  1860.     }

  1861. #endif

  1862. 

  1863.     paramData.mappedControlIndex = index;

  1864. 

  1865. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1866.     if (index == CONTROL_INDEX_MIDI_LEARN)

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

  1868.     else

  1869.         pData->midiLearnParameterIndex = -1;

  1870. 

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

  1872.                             ENGINE_CALLBACK_PARAMETER_MAPPED_CONTROL_INDEX_CHANGED,

  1873.                             pData->id,

  1874.                             static_cast<int>(parameterId),

  1875.                             index,

  1876.                             0, 0.0f, nullptr);

  1877. #else

  1878.     return;

  1879.     // unused

  1880.     (void)reconfigureNow;

  1881. #endif

  1882. }

  1883. 

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

  1885.                                           const bool sendOsc, const bool sendCallback) noexcept

  1886. {

  1887.     if (pData->engineBridged) {

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

  1889.     } else {

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

  1891.     }

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

  1893. 

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

  1895. 

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

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

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

  1899.         return;

  1900. 

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

  1902.     {

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

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

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

  1906.     }

  1907. 

  1908.     paramData.hints |= PARAMETER_MAPPED_RANGES_SET;

  1909.     paramData.mappedMinimum = minimum;

  1910.     paramData.mappedMaximum = maximum;

  1911. 

  1912. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

  1915. 

  1916.     char strBuf[STR_MAX+1];

  1917.     carla_zeroChars(strBuf, STR_MAX+1);

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

  1919. 

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

  1921.                             ENGINE_CALLBACK_PARAMETER_MAPPED_RANGE_CHANGED,

  1922.                             pData->id,

  1923.                             static_cast<int>(parameterId),

  1924.                             0, 0, 0.0f,

  1925.                             strBuf);

  1926. #endif

  1927. }

  1928. 

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

  1930. {

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

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

  1933.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

  1934. 

  1935.     // Ignore some keys

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

  1937.     {

  1938.         const PluginType ptype = getType();

  1939. 

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

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

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

  1943.             return;

  1944.     }

  1945. 

  1946.     // Check if we already have this key

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

  1948.     {

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

  1950.         CARLA_SAFE_ASSERT_CONTINUE(customData.isValid());

  1951. 

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

  1953.         {

  1954.             if (customData.value != nullptr)

  1955.                 delete[] customData.value;

  1956. 

  1957.             customData.value = carla_strdup(value);

  1958.             return;

  1959.         }

  1960.     }

  1961. 

  1962.     // Otherwise store it

  1963.     CustomData customData;

  1964.     customData.type  = carla_strdup(type);

  1965.     customData.key   = carla_strdup(key);

  1966.     customData.value = carla_strdup(value);

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

  1968. }

  1969. 

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

  1971. {

  1972.     CARLA_SAFE_ASSERT_RETURN(data != nullptr,);

  1973.     CARLA_SAFE_ASSERT_RETURN(dataSize > 0,);

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

  1975. }

  1976. 

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

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

  1979. {

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

  1981. 

  1982.     pData->prog.current = index;

  1983. 

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

  1985.                             ENGINE_CALLBACK_PROGRAM_CHANGED,

  1986.                             pData->id,

  1987.                             index,

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

  1989. 

  1990.     // Change default parameter values

  1991.     if (index >= 0)

  1992.     {

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

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

  1995. 

  1996.         switch (getType())

  1997.         {

  1998.         case PLUGIN_SF2:

  1999.         case PLUGIN_SFZ:

  2000.             break;

  2001. 

  2002.         default:

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

  2004.             break;

  2005.         }

  2006.     }

  2007. }

  2008. 

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

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

  2011. {

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

  2013. 

  2014.     pData->midiprog.current = index;

  2015. 

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

  2017.                             ENGINE_CALLBACK_MIDI_PROGRAM_CHANGED,

  2018.                             pData->id,

  2019.                             index,

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

  2021. 

  2022.     // Change default parameter values

  2023.     if (index >= 0)

  2024.     {

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

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

  2027. 

  2028.         switch (getType())

  2029.         {

  2030.         case PLUGIN_SF2:

  2031.         case PLUGIN_SFZ:

  2032.             break;

  2033. 

  2034.         default:

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

  2036.             break;

  2037.         }

  2038.     }

  2039. }

  2040. 

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

  2042. {

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

  2044.     {

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

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

  2047.     }

  2048. }

  2049. 

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

  2051. {

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

  2053. 

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

  2055.     pData->prog.current = index;

  2056. 

  2057.     // Change default parameter values

  2058.     switch (getType())

  2059.     {

  2060.     case PLUGIN_SF2:

  2061.     case PLUGIN_SFZ:

  2062.         break;

  2063. 

  2064.     default:

  2065.         pData->updateDefaultParameterValues(this);

  2066.         break;

  2067.     }

  2068. 

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

  2070. }

  2071. 

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

  2073. {

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

  2075. 

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

  2077.     pData->midiprog.current = index;

  2078. 

  2079.     // Change default parameter values

  2080.     switch (getType())

  2081.     {

  2082.     case PLUGIN_SF2:

  2083.     case PLUGIN_SFZ:

  2084.         break;

  2085. 

  2086.     default:

  2087.         pData->updateDefaultParameterValues(this);

  2088.         break;

  2089.     }

  2090. 

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

  2092. }

  2093. 

  2094. // -------------------------------------------------------------------

  2095. // Plugin state

  2096. 

  2097. void CarlaPlugin::reloadPrograms(const bool)

  2098. {

  2099. }

  2100. 

  2101. // -------------------------------------------------------------------

  2102. // Plugin processing

  2103. 

  2104. void CarlaPlugin::activate() noexcept

  2105. {

  2106.     CARLA_SAFE_ASSERT(! pData->active);

  2107. }

  2108. 

  2109. void CarlaPlugin::deactivate() noexcept

  2110. {

  2111.     CARLA_SAFE_ASSERT(pData->active);

  2112. }

  2113. 

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

  2115. {

  2116.    #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

  2119.    #else

  2120.     // unused

  2121.     (void)newBufferSize;

  2122.    #endif

  2123. }

  2124. 

  2125. void CarlaPlugin::sampleRateChanged(const double)

  2126. {

  2127. }

  2128. 

  2129. void CarlaPlugin::offlineModeChanged(const bool)

  2130. {

  2131. }

  2132. 

  2133. // -------------------------------------------------------------------

  2134. // Misc

  2135. 

  2136. void CarlaPlugin::idle()

  2137. {

  2138.     if (! pData->enabled)

  2139.         return;

  2140. 

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

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

  2143.     const uint32_t latency = getLatencyInFrames();

  2144. 

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

  2146.     {

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

  2148. 

  2149.         const ScopedSingleProcessLocker sspl(this, true);

  2150. 

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

  2152. #ifndef BUILD_BRIDGE

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

  2154. #else

  2155.         pData->latency.frames = latency;

  2156. #endif

  2157.     }

  2158. 

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

  2160. 

  2161.     if (rtEvents.isEmpty())

  2162.         return;

  2163. 

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

  2165.     {

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

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

  2168. 

  2169.         switch (event.type)

  2170.         {

  2171.         case kPluginPostRtEventNull: {

  2172.         } break;

  2173. 

  2174.         case kPluginPostRtEventParameterChange: {

  2175.             // Update UI

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

  2177.             {

  2178.                 if (needsUiMainThread)

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

  2180.                 else

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

  2182.             }

  2183. 

  2184.             if (event.sendCallback)

  2185.             {

  2186.                 // Update Host

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

  2188.                                         ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  2189.                                         pData->id,

  2190.                                         event.parameter.index,

  2191.                                         0, 0,

  2192.                                         event.parameter.value,

  2193.                                         nullptr);

  2194.             }

  2195.         } break;

  2196. 

  2197.         case kPluginPostRtEventProgramChange: {

  2198.             // Update UI

  2199.             if (hasUI)

  2200.             {

  2201.                 if (needsUiMainThread)

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

  2203.                 else

  2204.                     uiProgramChange(event.program.index);

  2205.             }

  2206. 

  2207.             // Update param values

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

  2209.             {

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

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

  2212. 

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

  2214.                                         ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  2215.                                         pData->id,

  2216.                                         static_cast<int>(j),

  2217.                                         0, 0,

  2218.                                         paramValue,

  2219.                                         nullptr);

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

  2221.                                         ENGINE_CALLBACK_PARAMETER_DEFAULT_CHANGED,

  2222.                                         pData->id,

  2223.                                         static_cast<int>(j),

  2224.                                         0, 0,

  2225.                                         paramDefault,

  2226.                                         nullptr);

  2227.             }

  2228. 

  2229.             if (event.sendCallback)

  2230.             {

  2231.                 // Update Host

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

  2233.                                         ENGINE_CALLBACK_PROGRAM_CHANGED,

  2234.                                         pData->id,

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

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

  2237.             }

  2238.         } break;

  2239. 

  2240.         case kPluginPostRtEventMidiProgramChange: {

  2241.             // Update UI

  2242.             if (hasUI)

  2243.             {

  2244.                 if (needsUiMainThread)

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

  2246.                 else

  2247.                     uiMidiProgramChange(event.program.index);

  2248.             }

  2249. 

  2250.             // Update param values

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

  2252.             {

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

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

  2255. 

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

  2257.                                         ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  2258.                                         pData->id,

  2259.                                         static_cast<int>(j),

  2260.                                         0, 0,

  2261.                                         paramValue,

  2262.                                         nullptr);

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

  2264.                                         ENGINE_CALLBACK_PARAMETER_DEFAULT_CHANGED,

  2265.                                         pData->id,

  2266.                                         static_cast<int>(j),

  2267.                                         0, 0,

  2268.                                         paramDefault,

  2269.                                         nullptr);

  2270.             }

  2271. 

  2272.             if (event.sendCallback)

  2273.             {

  2274.                 // Update Host

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

  2276.                                         ENGINE_CALLBACK_MIDI_PROGRAM_CHANGED,

  2277.                                         pData->id,

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

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

  2280.             }

  2281.         } break;

  2282. 

  2283.         case kPluginPostRtEventNoteOn: {

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

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

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

  2287. 

  2288.             // Update UI

  2289.             if (hasUI)

  2290.             {

  2291.                 if (needsUiMainThread)

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

  2293.                 else

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

  2295.             }

  2296. 

  2297.             if (event.sendCallback)

  2298.             {

  2299.                 // Update Host

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

  2301.                                         ENGINE_CALLBACK_NOTE_ON,

  2302.                                         pData->id,

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

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

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

  2306.                                         0.0f, nullptr);

  2307.             }

  2308.         } break;

  2309. 

  2310.         case kPluginPostRtEventNoteOff: {

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

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

  2313. 

  2314.             // Update UI

  2315.             if (hasUI)

  2316.             {

  2317.                 if (needsUiMainThread)

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

  2319.                 else

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

  2321.             }

  2322. 

  2323.             if (event.sendCallback)

  2324.             {

  2325.                 // Update Host

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

  2327.                                         ENGINE_CALLBACK_NOTE_OFF,

  2328.                                         pData->id,

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

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

  2331.                                         0, 0.0f, nullptr);

  2332.             }

  2333.         } break;

  2334. 

  2335.         case kPluginPostRtEventMidiLearn: {

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

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

  2338. 

  2339. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2340.             if (event.sendCallback)

  2341.             {

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

  2343.                                         ENGINE_CALLBACK_PARAMETER_MAPPED_CONTROL_INDEX_CHANGED,

  2344.                                         pData->id,

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

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

  2347.                                         0, 0.0f, nullptr);

  2348. 

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

  2350.                                         ENGINE_CALLBACK_PARAMETER_MIDI_CHANNEL_CHANGED,

  2351.                                         pData->id,

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

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

  2354.                                         0, 0.0f, nullptr);

  2355.             }

  2356. #endif

  2357.         } break;

  2358.         }

  2359.     }

  2360. }

  2361. 

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

  2363. {

  2364.     if (forcedOffline)

  2365.     {

  2366. #ifndef STOAT_TEST_BUILD

  2367.         pData->masterMutex.lock();

  2368.         return true;

  2369. #endif

  2370.     }

  2371. 

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

  2373. }

  2374. 

  2375. void CarlaPlugin::unlock() noexcept

  2376. {

  2377.     pData->masterMutex.unlock();

  2378. }

  2379. 

  2380. // -------------------------------------------------------------------

  2381. // Plugin buffers

  2382. 

  2383. void CarlaPlugin::initBuffers() const noexcept

  2384. {

  2385.     pData->audioIn.initBuffers();

  2386.     pData->audioOut.initBuffers();

  2387.     pData->cvIn.initBuffers();

  2388.     pData->cvOut.initBuffers();

  2389.     pData->event.initBuffers();

  2390. }

  2391. 

  2392. void CarlaPlugin::clearBuffers() noexcept

  2393. {

  2394.     pData->clearBuffers();

  2395. }

  2396. 

  2397. // -------------------------------------------------------------------

  2398. // OSC stuff

  2399. 

  2400. // FIXME

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

  2402. {

  2403.     // do nothing

  2404. }

  2405. 

  2406. // -------------------------------------------------------------------

  2407. // MIDI events

  2408. 

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

  2410. {

  2411.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2412.     CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

  2413.     CARLA_SAFE_ASSERT_RETURN(velo < MAX_MIDI_VALUE,);

  2414. 

  2415.     if (! pData->active)

  2416.         return;

  2417. 

  2418.     ExternalMidiNote extNote;

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

  2420.     extNote.note    = note;

  2421.     extNote.velo    = velo;

  2422. 

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

  2424. 

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

  2426.     {

  2427.         if (velo > 0)

  2428.             uiNoteOn(channel, note, velo);

  2429.         else

  2430.             uiNoteOff(channel, note);

  2431.     }

  2432. 

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

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

  2435.                             pData->id,

  2436.                             channel,

  2437.                             note,

  2438.                             velo,

  2439.                             0.0f, nullptr);

  2440. }

  2441. 

  2442. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2443. void CarlaPlugin::postponeRtAllNotesOff()

  2444. {

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

  2446.         return;

  2447. 

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

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

  2450. 

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

  2452.     {

  2453.         postEvent.note.note = i;

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

  2455.     }

  2456. }

  2457. #endif

  2458. 

  2459. // -------------------------------------------------------------------

  2460. // UI Stuff

  2461. 

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

  2463. {

  2464.     pData->uiTitle = title;

  2465. }

  2466. 

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

  2468. {

  2469.     if (yesNo) {

  2470.         CARLA_SAFE_ASSERT(false);

  2471.     }

  2472. }

  2473. 

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

  2475. {

  2476.     return nullptr;

  2477. }

  2478. 

  2479. void CarlaPlugin::uiIdle()

  2480. {

  2481.     if (pData->hints & PLUGIN_NEEDS_UI_MAIN_THREAD)

  2482.     {

  2483.         // Update parameter outputs

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

  2485.         {

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

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

  2488.         }

  2489. 

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

  2491. 

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

  2493.         {

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

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

  2496. 

  2497.             switch (event.type)

  2498.             {

  2499.             case kPluginPostRtEventNull:

  2500.             case kPluginPostRtEventMidiLearn:

  2501.                 break;

  2502. 

  2503.             case kPluginPostRtEventParameterChange:

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

  2505.                 break;

  2506. 

  2507.             case kPluginPostRtEventProgramChange:

  2508.                 uiProgramChange(event.program.index);

  2509.                 break;

  2510. 

  2511.             case kPluginPostRtEventMidiProgramChange:

  2512.                 uiMidiProgramChange(event.program.index);

  2513.                 break;

  2514. 

  2515.             case kPluginPostRtEventNoteOn:

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

  2517.                 break;

  2518. 

  2519.             case kPluginPostRtEventNoteOff:

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

  2521.                 break;

  2522.             }

  2523.         }

  2524. 

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

  2526.     }

  2527. 

  2528. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  2530.         return;

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

  2532.         return;

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

  2534.         return;

  2535. 

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

  2537. 

  2538.     String uiTitle;

  2539. 

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

  2541.     {

  2542.         uiTitle = pData->uiTitle;

  2543.     }

  2544.     else

  2545.     {

  2546.         uiTitle  = pData->name;

  2547.         uiTitle += " (GUI)";

  2548.     }

  2549. 

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

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

  2552.     {

  2553.         pData->transientTryCounter = 0;

  2554.         pData->transientFirstTry = false;

  2555.     }

  2556. #endif

  2557. }

  2558. 

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

  2560. {

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

  2562.     return;

  2563. 

  2564.     // unused

  2565.     (void)value;

  2566. }

  2567. 

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

  2569. {

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

  2571. }

  2572. 

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

  2574. {

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

  2576. }

  2577. 

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

  2579. {

  2580.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2581.     CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

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

  2583. }

  2584. 

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

  2586. {

  2587.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2588.     CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

  2589. }

  2590. 

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

  2592. {

  2593.     return pData->engine;

  2594. }

  2595. 

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

  2597. {

  2598.     return pData->client;

  2599. }

  2600. 

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

  2602. {

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

  2604. }

  2605. 

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

  2607. {

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

  2609. }

  2610. 

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

  2612. {

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

  2614. }

  2615. 

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

  2617. {

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

  2619. }

  2620. 

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

  2622. {

  2623.     return pData->event.portIn;

  2624. }

  2625. 

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

  2627. {

  2628.     return pData->event.portOut;

  2629. }

  2630. 

  2631. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  2633. {

  2634.     if (pData->midiLearnParameterIndex < 0)

  2635.         return;

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

  2637.         return;

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

  2639.         return;

  2640. 

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

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

  2643. 

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

  2645.     CARLA_SAFE_ASSERT_INT_RETURN(paramData.mappedControlIndex == CONTROL_INDEX_MIDI_LEARN,

  2646.                                  paramData.mappedControlIndex,);

  2647. 

  2648.     event.ctrl.handled = true;

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

  2650.     paramData.midiChannel = event.channel;

  2651. 

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

  2653.     pData->midiLearnParameterIndex = -1;

  2654. }

  2655. #endif

  2656. 

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

  2658. {

  2659.     return nullptr;

  2660. }

  2661. 

  2662. const void* CarlaPlugin::getNativeDescriptor() const noexcept

  2663. {

  2664.     return nullptr;

  2665. }

  2666. 

  2667. uintptr_t CarlaPlugin::getUiBridgeProcessId() const noexcept

  2668. {

  2669.     return 0;

  2670. }

  2671. 

  2672. // -------------------------------------------------------------------

  2673. 

  2674. uint32_t CarlaPlugin::getPatchbayNodeId() const noexcept

  2675. {

  2676.     return pData->nodeId;

  2677. }

  2678. 

  2679. void CarlaPlugin::setPatchbayNodeId(const uint32_t nodeId) noexcept

  2680. {

  2681.     pData->nodeId = nodeId;

  2682. }

  2683. 

  2684. // -------------------------------------------------------------------

  2685. 

  2686. void CarlaPlugin::cloneLV2Files(const CarlaPlugin&)

  2687. {

  2688.     carla_stderr2("Warning: cloneLV2Files() called for non-implemented type");

  2689. }

  2690. 

  2691. void CarlaPlugin::restoreLV2State(const bool temporary) noexcept

  2692. {

  2693.     carla_stderr2("Warning: restoreLV2State(%s) called for non-implemented type", bool2str(temporary));

  2694. }

  2695. 

  2696. void CarlaPlugin::prepareForDeletion() noexcept

  2697. {

  2698.     carla_debug("CarlaPlugin::prepareForDeletion");

  2699. 

  2700.     const CarlaMutexLocker cml(pData->masterMutex);

  2701. 

  2702.     pData->client->deactivate(true);

  2703. }

  2704. 

  2705. void CarlaPlugin::waitForBridgeSaveSignal() noexcept

  2706. {

  2707. }

  2708. 

  2709. // -------------------------------------------------------------------

  2710. // Scoped Disabler

  2711. 

  2712. CarlaPlugin::ScopedDisabler::ScopedDisabler(CarlaPlugin* const plugin) noexcept

  2713.     : fPlugin(plugin),

  2714.       fWasEnabled(false)

  2715. {

  2716.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2717.     CARLA_SAFE_ASSERT_RETURN(plugin->pData != nullptr,);

  2718.     CARLA_SAFE_ASSERT_RETURN(plugin->pData->client != nullptr,);

  2719.     carla_debug("CarlaPlugin::ScopedDisabler(%p)", plugin);

  2720. 

  2721.     plugin->pData->masterMutex.lock();

  2722. 

  2723.     if (plugin->pData->enabled)

  2724.     {

  2725.         fWasEnabled = true;

  2726.         plugin->pData->enabled = false;

  2727. 

  2728.         if (plugin->pData->client->isActive())

  2729.             plugin->pData->client->deactivate(false);

  2730.     }

  2731. }

  2732. 

  2733. CarlaPlugin::ScopedDisabler::~ScopedDisabler() noexcept

  2734. {

  2735.     CARLA_SAFE_ASSERT_RETURN(fPlugin != nullptr,);

  2736.     CARLA_SAFE_ASSERT_RETURN(fPlugin->pData != nullptr,);

  2737.     CARLA_SAFE_ASSERT_RETURN(fPlugin->pData->client != nullptr,);

  2738.     carla_debug("CarlaPlugin::~ScopedDisabler()");

  2739. 

  2740.     if (fWasEnabled)

  2741.     {

  2742.         fPlugin->pData->enabled = true;

  2743.         fPlugin->pData->client->activate();

  2744.     }

  2745. 

  2746.     fPlugin->pData->masterMutex.unlock();

  2747. }

  2748. 

  2749. // -------------------------------------------------------------------

  2750. // Scoped Process Locker

  2751. 

  2752. CarlaPlugin::ScopedSingleProcessLocker::ScopedSingleProcessLocker(CarlaPlugin* const plugin, const bool block) noexcept

  2753.     : fPlugin(plugin),

  2754.       fBlock(block)

  2755. {

  2756.     CARLA_SAFE_ASSERT_RETURN(fPlugin != nullptr,);

  2757.     CARLA_SAFE_ASSERT_RETURN(fPlugin->pData != nullptr,);

  2758.     carla_debug("CarlaPlugin::ScopedSingleProcessLocker(%p, %s)", plugin, bool2str(block));

  2759. 

  2760.     if (! fBlock)

  2761.         return;

  2762. 

  2763.     plugin->pData->singleMutex.lock();

  2764. }

  2765. 

  2766. CarlaPlugin::ScopedSingleProcessLocker::~ScopedSingleProcessLocker() noexcept

  2767. {

  2768.     CARLA_SAFE_ASSERT_RETURN(fPlugin != nullptr,);

  2769.     CARLA_SAFE_ASSERT_RETURN(fPlugin->pData != nullptr,);

  2770.     carla_debug("CarlaPlugin::~ScopedSingleProcessLocker()");

  2771. 

  2772.     if (! fBlock)

  2773.         return;

  2774. 

  2775. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2776.     if (fPlugin->pData->singleMutex.wasTryLockCalled())

  2777.         fPlugin->pData->needsReset = true;

  2778. #endif

  2779. 

  2780.     fPlugin->pData->singleMutex.unlock();

  2781. }

  2782. 

  2783. // -------------------------------------------------------------------

  2784. 

  2785. CARLA_BACKEND_END_NAMESPACE