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.
6810 Commits
16 Branches
14GB
Tree: 1c25210bd6
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '1c25210bd6'
${ noResults }
Carla/source/backend/plugin/CarlaPlugin.cpp

2756 lines
91KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin

  3.  * Copyright (C) 2011-2023 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, {} };

  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_COPYABLE(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. uint CarlaPlugin::getAudioPortHints(bool, uint32_t) const noexcept

  246. {

  247.     return 0x0;

  248. }

  249. 

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

  251. {

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

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

  254. }

  255. 

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

  257. {

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

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

  260. }

  261. 

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

  263. {

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

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

  266. }

  267. 

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

  269. {

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

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

  272. }

  273. 

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

  275. {

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

  277. }

  278. 

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

  280. {

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

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

  283.     return 0;

  284. }

  285. 

  286. // -------------------------------------------------------------------

  287. // Information (per-plugin data)

  288. 

  289. uint CarlaPlugin::getOptionsAvailable() const noexcept

  290. {

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

  292.     return 0x0;

  293. }

  294. 

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

  296. {

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

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

  299.     return 0.0f;

  300. }

  301. 

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

  303. {

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

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

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

  307.     return 0.0f;

  308. }

  309. 

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

  311. {

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

  313.     return false;

  314. }

  315. 

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

  317. {

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

  319.     return false;

  320. }

  321. 

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

  323. {

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

  325.     return false;

  326. }

  327. 

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

  329. {

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

  331.     return false;

  332. }

  333. 

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

  335. {

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

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

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

  339.     return false;

  340. }

  341. 

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

  343. {

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

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

  346.     return false;

  347. }

  348. 

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

  350. {

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

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

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

  354.     return false;

  355. }

  356. 

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

  358. {

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

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

  361.     return false;

  362. }

  363. 

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

  365. {

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

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

  368.     return false;

  369. }

  370. 

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

  372. {

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

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

  375.     return false;

  376. }

  377. 

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

  379. {

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

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

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

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

  384.     return false;

  385. }

  386. 

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

  388. {

  389. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  391. 

  392.     switch (parameterId)

  393.     {

  394.     case PARAMETER_ACTIVE:

  395.         return pData->active;

  396.     case PARAMETER_CTRL_CHANNEL:

  397.         return pData->ctrlChannel;

  398.     case PARAMETER_DRYWET:

  399.         return pData->postProc.dryWet;

  400.     case PARAMETER_VOLUME:

  401.         return pData->postProc.volume;

  402.     case PARAMETER_BALANCE_LEFT:

  403.         return pData->postProc.balanceLeft;

  404.     case PARAMETER_BALANCE_RIGHT:

  405.         return pData->postProc.balanceRight;

  406.     case PARAMETER_PANNING:

  407.         return pData->postProc.panning;

  408.     };

  409. #endif

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

  411. 

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

  413. }

  414. 

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

  416. {

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

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

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

  420.     return true;

  421. }

  422. 

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

  424. {

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

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

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

  428.     return true;

  429. }

  430. 

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

  432. {

  433.     ins  = 0;

  434.     outs = 0;

  435. 

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

  437.     {

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

  439.             ++ins;

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

  441.             ++outs;

  442.     }

  443. }

  444. 

  445. // -------------------------------------------------------------------

  446. // Set data (state)

  447. 

  448. void CarlaPlugin::prepareForSave(bool)

  449. {

  450. }

  451. 

  452. void CarlaPlugin::resetParameters() noexcept

  453. {

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

  455.     {

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

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

  458. 

  459.         if (paramData.type != PARAMETER_INPUT)

  460.             continue;

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

  462.             continue;

  463. 

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

  465.     }

  466. }

  467. 

  468. void CarlaPlugin::randomizeParameters() noexcept

  469. {

  470.     float value, random;

  471. 

  472.     char strBuf[STR_MAX+1];

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

  474. 

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

  476. 

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

  478.     {

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

  480. 

  481.         if (paramData.type != PARAMETER_INPUT)

  482.             continue;

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

  484.             continue;

  485. 

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

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

  488. 

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

  490.             continue;

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

  492.             continue;

  493. 

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

  495. 

  496.         if (paramData.hints & PARAMETER_IS_BOOLEAN)

  497.         {

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

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

  500.         }

  501.         else

  502.         {

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

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

  505. 

  506.             if (paramData.hints & PARAMETER_IS_INTEGER)

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

  508.         }

  509. 

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

  511.     }

  512. }

  513. 

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

  515. {

  516.     pData->stateSave.clear();

  517. 

  518.     if (callPrepareForSave)

  519.     {

  520.         pData->stateSave.temporary = true;

  521.         prepareForSave(true);

  522.     }

  523. 

  524.     const PluginType pluginType = getType();

  525. 

  526.     char strBuf[STR_MAX+1];

  527.     carla_zeroChars(strBuf, STR_MAX+1);

  528. 

  529.     // ---------------------------------------------------------------

  530.     // Basic info

  531. 

  532.     if (! getLabel(strBuf))

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

  534. 

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

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

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

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

  539. // #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  541. // #endif

  542. 

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

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

  545. 

  546.    #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  547.     // ---------------------------------------------------------------

  548.     // Internals

  549. 

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

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

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

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

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

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

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

  557.    #endif

  558. 

  559.     if (pData->hints & PLUGIN_IS_BRIDGE)

  560.         waitForBridgeSaveSignal();

  561. 

  562.     // ---------------------------------------------------------------

  563.     // Chunk

  564. 

  565.     bool usingChunk = false;

  566. 

  567.     if (pData->options & PLUGIN_OPTION_USE_CHUNKS)

  568.     {

  569.         void* data = nullptr;

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

  571. 

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

  573.         {

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

  575. 

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

  577.                 usingChunk = true;

  578.         }

  579.     }

  580. 

  581.     // ---------------------------------------------------------------

  582.     // Current Program

  583. 

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

  585.     {

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

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

  588.     }

  589. 

  590.     // ---------------------------------------------------------------

  591.     // Current MIDI Program

  592. 

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

  594.     {

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

  596. 

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

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

  599.     }

  600. 

  601.     // ---------------------------------------------------------------

  602.     // Parameters

  603. 

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

  605. 

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

  607.     {

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

  609. 

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

  611.             continue;

  612.         if (paramData.hints & PARAMETER_IS_NOT_SAVED)

  613.             continue;

  614. 

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

  616. 

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

  618.             continue;

  619. 

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

  621. 

  622.         stateParameter->dummy = dummy;

  623.         stateParameter->index = paramData.index;

  624.        #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  625.         if (paramData.mappedControlIndex != CONTROL_INDEX_MIDI_LEARN)

  626.         {

  627.             stateParameter->mappedControlIndex = paramData.mappedControlIndex;

  628.             stateParameter->midiChannel        = paramData.midiChannel;

  629. 

  630.             if (paramData.hints & PARAMETER_MAPPED_RANGES_SET)

  631.             {

  632.                 stateParameter->mappedMinimum = paramData.mappedMinimum;

  633.                 stateParameter->mappedMaximum = paramData.mappedMaximum;

  634.                 stateParameter->mappedRangeValid = true;

  635. 

  636.                 if (paramData.hints & PARAMETER_USES_SAMPLERATE)

  637.                 {

  638.                     stateParameter->mappedMinimum /= sampleRate;

  639.                     stateParameter->mappedMaximum /= sampleRate;

  640.                 }

  641.             }

  642.         }

  643.        #endif

  644. 

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

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

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

  648. 

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

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

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

  652. 

  653.         if (! dummy)

  654.         {

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

  656. 

  657.             if (paramData.hints & PARAMETER_USES_SAMPLERATE)

  658.                 stateParameter->value /= sampleRate;

  659.         }

  660. 

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

  662.     }

  663. 

  664.     // ---------------------------------------------------------------

  665.     // Custom Data

  666. 

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

  668.     {

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

  670.         CARLA_SAFE_ASSERT_CONTINUE(cData.isValid());

  671. 

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

  673. 

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

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

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

  677. 

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

  679.     }

  680. 

  681.     return pData->stateSave;

  682. }

  683. 

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

  685. {

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

  687.     const PluginType pluginType = getType();

  688. 

  689.     char strBuf[STR_MAX+1];

  690.     carla_zeroChars(strBuf, STR_MAX+1);

  691. 

  692.     // ---------------------------------------------------------------

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

  694. 

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

  696.     {

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

  698.         CARLA_SAFE_ASSERT_CONTINUE(stateCustomData != nullptr);

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

  700. 

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

  702. 

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

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

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

  706.             pass();

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

  708.             pass();

  709.         else

  710.             continue;

  711. 

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

  713.     }

  714. 

  715.     // ---------------------------------------------------------------

  716.     // Part 2 - set program

  717. 

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

  719.     {

  720.         int32_t programId = -1;

  721. 

  722.         // index < count

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

  724.         {

  725.             programId = stateSave.currentProgramIndex;

  726.         }

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

  728.         else

  729.         {

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

  731.             {

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

  733.                 {

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

  735.                     break;

  736.                 }

  737.             }

  738.         }

  739. 

  740.         // set program now, if valid

  741.         if (programId >= 0)

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

  743.     }

  744. 

  745.     // ---------------------------------------------------------------

  746.     // Part 3 - set midi program

  747. 

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

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

  750. 

  751.     // ---------------------------------------------------------------

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

  753. 

  754.     LinkedList<ParamSymbol*> paramSymbols;

  755. 

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

  757.     {

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

  759.         {

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

  761.                 continue;

  762. 

  763.             if (getParameterSymbol(i, strBuf))

  764.             {

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

  766.                 paramSymbols.append(paramSymbol);

  767.             }

  768.         }

  769.     }

  770. 

  771.     // ---------------------------------------------------------------

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

  773. 

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

  775. 

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

  777.     {

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

  779.         CARLA_SAFE_ASSERT_CONTINUE(stateParameter != nullptr);

  780. 

  781.         int32_t index = -1;

  782. 

  783.         if (pluginType == PLUGIN_LADSPA)

  784.         {

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

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

  787.             {

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

  789.                 {

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

  791.                     CARLA_SAFE_ASSERT_CONTINUE(paramSymbol != nullptr);

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

  793. 

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

  795.                     {

  796.                         index = paramSymbol->index;

  797.                         break;

  798.                     }

  799.                 }

  800.                 if (index == -1)

  801.                     index = stateParameter->index;

  802.             }

  803.             else

  804.             {

  805.                 index = stateParameter->index;

  806.             }

  807.         }

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

  809.         {

  810.             // Symbol only

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

  812.             {

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

  814.                 {

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

  816.                     CARLA_SAFE_ASSERT_CONTINUE(paramSymbol != nullptr);

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

  818. 

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

  820.                     {

  821.                         index = paramSymbol->index;

  822.                         break;

  823.                     }

  824.                 }

  825.                 if (index == -1)

  826.                 {

  827.                     if (pluginType == PLUGIN_LV2)

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

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

  830.                     else

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

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

  833.                 }

  834.             }

  835.             else

  836.             {

  837.                 if (pluginType == PLUGIN_LV2)

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

  839.                 else

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

  841.             }

  842.         }

  843.         else

  844.         {

  845.             // Index only

  846.             index = stateParameter->index;

  847.         }

  848. 

  849.         // Now set parameter

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

  851.         {

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

  853. 

  854.             if (! stateParameter->dummy)

  855.             {

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

  857.                     stateParameter->value *= sampleRate;

  858. 

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

  860.             }

  861. 

  862.            #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  863.             if (stateParameter->mappedRangeValid)

  864.             {

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

  866.                 {

  867.                     stateParameter->mappedMinimum *= sampleRate;

  868.                     stateParameter->mappedMaximum *= sampleRate;

  869.                 }

  870. 

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

  872.                                         stateParameter->mappedMinimum,

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

  874.             }

  875. 

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

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

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

  879.            #endif

  880.         }

  881.         else

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

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

  884.     }

  885. 

  886.     // ---------------------------------------------------------------

  887.     // Part 4c - clear

  888. 

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

  890.     {

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

  892.         delete paramSymbol;

  893.     }

  894. 

  895.     paramSymbols.clear();

  896. 

  897.     // ---------------------------------------------------------------

  898.     // Part 5 - set custom data

  899. 

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

  901.     {

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

  903.         CARLA_SAFE_ASSERT_CONTINUE(stateCustomData != nullptr);

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

  905. 

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

  907. 

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

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

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

  911.             continue;

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

  913.             continue;

  914. 

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

  916.     }

  917. 

  918.     // ---------------------------------------------------------------

  919.     // Part 5x - set lv2 state

  920. 

  921.     if (pluginType == PLUGIN_LV2)

  922.     {

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

  924.         {

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

  926.             CARLA_SAFE_ASSERT_CONTINUE(customData.isValid());

  927. 

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

  929.                 continue;

  930. 

  931.             restoreLV2State(stateSave.temporary);

  932.             break;

  933.         }

  934.     }

  935. 

  936.     // ---------------------------------------------------------------

  937.     // Part 6 - set chunk

  938. 

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

  940.     {

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

  942.        #ifdef CARLA_PROPER_CPP11_SUPPORT

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

  944.        #else

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

  946.        #endif

  947.     }

  948. 

  949.    #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  950.     // ---------------------------------------------------------------

  951.     // Part 6 - set internal stuff

  952. 

  953.     const uint availOptions = getOptionsAvailable();

  954. 

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

  956.     {

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

  958. 

  959.         if (availOptions & option)

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

  961.     }

  962. 

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

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

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

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

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

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

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

  970. 

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

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

  973.    #endif

  974. }

  975. 

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

  977. {

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

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

  980. 

  981.     MemoryOutputStream out, streamState;

  982.     getStateSave().dumpToMemoryStream(streamState);

  983. 

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

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

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

  987.     out << streamState;

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

  989. 

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

  991.     File file(jfilename);

  992. 

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

  994.         return true;

  995. 

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

  997.     return false;

  998. }

  999. 

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

  1001. {

  1002.     // TODO set errors

  1003. 

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

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

  1006. 

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

  1008.     File file(jfilename);

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

  1010. 

  1011.     XmlDocument xml(file);

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

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

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

  1015. 

  1016.     // completely load file

  1017.     xmlElement = xml.getDocumentElement(false);

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

  1019. 

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

  1021.     {

  1022.         loadStateSave(pData->stateSave);

  1023.         return true;

  1024.     }

  1025. 

  1026.     return false;

  1027. }

  1028. 

  1029. #ifndef CARLA_PLUGIN_ONLY_BRIDGE

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

  1031. {

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

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

  1034. 

  1035.     CarlaString bundlepath(lv2path);

  1036. 

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

  1038.         bundlepath += ".lv2";

  1039. 

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

  1041. 

  1042.     if (bundlefolder.existsAsFile())

  1043.     {

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

  1045.         return false;

  1046.     }

  1047. 

  1048.     if (! bundlefolder.exists())

  1049.     {

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

  1051. 

  1052.         if (res.failed())

  1053.         {

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

  1055.             return false;

  1056.         }

  1057.     }

  1058. 

  1059.     CarlaString symbol(pData->name);

  1060.     symbol.toBasic();

  1061. 

  1062.     {

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

  1064. 

  1065.         if (! saveStateToFile(pluginFilename))

  1066.             return false;

  1067.     }

  1068. 

  1069.     {

  1070.         MemoryOutputStream manifestStream;

  1071. 

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

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

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

  1075.         manifestStream << "\n";

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

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

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

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

  1080.         manifestStream << "\n";

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

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

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

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

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

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

  1087.         manifestStream << "\n";

  1088. 

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

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

  1091. 

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

  1093.         {

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

  1095.             return false;

  1096.         }

  1097.     }

  1098. 

  1099.     {

  1100.         MemoryOutputStream mainStream;

  1101. 

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

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

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

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

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

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

  1108.         mainStream << "\n";

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

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

  1111.         mainStream << "\n";

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

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

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

  1115.         mainStream << "\n";

  1116. 

  1117.         if (pData->hints & PLUGIN_HAS_CUSTOM_UI)

  1118.         {

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

  1120.             mainStream << "\n";

  1121.         }

  1122. 

  1123.         const uint32_t midiIns  = getMidiInCount();

  1124.         const uint32_t midiOuts = getMidiOutCount();

  1125. 

  1126.         int portIndex = 0;

  1127. 

  1128.         if (midiIns > 0)

  1129.         {

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

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

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

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

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

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

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

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

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

  1139.             ++portIndex;

  1140. 

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

  1142.             {

  1143.                 const String portIndexNum(portIndex++);

  1144.                 const String portIndexLabel(portIndex);

  1145. 

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

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

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

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

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

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

  1152.             }

  1153.         }

  1154.         else

  1155.         {

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

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

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

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

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

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

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

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

  1164.             ++portIndex;

  1165.         }

  1166. 

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

  1168.         {

  1169.             const String portIndexNum(portIndex++);

  1170.             const String portIndexLabel(portIndex);

  1171. 

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

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

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

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

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

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

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

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

  1180.         }

  1181. 

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

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

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

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

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

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

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

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

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

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

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

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

  1194. 

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

  1196.         {

  1197.             const String portIndexNum(portIndex++);

  1198.             const String portIndexLabel(i+1);

  1199. 

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

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

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

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

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

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

  1206.         }

  1207. 

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

  1209.         {

  1210.             const String portIndexNum(portIndex++);

  1211.             const String portIndexLabel(i+1);

  1212. 

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

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

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

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

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

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

  1219.         }

  1220. 

  1221.         CarlaStringList uniqueSymbolNames;

  1222. 

  1223.         char strBufName[STR_MAX+1];

  1224.         char strBufSymbol[STR_MAX+1];

  1225.         carla_zeroChars(strBufName, STR_MAX+1);

  1226.         carla_zeroChars(strBufSymbol, STR_MAX+1);

  1227. 

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

  1229.         {

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

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

  1232. 

  1233.             const String portIndexNum(portIndex++);

  1234. 

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

  1236. 

  1237.             if (paramData.type == PARAMETER_INPUT)

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

  1239.             else

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

  1241. 

  1242.             if (paramData.hints & PARAMETER_IS_BOOLEAN)

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

  1244. 

  1245.             if (paramData.hints & PARAMETER_IS_INTEGER)

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

  1247. 

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

  1249. 

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

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

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

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

  1254. 

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

  1256.             {

  1257.                 CarlaString s(strBufName);

  1258.                 s.toBasic();

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

  1260. 

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

  1262.                 {

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

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

  1265.                     strBufSymbol[0]   = '_';

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

  1267.                 }

  1268.             }

  1269. 

  1270.             if (uniqueSymbolNames.contains(strBufSymbol))

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

  1272. 

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

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

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

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

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

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

  1279. 

  1280.             // TODO midiCC, midiChannel

  1281. 

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

  1283.         }

  1284. 

  1285.         char strBuf[STR_MAX+1];

  1286.         carla_zeroChars(strBuf, STR_MAX+1);

  1287. 

  1288.         if (! getMaker(strBuf))

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

  1290. 

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

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

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

  1294.         mainStream << "\n";

  1295. 

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

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

  1298. 

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

  1300.         {

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

  1302.             return false;

  1303.         }

  1304.     }

  1305. 

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

  1307. 

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

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

  1310. 

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

  1312. 

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

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

  1315. 

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

  1317.     {

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

  1319.         return false;

  1320.     }

  1321. 

  1322. #ifdef CARLA_OS_WIN

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

  1324. 

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

  1326.     const File binFolder1(opts.binaryDir);

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

  1328.     binFolder2.createDirectory();

  1329. 

  1330.     static const char* files[] = {

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

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

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

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

  1335.       "libcarla_utils.dll"

  1336.     };

  1337. 

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

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

  1340. #else

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

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

  1343. #endif

  1344. 

  1345.     return true;

  1346. }

  1347. #endif

  1348. 

  1349. // -------------------------------------------------------------------

  1350. // Set data (internal stuff)

  1351. 

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

  1353. {

  1354.     pData->id = newId;

  1355. }

  1356. 

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

  1358. {

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

  1360. 

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

  1362.         delete[] pData->name;

  1363. 

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

  1365. }

  1366. 

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

  1368. {

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

  1370. 

  1371.     if (yesNo)

  1372.         pData->options |= option;

  1373.     else

  1374.         pData->options &= ~option;

  1375. 

  1376. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1377.     if (sendCallback)

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

  1379.                                 ENGINE_CALLBACK_OPTION_CHANGED,

  1380.                                 pData->id,

  1381.                                 static_cast<int>(option),

  1382.                                 yesNo ? 1 : 0,

  1383.                                 0, 0.0f, nullptr);

  1384. #else

  1385.     // unused

  1386.     return; (void)sendCallback;

  1387. #endif

  1388. }

  1389. 

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

  1391. {

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

  1393.         return;

  1394. 

  1395.     pData->masterMutex.lock();

  1396.     pData->enabled = yesNo;

  1397. 

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

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

  1400. 

  1401.     pData->masterMutex.unlock();

  1402. }

  1403. 

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

  1405. {

  1406.     if (pData->engineBridged) {

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

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

  1409.         // nothing here

  1410.     } else {

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

  1412.     }

  1413. 

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

  1415.         return;

  1416. 

  1417.     {

  1418.         const ScopedSingleProcessLocker spl(this, true);

  1419. 

  1420.         if (active)

  1421.             activate();

  1422.         else

  1423.             deactivate();

  1424.     }

  1425. 

  1426.     pData->active = active;

  1427. 

  1428. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  1430. 

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

  1432.                             ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  1433.                             pData->id,

  1434.                             PARAMETER_ACTIVE,

  1435.                             0, 0,

  1436.                             value,

  1437.                             nullptr);

  1438. #endif

  1439. }

  1440. 

  1441. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  1443. {

  1444.     if (pData->engineBridged) {

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

  1446.     } else {

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

  1448.     }

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

  1450. 

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

  1452. 

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

  1454.         return;

  1455. 

  1456.     pData->postProc.dryWet = fixedValue;

  1457. 

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

  1459.                             ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  1460.                             pData->id,

  1461.                             PARAMETER_DRYWET,

  1462.                             0, 0,

  1463.                             fixedValue,

  1464.                             nullptr);

  1465. }

  1466. 

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

  1468. {

  1469.     if (pData->engineBridged) {

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

  1471.     } else {

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

  1473.     }

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

  1475. 

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

  1477. 

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

  1479.         return;

  1480. 

  1481.     pData->postProc.volume = fixedValue;

  1482. 

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

  1484.                             ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  1485.                             pData->id,

  1486.                             PARAMETER_VOLUME,

  1487.                             0, 0,

  1488.                             fixedValue,

  1489.                             nullptr);

  1490. }

  1491. 

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

  1493. {

  1494.     if (pData->engineBridged) {

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

  1496.     } else {

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

  1498.     }

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

  1500. 

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

  1502. 

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

  1504.         return;

  1505. 

  1506.     pData->postProc.balanceLeft = fixedValue;

  1507. 

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

  1509.                             ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  1510.                             pData->id,

  1511.                             PARAMETER_BALANCE_LEFT,

  1512.                             0, 0,

  1513.                             fixedValue,

  1514.                             nullptr);

  1515. }

  1516. 

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

  1518. {

  1519.     if (pData->engineBridged) {

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

  1521.     } else {

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

  1523.     }

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

  1525. 

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

  1527. 

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

  1529.         return;

  1530. 

  1531.     pData->postProc.balanceRight = fixedValue;

  1532. 

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

  1534.                             ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  1535.                             pData->id,

  1536.                             PARAMETER_BALANCE_RIGHT,

  1537.                             0, 0,

  1538.                             fixedValue,

  1539.                             nullptr);

  1540. }

  1541. 

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

  1543. {

  1544.     if (pData->engineBridged) {

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

  1546.     } else {

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

  1548.     }

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

  1550. 

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

  1552. 

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

  1554.         return;

  1555. 

  1556.     pData->postProc.panning = fixedValue;

  1557. 

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

  1559.                             ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  1560.                             pData->id,

  1561.                             PARAMETER_PANNING,

  1562.                             0, 0,

  1563.                             fixedValue,

  1564.                             nullptr);

  1565. }

  1566. 

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

  1568. {

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

  1570. 

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

  1572. 

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

  1574.         return;

  1575. 

  1576.     pData->postProc.dryWet = fixedValue;

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

  1578. }

  1579. 

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

  1581. {

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

  1583. 

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

  1585. 

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

  1587.         return;

  1588. 

  1589.     pData->postProc.volume = fixedValue;

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

  1591. }

  1592. 

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

  1594. {

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

  1596. 

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

  1598. 

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

  1600.         return;

  1601. 

  1602.     pData->postProc.balanceLeft = fixedValue;

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

  1604. }

  1605. 

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

  1607. {

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

  1609. 

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

  1611. 

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

  1613.         return;

  1614. 

  1615.     pData->postProc.balanceRight = fixedValue;

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

  1617. }

  1618. 

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

  1620. {

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

  1622. 

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

  1624. 

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

  1626.         return;

  1627. 

  1628.     pData->postProc.panning = fixedValue;

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

  1630. }

  1631. #endif // ! BUILD_BRIDGE_ALTERNATIVE_ARCH

  1632. 

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

  1634. {

  1635.     if (pData->engineBridged) {

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

  1637.     } else {

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

  1639.     }

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

  1641. 

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

  1643.         return;

  1644. 

  1645.     pData->ctrlChannel = channel;

  1646. 

  1647. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  1649. 

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

  1651.                             ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  1652.                             pData->id,

  1653.                             PARAMETER_CTRL_CHANNEL,

  1654.                             0, 0,

  1655.                             channelf, nullptr);

  1656. #endif

  1657. }

  1658. 

  1659. // -------------------------------------------------------------------

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

  1661. 

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

  1663. {

  1664.     if (pData->engineBridged) {

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

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

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

  1668.         // nothing here

  1669.     } else {

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

  1671.     }

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

  1673. 

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

  1675.         uiParameterChange(parameterId, value);

  1676. 

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

  1678.                             ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  1679.                             pData->id,

  1680.                             static_cast<int>(parameterId),

  1681.                             0, 0,

  1682.                             value,

  1683.                             nullptr);

  1684. }

  1685. 

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

  1687. {

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

  1689. }

  1690. 

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

  1692. {

  1693. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  1695. 

  1696.     switch (rindex)

  1697.     {

  1698.     case PARAMETER_ACTIVE:

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

  1700.     case PARAMETER_CTRL_CHANNEL:

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

  1702.     case PARAMETER_DRYWET:

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

  1704.     case PARAMETER_VOLUME:

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

  1706.     case PARAMETER_BALANCE_LEFT:

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

  1708.     case PARAMETER_BALANCE_RIGHT:

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

  1710.     case PARAMETER_PANNING:

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

  1712.     }

  1713. #endif

  1714.     CARLA_SAFE_ASSERT_RETURN(rindex >= 0,);

  1715. 

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

  1717.     {

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

  1719.         {

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

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

  1722.             break;

  1723.         }

  1724.     }

  1725. }

  1726. 

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

  1728. {

  1729.     if (pData->engineBridged) {

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

  1731.     } else {

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

  1733.     }

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

  1735.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  1736. 

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

  1738.         return;

  1739. 

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

  1741. 

  1742. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  1744.                             ENGINE_CALLBACK_PARAMETER_MIDI_CHANNEL_CHANGED,

  1745.                             pData->id,

  1746.                             static_cast<int>(parameterId),

  1747.                             channel,

  1748.                             0, 0.0f, nullptr);

  1749. #endif

  1750. }

  1751. 

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

  1753.                                                  const bool sendOsc, const bool sendCallback,

  1754.                                                  const bool reconfigureNow) noexcept

  1755. {

  1756.     if (pData->engineBridged) {

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

  1758.     } else {

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

  1760.     }

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

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

  1763. 

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

  1765. 

  1766.     if (paramData.mappedControlIndex == index)

  1767.         return;

  1768. 

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

  1770. 

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

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

  1773. 

  1774. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1775.     char strBuf[STR_MAX+1];

  1776.     carla_zeroChars(strBuf, STR_MAX+1);

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

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

  1779. 

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

  1781.     if (portNameSize < STR_MAX)

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

  1783. 

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

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

  1786.     {

  1787.         const int32_t oldParameterId = pData->midiLearnParameterIndex;

  1788.         pData->midiLearnParameterIndex = -1;

  1789. 

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

  1791. 

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

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

  1794.                                 ENGINE_CALLBACK_PARAMETER_MAPPED_CONTROL_INDEX_CHANGED,

  1795.                                 pData->id,

  1796.                                 oldParameterId,

  1797.                                 CONTROL_INDEX_NONE,

  1798.                                 0, 0.0f, nullptr);

  1799.     }

  1800. 

  1801.     // mapping new parameter to CV

  1802.     if (index == CONTROL_INDEX_CV)

  1803.     {

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

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

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

  1807. 

  1808.         CarlaEngineCVPort* const cvPort =

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

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

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

  1812.     }

  1813.     // unmapping from CV

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

  1815.     {

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

  1817. 

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

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

  1820.     }

  1821.     // mapping to something new

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

  1823.     {

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

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

  1826.             setParameterMappedRange(parameterId,

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

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

  1829.                                     true, true);

  1830.     }

  1831. #endif

  1832. 

  1833.     paramData.mappedControlIndex = index;

  1834. 

  1835. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1836.     if (index == CONTROL_INDEX_MIDI_LEARN)

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

  1838.     else

  1839.         pData->midiLearnParameterIndex = -1;

  1840. 

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

  1842.                             ENGINE_CALLBACK_PARAMETER_MAPPED_CONTROL_INDEX_CHANGED,

  1843.                             pData->id,

  1844.                             static_cast<int>(parameterId),

  1845.                             index,

  1846.                             0, 0.0f, nullptr);

  1847. #else

  1848.     return;

  1849.     // unused

  1850.     (void)reconfigureNow;

  1851. #endif

  1852. }

  1853. 

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

  1855.                                           const bool sendOsc, const bool sendCallback) noexcept

  1856. {

  1857.     if (pData->engineBridged) {

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

  1859.     } else {

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

  1861.     }

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

  1863. 

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

  1865. 

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

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

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

  1869.         return;

  1870. 

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

  1872.     {

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

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

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

  1876.     }

  1877. 

  1878.     paramData.hints |= PARAMETER_MAPPED_RANGES_SET;

  1879.     paramData.mappedMinimum = minimum;

  1880.     paramData.mappedMaximum = maximum;

  1881. 

  1882. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

  1885. 

  1886.     char strBuf[STR_MAX+1];

  1887.     carla_zeroChars(strBuf, STR_MAX+1);

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

  1889. 

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

  1891.                             ENGINE_CALLBACK_PARAMETER_MAPPED_RANGE_CHANGED,

  1892.                             pData->id,

  1893.                             static_cast<int>(parameterId),

  1894.                             0, 0, 0.0f,

  1895.                             strBuf);

  1896. #endif

  1897. }

  1898. 

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

  1900. {

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

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

  1903.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

  1904. 

  1905.     // Ignore some keys

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

  1907.     {

  1908.         const PluginType ptype = getType();

  1909. 

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

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

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

  1913.             return;

  1914.     }

  1915. 

  1916.     // Check if we already have this key

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

  1918.     {

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

  1920.         CARLA_SAFE_ASSERT_CONTINUE(customData.isValid());

  1921. 

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

  1923.         {

  1924.             if (customData.value != nullptr)

  1925.                 delete[] customData.value;

  1926. 

  1927.             customData.value = carla_strdup(value);

  1928.             return;

  1929.         }

  1930.     }

  1931. 

  1932.     // Otherwise store it

  1933.     CustomData customData;

  1934.     customData.type  = carla_strdup(type);

  1935.     customData.key   = carla_strdup(key);

  1936.     customData.value = carla_strdup(value);

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

  1938. }

  1939. 

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

  1941. {

  1942.     CARLA_SAFE_ASSERT_RETURN(data != nullptr,);

  1943.     CARLA_SAFE_ASSERT_RETURN(dataSize > 0,);

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

  1945. }

  1946. 

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

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

  1949. {

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

  1951. 

  1952.     pData->prog.current = index;

  1953. 

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

  1955.                             ENGINE_CALLBACK_PROGRAM_CHANGED,

  1956.                             pData->id,

  1957.                             index,

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

  1959. 

  1960.     // Change default parameter values

  1961.     if (index >= 0)

  1962.     {

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

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

  1965. 

  1966.         switch (getType())

  1967.         {

  1968.         case PLUGIN_SF2:

  1969.         case PLUGIN_SFZ:

  1970.             break;

  1971. 

  1972.         default:

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

  1974.             break;

  1975.         }

  1976.     }

  1977. }

  1978. 

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

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

  1981. {

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

  1983. 

  1984.     pData->midiprog.current = index;

  1985. 

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

  1987.                             ENGINE_CALLBACK_MIDI_PROGRAM_CHANGED,

  1988.                             pData->id,

  1989.                             index,

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

  1991. 

  1992.     // Change default parameter values

  1993.     if (index >= 0)

  1994.     {

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

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

  1997. 

  1998.         switch (getType())

  1999.         {

  2000.         case PLUGIN_SF2:

  2001.         case PLUGIN_SFZ:

  2002.             break;

  2003. 

  2004.         default:

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

  2006.             break;

  2007.         }

  2008.     }

  2009. }

  2010. 

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

  2012. {

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

  2014.     {

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

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

  2017.     }

  2018. }

  2019. 

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

  2021. {

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

  2023. 

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

  2025.     pData->prog.current = index;

  2026. 

  2027.     // Change default parameter values

  2028.     switch (getType())

  2029.     {

  2030.     case PLUGIN_SF2:

  2031.     case PLUGIN_SFZ:

  2032.         break;

  2033. 

  2034.     default:

  2035.         pData->updateDefaultParameterValues(this);

  2036.         break;

  2037.     }

  2038. 

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

  2040. }

  2041. 

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

  2043. {

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

  2045. 

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

  2047.     pData->midiprog.current = index;

  2048. 

  2049.     // Change default parameter values

  2050.     switch (getType())

  2051.     {

  2052.     case PLUGIN_SF2:

  2053.     case PLUGIN_SFZ:

  2054.         break;

  2055. 

  2056.     default:

  2057.         pData->updateDefaultParameterValues(this);

  2058.         break;

  2059.     }

  2060. 

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

  2062. }

  2063. 

  2064. // -------------------------------------------------------------------

  2065. // Plugin state

  2066. 

  2067. void CarlaPlugin::reloadPrograms(const bool)

  2068. {

  2069. }

  2070. 

  2071. // -------------------------------------------------------------------

  2072. // Plugin processing

  2073. 

  2074. void CarlaPlugin::activate() noexcept

  2075. {

  2076.     CARLA_SAFE_ASSERT(! pData->active);

  2077. }

  2078. 

  2079. void CarlaPlugin::deactivate() noexcept

  2080. {

  2081.     CARLA_SAFE_ASSERT(pData->active);

  2082. }

  2083. 

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

  2085. {

  2086.    #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

  2089.    #else

  2090.     // unused

  2091.     (void)newBufferSize;

  2092.    #endif

  2093. }

  2094. 

  2095. void CarlaPlugin::sampleRateChanged(const double)

  2096. {

  2097. }

  2098. 

  2099. void CarlaPlugin::offlineModeChanged(const bool)

  2100. {

  2101. }

  2102. 

  2103. // -------------------------------------------------------------------

  2104. // Misc

  2105. 

  2106. void CarlaPlugin::idle()

  2107. {

  2108.     if (! pData->enabled)

  2109.         return;

  2110. 

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

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

  2113.     const uint32_t latency = getLatencyInFrames();

  2114. 

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

  2116.     {

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

  2118. 

  2119.         const ScopedSingleProcessLocker sspl(this, true);

  2120. 

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

  2122. #ifndef BUILD_BRIDGE

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

  2124. #else

  2125.         pData->latency.frames = latency;

  2126. #endif

  2127.     }

  2128. 

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

  2130. 

  2131.     if (rtEvents.isEmpty())

  2132.         return;

  2133. 

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

  2135.     {

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

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

  2138. 

  2139.         switch (event.type)

  2140.         {

  2141.         case kPluginPostRtEventNull: {

  2142.         } break;

  2143. 

  2144.         case kPluginPostRtEventParameterChange: {

  2145.             // Update UI

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

  2147.             {

  2148.                 if (needsUiMainThread)

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

  2150.                 else

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

  2152.             }

  2153. 

  2154.             if (event.sendCallback)

  2155.             {

  2156.                 // Update Host

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

  2158.                                         ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  2159.                                         pData->id,

  2160.                                         event.parameter.index,

  2161.                                         0, 0,

  2162.                                         event.parameter.value,

  2163.                                         nullptr);

  2164.             }

  2165.         } break;

  2166. 

  2167.         case kPluginPostRtEventProgramChange: {

  2168.             // Update UI

  2169.             if (hasUI)

  2170.             {

  2171.                 if (needsUiMainThread)

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

  2173.                 else

  2174.                     uiProgramChange(event.program.index);

  2175.             }

  2176. 

  2177.             // Update param values

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

  2179.             {

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

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

  2182. 

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

  2184.                                         ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  2185.                                         pData->id,

  2186.                                         static_cast<int>(j),

  2187.                                         0, 0,

  2188.                                         paramValue,

  2189.                                         nullptr);

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

  2191.                                         ENGINE_CALLBACK_PARAMETER_DEFAULT_CHANGED,

  2192.                                         pData->id,

  2193.                                         static_cast<int>(j),

  2194.                                         0, 0,

  2195.                                         paramDefault,

  2196.                                         nullptr);

  2197.             }

  2198. 

  2199.             if (event.sendCallback)

  2200.             {

  2201.                 // Update Host

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

  2203.                                         ENGINE_CALLBACK_PROGRAM_CHANGED,

  2204.                                         pData->id,

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

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

  2207.             }

  2208.         } break;

  2209. 

  2210.         case kPluginPostRtEventMidiProgramChange: {

  2211.             // Update UI

  2212.             if (hasUI)

  2213.             {

  2214.                 if (needsUiMainThread)

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

  2216.                 else

  2217.                     uiMidiProgramChange(event.program.index);

  2218.             }

  2219. 

  2220.             // Update param values

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

  2222.             {

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

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

  2225. 

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

  2227.                                         ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  2228.                                         pData->id,

  2229.                                         static_cast<int>(j),

  2230.                                         0, 0,

  2231.                                         paramValue,

  2232.                                         nullptr);

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

  2234.                                         ENGINE_CALLBACK_PARAMETER_DEFAULT_CHANGED,

  2235.                                         pData->id,

  2236.                                         static_cast<int>(j),

  2237.                                         0, 0,

  2238.                                         paramDefault,

  2239.                                         nullptr);

  2240.             }

  2241. 

  2242.             if (event.sendCallback)

  2243.             {

  2244.                 // Update Host

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

  2246.                                         ENGINE_CALLBACK_MIDI_PROGRAM_CHANGED,

  2247.                                         pData->id,

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

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

  2250.             }

  2251.         } break;

  2252. 

  2253.         case kPluginPostRtEventNoteOn: {

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

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

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

  2257. 

  2258.             // Update UI

  2259.             if (hasUI)

  2260.             {

  2261.                 if (needsUiMainThread)

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

  2263.                 else

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

  2265.             }

  2266. 

  2267.             if (event.sendCallback)

  2268.             {

  2269.                 // Update Host

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

  2271.                                         ENGINE_CALLBACK_NOTE_ON,

  2272.                                         pData->id,

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

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

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

  2276.                                         0.0f, nullptr);

  2277.             }

  2278.         } break;

  2279. 

  2280.         case kPluginPostRtEventNoteOff: {

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

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

  2283. 

  2284.             // Update UI

  2285.             if (hasUI)

  2286.             {

  2287.                 if (needsUiMainThread)

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

  2289.                 else

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

  2291.             }

  2292. 

  2293.             if (event.sendCallback)

  2294.             {

  2295.                 // Update Host

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

  2297.                                         ENGINE_CALLBACK_NOTE_OFF,

  2298.                                         pData->id,

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

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

  2301.                                         0, 0.0f, nullptr);

  2302.             }

  2303.         } break;

  2304. 

  2305.         case kPluginPostRtEventMidiLearn: {

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

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

  2308. 

  2309. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2310.             if (event.sendCallback)

  2311.             {

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

  2313.                                         ENGINE_CALLBACK_PARAMETER_MAPPED_CONTROL_INDEX_CHANGED,

  2314.                                         pData->id,

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

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

  2317.                                         0, 0.0f, nullptr);

  2318. 

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

  2320.                                         ENGINE_CALLBACK_PARAMETER_MIDI_CHANNEL_CHANGED,

  2321.                                         pData->id,

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

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

  2324.                                         0, 0.0f, nullptr);

  2325.             }

  2326. #endif

  2327.         } break;

  2328.         }

  2329.     }

  2330. }

  2331. 

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

  2333. {

  2334.     if (forcedOffline)

  2335.     {

  2336. #ifndef STOAT_TEST_BUILD

  2337.         pData->masterMutex.lock();

  2338.         return true;

  2339. #endif

  2340.     }

  2341. 

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

  2343. }

  2344. 

  2345. void CarlaPlugin::unlock() noexcept

  2346. {

  2347.     pData->masterMutex.unlock();

  2348. }

  2349. 

  2350. // -------------------------------------------------------------------

  2351. // Plugin buffers

  2352. 

  2353. void CarlaPlugin::initBuffers() const noexcept

  2354. {

  2355.     pData->audioIn.initBuffers();

  2356.     pData->audioOut.initBuffers();

  2357.     pData->cvIn.initBuffers();

  2358.     pData->cvOut.initBuffers();

  2359.     pData->event.initBuffers();

  2360. }

  2361. 

  2362. void CarlaPlugin::clearBuffers() noexcept

  2363. {

  2364.     pData->clearBuffers();

  2365. }

  2366. 

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

  2368. // OSC stuff

  2369. 

  2370. // FIXME

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

  2372. {

  2373.     // do nothing

  2374. }

  2375. 

  2376. // -------------------------------------------------------------------

  2377. // MIDI events

  2378. 

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

  2380. {

  2381.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2382.     CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

  2383.     CARLA_SAFE_ASSERT_RETURN(velo < MAX_MIDI_VALUE,);

  2384. 

  2385.     if (! pData->active)

  2386.         return;

  2387. 

  2388.     ExternalMidiNote extNote;

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

  2390.     extNote.note    = note;

  2391.     extNote.velo    = velo;

  2392. 

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

  2394. 

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

  2396.     {

  2397.         if (velo > 0)

  2398.             uiNoteOn(channel, note, velo);

  2399.         else

  2400.             uiNoteOff(channel, note);

  2401.     }

  2402. 

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

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

  2405.                             pData->id,

  2406.                             channel,

  2407.                             note,

  2408.                             velo,

  2409.                             0.0f, nullptr);

  2410. }

  2411. 

  2412. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2413. void CarlaPlugin::postponeRtAllNotesOff()

  2414. {

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

  2416.         return;

  2417. 

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

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

  2420. 

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

  2422.     {

  2423.         postEvent.note.note = i;

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

  2425.     }

  2426. }

  2427. #endif

  2428. 

  2429. // -------------------------------------------------------------------

  2430. // UI Stuff

  2431. 

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

  2433. {

  2434.     pData->uiTitle = title;

  2435. }

  2436. 

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

  2438. {

  2439.     if (yesNo) {

  2440.         CARLA_SAFE_ASSERT(false);

  2441.     }

  2442. }

  2443. 

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

  2445. {

  2446.     return nullptr;

  2447. }

  2448. 

  2449. void CarlaPlugin::uiIdle()

  2450. {

  2451.     if (pData->hints & PLUGIN_NEEDS_UI_MAIN_THREAD)

  2452.     {

  2453.         // Update parameter outputs

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

  2455.         {

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

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

  2458.         }

  2459. 

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

  2461. 

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

  2463.         {

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

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

  2466. 

  2467.             switch (event.type)

  2468.             {

  2469.             case kPluginPostRtEventNull:

  2470.             case kPluginPostRtEventMidiLearn:

  2471.                 break;

  2472. 

  2473.             case kPluginPostRtEventParameterChange:

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

  2475.                 break;

  2476. 

  2477.             case kPluginPostRtEventProgramChange:

  2478.                 uiProgramChange(event.program.index);

  2479.                 break;

  2480. 

  2481.             case kPluginPostRtEventMidiProgramChange:

  2482.                 uiMidiProgramChange(event.program.index);

  2483.                 break;

  2484. 

  2485.             case kPluginPostRtEventNoteOn:

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

  2487.                 break;

  2488. 

  2489.             case kPluginPostRtEventNoteOff:

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

  2491.                 break;

  2492.             }

  2493.         }

  2494. 

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

  2496.     }

  2497. 

  2498. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  2500.         return;

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

  2502.         return;

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

  2504.         return;

  2505. 

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

  2507. 

  2508.     CarlaString uiTitle;

  2509. 

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

  2511.     {

  2512.         uiTitle = pData->uiTitle;

  2513.     }

  2514.     else

  2515.     {

  2516.         uiTitle  = pData->name;

  2517.         uiTitle += " (GUI)";

  2518.     }

  2519. 

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

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

  2522.     {

  2523.         pData->transientTryCounter = 0;

  2524.         pData->transientFirstTry = false;

  2525.     }

  2526. #endif

  2527. }

  2528. 

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

  2530. {

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

  2532.     return;

  2533. 

  2534.     // unused

  2535.     (void)value;

  2536. }

  2537. 

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

  2539. {

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

  2541. }

  2542. 

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

  2544. {

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

  2546. }

  2547. 

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

  2549. {

  2550.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2551.     CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

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

  2553. }

  2554. 

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

  2556. {

  2557.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2558.     CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

  2559. }

  2560. 

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

  2562. {

  2563.     return pData->engine;

  2564. }

  2565. 

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

  2567. {

  2568.     return pData->client;

  2569. }

  2570. 

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

  2572. {

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

  2574. }

  2575. 

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

  2577. {

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

  2579. }

  2580. 

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

  2582. {

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

  2584. }

  2585. 

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

  2587. {

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

  2589. }

  2590. 

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

  2592. {

  2593.     return pData->event.portIn;

  2594. }

  2595. 

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

  2597. {

  2598.     return pData->event.portOut;

  2599. }

  2600. 

  2601. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  2603. {

  2604.     if (pData->midiLearnParameterIndex < 0)

  2605.         return;

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

  2607.         return;

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

  2609.         return;

  2610. 

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

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

  2613. 

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

  2615.     CARLA_SAFE_ASSERT_INT_RETURN(paramData.mappedControlIndex == CONTROL_INDEX_MIDI_LEARN,

  2616.                                  paramData.mappedControlIndex,);

  2617. 

  2618.     event.ctrl.handled = true;

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

  2620.     paramData.midiChannel = event.channel;

  2621. 

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

  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