falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
5762 Commits
16 Branches
215MB
Tree: 838a00566f
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '838a00566f'
${ noResults }
Carla/source/backend/plugin/CarlaPlugin.cpp

2756 lines
91KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin

  3.  * Copyright (C) 2011-2020 Filipe Coelho <falktx@falktx.com>

  4.  *

  5.  * This program is free software; you can redistribute it and/or

  6.  * modify it under the terms of the GNU General Public License as

  7.  * published by the Free Software Foundation; either version 2 of

  8.  * the License, or any later version.

  9.  *

  10.  * This program is distributed in the hope that it will be useful,

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

  13.  * GNU General Public License for more details.

  14.  *

  15.  * For a full copy of the GNU General Public License see the doc/GPL.txt file.

  16.  */

  17. 

  18. #include "CarlaPluginInternal.hpp"

  19. #include "CarlaEngine.hpp"

  20. 

  21. #include "CarlaBackendUtils.hpp"

  22. #include "CarlaBase64Utils.hpp"

  23. #include "CarlaMathUtils.hpp"

  24. #include "CarlaMIDI.h"

  25. #include "CarlaPluginUI.hpp"

  26. #include "CarlaScopeUtils.hpp"

  27. #include "CarlaStringList.hpp"

  28. 

  29. #include <ctime>

  30. 

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

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

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

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

  35. 

  36. using water::CharPointer_UTF8;

  37. using water::File;

  38. using water::MemoryOutputStream;

  39. using water::Result;

  40. using water::String;

  41. using water::XmlDocument;

  42. using water::XmlElement;

  43. 

  44. CARLA_BACKEND_START_NAMESPACE

  45. 

  46. // -------------------------------------------------------------------------------------------------------------------

  47. // Fallback data

  48. 

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

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

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

  52. 

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

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

  55. static const PluginPostRtEvent kPluginPostRtEventFallback = { kPluginPostRtEventNull, false, 0, 0, 0, 0.0f };

  56. 

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

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

  59. 

  60. struct ParamSymbol {

  61.     int32_t index;

  62.     const char* symbol;

  63. 

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

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

  66.           symbol(carla_strdup(s)) {}

  67. 

  68.     ~ParamSymbol() noexcept

  69.     {

  70.         CARLA_SAFE_ASSERT_RETURN(symbol != nullptr,)

  71. 

  72.         delete[] symbol;

  73.         symbol = nullptr;

  74.     }

  75. 

  76. #ifdef CARLA_PROPER_CPP11_SUPPORT

  77.     ParamSymbol() = delete;

  78.     CARLA_DECLARE_NON_COPY_STRUCT(ParamSymbol)

  79. #endif

  80. };

  81. 

  82. // -------------------------------------------------------------------------------------------------------------------

  83. // Constructor and destructor

  84. 

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

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

  87. {

  88.     CARLA_SAFE_ASSERT_RETURN(engine != nullptr,);

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

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

  91. 

  92.     switch (engine->getProccessMode())

  93.     {

  94.     case ENGINE_PROCESS_MODE_SINGLE_CLIENT:

  95.     case ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS:

  96.         CARLA_SAFE_ASSERT(id < MAX_DEFAULT_PLUGINS);

  97.         break;

  98. 

  99.     case ENGINE_PROCESS_MODE_CONTINUOUS_RACK:

  100.         CARLA_SAFE_ASSERT(id < MAX_RACK_PLUGINS);

  101.         break;

  102. 

  103.     case ENGINE_PROCESS_MODE_PATCHBAY:

  104.         CARLA_SAFE_ASSERT(id < MAX_PATCHBAY_PLUGINS);

  105.         break;

  106. 

  107.     case ENGINE_PROCESS_MODE_BRIDGE:

  108.         CARLA_SAFE_ASSERT(id == 0);

  109.         break;

  110.     }

  111. }

  112. 

  113. CarlaPlugin::~CarlaPlugin()

  114. {

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

  116. 

  117.     delete pData;

  118. }

  119. 

  120. // -------------------------------------------------------------------

  121. // Information (base)

  122. 

  123. uint CarlaPlugin::getId() const noexcept

  124. {

  125.     return pData->id;

  126. }

  127. 

  128. uint CarlaPlugin::getHints() const noexcept

  129. {

  130.     return pData->hints;

  131. }

  132. 

  133. uint CarlaPlugin::getOptionsEnabled() const noexcept

  134. {

  135.     return pData->options;

  136. }

  137. 

  138. bool CarlaPlugin::isEnabled() const noexcept

  139. {

  140.     return pData->enabled;

  141. }

  142. 

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

  144. {

  145.     return pData->name;

  146. }

  147. 

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

  149. {

  150.     return pData->filename;

  151. }

  152. 

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

  154. {

  155.     return pData->iconName;

  156. }

  157. 

  158. PluginCategory CarlaPlugin::getCategory() const noexcept

  159. {

  160.     return getPluginCategoryFromName(pData->name);

  161. }

  162. 

  163. int64_t CarlaPlugin::getUniqueId() const noexcept

  164. {

  165.     return 0;

  166. }

  167. 

  168. uint32_t CarlaPlugin::getLatencyInFrames() const noexcept

  169. {

  170.     return 0;

  171. }

  172. 

  173. // -------------------------------------------------------------------

  174. // Information (count)

  175. 

  176. uint32_t CarlaPlugin::getAudioInCount() const noexcept

  177. {

  178.     return pData->audioIn.count;

  179. }

  180. 

  181. uint32_t CarlaPlugin::getAudioOutCount() const noexcept

  182. {

  183.     return pData->audioOut.count;

  184. }

  185. 

  186. uint32_t CarlaPlugin::getCVInCount() const noexcept

  187. {

  188.     return pData->cvIn.count;

  189. }

  190. 

  191. uint32_t CarlaPlugin::getCVOutCount() const noexcept

  192. {

  193.     return pData->cvOut.count;

  194. }

  195. 

  196. uint32_t CarlaPlugin::getMidiInCount() const noexcept

  197. {

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

  199. }

  200. 

  201. uint32_t CarlaPlugin::getMidiOutCount() const noexcept

  202. {

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

  204. }

  205. 

  206. uint32_t CarlaPlugin::getParameterCount() const noexcept

  207. {

  208.     return pData->param.count;

  209. }

  210. 

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

  212. {

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

  214.     return 0;

  215. }

  216. 

  217. uint32_t CarlaPlugin::getProgramCount() const noexcept

  218. {

  219.     return pData->prog.count;

  220. }

  221. 

  222. uint32_t CarlaPlugin::getMidiProgramCount() const noexcept

  223. {

  224.     return pData->midiprog.count;

  225. }

  226. 

  227. uint32_t CarlaPlugin::getCustomDataCount() const noexcept

  228. {

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

  230. }

  231. 

  232. // -------------------------------------------------------------------

  233. // Information (current data)

  234. 

  235. int32_t CarlaPlugin::getCurrentProgram() const noexcept

  236. {

  237.     return pData->prog.current;

  238. }

  239. 

  240. int32_t CarlaPlugin::getCurrentMidiProgram() const noexcept

  241. {

  242.     return pData->midiprog.current;

  243. }

  244. 

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

  246. {

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

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

  249. }

  250. 

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

  252. {

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

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

  255. }

  256. 

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

  258. {

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

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

  261. }

  262. 

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

  264. {

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

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

  267. }

  268. 

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

  270. {

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

  272. }

  273. 

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

  275. {

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

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

  278.     return 0;

  279. }

  280. 

  281. // -------------------------------------------------------------------

  282. // Information (per-plugin data)

  283. 

  284. uint CarlaPlugin::getOptionsAvailable() const noexcept

  285. {

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

  287.     return 0x0;

  288. }

  289. 

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

  291. {

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

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

  294.     return 0.0f;

  295. }

  296. 

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

  298. {

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

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

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

  302.     return 0.0f;

  303. }

  304. 

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

  306. {

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

  308.     return false;

  309. }

  310. 

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

  312. {

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

  314.     return false;

  315. }

  316. 

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

  318. {

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

  320.     return false;

  321. }

  322. 

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

  324. {

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

  326.     return false;

  327. }

  328. 

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

  330. {

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

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

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

  334.     return false;

  335. }

  336. 

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

  338. {

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

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

  341.     return false;

  342. }

  343. 

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

  345. {

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

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

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

  349.     return false;

  350. }

  351. 

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

  353. {

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

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

  356.     return false;

  357. }

  358. 

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

  360. {

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

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

  363.     return false;

  364. }

  365. 

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

  367. {

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

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

  370.     return false;

  371. }

  372. 

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

  374. {

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

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

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

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

  379.     return false;

  380. }

  381. 

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

  383. {

  384. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  386. 

  387.     switch (parameterId)

  388.     {

  389.     case PARAMETER_ACTIVE:

  390.         return pData->active;

  391.     case PARAMETER_CTRL_CHANNEL:

  392.         return pData->ctrlChannel;

  393.     case PARAMETER_DRYWET:

  394.         return pData->postProc.dryWet;

  395.     case PARAMETER_VOLUME:

  396.         return pData->postProc.volume;

  397.     case PARAMETER_BALANCE_LEFT:

  398.         return pData->postProc.balanceLeft;

  399.     case PARAMETER_BALANCE_RIGHT:

  400.         return pData->postProc.balanceRight;

  401.     case PARAMETER_PANNING:

  402.         return pData->postProc.panning;

  403.     };

  404. #endif

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

  406. 

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

  408. }

  409. 

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

  411. {

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

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

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

  415.     return true;

  416. }

  417. 

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

  419. {

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

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

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

  423.     return true;

  424. }

  425. 

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

  427. {

  428.     ins  = 0;

  429.     outs = 0;

  430. 

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

  432.     {

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

  434.             ++ins;

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

  436.             ++outs;

  437.     }

  438. }

  439. 

  440. // -------------------------------------------------------------------

  441. // Set data (state)

  442. 

  443. void CarlaPlugin::prepareForSave(bool)

  444. {

  445. }

  446. 

  447. void CarlaPlugin::resetParameters() noexcept

  448. {

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

  450.     {

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

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

  453. 

  454.         if (paramData.type != PARAMETER_INPUT)

  455.             continue;

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

  457.             continue;

  458. 

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

  460.     }

  461. }

  462. 

  463. void CarlaPlugin::randomizeParameters() noexcept

  464. {

  465.     float value, random;

  466. 

  467.     char strBuf[STR_MAX+1];

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

  469. 

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

  471. 

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

  473.     {

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

  475. 

  476.         if (paramData.type != PARAMETER_INPUT)

  477.             continue;

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

  479.             continue;

  480. 

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

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

  483. 

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

  485.             continue;

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

  487.             continue;

  488. 

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

  490. 

  491.         if (paramData.hints & PARAMETER_IS_BOOLEAN)

  492.         {

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

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

  495.         }

  496.         else

  497.         {

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

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

  500. 

  501.             if (paramData.hints & PARAMETER_IS_INTEGER)

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

  503.         }

  504. 

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

  506.     }

  507. }

  508. 

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

  510. {

  511.     pData->stateSave.clear();

  512. 

  513.     if (callPrepareForSave)

  514.     {

  515.         pData->stateSave.temporary = true;

  516.         prepareForSave(true);

  517.     }

  518. 

  519.     const PluginType pluginType(getType());

  520. 

  521.     char strBuf[STR_MAX+1];

  522.     carla_zeroChars(strBuf, STR_MAX+1);

  523. 

  524.     // ---------------------------------------------------------------

  525.     // Basic info

  526. 

  527.     if (! getLabel(strBuf))

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

  529. 

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

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

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

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

  534. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  536. #endif

  537. 

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

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

  540. 

  541. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  542.     // ---------------------------------------------------------------

  543.     // Internals

  544. 

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

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

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

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

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

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

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

  552. #endif

  553. 

  554.     if (pData->hints & PLUGIN_IS_BRIDGE)

  555.         waitForBridgeSaveSignal();

  556. 

  557.     // ---------------------------------------------------------------

  558.     // Chunk

  559. 

  560.     bool usingChunk = false;

  561. 

  562.     if (pData->options & PLUGIN_OPTION_USE_CHUNKS)

  563.     {

  564.         void* data = nullptr;

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

  566. 

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

  568.         {

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

  570. 

  571.             if (pluginType != PLUGIN_INTERNAL)

  572.                 usingChunk = true;

  573.         }

  574.     }

  575. 

  576.     // ---------------------------------------------------------------

  577.     // Current Program

  578. 

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

  580.     {

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

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

  583.     }

  584. 

  585.     // ---------------------------------------------------------------

  586.     // Current MIDI Program

  587. 

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

  589.     {

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

  591. 

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

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

  594.     }

  595. 

  596.     // ---------------------------------------------------------------

  597.     // Parameters

  598. 

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

  600. 

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

  602.     {

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

  604. 

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

  606.             continue;

  607. 

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

  609. 

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

  611.             continue;

  612. 

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

  614. 

  615.         stateParameter->dummy = dummy;

  616.         stateParameter->index = paramData.index;

  617. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  618.         if (paramData.mappedControlIndex != CONTROL_INDEX_MIDI_LEARN)

  619.         {

  620.             stateParameter->mappedControlIndex = paramData.mappedControlIndex;

  621.             stateParameter->midiChannel        = paramData.midiChannel;

  622. 

  623.             if (paramData.hints & PARAMETER_MAPPED_RANGES_SET)

  624.             {

  625.                 stateParameter->mappedMinimum = paramData.mappedMinimum;

  626.                 stateParameter->mappedMaximum = paramData.mappedMaximum;

  627.                 stateParameter->mappedRangeValid = true;

  628. 

  629.                 if (paramData.hints & PARAMETER_USES_SAMPLERATE)

  630.                 {

  631.                     stateParameter->mappedMinimum /= sampleRate;

  632.                     stateParameter->mappedMaximum /= sampleRate;

  633.                 }

  634.             }

  635.         }

  636. #endif

  637. 

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

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

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

  641. 

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

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

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

  645. 

  646.         if (! dummy)

  647.         {

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

  649. 

  650.             if (paramData.hints & PARAMETER_USES_SAMPLERATE)

  651.                 stateParameter->value /= sampleRate;

  652.         }

  653. 

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

  655.     }

  656. 

  657.     // ---------------------------------------------------------------

  658.     // Custom Data

  659. 

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

  661.     {

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

  663.         CARLA_SAFE_ASSERT_CONTINUE(cData.isValid());

  664. 

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

  666. 

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

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

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

  670. 

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

  672.     }

  673. 

  674.     return pData->stateSave;

  675. }

  676. 

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

  678. {

  679.     const bool usesMultiProgs(pData->hints & PLUGIN_USES_MULTI_PROGS);

  680.     const PluginType pluginType(getType());

  681. 

  682.     char strBuf[STR_MAX+1];

  683.     carla_zeroChars(strBuf, STR_MAX+1);

  684. 

  685.     // ---------------------------------------------------------------

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

  687. 

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

  689.     {

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

  691.         CARLA_SAFE_ASSERT_CONTINUE(stateCustomData != nullptr);

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

  693. 

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

  695. 

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

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

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

  699.             pass();

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

  701.             pass();

  702.         else

  703.             continue;

  704. 

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

  706.     }

  707. 

  708.     // ---------------------------------------------------------------

  709.     // Part 2 - set program

  710. 

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

  712.     {

  713.         int32_t programId = -1;

  714. 

  715.         // index < count

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

  717.         {

  718.             programId = stateSave.currentProgramIndex;

  719.         }

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

  721.         else

  722.         {

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

  724.             {

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

  726.                 {

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

  728.                     break;

  729.                 }

  730.             }

  731.         }

  732. 

  733.         // set program now, if valid

  734.         if (programId >= 0)

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

  736.     }

  737. 

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

  739.     // Part 3 - set midi program

  740. 

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

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

  743. 

  744.     // ---------------------------------------------------------------

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

  746. 

  747.     LinkedList<ParamSymbol*> paramSymbols;

  748. 

  749.     if (pluginType == PLUGIN_LADSPA || pluginType == PLUGIN_LV2)

  750.     {

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

  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)

  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.                     carla_stderr("Failed to find LV2 parameter symbol '%s' for '%s'",

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

  818.             }

  819.             else

  820.             {

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

  822.             }

  823.         }

  824.         else

  825.         {

  826.             // Index only

  827.             index = stateParameter->index;

  828.         }

  829. 

  830.         // Now set parameter

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

  832.         {

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

  834. 

  835.             if (! stateParameter->dummy)

  836.             {

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

  838.                     stateParameter->value *= sampleRate;

  839. 

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

  841.             }

  842. 

  843. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  844.             if (stateParameter->mappedRangeValid)

  845.             {

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

  847.                 {

  848.                     stateParameter->mappedMinimum *= sampleRate;

  849.                     stateParameter->mappedMaximum *= sampleRate;

  850.                 }

  851. 

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

  853.                                         stateParameter->mappedMinimum,

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

  855.             }

  856. 

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

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

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

  860. #endif

  861.         }

  862.         else

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

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

  865.     }

  866. 

  867.     // ---------------------------------------------------------------

  868.     // Part 4c - clear

  869. 

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

  871.     {

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

  873.         delete paramSymbol;

  874.     }

  875. 

  876.     paramSymbols.clear();

  877. 

  878.     // ---------------------------------------------------------------

  879.     // Part 5 - set custom data

  880. 

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

  882.     {

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

  884.         CARLA_SAFE_ASSERT_CONTINUE(stateCustomData != nullptr);

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

  886. 

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

  888. 

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

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

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

  892.             continue;

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

  894.             continue;

  895. 

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

  897.     }

  898. 

  899.     // ---------------------------------------------------------------

  900.     // Part 5x - set lv2 state

  901. 

  902.     if (pluginType == PLUGIN_LV2)

  903.     {

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

  905.         {

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

  907.             CARLA_SAFE_ASSERT_CONTINUE(customData.isValid());

  908. 

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

  910.                 continue;

  911. 

  912.             restoreLV2State(stateSave.temporary);

  913.             break;

  914.         }

  915.     }

  916. 

  917.     // ---------------------------------------------------------------

  918.     // Part 6 - set chunk

  919. 

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

  921.     {

  922.         std::vector<uint8_t> chunk(carla_getChunkFromBase64String(stateSave.chunk));

  923. #ifdef CARLA_PROPER_CPP11_SUPPORT

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

  925. #else

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

  927. #endif

  928.     }

  929. 

  930. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  931.     // ---------------------------------------------------------------

  932.     // Part 6 - set internal stuff

  933. 

  934.     const uint availOptions(getOptionsAvailable());

  935. 

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

  937.     {

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

  939. 

  940.         if (availOptions & option)

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

  942.     }

  943. 

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

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

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

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

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

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

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

  951. 

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

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

  954. #endif

  955. }

  956. 

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

  958. {

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

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

  961. 

  962.     MemoryOutputStream out, streamState;

  963.     getStateSave().dumpToMemoryStream(streamState);

  964. 

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

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

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

  968.     out << streamState;

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

  970. 

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

  972.     File file(jfilename);

  973. 

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

  975.         return true;

  976. 

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

  978.     return false;

  979. }

  980. 

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

  982. {

  983.     // TODO set errors

  984. 

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

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

  987. 

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

  989.     File file(jfilename);

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

  991. 

  992.     XmlDocument xml(file);

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

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

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

  996. 

  997.     // completely load file

  998.     xmlElement = xml.getDocumentElement(false);

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

  1000. 

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

  1002.     {

  1003.         loadStateSave(pData->stateSave);

  1004.         return true;

  1005.     }

  1006. 

  1007.     return false;

  1008. }

  1009. 

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

  1011. {

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

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

  1014. 

  1015.     CarlaString bundlepath(lv2path);

  1016. 

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

  1018.         bundlepath += ".lv2";

  1019. 

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

  1021. 

  1022.     if (bundlefolder.existsAsFile())

  1023.     {

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

  1025.         return false;

  1026.     }

  1027. 

  1028.     if (! bundlefolder.exists())

  1029.     {

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

  1031. 

  1032.         if (res.failed())

  1033.         {

  1034.             pData->engine->setLastError(res.getErrorMessage().toRawUTF8());

  1035.             return false;

  1036.         }

  1037.     }

  1038. 

  1039.     CarlaString symbol(pData->name);

  1040.     symbol.toBasic();

  1041. 

  1042.     {

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

  1044. 

  1045.         if (! saveStateToFile(pluginFilename))

  1046.             return false;

  1047.     }

  1048. 

  1049.     {

  1050.         MemoryOutputStream manifestStream;

  1051. 

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

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

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

  1055.         manifestStream << "\n";

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

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

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

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

  1060.         manifestStream << "\n";

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

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

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

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

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

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

  1067.         manifestStream << "\n";

  1068. 

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

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

  1071. 

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

  1073.         {

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

  1075.             return false;

  1076.         }

  1077.     }

  1078. 

  1079.     {

  1080.         MemoryOutputStream mainStream;

  1081. 

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

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

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

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

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

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

  1088.         mainStream << "\n";

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

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

  1091.         mainStream << "\n";

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

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

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

  1095.         mainStream << "\n";

  1096. 

  1097.         if (pData->hints & PLUGIN_HAS_CUSTOM_UI)

  1098.         {

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

  1100.             mainStream << "\n";

  1101.         }

  1102. 

  1103.         const uint32_t midiIns  = getMidiInCount();

  1104.         const uint32_t midiOuts = getMidiOutCount();

  1105. 

  1106.         int portIndex = 0;

  1107. 

  1108.         if (midiIns > 0)

  1109.         {

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

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

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

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

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

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

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

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

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

  1119.             ++portIndex;

  1120. 

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

  1122.             {

  1123.                 const String portIndexNum(portIndex++);

  1124.                 const String portIndexLabel(portIndex);

  1125. 

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

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

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

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

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

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

  1132.             }

  1133.         }

  1134.         else

  1135.         {

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

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

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

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

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

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

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

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

  1144.             ++portIndex;

  1145.         }

  1146. 

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

  1148.         {

  1149.             const String portIndexNum(portIndex++);

  1150.             const String portIndexLabel(portIndex);

  1151. 

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

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

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

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

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

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

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

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

  1160.         }

  1161. 

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

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

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

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

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

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

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

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

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

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

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

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

  1174. 

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

  1176.         {

  1177.             const String portIndexNum(portIndex++);

  1178.             const String portIndexLabel(i+1);

  1179. 

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

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

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

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

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

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

  1186.         }

  1187. 

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

  1189.         {

  1190.             const String portIndexNum(portIndex++);

  1191.             const String portIndexLabel(i+1);

  1192. 

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

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

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

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

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

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

  1199.         }

  1200. 

  1201.         CarlaStringList uniqueSymbolNames;

  1202. 

  1203.         char strBufName[STR_MAX+1];

  1204.         char strBufSymbol[STR_MAX+1];

  1205.         carla_zeroChars(strBufName, STR_MAX+1);

  1206.         carla_zeroChars(strBufSymbol, STR_MAX+1);

  1207. 

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

  1209.         {

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

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

  1212. 

  1213.             const String portIndexNum(portIndex++);

  1214. 

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

  1216. 

  1217.             if (paramData.type == PARAMETER_INPUT)

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

  1219.             else

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

  1221. 

  1222.             if (paramData.hints & PARAMETER_IS_BOOLEAN)

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

  1224. 

  1225.             if (paramData.hints & PARAMETER_IS_INTEGER)

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

  1227. 

  1228.             // TODO logarithmic, enabled (not on gui), automable, samplerate, scalepoints

  1229. 

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

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

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

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

  1234. 

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

  1236.             {

  1237.                 CarlaString s(strBufName);

  1238.                 s.toBasic();

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

  1240. 

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

  1242.                 {

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

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

  1245.                     strBufSymbol[0]   = '_';

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

  1247.                 }

  1248.             }

  1249. 

  1250.             if (uniqueSymbolNames.contains(strBufSymbol))

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

  1252. 

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

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

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

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

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

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

  1259. 

  1260.             // TODO midiCC, midiChannel

  1261. 

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

  1263.         }

  1264. 

  1265.         char strBuf[STR_MAX+1];

  1266.         carla_zeroChars(strBuf, STR_MAX+1);

  1267. 

  1268.         if (! getMaker(strBuf))

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

  1270. 

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

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

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

  1274.         mainStream << "\n";

  1275. 

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

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

  1278. 

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

  1280.         {

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

  1282.             return false;

  1283.         }

  1284.     }

  1285. 

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

  1287. 

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

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

  1290. 

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

  1292. 

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

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

  1295. 

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

  1297.     {

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

  1299.         return false;

  1300.     }

  1301. 

  1302. #ifdef CARLA_OS_WIN

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

  1304. 

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

  1306.     const File binFolder1(opts.binaryDir);

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

  1308.     binFolder2.createDirectory();

  1309. 

  1310.     static const char* files[] = {

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

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

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

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

  1315.       "libcarla_utils.dll"

  1316.     };

  1317. 

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

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

  1320. #else

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

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

  1323. #endif

  1324. 

  1325.     return true;

  1326. }

  1327. 

  1328. // -------------------------------------------------------------------

  1329. // Set data (internal stuff)

  1330. 

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

  1332. {

  1333.     pData->id = newId;

  1334. }

  1335. 

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

  1337. {

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

  1339. 

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

  1341.         delete[] pData->name;

  1342. 

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

  1344. }

  1345. 

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

  1347. {

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

  1349. 

  1350.     if (yesNo)

  1351.         pData->options |= option;

  1352.     else

  1353.         pData->options &= ~option;

  1354. 

  1355. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1356.     if (sendCallback)

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

  1358.                                 ENGINE_CALLBACK_OPTION_CHANGED,

  1359.                                 pData->id,

  1360.                                 static_cast<int>(option),

  1361.                                 yesNo ? 1 : 0,

  1362.                                 0, 0.0f, nullptr);

  1363. #else

  1364.     // unused

  1365.     return; (void)sendCallback;

  1366. #endif

  1367. }

  1368. 

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

  1370. {

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

  1372.         return;

  1373. 

  1374.     pData->masterMutex.lock();

  1375.     pData->enabled = yesNo;

  1376. 

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

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

  1379. 

  1380.     pData->masterMutex.unlock();

  1381. }

  1382. 

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

  1384. {

  1385.     if (pData->engineBridged) {

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

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

  1388.         // nothing here

  1389.     } else {

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

  1391.     }

  1392. 

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

  1394.         return;

  1395. 

  1396.     {

  1397.         const ScopedSingleProcessLocker spl(this, true);

  1398. 

  1399.         if (active)

  1400.             activate();

  1401.         else

  1402.             deactivate();

  1403.     }

  1404. 

  1405.     pData->active = active;

  1406. 

  1407. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  1409. 

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

  1411.                             ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  1412.                             pData->id,

  1413.                             PARAMETER_ACTIVE,

  1414.                             0, 0,

  1415.                             value,

  1416.                             nullptr);

  1417. #endif

  1418. }

  1419. 

  1420. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  1422. {

  1423.     if (pData->engineBridged) {

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

  1425.     } else {

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

  1427.     }

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

  1429. 

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

  1431. 

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

  1433.         return;

  1434. 

  1435.     pData->postProc.dryWet = fixedValue;

  1436. 

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

  1438.                             ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  1439.                             pData->id,

  1440.                             PARAMETER_DRYWET,

  1441.                             0, 0,

  1442.                             fixedValue,

  1443.                             nullptr);

  1444. }

  1445. 

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

  1447. {

  1448.     if (pData->engineBridged) {

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

  1450.     } else {

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

  1452.     }

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

  1454. 

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

  1456. 

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

  1458.         return;

  1459. 

  1460.     pData->postProc.volume = fixedValue;

  1461. 

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

  1463.                             ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  1464.                             pData->id,

  1465.                             PARAMETER_VOLUME,

  1466.                             0, 0,

  1467.                             fixedValue,

  1468.                             nullptr);

  1469. }

  1470. 

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

  1472. {

  1473.     if (pData->engineBridged) {

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

  1475.     } else {

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

  1477.     }

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

  1479. 

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

  1481. 

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

  1483.         return;

  1484. 

  1485.     pData->postProc.balanceLeft = fixedValue;

  1486. 

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

  1488.                             ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  1489.                             pData->id,

  1490.                             PARAMETER_BALANCE_LEFT,

  1491.                             0, 0,

  1492.                             fixedValue,

  1493.                             nullptr);

  1494. }

  1495. 

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

  1497. {

  1498.     if (pData->engineBridged) {

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

  1500.     } else {

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

  1502.     }

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

  1504. 

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

  1506. 

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

  1508.         return;

  1509. 

  1510.     pData->postProc.balanceRight = fixedValue;

  1511. 

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

  1513.                             ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  1514.                             pData->id,

  1515.                             PARAMETER_BALANCE_RIGHT,

  1516.                             0, 0,

  1517.                             fixedValue,

  1518.                             nullptr);

  1519. }

  1520. 

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

  1522. {

  1523.     if (pData->engineBridged) {

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

  1525.     } else {

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

  1527.     }

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

  1529. 

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

  1531. 

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

  1533.         return;

  1534. 

  1535.     pData->postProc.panning = fixedValue;

  1536. 

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

  1538.                             ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  1539.                             pData->id,

  1540.                             PARAMETER_PANNING,

  1541.                             0, 0,

  1542.                             fixedValue,

  1543.                             nullptr);

  1544. }

  1545. 

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

  1547. {

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

  1549. 

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

  1551. 

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

  1553.         return;

  1554. 

  1555.     pData->postProc.dryWet = fixedValue;

  1556.     pData->postponeRtEvent(kPluginPostRtEventParameterChange, sendCallbackLater, PARAMETER_DRYWET, 0, 0, fixedValue);

  1557. }

  1558. 

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

  1560. {

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

  1562. 

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

  1564. 

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

  1566.         return;

  1567. 

  1568.     pData->postProc.volume = fixedValue;

  1569.     pData->postponeRtEvent(kPluginPostRtEventParameterChange, sendCallbackLater, PARAMETER_VOLUME, 0, 0, fixedValue);

  1570. }

  1571. 

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

  1573. {

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

  1575. 

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

  1577. 

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

  1579.         return;

  1580. 

  1581.     pData->postProc.balanceLeft = fixedValue;

  1582.     pData->postponeRtEvent(kPluginPostRtEventParameterChange, sendCallbackLater, PARAMETER_BALANCE_LEFT, 0, 0, fixedValue);

  1583. }

  1584. 

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

  1586. {

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

  1588. 

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

  1590. 

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

  1592.         return;

  1593. 

  1594.     pData->postProc.balanceRight = fixedValue;

  1595.     pData->postponeRtEvent(kPluginPostRtEventParameterChange, sendCallbackLater, PARAMETER_BALANCE_RIGHT, 0, 0, fixedValue);

  1596. }

  1597. 

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

  1599. {

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

  1601. 

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

  1603. 

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

  1605.         return;

  1606. 

  1607.     pData->postProc.panning = fixedValue;

  1608.     pData->postponeRtEvent(kPluginPostRtEventParameterChange, sendCallbackLater, PARAMETER_PANNING, 0, 0, fixedValue);

  1609. }

  1610. #endif // ! BUILD_BRIDGE_ALTERNATIVE_ARCH

  1611. 

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

  1613. {

  1614.     if (pData->engineBridged) {

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

  1616.     } else {

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

  1618.     }

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

  1620. 

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

  1622.         return;

  1623. 

  1624.     pData->ctrlChannel = channel;

  1625. 

  1626. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  1628. 

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

  1630.                             ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  1631.                             pData->id,

  1632.                             PARAMETER_CTRL_CHANNEL,

  1633.                             0, 0,

  1634.                             channelf, nullptr);

  1635. #endif

  1636. }

  1637. 

  1638. // -------------------------------------------------------------------

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

  1640. 

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

  1642. {

  1643.     if (pData->engineBridged) {

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

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

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

  1647.         // nothing here

  1648.     } else {

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

  1650.     }

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

  1652. 

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

  1654.         uiParameterChange(parameterId, value);

  1655. 

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

  1657.                             ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  1658.                             pData->id,

  1659.                             static_cast<int>(parameterId),

  1660.                             0, 0,

  1661.                             value,

  1662.                             nullptr);

  1663. }

  1664. 

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

  1666. {

  1667.     pData->postponeRtEvent(kPluginPostRtEventParameterChange,

  1668.                            sendCallbackLater, static_cast<int32_t>(parameterId), 0, 0, value);

  1669. }

  1670. 

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

  1672. {

  1673. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  1675. 

  1676.     switch (rindex)

  1677.     {

  1678.     case PARAMETER_ACTIVE:

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

  1680.     case PARAMETER_CTRL_CHANNEL:

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

  1682.     case PARAMETER_DRYWET:

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

  1684.     case PARAMETER_VOLUME:

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

  1686.     case PARAMETER_BALANCE_LEFT:

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

  1688.     case PARAMETER_BALANCE_RIGHT:

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

  1690.     case PARAMETER_PANNING:

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

  1692.     }

  1693. #endif

  1694.     CARLA_SAFE_ASSERT_RETURN(rindex >= 0,);

  1695. 

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

  1697.     {

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

  1699.         {

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

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

  1702.             break;

  1703.         }

  1704.     }

  1705. }

  1706. 

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

  1708. {

  1709.     if (pData->engineBridged) {

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

  1711.     } else {

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

  1713.     }

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

  1715.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  1716. 

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

  1718.         return;

  1719. 

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

  1721. 

  1722. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  1724.                             ENGINE_CALLBACK_PARAMETER_MIDI_CHANNEL_CHANGED,

  1725.                             pData->id,

  1726.                             static_cast<int>(parameterId),

  1727.                             channel,

  1728.                             0, 0.0f, nullptr);

  1729. #endif

  1730. }

  1731. 

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

  1733.                                                  const bool sendOsc, const bool sendCallback,

  1734.                                                  const bool reconfigureNow) noexcept

  1735. {

  1736.     if (pData->engineBridged) {

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

  1738.     } else {

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

  1740.     }

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

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

  1743. 

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

  1745. 

  1746.     if (paramData.mappedControlIndex == index)

  1747.         return;

  1748. 

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

  1750. 

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

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

  1753. 

  1754. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1755.     char strBuf[STR_MAX+1];

  1756.     carla_zeroChars(strBuf, STR_MAX+1);

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

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

  1759. 

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

  1761.     if (portNameSize < STR_MAX)

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

  1763. 

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

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

  1766.     {

  1767.         const int32_t oldParameterId = pData->midiLearnParameterIndex;

  1768.         pData->midiLearnParameterIndex = -1;

  1769. 

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

  1771. 

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

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

  1774.                                 ENGINE_CALLBACK_PARAMETER_MAPPED_CONTROL_INDEX_CHANGED,

  1775.                                 pData->id,

  1776.                                 oldParameterId,

  1777.                                 CONTROL_INDEX_NONE,

  1778.                                 0, 0.0f, nullptr);

  1779.     }

  1780. 

  1781.     // mapping new parameter to CV

  1782.     if (index == CONTROL_INDEX_CV)

  1783.     {

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

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

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

  1787. 

  1788.         CarlaEngineCVPort* const cvPort =

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

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

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

  1792.     }

  1793.     // unmapping from CV

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

  1795.     {

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

  1797. 

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

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

  1800.     }

  1801.     // mapping to something new

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

  1803.     {

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

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

  1806.             setParameterMappedRange(parameterId,

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

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

  1809.                                     true, true);

  1810.     }

  1811. #endif

  1812. 

  1813.     paramData.mappedControlIndex = index;

  1814. 

  1815. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1816.     if (index == CONTROL_INDEX_MIDI_LEARN)

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

  1818.     else

  1819.         pData->midiLearnParameterIndex = -1;

  1820. 

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

  1822.                             ENGINE_CALLBACK_PARAMETER_MAPPED_CONTROL_INDEX_CHANGED,

  1823.                             pData->id,

  1824.                             static_cast<int>(parameterId),

  1825.                             index,

  1826.                             0, 0.0f, nullptr);

  1827. #else

  1828.     return;

  1829.     // unused

  1830.     (void)reconfigureNow;

  1831. #endif

  1832. }

  1833. 

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

  1835.                                           const bool sendOsc, const bool sendCallback) noexcept

  1836. {

  1837.     if (pData->engineBridged) {

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

  1839.     } else {

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

  1841.     }

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

  1843. 

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

  1845. 

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

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

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

  1849.         return;

  1850. 

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

  1852.     {

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

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

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

  1856.     }

  1857. 

  1858.     paramData.hints |= PARAMETER_MAPPED_RANGES_SET;

  1859.     paramData.mappedMinimum = minimum;

  1860.     paramData.mappedMaximum = maximum;

  1861. 

  1862. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

  1865. 

  1866.     char strBuf[STR_MAX+1];

  1867.     carla_zeroChars(strBuf, STR_MAX+1);

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

  1869. 

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

  1871.                             ENGINE_CALLBACK_PARAMETER_MAPPED_RANGE_CHANGED,

  1872.                             pData->id,

  1873.                             static_cast<int>(parameterId),

  1874.                             0, 0, 0.0f,

  1875.                             strBuf);

  1876. #endif

  1877. }

  1878. 

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

  1880. {

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

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

  1883.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

  1884. 

  1885.     // Ignore some keys

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

  1887.     {

  1888.         const PluginType ptype = getType();

  1889. 

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

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

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

  1893.             return;

  1894.     }

  1895. 

  1896.     // Check if we already have this key

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

  1898.     {

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

  1900.         CARLA_SAFE_ASSERT_CONTINUE(customData.isValid());

  1901. 

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

  1903.         {

  1904.             if (customData.value != nullptr)

  1905.                 delete[] customData.value;

  1906. 

  1907.             customData.value = carla_strdup(value);

  1908.             return;

  1909.         }

  1910.     }

  1911. 

  1912.     // Otherwise store it

  1913.     CustomData customData;

  1914.     customData.type  = carla_strdup(type);

  1915.     customData.key   = carla_strdup(key);

  1916.     customData.value = carla_strdup(value);

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

  1918. }

  1919. 

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

  1921. {

  1922.     CARLA_SAFE_ASSERT_RETURN(data != nullptr,);

  1923.     CARLA_SAFE_ASSERT_RETURN(dataSize > 0,);

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

  1925. }

  1926. 

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

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

  1929. {

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

  1931. 

  1932.     pData->prog.current = index;

  1933. 

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

  1935.                             ENGINE_CALLBACK_PROGRAM_CHANGED,

  1936.                             pData->id,

  1937.                             index,

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

  1939. 

  1940.     // Change default parameter values

  1941.     if (index >= 0)

  1942.     {

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

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

  1945. 

  1946.         switch (getType())

  1947.         {

  1948.         case PLUGIN_SF2:

  1949.         case PLUGIN_SFZ:

  1950.             break;

  1951. 

  1952.         default:

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

  1954.             break;

  1955.         }

  1956.     }

  1957. }

  1958. 

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

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

  1961. {

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

  1963. 

  1964.     pData->midiprog.current = index;

  1965. 

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

  1967.                             ENGINE_CALLBACK_MIDI_PROGRAM_CHANGED,

  1968.                             pData->id,

  1969.                             index,

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

  1971. 

  1972.     // Change default parameter values

  1973.     if (index >= 0)

  1974.     {

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

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

  1977. 

  1978.         switch (getType())

  1979.         {

  1980.         case PLUGIN_SF2:

  1981.         case PLUGIN_SFZ:

  1982.             break;

  1983. 

  1984.         default:

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

  1986.             break;

  1987.         }

  1988.     }

  1989. }

  1990. 

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

  1992. {

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

  1994.     {

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

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

  1997.     }

  1998. }

  1999. 

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

  2001. {

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

  2003. 

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

  2005.     pData->prog.current = index;

  2006. 

  2007.     // Change default parameter values

  2008.     switch (getType())

  2009.     {

  2010.     case PLUGIN_SF2:

  2011.     case PLUGIN_SFZ:

  2012.         break;

  2013. 

  2014.     default:

  2015.         pData->updateDefaultParameterValues(this);

  2016.         break;

  2017.     }

  2018. 

  2019.     pData->postponeRtEvent(kPluginPostRtEventProgramChange, sendCallbackLater, index, 0, 0, 0.0f);

  2020. }

  2021. 

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

  2023. {

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

  2025. 

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

  2027.     pData->midiprog.current = index;

  2028. 

  2029.     // Change default parameter values

  2030.     switch (getType())

  2031.     {

  2032.     case PLUGIN_SF2:

  2033.     case PLUGIN_SFZ:

  2034.         break;

  2035. 

  2036.     default:

  2037.         pData->updateDefaultParameterValues(this);

  2038.         break;

  2039.     }

  2040. 

  2041.     pData->postponeRtEvent(kPluginPostRtEventMidiProgramChange, sendCallbackLater, index, 0, 0, 0.0f);

  2042. }

  2043. 

  2044. // -------------------------------------------------------------------

  2045. // Plugin state

  2046. 

  2047. void CarlaPlugin::reloadPrograms(const bool)

  2048. {

  2049. }

  2050. 

  2051. // -------------------------------------------------------------------

  2052. // Plugin processing

  2053. 

  2054. void CarlaPlugin::activate() noexcept

  2055. {

  2056.     CARLA_SAFE_ASSERT(! pData->active);

  2057. }

  2058. 

  2059. void CarlaPlugin::deactivate() noexcept

  2060. {

  2061.     CARLA_SAFE_ASSERT(pData->active);

  2062. }

  2063. 

  2064. void CarlaPlugin::bufferSizeChanged(const uint32_t)

  2065. {

  2066. }

  2067. 

  2068. void CarlaPlugin::sampleRateChanged(const double)

  2069. {

  2070. }

  2071. 

  2072. void CarlaPlugin::offlineModeChanged(const bool)

  2073. {

  2074. }

  2075. 

  2076. // -------------------------------------------------------------------

  2077. // Misc

  2078. 

  2079. void CarlaPlugin::idle()

  2080. {

  2081.     if (! pData->enabled)

  2082.         return;

  2083. 

  2084.     const bool hasUI(pData->hints & PLUGIN_HAS_CUSTOM_UI);

  2085.     const bool needsUiMainThread(pData->hints & PLUGIN_NEEDS_UI_MAIN_THREAD);

  2086.     const uint32_t latency(getLatencyInFrames());

  2087. 

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

  2089.     {

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

  2091. 

  2092.         const ScopedSingleProcessLocker sspl(this, true);

  2093. 

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

  2095. #ifndef BUILD_BRIDGE

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

  2097. #else

  2098.         pData->latency.frames = latency;

  2099. #endif

  2100.     }

  2101. 

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

  2103. 

  2104.     if (rtEvents.isEmpty())

  2105.         return;

  2106. 

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

  2108.     {

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

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

  2111. 

  2112.         switch (event.type)

  2113.         {

  2114.         case kPluginPostRtEventNull: {

  2115.         } break;

  2116. 

  2117.         case kPluginPostRtEventDebug: {

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

  2119.                                     ENGINE_CALLBACK_DEBUG, pData->id,

  2120.                                     event.value1, event.value2, event.value3, event.valuef, nullptr);

  2121.         } break;

  2122. 

  2123.         case kPluginPostRtEventParameterChange: {

  2124.             // Update UI

  2125.             if (event.value1 >= 0 && hasUI)

  2126.             {

  2127.                 if (needsUiMainThread)

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

  2129.                 else

  2130.                     uiParameterChange(static_cast<uint32_t>(event.value1), event.valuef);

  2131.             }

  2132. 

  2133.             if (event.sendCallback)

  2134.             {

  2135.                 // Update Host

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

  2137.                                         ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  2138.                                         pData->id,

  2139.                                         event.value1,

  2140.                                         0, 0,

  2141.                                         event.valuef,

  2142.                                         nullptr);

  2143.             }

  2144.         } break;

  2145. 

  2146.         case kPluginPostRtEventProgramChange: {

  2147.             // Update UI

  2148.             if (event.value1 >= 0 && hasUI)

  2149.             {

  2150.                 if (needsUiMainThread)

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

  2152.                 else

  2153.                     uiProgramChange(static_cast<uint32_t>(event.value1));

  2154.             }

  2155. 

  2156.             // Update param values

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

  2158.             {

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

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

  2161. 

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

  2163.                                         ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  2164.                                         pData->id,

  2165.                                         static_cast<int>(j),

  2166.                                         0, 0,

  2167.                                         paramValue,

  2168.                                         nullptr);

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

  2170.                                         ENGINE_CALLBACK_PARAMETER_DEFAULT_CHANGED,

  2171.                                         pData->id,

  2172.                                         static_cast<int>(j),

  2173.                                         0, 0,

  2174.                                         paramDefault,

  2175.                                         nullptr);

  2176.             }

  2177. 

  2178.             if (event.sendCallback)

  2179.             {

  2180.                 // Update Host

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

  2182.                                         ENGINE_CALLBACK_PROGRAM_CHANGED,

  2183.                                         pData->id,

  2184.                                         event.value1,

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

  2186.             }

  2187.         } break;

  2188. 

  2189.         case kPluginPostRtEventMidiProgramChange: {

  2190.             // Update UI

  2191.             if (event.value1 >= 0 && hasUI)

  2192.             {

  2193.                 if (needsUiMainThread)

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

  2195.                 else

  2196.                     uiMidiProgramChange(static_cast<uint32_t>(event.value1));

  2197.             }

  2198. 

  2199.             // Update param values

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

  2201.             {

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

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

  2204. 

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

  2206.                                         ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  2207.                                         pData->id,

  2208.                                         static_cast<int>(j),

  2209.                                         0, 0,

  2210.                                         paramValue,

  2211.                                         nullptr);

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

  2213.                                         ENGINE_CALLBACK_PARAMETER_DEFAULT_CHANGED,

  2214.                                         pData->id,

  2215.                                         static_cast<int>(j),

  2216.                                         0, 0,

  2217.                                         paramDefault,

  2218.                                         nullptr);

  2219.             }

  2220. 

  2221.             if (event.sendCallback)

  2222.             {

  2223.                 // Update Host

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

  2225.                                         ENGINE_CALLBACK_MIDI_PROGRAM_CHANGED,

  2226.                                         pData->id,

  2227.                                         event.value1,

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

  2229.             }

  2230.         } break;

  2231. 

  2232.         case kPluginPostRtEventNoteOn: {

  2233.             CARLA_SAFE_ASSERT_BREAK(event.value1 >= 0 && event.value1 < MAX_MIDI_CHANNELS);

  2234.             CARLA_SAFE_ASSERT_BREAK(event.value2 >= 0 && event.value2 < MAX_MIDI_NOTE);

  2235.             CARLA_SAFE_ASSERT_BREAK(event.value3 >= 0 && event.value3 < MAX_MIDI_VALUE);

  2236. 

  2237.             const uint8_t channel  = static_cast<uint8_t>(event.value1);

  2238.             const uint8_t note     = static_cast<uint8_t>(event.value2);

  2239.             const uint8_t velocity = static_cast<uint8_t>(event.value3);

  2240. 

  2241.             // Update UI

  2242.             if (hasUI)

  2243.             {

  2244.                 if (needsUiMainThread)

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

  2246.                 else

  2247.                     uiNoteOn(channel, note, velocity);

  2248.             }

  2249. 

  2250.             if (event.sendCallback)

  2251.             {

  2252.                 // Update Host

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

  2254.                                         ENGINE_CALLBACK_NOTE_ON,

  2255.                                         pData->id,

  2256.                                         event.value1,

  2257.                                         event.value2,

  2258.                                         event.value3,

  2259.                                         0.0f, nullptr);

  2260.             }

  2261.         } break;

  2262. 

  2263.         case kPluginPostRtEventNoteOff: {

  2264.             CARLA_SAFE_ASSERT_BREAK(event.value1 >= 0 && event.value1 < MAX_MIDI_CHANNELS);

  2265.             CARLA_SAFE_ASSERT_BREAK(event.value2 >= 0 && event.value2 < MAX_MIDI_NOTE);

  2266. 

  2267.             const uint8_t channel = static_cast<uint8_t>(event.value1);

  2268.             const uint8_t note    = static_cast<uint8_t>(event.value2);

  2269. 

  2270.             // Update UI

  2271.             if (hasUI)

  2272.             {

  2273.                 if (needsUiMainThread)

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

  2275.                 else

  2276.                     uiNoteOff(channel, note);

  2277.             }

  2278. 

  2279.             if (event.sendCallback)

  2280.             {

  2281.                 // Update Host

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

  2283.                                         ENGINE_CALLBACK_NOTE_OFF,

  2284.                                         pData->id,

  2285.                                         event.value1,

  2286.                                         event.value2,

  2287.                                         0, 0.0f, nullptr);

  2288.             }

  2289.         } break;

  2290. 

  2291.         case kPluginPostRtEventMidiLearn: {

  2292.             CARLA_SAFE_ASSERT_BREAK(event.value1 >= 0 && event.value1 < MAX_MIDI_CHANNELS);

  2293.             CARLA_SAFE_ASSERT_BREAK(event.value2 >= 0 && event.value2 < MAX_MIDI_NOTE);

  2294. 

  2295. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2296.             if (event.sendCallback)

  2297.             {

  2298.                 const int32_t parameterId = event.value1;

  2299.                 const int32_t midiCC      = event.value2;

  2300.                 const int32_t midiChannel = event.value3;

  2301. 

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

  2303.                                         ENGINE_CALLBACK_PARAMETER_MAPPED_CONTROL_INDEX_CHANGED,

  2304.                                         pData->id,

  2305.                                         parameterId,

  2306.                                         midiCC,

  2307.                                         0, 0.0f, nullptr);

  2308. 

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

  2310.                                         ENGINE_CALLBACK_PARAMETER_MIDI_CHANNEL_CHANGED,

  2311.                                         pData->id,

  2312.                                         parameterId,

  2313.                                         midiChannel,

  2314.                                         0, 0.0f, nullptr);

  2315. 

  2316.             }

  2317. #endif

  2318.         } break;

  2319.         }

  2320.     }

  2321. }

  2322. 

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

  2324. {

  2325.     if (forcedOffline)

  2326.     {

  2327. #ifndef STOAT_TEST_BUILD

  2328.         pData->masterMutex.lock();

  2329.         return true;

  2330. #endif

  2331.     }

  2332. 

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

  2334. }

  2335. 

  2336. void CarlaPlugin::unlock() noexcept

  2337. {

  2338.     pData->masterMutex.unlock();

  2339. }

  2340. 

  2341. // -------------------------------------------------------------------

  2342. // Plugin buffers

  2343. 

  2344. void CarlaPlugin::initBuffers() const noexcept

  2345. {

  2346.     pData->audioIn.initBuffers();

  2347.     pData->audioOut.initBuffers();

  2348.     pData->cvIn.initBuffers();

  2349.     pData->cvOut.initBuffers();

  2350.     pData->event.initBuffers();

  2351. }

  2352. 

  2353. void CarlaPlugin::clearBuffers() noexcept

  2354. {

  2355.     pData->clearBuffers();

  2356. }

  2357. 

  2358. // -------------------------------------------------------------------

  2359. // OSC stuff

  2360. 

  2361. // FIXME

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

  2363. {

  2364.     // do nothing

  2365. }

  2366. 

  2367. // -------------------------------------------------------------------

  2368. // MIDI events

  2369. 

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

  2371. {

  2372.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2373.     CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

  2374.     CARLA_SAFE_ASSERT_RETURN(velo < MAX_MIDI_VALUE,);

  2375. 

  2376.     if (! pData->active)

  2377.         return;

  2378. 

  2379.     ExternalMidiNote extNote;

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

  2381.     extNote.note    = note;

  2382.     extNote.velo    = velo;

  2383. 

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

  2385. 

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

  2387.     {

  2388.         if (velo > 0)

  2389.             uiNoteOn(channel, note, velo);

  2390.         else

  2391.             uiNoteOff(channel, note);

  2392.     }

  2393. 

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

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

  2396.                             pData->id,

  2397.                             channel,

  2398.                             note,

  2399.                             velo,

  2400.                             0.0f, nullptr);

  2401. }

  2402. 

  2403. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2404. void CarlaPlugin::postponeRtAllNotesOff()

  2405. {

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

  2407.         return;

  2408. 

  2409.     PluginPostRtEvent postEvent = {

  2410.         kPluginPostRtEventNoteOff,

  2411.         true,

  2412.         pData->ctrlChannel,

  2413.         0, 0, 0.0f

  2414.     };

  2415. 

  2416.     for (int32_t i=0; i < MAX_MIDI_NOTE; ++i)

  2417.     {

  2418.         postEvent.value2 = i;

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

  2420.     }

  2421. }

  2422. #endif

  2423. 

  2424. // -------------------------------------------------------------------

  2425. // UI Stuff

  2426. 

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

  2428. {

  2429.     pData->uiTitle = title;

  2430. }

  2431. 

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

  2433. {

  2434.     if (yesNo) {

  2435.         CARLA_SAFE_ASSERT(false);

  2436.     }

  2437. }

  2438. 

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

  2440. {

  2441.     return nullptr;

  2442. }

  2443. 

  2444. void CarlaPlugin::uiIdle()

  2445. {

  2446.     if (pData->hints & PLUGIN_NEEDS_UI_MAIN_THREAD)

  2447.     {

  2448.         // Update parameter outputs

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

  2450.         {

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

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

  2453.         }

  2454. 

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

  2456. 

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

  2458.         {

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

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

  2461. 

  2462.             switch (event.type)

  2463.             {

  2464.             case kPluginPostRtEventNull:

  2465.             case kPluginPostRtEventDebug:

  2466.             case kPluginPostRtEventMidiLearn:

  2467.                 break;

  2468. 

  2469.             case kPluginPostRtEventParameterChange:

  2470.                 uiParameterChange(static_cast<uint32_t>(event.value1), event.valuef);

  2471.                 break;

  2472. 

  2473.             case kPluginPostRtEventProgramChange:

  2474.                 uiProgramChange(static_cast<uint32_t>(event.value1));

  2475.                 break;

  2476. 

  2477.             case kPluginPostRtEventMidiProgramChange:

  2478.                 uiMidiProgramChange(static_cast<uint32_t>(event.value1));

  2479.                 break;

  2480. 

  2481.             case kPluginPostRtEventNoteOn:

  2482.                 uiNoteOn(static_cast<uint8_t>(event.value1),

  2483.                          static_cast<uint8_t>(event.value2),

  2484.                          static_cast<uint8_t>(event.value3));

  2485.                 break;

  2486. 

  2487.             case kPluginPostRtEventNoteOff:

  2488.                 uiNoteOff(static_cast<uint8_t>(event.value1),

  2489.                           static_cast<uint8_t>(event.value2));

  2490.                 break;

  2491.             }

  2492.         }

  2493. 

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

  2495.     }

  2496. 

  2497. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  2499.         return;

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

  2501.         return;

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

  2503.         return;

  2504. 

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

  2506. 

  2507.     CarlaString uiTitle;

  2508. 

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

  2510.     {

  2511.         uiTitle = pData->uiTitle;

  2512.     }

  2513.     else

  2514.     {

  2515.         uiTitle  = pData->name;

  2516.         uiTitle += " (GUI)";

  2517.     }

  2518. 

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

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

  2521.     {

  2522.         pData->transientTryCounter = 0;

  2523.         pData->transientFirstTry = false;

  2524.     }

  2525. #endif

  2526. }

  2527. 

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

  2529. {

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

  2531.     return;

  2532. 

  2533.     // unused

  2534.     (void)value;

  2535. }

  2536. 

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

  2538. {

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

  2540. }

  2541. 

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

  2543. {

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

  2545. }

  2546. 

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

  2548. {

  2549.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2550.     CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

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

  2552. }

  2553. 

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

  2555. {

  2556.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2557.     CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

  2558. }

  2559. 

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

  2561. {

  2562.     return pData->engine;

  2563. }

  2564. 

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

  2566. {

  2567.     return pData->client;

  2568. }

  2569. 

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

  2571. {

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

  2573. }

  2574. 

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

  2576. {

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

  2578. }

  2579. 

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

  2581. {

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

  2583. }

  2584. 

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

  2586. {

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

  2588. }

  2589. 

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

  2591. {

  2592.     return pData->event.portIn;

  2593. }

  2594. 

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

  2596. {

  2597.     return pData->event.portOut;

  2598. }

  2599. 

  2600. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  2602. {

  2603.     if (pData->midiLearnParameterIndex < 0)

  2604.         return;

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

  2606.         return;

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

  2608.         return;

  2609. 

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

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

  2612. 

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

  2614.     CARLA_SAFE_ASSERT_INT_RETURN(paramData.mappedControlIndex == CONTROL_INDEX_MIDI_LEARN,

  2615.                                  paramData.mappedControlIndex,);

  2616. 

  2617.     event.ctrl.handled = true;

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

  2619.     paramData.midiChannel = event.channel;

  2620. 

  2621.     pData->postponeRtEvent(kPluginPostRtEventMidiLearn, true,

  2622.                            pData->midiLearnParameterIndex, event.ctrl.param, event.channel, 0.0f);

  2623.     pData->midiLearnParameterIndex = -1;

  2624. }

  2625. #endif

  2626. 

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

  2628. {

  2629.     return nullptr;

  2630. }

  2631. 

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

  2633. {

  2634.     return nullptr;

  2635. }

  2636. 

  2637. uintptr_t CarlaPlugin::getUiBridgeProcessId() const noexcept

  2638. {

  2639.     return 0;

  2640. }

  2641. 

  2642. // -------------------------------------------------------------------

  2643. 

  2644. uint32_t CarlaPlugin::getPatchbayNodeId() const noexcept

  2645. {

  2646.     return pData->nodeId;

  2647. }

  2648. 

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

  2650. {

  2651.     pData->nodeId = nodeId;

  2652. }

  2653. 

  2654. // -------------------------------------------------------------------

  2655. 

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

  2657. {

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

  2659. }

  2660. 

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

  2662. {

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

  2664. }

  2665. 

  2666. void CarlaPlugin::prepareForDeletion() noexcept

  2667. {

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

  2669. 

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

  2671. 

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

  2673. }

  2674. 

  2675. void CarlaPlugin::waitForBridgeSaveSignal() noexcept

  2676. {

  2677. }

  2678. 

  2679. // -------------------------------------------------------------------

  2680. // Scoped Disabler

  2681. 

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

  2683.     : fPlugin(plugin),

  2684.       fWasEnabled(false)

  2685. {

  2686.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

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

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

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

  2690. 

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

  2692. 

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

  2694.     {

  2695.         fWasEnabled = true;

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

  2697. 

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

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

  2700.     }

  2701. }

  2702. 

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

  2704. {

  2705.     CARLA_SAFE_ASSERT_RETURN(fPlugin != nullptr,);

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

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

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

  2709. 

  2710.     if (fWasEnabled)

  2711.     {

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

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

  2714.     }

  2715. 

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

  2717. }

  2718. 

  2719. // -------------------------------------------------------------------

  2720. // Scoped Process Locker

  2721. 

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

  2723.     : fPlugin(plugin),

  2724.       fBlock(block)

  2725. {

  2726.     CARLA_SAFE_ASSERT_RETURN(fPlugin != nullptr,);

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

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

  2729. 

  2730.     if (! fBlock)

  2731.         return;

  2732. 

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

  2734. }

  2735. 

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

  2737. {

  2738.     CARLA_SAFE_ASSERT_RETURN(fPlugin != nullptr,);

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

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

  2741. 

  2742.     if (! fBlock)

  2743.         return;

  2744. 

  2745. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

  2748. #endif

  2749. 

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

  2751. }

  2752. 

  2753. // -------------------------------------------------------------------

  2754. 

  2755. CARLA_BACKEND_END_NAMESPACE