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

2626 lines
86KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin

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

  4.  *

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

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

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

  8.  * the License, or any later version.

  9.  *

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

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

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

  13.  * GNU General Public License for more details.

  14.  *

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

  16.  */

  17. 

  18. #include "CarlaPluginInternal.hpp"

  19. #include "CarlaEngine.hpp"

  20. 

  21. #include "CarlaBackendUtils.hpp"

  22. #include "CarlaBase64Utils.hpp"

  23. #include "CarlaMathUtils.hpp"

  24. #include "CarlaPluginUI.hpp"

  25. #include "CarlaScopeUtils.hpp"

  26. #include "CarlaStringList.hpp"

  27. 

  28. #include <ctime>

  29. 

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

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

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

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

  34. 

  35. using water::CharPointer_UTF8;

  36. using water::File;

  37. using water::MemoryOutputStream;

  38. using water::Result;

  39. using water::String;

  40. using water::XmlDocument;

  41. using water::XmlElement;

  42. 

  43. CARLA_BACKEND_START_NAMESPACE

  44. 

  45. // -------------------------------------------------------------------

  46. // Fallback data

  47. 

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

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

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

  51. 

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

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

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

  55. 

  56. // -------------------------------------------------------------------

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

  58. 

  59. struct ParamSymbol {

  60.     int32_t index;

  61.     const char* symbol;

  62. 

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

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

  65.           symbol(carla_strdup(s)) {}

  66. 

  67.     ~ParamSymbol() noexcept

  68.     {

  69.         CARLA_SAFE_ASSERT_RETURN(symbol != nullptr,)

  70. 

  71.         delete[] symbol;

  72.         symbol = nullptr;

  73.     }

  74. 

  75. #ifdef CARLA_PROPER_CPP11_SUPPORT

  76.     ParamSymbol() = delete;

  77.     CARLA_DECLARE_NON_COPY_STRUCT(ParamSymbol)

  78. #endif

  79. };

  80. 

  81. // -------------------------------------------------------------------

  82. // Constructor and destructor

  83. 

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

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

  86. {

  87.     CARLA_SAFE_ASSERT_RETURN(engine != nullptr,);

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

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

  90. 

  91.     switch (engine->getProccessMode())

  92.     {

  93.     case ENGINE_PROCESS_MODE_SINGLE_CLIENT:

  94.     case ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS:

  95.         CARLA_SAFE_ASSERT(id < MAX_DEFAULT_PLUGINS);

  96.         break;

  97. 

  98.     case ENGINE_PROCESS_MODE_CONTINUOUS_RACK:

  99.         CARLA_SAFE_ASSERT(id < MAX_RACK_PLUGINS);

  100.         break;

  101. 

  102.     case ENGINE_PROCESS_MODE_PATCHBAY:

  103.         CARLA_SAFE_ASSERT(id < MAX_PATCHBAY_PLUGINS);

  104.         break;

  105. 

  106.     case ENGINE_PROCESS_MODE_BRIDGE:

  107.         CARLA_SAFE_ASSERT(id == 0);

  108.         break;

  109.     }

  110. }

  111. 

  112. CarlaPlugin::~CarlaPlugin()

  113. {

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

  115. 

  116.     delete pData;

  117. }

  118. 

  119. // -------------------------------------------------------------------

  120. // Information (base)

  121. 

  122. uint CarlaPlugin::getId() const noexcept

  123. {

  124.     return pData->id;

  125. }

  126. 

  127. uint CarlaPlugin::getHints() const noexcept

  128. {

  129.     return pData->hints;

  130. }

  131. 

  132. uint CarlaPlugin::getOptionsEnabled() const noexcept

  133. {

  134.     return pData->options;

  135. }

  136. 

  137. bool CarlaPlugin::isEnabled() const noexcept

  138. {

  139.     return pData->enabled;

  140. }

  141. 

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

  143. {

  144.     return pData->name;

  145. }

  146. 

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

  148. {

  149.     return pData->filename;

  150. }

  151. 

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

  153. {

  154.     return pData->iconName;

  155. }

  156. 

  157. PluginCategory CarlaPlugin::getCategory() const noexcept

  158. {

  159.     return getPluginCategoryFromName(pData->name);

  160. }

  161. 

  162. int64_t CarlaPlugin::getUniqueId() const noexcept

  163. {

  164.     return 0;

  165. }

  166. 

  167. uint32_t CarlaPlugin::getLatencyInFrames() const noexcept

  168. {

  169.     return 0;

  170. }

  171. 

  172. // -------------------------------------------------------------------

  173. // Information (count)

  174. 

  175. uint32_t CarlaPlugin::getAudioInCount() const noexcept

  176. {

  177.     return pData->audioIn.count;

  178. }

  179. 

  180. uint32_t CarlaPlugin::getAudioOutCount() const noexcept

  181. {

  182.     return pData->audioOut.count;

  183. }

  184. 

  185. uint32_t CarlaPlugin::getCVInCount() const noexcept

  186. {

  187.     return pData->cvIn.count;

  188. }

  189. 

  190. uint32_t CarlaPlugin::getCVOutCount() const noexcept

  191. {

  192.     return pData->cvOut.count;

  193. }

  194. 

  195. uint32_t CarlaPlugin::getMidiInCount() const noexcept

  196. {

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

  198. }

  199. 

  200. uint32_t CarlaPlugin::getMidiOutCount() const noexcept

  201. {

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

  203. }

  204. 

  205. uint32_t CarlaPlugin::getParameterCount() const noexcept

  206. {

  207.     return pData->param.count;

  208. }

  209. 

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

  211. {

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

  213.     return 0;

  214. }

  215. 

  216. uint32_t CarlaPlugin::getProgramCount() const noexcept

  217. {

  218.     return pData->prog.count;

  219. }

  220. 

  221. uint32_t CarlaPlugin::getMidiProgramCount() const noexcept

  222. {

  223.     return pData->midiprog.count;

  224. }

  225. 

  226. uint32_t CarlaPlugin::getCustomDataCount() const noexcept

  227. {

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

  229. }

  230. 

  231. // -------------------------------------------------------------------

  232. // Information (current data)

  233. 

  234. int32_t CarlaPlugin::getCurrentProgram() const noexcept

  235. {

  236.     return pData->prog.current;

  237. }

  238. 

  239. int32_t CarlaPlugin::getCurrentMidiProgram() const noexcept

  240. {

  241.     return pData->midiprog.current;

  242. }

  243. 

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

  245. {

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

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

  248. }

  249. 

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

  251. {

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

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

  254. }

  255. 

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

  257. {

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

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

  260. }

  261. 

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

  263. {

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

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

  266. }

  267. 

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

  269. {

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

  271. }

  272. 

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

  274. {

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

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

  277.     return 0;

  278. }

  279. 

  280. // -------------------------------------------------------------------

  281. // Information (per-plugin data)

  282. 

  283. uint CarlaPlugin::getOptionsAvailable() const noexcept

  284. {

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

  286.     return 0x0;

  287. }

  288. 

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

  290. {

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

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

  293.     return 0.0f;

  294. }

  295. 

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

  297. {

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

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

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

  301.     return 0.0f;

  302. }

  303. 

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

  305. {

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

  307.     return false;

  308. }

  309. 

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

  311. {

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

  313.     return false;

  314. }

  315. 

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

  317. {

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

  319.     return false;

  320. }

  321. 

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

  323. {

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

  325.     return false;

  326. }

  327. 

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

  329. {

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

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

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

  333.     return false;

  334. }

  335. 

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

  337. {

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

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

  340.     return false;

  341. }

  342. 

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

  344. {

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

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

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

  348.     return false;

  349. }

  350. 

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

  352. {

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

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

  355.     return false;

  356. }

  357. 

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

  359. {

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

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

  362.     return false;

  363. }

  364. 

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

  366. {

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

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

  369.     return false;

  370. }

  371. 

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

  373. {

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

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

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

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

  378.     return false;

  379. }

  380. 

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

  382. {

  383. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  385. 

  386.     switch (parameterId)

  387.     {

  388.     case PARAMETER_ACTIVE:

  389.         return pData->active;

  390.     case PARAMETER_CTRL_CHANNEL:

  391.         return pData->ctrlChannel;

  392.     case PARAMETER_DRYWET:

  393.         return pData->postProc.dryWet;

  394.     case PARAMETER_VOLUME:

  395.         return pData->postProc.volume;

  396.     case PARAMETER_BALANCE_LEFT:

  397.         return pData->postProc.balanceLeft;

  398.     case PARAMETER_BALANCE_RIGHT:

  399.         return pData->postProc.balanceRight;

  400.     case PARAMETER_PANNING:

  401.         return pData->postProc.panning;

  402.     };

  403. #endif

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

  405. 

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

  407. }

  408. 

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

  410. {

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

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

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

  414.     return true;

  415. }

  416. 

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

  418. {

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

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

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

  422.     return true;

  423. }

  424. 

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

  426. {

  427.     ins  = 0;

  428.     outs = 0;

  429. 

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

  431.     {

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

  433.             ++ins;

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

  435.             ++outs;

  436.     }

  437. }

  438. 

  439. // -------------------------------------------------------------------

  440. // Set data (state)

  441. 

  442. void CarlaPlugin::prepareForSave()

  443. {

  444. }

  445. 

  446. void CarlaPlugin::resetParameters() noexcept

  447. {

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

  449.     {

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

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

  452. 

  453.         if (paramData.type != PARAMETER_INPUT)

  454.             continue;

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

  456.             continue;

  457. 

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

  459.     }

  460. }

  461. 

  462. void CarlaPlugin::randomizeParameters() noexcept

  463. {

  464.     float value, random;

  465. 

  466.     char strBuf[STR_MAX+1];

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

  468. 

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

  470. 

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

  472.     {

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

  474. 

  475.         if (paramData.type != PARAMETER_INPUT)

  476.             continue;

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

  478.             continue;

  479. 

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

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

  482. 

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

  484.             continue;

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

  486.             continue;

  487. 

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

  489. 

  490.         if (paramData.hints & PARAMETER_IS_BOOLEAN)

  491.         {

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

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

  494.         }

  495.         else

  496.         {

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

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

  499. 

  500.             if (paramData.hints & PARAMETER_IS_INTEGER)

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

  502.         }

  503. 

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

  505.     }

  506. }

  507. 

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

  509. {

  510.     if (callPrepareForSave)

  511.         prepareForSave();

  512. 

  513.     pData->stateSave.clear();

  514. 

  515.     const PluginType pluginType(getType());

  516. 

  517.     char strBuf[STR_MAX+1];

  518.     carla_zeroChars(strBuf, STR_MAX+1);

  519. 

  520.     // ---------------------------------------------------------------

  521.     // Basic info

  522. 

  523.     if (! getLabel(strBuf))

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

  525. 

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

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

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

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

  530. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  532. #endif

  533. 

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

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

  536. 

  537. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  538.     // ---------------------------------------------------------------

  539.     // Internals

  540. 

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

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

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

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

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

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

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

  548. #endif

  549. 

  550.     bool usingChunk = false;

  551. 

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

  553.     // Chunk

  554. 

  555.     if (pData->options & PLUGIN_OPTION_USE_CHUNKS)

  556.     {

  557.         void* data = nullptr;

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

  559. 

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

  561.         {

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

  563. 

  564.             if (pluginType != PLUGIN_INTERNAL)

  565.                 usingChunk = true;

  566.         }

  567.     }

  568. 

  569.     // ---------------------------------------------------------------

  570.     // Current Program

  571. 

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

  573.     {

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

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

  576.     }

  577. 

  578.     // ---------------------------------------------------------------

  579.     // Current MIDI Program

  580. 

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

  582.     {

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

  584. 

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

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

  587.     }

  588. 

  589.     // ---------------------------------------------------------------

  590.     // Parameters

  591. 

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

  593. 

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

  595.     {

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

  597. 

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

  599.             continue;

  600. 

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

  602. 

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

  604.             continue;

  605. 

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

  607. 

  608.         stateParameter->dummy = dummy;

  609.         stateParameter->index = paramData.index;

  610. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  611.         stateParameter->mappedControlIndex = paramData.mappedControlIndex;

  612.         stateParameter->midiChannel        = paramData.midiChannel;

  613. 

  614.         if (paramData.hints & PARAMETER_MAPPED_RANGES_SET)

  615.         {

  616.             stateParameter->mappedMinimum = paramData.mappedMinimum;

  617.             stateParameter->mappedMaximum = paramData.mappedMaximum;

  618.             stateParameter->mappedRangeValid = true;

  619. 

  620.             if (paramData.hints & PARAMETER_USES_SAMPLERATE)

  621.             {

  622.                 stateParameter->mappedMinimum /= sampleRate;

  623.                 stateParameter->mappedMaximum /= sampleRate;

  624.             }

  625.         }

  626. #endif

  627. 

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

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

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

  631. 

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

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

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

  635. 

  636.         if (! dummy)

  637.         {

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

  639. 

  640.             if (paramData.hints & PARAMETER_USES_SAMPLERATE)

  641.                 stateParameter->value /= sampleRate;

  642.         }

  643. 

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

  645.     }

  646. 

  647.     // ---------------------------------------------------------------

  648.     // Custom Data

  649. 

  650.     if (pData->hints & PLUGIN_IS_BRIDGE)

  651.         waitForBridgeSaveSignal();

  652. 

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

  654.     {

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

  656.         CARLA_SAFE_ASSERT_CONTINUE(cData.isValid());

  657. 

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

  659. 

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

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

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

  663. 

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

  665.     }

  666. 

  667.     return pData->stateSave;

  668. }

  669. 

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

  671. {

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

  673.     const PluginType pluginType(getType());

  674. 

  675.     char strBuf[STR_MAX+1];

  676.     carla_zeroChars(strBuf, STR_MAX+1);

  677. 

  678.     // ---------------------------------------------------------------

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

  680. 

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

  682.     {

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

  684.         CARLA_SAFE_ASSERT_CONTINUE(stateCustomData != nullptr);

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

  686. 

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

  688. 

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

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

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

  692.             pass();

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

  694.             pass();

  695.         else

  696.             continue;

  697. 

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

  699.     }

  700. 

  701.     // ---------------------------------------------------------------

  702.     // Part 2 - set program

  703. 

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

  705.     {

  706.         int32_t programId = -1;

  707. 

  708.         // index < count

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

  710.         {

  711.             programId = stateSave.currentProgramIndex;

  712.         }

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

  714.         else

  715.         {

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

  717.             {

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

  719.                 {

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

  721.                     break;

  722.                 }

  723.             }

  724.         }

  725. 

  726.         // set program now, if valid

  727.         if (programId >= 0)

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

  729.     }

  730. 

  731.     // ---------------------------------------------------------------

  732.     // Part 3 - set midi program

  733. 

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

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

  736. 

  737.     // ---------------------------------------------------------------

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

  739. 

  740.     LinkedList<ParamSymbol*> paramSymbols;

  741. 

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

  743.     {

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

  745.         {

  746.             if (getParameterSymbol(i, strBuf))

  747.             {

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

  749.                 paramSymbols.append(paramSymbol);

  750.             }

  751.         }

  752.     }

  753. 

  754.     // ---------------------------------------------------------------

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

  756. 

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

  758. 

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

  760.     {

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

  762.         CARLA_SAFE_ASSERT_CONTINUE(stateParameter != nullptr);

  763. 

  764.         int32_t index = -1;

  765. 

  766.         if (pluginType == PLUGIN_LADSPA)

  767.         {

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

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

  770.             {

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

  772.                 {

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

  774.                     CARLA_SAFE_ASSERT_CONTINUE(paramSymbol != nullptr);

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

  776. 

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

  778.                     {

  779.                         index = paramSymbol->index;

  780.                         break;

  781.                     }

  782.                 }

  783.                 if (index == -1)

  784.                     index = stateParameter->index;

  785.             }

  786.             else

  787.             {

  788.                 index = stateParameter->index;

  789.             }

  790.         }

  791.         else if (pluginType == PLUGIN_LV2)

  792.         {

  793.             // Symbol only

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

  795.             {

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

  797.                 {

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

  799.                     CARLA_SAFE_ASSERT_CONTINUE(paramSymbol != nullptr);

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

  801. 

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

  803.                     {

  804.                         index = paramSymbol->index;

  805.                         break;

  806.                     }

  807.                 }

  808.                 if (index == -1)

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

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

  811.             }

  812.             else

  813.             {

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

  815.             }

  816.         }

  817.         else

  818.         {

  819.             // Index only

  820.             index = stateParameter->index;

  821.         }

  822. 

  823.         // Now set parameter

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

  825.         {

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

  827. 

  828.             if (! stateParameter->dummy)

  829.             {

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

  831.                     stateParameter->value *= sampleRate;

  832. 

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

  834.             }

  835. 

  836. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  837.             if (stateParameter->mappedRangeValid)

  838.             {

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

  840.                 {

  841.                     stateParameter->mappedMinimum *= sampleRate;

  842.                     stateParameter->mappedMaximum *= sampleRate;

  843.                 }

  844. 

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

  846.                                         stateParameter->mappedMinimum,

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

  848.             }

  849. 

  850.             setParameterMappedControlIndex(static_cast<uint32_t>(index), stateParameter->mappedControlIndex, true, true);

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

  852. #endif

  853.         }

  854.         else

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

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

  857.     }

  858. 

  859.     // ---------------------------------------------------------------

  860.     // Part 4c - clear

  861. 

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

  863.     {

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

  865.         delete paramSymbol;

  866.     }

  867. 

  868.     paramSymbols.clear();

  869. 

  870.     // ---------------------------------------------------------------

  871.     // Part 5 - set custom data

  872. 

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

  874.     {

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

  876.         CARLA_SAFE_ASSERT_CONTINUE(stateCustomData != nullptr);

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

  878. 

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

  880. 

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

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

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

  884.             continue;

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

  886.             continue;

  887. 

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

  889.     }

  890. 

  891.     // ---------------------------------------------------------------

  892.     // Part 5x - set lv2 state

  893. 

  894.     if (pluginType == PLUGIN_LV2)

  895.     {

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

  897.         {

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

  899.             CARLA_SAFE_ASSERT_CONTINUE(customData.isValid());

  900. 

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

  902.                 continue;

  903. 

  904.             restoreLV2State();

  905.             break;

  906.         }

  907.     }

  908. 

  909.     // ---------------------------------------------------------------

  910.     // Part 6 - set chunk

  911. 

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

  913.     {

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

  915. #ifdef CARLA_PROPER_CPP11_SUPPORT

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

  917. #else

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

  919. #endif

  920.     }

  921. 

  922. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  924.     // Part 6 - set internal stuff

  925. 

  926.     const uint availOptions(getOptionsAvailable());

  927. 

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

  929.     {

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

  931. 

  932.         if (availOptions & option)

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

  934.     }

  935. 

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

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

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

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

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

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

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

  943. 

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

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

  946. #endif

  947. }

  948. 

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

  950. {

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

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

  953. 

  954.     MemoryOutputStream out, streamState;

  955.     getStateSave().dumpToMemoryStream(streamState);

  956. 

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

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

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

  960.     out << streamState;

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

  962. 

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

  964.     File file(jfilename);

  965. 

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

  967.         return true;

  968. 

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

  970.     return false;

  971. }

  972. 

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

  974. {

  975.     // TODO set errors

  976. 

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

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

  979. 

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

  981.     File file(jfilename);

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

  983. 

  984.     XmlDocument xml(file);

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

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

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

  988. 

  989.     // completely load file

  990.     xmlElement = xml.getDocumentElement(false);

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

  992. 

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

  994.     {

  995.         loadStateSave(pData->stateSave);

  996.         return true;

  997.     }

  998. 

  999.     return false;

  1000. }

  1001. 

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

  1003. {

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

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

  1006. 

  1007.     CarlaString bundlepath(lv2path);

  1008. 

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

  1010.         bundlepath += ".lv2";

  1011. 

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

  1013. 

  1014.     if (bundlefolder.existsAsFile())

  1015.     {

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

  1017.         return false;

  1018.     }

  1019. 

  1020.     if (! bundlefolder.exists())

  1021.     {

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

  1023. 

  1024.         if (res.failed())

  1025.         {

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

  1027.             return false;

  1028.         }

  1029.     }

  1030. 

  1031.     CarlaString symbol(pData->name);

  1032.     symbol.toBasic();

  1033. 

  1034.     {

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

  1036. 

  1037.         if (! saveStateToFile(pluginFilename))

  1038.             return false;

  1039.     }

  1040. 

  1041.     {

  1042.         MemoryOutputStream manifestStream;

  1043. 

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

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

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

  1047.         manifestStream << "\n";

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

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

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

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

  1052.         manifestStream << "\n";

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

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

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

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

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

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

  1059.         manifestStream << "\n";

  1060. 

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

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

  1063. 

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

  1065.         {

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

  1067.             return false;

  1068.         }

  1069.     }

  1070. 

  1071.     {

  1072.         MemoryOutputStream mainStream;

  1073. 

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

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

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

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

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

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

  1080.         mainStream << "\n";

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

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

  1083.         mainStream << "\n";

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

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

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

  1087.         mainStream << "\n";

  1088. 

  1089.         if (pData->hints & PLUGIN_HAS_CUSTOM_UI)

  1090.         {

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

  1092.             mainStream << "\n";

  1093.         }

  1094. 

  1095.         const uint32_t midiIns  = getMidiInCount();

  1096.         const uint32_t midiOuts = getMidiOutCount();

  1097. 

  1098.         int portIndex = 0;

  1099. 

  1100.         if (midiIns > 0)

  1101.         {

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

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

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

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

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

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

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

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

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

  1111.             ++portIndex;

  1112. 

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

  1114.             {

  1115.                 const String portIndexNum(portIndex++);

  1116.                 const String portIndexLabel(portIndex);

  1117. 

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

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

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

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

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

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

  1124.             }

  1125.         }

  1126.         else

  1127.         {

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

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

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

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

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

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

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

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

  1136.             ++portIndex;

  1137.         }

  1138. 

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

  1140.         {

  1141.             const String portIndexNum(portIndex++);

  1142.             const String portIndexLabel(portIndex);

  1143. 

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

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

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

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

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

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

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

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

  1152.         }

  1153. 

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

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

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

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

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

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

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

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

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

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

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

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

  1166. 

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

  1168.         {

  1169.             const String portIndexNum(portIndex++);

  1170.             const String portIndexLabel(i+1);

  1171. 

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

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

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

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

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

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

  1178.         }

  1179. 

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

  1181.         {

  1182.             const String portIndexNum(portIndex++);

  1183.             const String portIndexLabel(i+1);

  1184. 

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

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

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

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

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

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

  1191.         }

  1192. 

  1193.         CarlaStringList uniqueSymbolNames;

  1194. 

  1195.         char strBufName[STR_MAX+1];

  1196.         char strBufSymbol[STR_MAX+1];

  1197.         carla_zeroChars(strBufName, STR_MAX+1);

  1198.         carla_zeroChars(strBufSymbol, STR_MAX+1);

  1199. 

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

  1201.         {

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

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

  1204. 

  1205.             const String portIndexNum(portIndex++);

  1206. 

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

  1208. 

  1209.             if (paramData.type == PARAMETER_INPUT)

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

  1211.             else

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

  1213. 

  1214.             if (paramData.hints & PARAMETER_IS_BOOLEAN)

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

  1216. 

  1217.             if (paramData.hints & PARAMETER_IS_INTEGER)

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

  1219. 

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

  1221. 

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

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

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

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

  1226. 

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

  1228.             {

  1229.                 CarlaString s(strBufName);

  1230.                 s.toBasic();

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

  1232. 

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

  1234.                 {

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

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

  1237.                     strBufSymbol[0]   = '_';

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

  1239.                 }

  1240.             }

  1241. 

  1242.             if (uniqueSymbolNames.contains(strBufSymbol))

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

  1244. 

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

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

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

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

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

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

  1251. 

  1252.             // TODO midiCC, midiChannel

  1253. 

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

  1255.         }

  1256. 

  1257.         char strBuf[STR_MAX+1];

  1258.         carla_zeroChars(strBuf, STR_MAX+1);

  1259. 

  1260.         if (! getMaker(strBuf))

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

  1262. 

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

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

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

  1266.         mainStream << "\n";

  1267. 

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

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

  1270. 

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

  1272.         {

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

  1274.             return false;

  1275.         }

  1276.     }

  1277. 

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

  1279. 

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

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

  1282. 

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

  1284. 

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

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

  1287. 

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

  1289.     {

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

  1291.         return false;

  1292.     }

  1293. 

  1294. #ifdef CARLA_OS_WIN

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

  1296. 

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

  1298.     const File binFolder1(opts.binaryDir);

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

  1300.     binFolder2.createDirectory();

  1301. 

  1302.     static const char* files[] = {

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

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

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

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

  1307.       "libcarla_utils.dll"

  1308.     };

  1309. 

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

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

  1312. #else

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

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

  1315. #endif

  1316. 

  1317.     return true;

  1318. }

  1319. 

  1320. // -------------------------------------------------------------------

  1321. // Set data (internal stuff)

  1322. 

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

  1324. {

  1325.     pData->id = newId;

  1326. }

  1327. 

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

  1329. {

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

  1331. 

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

  1333.         delete[] pData->name;

  1334. 

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

  1336. }

  1337. 

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

  1339. {

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

  1341. 

  1342.     if (yesNo)

  1343.         pData->options |= option;

  1344.     else

  1345.         pData->options &= ~option;

  1346. 

  1347. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1348.     if (sendCallback)

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

  1350.                                 ENGINE_CALLBACK_OPTION_CHANGED,

  1351.                                 pData->id,

  1352.                                 static_cast<int>(option),

  1353.                                 yesNo ? 1 : 0,

  1354.                                 0, 0.0f, nullptr);

  1355. #else

  1356.     // unused

  1357.     return; (void)sendCallback;

  1358. #endif

  1359. }

  1360. 

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

  1362. {

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

  1364.         return;

  1365. 

  1366.     pData->masterMutex.lock();

  1367.     pData->enabled = yesNo;

  1368. 

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

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

  1371. 

  1372.     pData->masterMutex.unlock();

  1373. }

  1374. 

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

  1376. {

  1377.     if (pData->engineBridged) {

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

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

  1380.         // nothing here

  1381.     } else {

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

  1383.     }

  1384. 

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

  1386.         return;

  1387. 

  1388.     {

  1389.         const ScopedSingleProcessLocker spl(this, true);

  1390. 

  1391.         if (active)

  1392.             activate();

  1393.         else

  1394.             deactivate();

  1395.     }

  1396. 

  1397.     pData->active = active;

  1398. 

  1399. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  1401. 

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

  1403.                             ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  1404.                             pData->id,

  1405.                             PARAMETER_ACTIVE,

  1406.                             0, 0,

  1407.                             value,

  1408.                             nullptr);

  1409. #endif

  1410. }

  1411. 

  1412. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  1414. {

  1415.     if (pData->engineBridged) {

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

  1417.     } else {

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

  1419.     }

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

  1421. 

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

  1423. 

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

  1425.         return;

  1426. 

  1427.     pData->postProc.dryWet = fixedValue;

  1428. 

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

  1430.                             ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  1431.                             pData->id,

  1432.                             PARAMETER_DRYWET,

  1433.                             0, 0,

  1434.                             fixedValue,

  1435.                             nullptr);

  1436. }

  1437. 

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

  1439. {

  1440.     if (pData->engineBridged) {

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

  1442.     } else {

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

  1444.     }

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

  1446. 

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

  1448. 

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

  1450.         return;

  1451. 

  1452.     pData->postProc.volume = fixedValue;

  1453. 

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

  1455.                             ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  1456.                             pData->id,

  1457.                             PARAMETER_VOLUME,

  1458.                             0, 0,

  1459.                             fixedValue,

  1460.                             nullptr);

  1461. }

  1462. 

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

  1464. {

  1465.     if (pData->engineBridged) {

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

  1467.     } else {

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

  1469.     }

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

  1471. 

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

  1473. 

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

  1475.         return;

  1476. 

  1477.     pData->postProc.balanceLeft = fixedValue;

  1478. 

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

  1480.                             ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  1481.                             pData->id,

  1482.                             PARAMETER_BALANCE_LEFT,

  1483.                             0, 0,

  1484.                             fixedValue,

  1485.                             nullptr);

  1486. }

  1487. 

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

  1489. {

  1490.     if (pData->engineBridged) {

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

  1492.     } else {

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

  1494.     }

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

  1496. 

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

  1498. 

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

  1500.         return;

  1501. 

  1502.     pData->postProc.balanceRight = fixedValue;

  1503. 

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

  1505.                             ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  1506.                             pData->id,

  1507.                             PARAMETER_BALANCE_RIGHT,

  1508.                             0, 0,

  1509.                             fixedValue,

  1510.                             nullptr);

  1511. }

  1512. 

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

  1514. {

  1515.     if (pData->engineBridged) {

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

  1517.     } else {

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

  1519.     }

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

  1521. 

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

  1523. 

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

  1525.         return;

  1526. 

  1527.     pData->postProc.panning = fixedValue;

  1528. 

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

  1530.                             ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  1531.                             pData->id,

  1532.                             PARAMETER_PANNING,

  1533.                             0, 0,

  1534.                             fixedValue,

  1535.                             nullptr);

  1536. }

  1537. 

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

  1539. {

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

  1541. 

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

  1543. 

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

  1545.         return;

  1546. 

  1547.     pData->postProc.dryWet = fixedValue;

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

  1549. }

  1550. 

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

  1552. {

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

  1554. 

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

  1556. 

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

  1558.         return;

  1559. 

  1560.     pData->postProc.volume = fixedValue;

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

  1562. }

  1563. 

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

  1565. {

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

  1567. 

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

  1569. 

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

  1571.         return;

  1572. 

  1573.     pData->postProc.balanceLeft = fixedValue;

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

  1575. }

  1576. 

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

  1578. {

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

  1580. 

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

  1582. 

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

  1584.         return;

  1585. 

  1586.     pData->postProc.balanceRight = fixedValue;

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

  1588. }

  1589. 

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

  1591. {

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

  1593. 

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

  1595. 

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

  1597.         return;

  1598. 

  1599.     pData->postProc.panning = fixedValue;

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

  1601. }

  1602. #endif // ! BUILD_BRIDGE_ALTERNATIVE_ARCH

  1603. 

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

  1605. {

  1606.     if (pData->engineBridged) {

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

  1608.     } else {

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

  1610.     }

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

  1612. 

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

  1614.         return;

  1615. 

  1616.     pData->ctrlChannel = channel;

  1617. 

  1618. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  1620. 

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

  1622.                             ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  1623.                             pData->id,

  1624.                             PARAMETER_CTRL_CHANNEL,

  1625.                             0, 0,

  1626.                             channelf, nullptr);

  1627. #endif

  1628. }

  1629. 

  1630. // -------------------------------------------------------------------

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

  1632. 

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

  1634. {

  1635.     if (pData->engineBridged) {

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

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

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

  1639.         // nothing here

  1640.     } else {

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

  1642.     }

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

  1644. 

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

  1646.         uiParameterChange(parameterId, value);

  1647. 

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

  1649.                             ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  1650.                             pData->id,

  1651.                             static_cast<int>(parameterId),

  1652.                             0, 0,

  1653.                             value,

  1654.                             nullptr);

  1655. }

  1656. 

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

  1658. {

  1659.     pData->postponeRtEvent(kPluginPostRtEventParameterChange,

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

  1661. }

  1662. 

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

  1664. {

  1665. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  1667. 

  1668.     switch (rindex)

  1669.     {

  1670.     case PARAMETER_ACTIVE:

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

  1672.     case PARAMETER_CTRL_CHANNEL:

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

  1674.     case PARAMETER_DRYWET:

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

  1676.     case PARAMETER_VOLUME:

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

  1678.     case PARAMETER_BALANCE_LEFT:

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

  1680.     case PARAMETER_BALANCE_RIGHT:

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

  1682.     case PARAMETER_PANNING:

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

  1684.     }

  1685. #endif

  1686.     CARLA_SAFE_ASSERT_RETURN(rindex >= 0,);

  1687. 

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

  1689.     {

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

  1691.         {

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

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

  1694.             break;

  1695.         }

  1696.     }

  1697. }

  1698. 

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

  1700. {

  1701.     if (pData->engineBridged) {

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

  1703.     } else {

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

  1705.     }

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

  1707.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  1708. 

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

  1710.         return;

  1711. 

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

  1713. 

  1714. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  1716.                             ENGINE_CALLBACK_PARAMETER_MIDI_CHANNEL_CHANGED,

  1717.                             pData->id,

  1718.                             static_cast<int>(parameterId),

  1719.                             channel,

  1720.                             0, 0.0f, nullptr);

  1721. #endif

  1722. }

  1723. 

  1724. void CarlaPlugin::setParameterMappedControlIndex(const uint32_t parameterId, const int16_t index, const bool sendOsc, const bool sendCallback) noexcept

  1725. {

  1726.     if (pData->engineBridged) {

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

  1728.     } else {

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

  1730.     }

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

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

  1733. 

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

  1735. 

  1736.     if (paramData.mappedControlIndex == index)

  1737.         return;

  1738. 

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

  1740. 

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

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

  1743. 

  1744. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1745.     char strBuf[STR_MAX+1];

  1746.     carla_zeroChars(strBuf, STR_MAX+1);

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

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

  1749. 

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

  1751.     if (portNameSize < STR_MAX)

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

  1753. 

  1754.     if (index == CONTROL_INDEX_CV)

  1755.     {

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

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

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

  1759. 

  1760.         CarlaEngineCVPort* const cvPort =

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

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

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

  1764.     }

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

  1766.     {

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

  1768. 

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

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

  1771.     }

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

  1773.     {

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

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

  1776.             setParameterMappedRange(parameterId,

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

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

  1779.                                     true, true);

  1780.     }

  1781. #endif

  1782. 

  1783.     paramData.mappedControlIndex = index;

  1784. 

  1785. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  1787.                             ENGINE_CALLBACK_PARAMETER_MAPPED_CONTROL_INDEX_CHANGED,

  1788.                             pData->id,

  1789.                             static_cast<int>(parameterId),

  1790.                             index,

  1791.                             0, 0.0f, nullptr);

  1792. #endif

  1793. }

  1794. 

  1795. void CarlaPlugin::setParameterMappedRange(const uint32_t parameterId, const float minimum, const float maximum, const bool sendOsc, const bool sendCallback) noexcept

  1796. {

  1797.     if (pData->engineBridged) {

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

  1799.     } else {

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

  1801.     }

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

  1803. 

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

  1805. 

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

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

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

  1809.         return;

  1810. 

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

  1812.     {

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

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

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

  1816.     }

  1817. 

  1818.     paramData.hints |= PARAMETER_MAPPED_RANGES_SET;

  1819.     paramData.mappedMinimum = minimum;

  1820.     paramData.mappedMaximum = maximum;

  1821. 

  1822. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

  1825. 

  1826.     char strBuf[STR_MAX+1];

  1827.     carla_zeroChars(strBuf, STR_MAX+1);

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

  1829. 

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

  1831.                             ENGINE_CALLBACK_PARAMETER_MAPPED_RANGE_CHANGED,

  1832.                             pData->id,

  1833.                             static_cast<int>(parameterId),

  1834.                             0, 0, 0.0f,

  1835.                             strBuf);

  1836. #endif

  1837. }

  1838. 

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

  1840. {

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

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

  1843.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

  1844. 

  1845.     // Ignore some keys

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

  1847.     {

  1848.         const PluginType ptype = getType();

  1849. 

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

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

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

  1853.             return;

  1854.     }

  1855. 

  1856.     // Check if we already have this key

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

  1858.     {

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

  1860.         CARLA_SAFE_ASSERT_CONTINUE(customData.isValid());

  1861. 

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

  1863.         {

  1864.             if (customData.value != nullptr)

  1865.                 delete[] customData.value;

  1866. 

  1867.             customData.value = carla_strdup(value);

  1868.             return;

  1869.         }

  1870.     }

  1871. 

  1872.     // Otherwise store it

  1873.     CustomData customData;

  1874.     customData.type  = carla_strdup(type);

  1875.     customData.key   = carla_strdup(key);

  1876.     customData.value = carla_strdup(value);

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

  1878. }

  1879. 

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

  1881. {

  1882.     CARLA_SAFE_ASSERT_RETURN(data != nullptr,);

  1883.     CARLA_SAFE_ASSERT_RETURN(dataSize > 0,);

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

  1885. }

  1886. 

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

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

  1889. {

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

  1891. 

  1892.     pData->prog.current = index;

  1893. 

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

  1895.                             ENGINE_CALLBACK_PROGRAM_CHANGED,

  1896.                             pData->id,

  1897.                             index,

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

  1899. 

  1900.     // Change default parameter values

  1901.     if (index >= 0)

  1902.     {

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

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

  1905. 

  1906.         switch (getType())

  1907.         {

  1908.         case PLUGIN_SF2:

  1909.         case PLUGIN_SFZ:

  1910.             break;

  1911. 

  1912.         default:

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

  1914.             break;

  1915.         }

  1916.     }

  1917. }

  1918. 

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

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

  1921. {

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

  1923. 

  1924.     pData->midiprog.current = index;

  1925. 

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

  1927.                             ENGINE_CALLBACK_MIDI_PROGRAM_CHANGED,

  1928.                             pData->id,

  1929.                             index,

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

  1931. 

  1932.     // Change default parameter values

  1933.     if (index >= 0)

  1934.     {

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

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

  1937. 

  1938.         switch (getType())

  1939.         {

  1940.         case PLUGIN_SF2:

  1941.         case PLUGIN_SFZ:

  1942.             break;

  1943. 

  1944.         default:

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

  1946.             break;

  1947.         }

  1948.     }

  1949. }

  1950. 

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

  1952. {

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

  1954.     {

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

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

  1957.     }

  1958. }

  1959. 

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

  1961. {

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

  1963. 

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

  1965.     pData->prog.current = index;

  1966. 

  1967.     // Change default parameter values

  1968.     switch (getType())

  1969.     {

  1970.     case PLUGIN_SF2:

  1971.     case PLUGIN_SFZ:

  1972.         break;

  1973. 

  1974.     default:

  1975.         pData->updateDefaultParameterValues(this);

  1976.         break;

  1977.     }

  1978. 

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

  1980. }

  1981. 

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

  1983. {

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

  1985. 

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

  1987.     pData->midiprog.current = index;

  1988. 

  1989.     // Change default parameter values

  1990.     switch (getType())

  1991.     {

  1992.     case PLUGIN_SF2:

  1993.     case PLUGIN_SFZ:

  1994.         break;

  1995. 

  1996.     default:

  1997.         pData->updateDefaultParameterValues(this);

  1998.         break;

  1999.     }

  2000. 

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

  2002. }

  2003. 

  2004. // -------------------------------------------------------------------

  2005. // Plugin state

  2006. 

  2007. void CarlaPlugin::reloadPrograms(const bool)

  2008. {

  2009. }

  2010. 

  2011. // -------------------------------------------------------------------

  2012. // Plugin processing

  2013. 

  2014. void CarlaPlugin::activate() noexcept

  2015. {

  2016.     CARLA_SAFE_ASSERT(! pData->active);

  2017. }

  2018. 

  2019. void CarlaPlugin::deactivate() noexcept

  2020. {

  2021.     CARLA_SAFE_ASSERT(pData->active);

  2022. }

  2023. 

  2024. void CarlaPlugin::bufferSizeChanged(const uint32_t)

  2025. {

  2026. }

  2027. 

  2028. void CarlaPlugin::sampleRateChanged(const double)

  2029. {

  2030. }

  2031. 

  2032. void CarlaPlugin::offlineModeChanged(const bool)

  2033. {

  2034. }

  2035. 

  2036. // -------------------------------------------------------------------

  2037. // Misc

  2038. 

  2039. void CarlaPlugin::idle()

  2040. {

  2041.     if (! pData->enabled)

  2042.         return;

  2043. 

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

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

  2046.     const uint32_t latency(getLatencyInFrames());

  2047. 

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

  2049.     {

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

  2051. 

  2052.         const ScopedSingleProcessLocker sspl(this, true);

  2053. 

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

  2055. #ifndef BUILD_BRIDGE

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

  2057. #else

  2058.         pData->latency.frames = latency;

  2059. #endif

  2060.     }

  2061. 

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

  2063. 

  2064.     if (rtEvents.isEmpty())

  2065.         return;

  2066. 

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

  2068.     {

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

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

  2071. 

  2072.         switch (event.type)

  2073.         {

  2074.         case kPluginPostRtEventNull: {

  2075.         } break;

  2076. 

  2077.         case kPluginPostRtEventDebug: {

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

  2079.                                     ENGINE_CALLBACK_DEBUG, pData->id,

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

  2081.         } break;

  2082. 

  2083.         case kPluginPostRtEventParameterChange: {

  2084.             // Update UI

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

  2086.             {

  2087.                 if (needsUiMainThread)

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

  2089.                 else

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

  2091.             }

  2092. 

  2093.             if (event.sendCallback)

  2094.             {

  2095.                 // Update Host

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

  2097.                                         ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  2098.                                         pData->id,

  2099.                                         event.value1,

  2100.                                         0, 0,

  2101.                                         event.valuef,

  2102.                                         nullptr);

  2103.             }

  2104.         } break;

  2105. 

  2106.         case kPluginPostRtEventProgramChange: {

  2107.             // Update UI

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

  2109.             {

  2110.                 if (needsUiMainThread)

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

  2112.                 else

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

  2114.             }

  2115. 

  2116.             // Update param values

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

  2118.             {

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

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

  2121. 

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

  2123.                                         ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  2124.                                         pData->id,

  2125.                                         static_cast<int>(j),

  2126.                                         0, 0,

  2127.                                         paramValue,

  2128.                                         nullptr);

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

  2130.                                         ENGINE_CALLBACK_PARAMETER_DEFAULT_CHANGED,

  2131.                                         pData->id,

  2132.                                         static_cast<int>(j),

  2133.                                         0, 0,

  2134.                                         paramDefault,

  2135.                                         nullptr);

  2136.             }

  2137. 

  2138.             if (event.sendCallback)

  2139.             {

  2140.                 // Update Host

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

  2142.                                         ENGINE_CALLBACK_PROGRAM_CHANGED,

  2143.                                         pData->id,

  2144.                                         event.value1,

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

  2146.             }

  2147.         } break;

  2148. 

  2149.         case kPluginPostRtEventMidiProgramChange: {

  2150.             // Update UI

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

  2152.             {

  2153.                 if (needsUiMainThread)

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

  2155.                 else

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

  2157.             }

  2158. 

  2159.             // Update param values

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

  2161.             {

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

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

  2164. 

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

  2166.                                         ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  2167.                                         pData->id,

  2168.                                         static_cast<int>(j),

  2169.                                         0, 0,

  2170.                                         paramValue,

  2171.                                         nullptr);

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

  2173.                                         ENGINE_CALLBACK_PARAMETER_DEFAULT_CHANGED,

  2174.                                         pData->id,

  2175.                                         static_cast<int>(j),

  2176.                                         0, 0,

  2177.                                         paramDefault,

  2178.                                         nullptr);

  2179.             }

  2180. 

  2181.             if (event.sendCallback)

  2182.             {

  2183.                 // Update Host

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

  2185.                                         ENGINE_CALLBACK_MIDI_PROGRAM_CHANGED,

  2186.                                         pData->id,

  2187.                                         event.value1,

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

  2189.             }

  2190.         } break;

  2191. 

  2192.         case kPluginPostRtEventNoteOn: {

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

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

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

  2196. 

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

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

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

  2200. 

  2201.             // Update UI

  2202.             if (hasUI)

  2203.             {

  2204.                 if (needsUiMainThread)

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

  2206.                 else

  2207.                     uiNoteOn(channel, note, velocity);

  2208.             }

  2209. 

  2210.             if (event.sendCallback)

  2211.             {

  2212.                 // Update Host

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

  2214.                                         ENGINE_CALLBACK_NOTE_ON,

  2215.                                         pData->id,

  2216.                                         event.value1,

  2217.                                         event.value2,

  2218.                                         event.value3,

  2219.                                         0.0f, nullptr);

  2220.             }

  2221.         } break;

  2222. 

  2223.         case kPluginPostRtEventNoteOff: {

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

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

  2226. 

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

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

  2229. 

  2230.             // Update UI

  2231.             if (hasUI)

  2232.             {

  2233.                 if (needsUiMainThread)

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

  2235.                 else

  2236.                     uiNoteOff(channel, note);

  2237.             }

  2238. 

  2239.             if (event.sendCallback)

  2240.             {

  2241.                 // Update Host

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

  2243.                                         ENGINE_CALLBACK_NOTE_OFF,

  2244.                                         pData->id,

  2245.                                         event.value1,

  2246.                                         event.value2,

  2247.                                         0, 0.0f, nullptr);

  2248.             }

  2249.         } break;

  2250.         }

  2251.     }

  2252. }

  2253. 

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

  2255. {

  2256.     if (forcedOffline)

  2257.     {

  2258. #ifndef STOAT_TEST_BUILD

  2259.         pData->masterMutex.lock();

  2260.         return true;

  2261. #endif

  2262.     }

  2263. 

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

  2265. }

  2266. 

  2267. void CarlaPlugin::unlock() noexcept

  2268. {

  2269.     pData->masterMutex.unlock();

  2270. }

  2271. 

  2272. // -------------------------------------------------------------------

  2273. // Plugin buffers

  2274. 

  2275. void CarlaPlugin::initBuffers() const noexcept

  2276. {

  2277.     pData->audioIn.initBuffers();

  2278.     pData->audioOut.initBuffers();

  2279.     pData->cvIn.initBuffers();

  2280.     pData->cvOut.initBuffers();

  2281.     pData->event.initBuffers();

  2282. }

  2283. 

  2284. void CarlaPlugin::clearBuffers() noexcept

  2285. {

  2286.     pData->clearBuffers();

  2287. }

  2288. 

  2289. // -------------------------------------------------------------------

  2290. // OSC stuff

  2291. 

  2292. // FIXME

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

  2294. {

  2295.     // do nothing

  2296. }

  2297. 

  2298. // -------------------------------------------------------------------

  2299. // MIDI events

  2300. 

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

  2302. {

  2303.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2304.     CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

  2305.     CARLA_SAFE_ASSERT_RETURN(velo < MAX_MIDI_VALUE,);

  2306. 

  2307.     if (! pData->active)

  2308.         return;

  2309. 

  2310.     ExternalMidiNote extNote;

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

  2312.     extNote.note    = note;

  2313.     extNote.velo    = velo;

  2314. 

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

  2316. 

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

  2318.     {

  2319.         if (velo > 0)

  2320.             uiNoteOn(channel, note, velo);

  2321.         else

  2322.             uiNoteOff(channel, note);

  2323.     }

  2324. 

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

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

  2327.                             pData->id,

  2328.                             channel,

  2329.                             note,

  2330.                             velo,

  2331.                             0.0f, nullptr);

  2332. }

  2333. 

  2334. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2335. void CarlaPlugin::postponeRtAllNotesOff()

  2336. {

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

  2338.         return;

  2339. 

  2340.     PluginPostRtEvent postEvent = {

  2341.         kPluginPostRtEventNoteOff,

  2342.         true,

  2343.         pData->ctrlChannel,

  2344.         0, 0, 0.0f

  2345.     };

  2346. 

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

  2348.     {

  2349.         postEvent.value2 = i;

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

  2351.     }

  2352. }

  2353. #endif

  2354. 

  2355. // -------------------------------------------------------------------

  2356. // UI Stuff

  2357. 

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

  2359. {

  2360.     if (yesNo) {

  2361.         CARLA_SAFE_ASSERT(false);

  2362.     }

  2363. }

  2364. 

  2365. void CarlaPlugin::uiIdle()

  2366. {

  2367.     if (pData->hints & PLUGIN_NEEDS_UI_MAIN_THREAD)

  2368.     {

  2369.         // Update parameter outputs

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

  2371.         {

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

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

  2374.         }

  2375. 

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

  2377. 

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

  2379.         {

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

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

  2382. 

  2383.             switch (event.type)

  2384.             {

  2385.             case kPluginPostRtEventNull:

  2386.             case kPluginPostRtEventDebug:

  2387.                 break;

  2388. 

  2389.             case kPluginPostRtEventParameterChange:

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

  2391.                 break;

  2392. 

  2393.             case kPluginPostRtEventProgramChange:

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

  2395.                 break;

  2396. 

  2397.             case kPluginPostRtEventMidiProgramChange:

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

  2399.                 break;

  2400. 

  2401.             case kPluginPostRtEventNoteOn:

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

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

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

  2405.                 break;

  2406. 

  2407.             case kPluginPostRtEventNoteOff:

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

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

  2410.                 break;

  2411.             }

  2412.         }

  2413. 

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

  2415.     }

  2416. 

  2417. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  2419.         return;

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

  2421.         return;

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

  2423.         return;

  2424. 

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

  2426. 

  2427.     CarlaString uiTitle(pData->name);

  2428.     uiTitle += " (GUI)";

  2429. 

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

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

  2432.     {

  2433.         pData->transientTryCounter = 0;

  2434.         pData->transientFirstTry = false;

  2435.     }

  2436. #endif

  2437. }

  2438. 

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

  2440. {

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

  2442.     return;

  2443. 

  2444.     // unused

  2445.     (void)value;

  2446. }

  2447. 

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

  2449. {

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

  2451. }

  2452. 

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

  2454. {

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

  2456. }

  2457. 

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

  2459. {

  2460.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2461.     CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

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

  2463. }

  2464. 

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

  2466. {

  2467.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2468.     CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

  2469. }

  2470. 

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

  2472. {

  2473.     return pData->engine;

  2474. }

  2475. 

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

  2477. {

  2478.     return pData->client;

  2479. }

  2480. 

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

  2482. {

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

  2484. }

  2485. 

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

  2487. {

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

  2489. }

  2490. 

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

  2492. {

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

  2494. }

  2495. 

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

  2497. {

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

  2499. }

  2500. 

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

  2502. {

  2503.     return pData->event.portIn;

  2504. }

  2505. 

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

  2507. {

  2508.     return pData->event.portOut;

  2509. }

  2510. 

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

  2512. {

  2513.     return nullptr;

  2514. }

  2515. 

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

  2517. {

  2518.     return nullptr;

  2519. }

  2520. 

  2521. uintptr_t CarlaPlugin::getUiBridgeProcessId() const noexcept

  2522. {

  2523.     return 0;

  2524. }

  2525. 

  2526. // -------------------------------------------------------------------

  2527. 

  2528. uint32_t CarlaPlugin::getPatchbayNodeId() const noexcept

  2529. {

  2530.     return pData->nodeId;

  2531. }

  2532. 

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

  2534. {

  2535.     pData->nodeId = nodeId;

  2536. }

  2537. 

  2538. // -------------------------------------------------------------------

  2539. 

  2540. void CarlaPlugin::restoreLV2State() noexcept

  2541. {

  2542.     carla_stderr2("Warning: restoreLV2State() called for non-implemented type");

  2543. }

  2544. 

  2545. void CarlaPlugin::waitForBridgeSaveSignal() noexcept

  2546. {

  2547. }

  2548. 

  2549. // -------------------------------------------------------------------

  2550. // Scoped Disabler

  2551. 

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

  2553.     : fPlugin(plugin),

  2554.       fWasEnabled(false)

  2555. {

  2556.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

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

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

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

  2560. 

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

  2562. 

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

  2564.     {

  2565.         fWasEnabled = true;

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

  2567. 

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

  2569.             plugin->pData->client->deactivate();

  2570.     }

  2571. }

  2572. 

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

  2574. {

  2575.     CARLA_SAFE_ASSERT_RETURN(fPlugin != nullptr,);

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

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

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

  2579. 

  2580.     if (fWasEnabled)

  2581.     {

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

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

  2584.     }

  2585. 

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

  2587. }

  2588. 

  2589. // -------------------------------------------------------------------

  2590. // Scoped Process Locker

  2591. 

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

  2593.     : fPlugin(plugin),

  2594.       fBlock(block)

  2595. {

  2596.     CARLA_SAFE_ASSERT_RETURN(fPlugin != nullptr,);

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

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

  2599. 

  2600.     if (! fBlock)

  2601.         return;

  2602. 

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

  2604. }

  2605. 

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

  2607. {

  2608.     CARLA_SAFE_ASSERT_RETURN(fPlugin != nullptr,);

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

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

  2611. 

  2612.     if (! fBlock)

  2613.         return;

  2614. 

  2615. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

  2618. #endif

  2619. 

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

  2621. }

  2622. 

  2623. // -------------------------------------------------------------------

  2624. 

  2625. CARLA_BACKEND_END_NAMESPACE