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

2615 lines
85KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin

  3.  * Copyright (C) 2011-2018 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 "CarlaStringList.hpp"

  26. 

  27. #include <ctime>

  28. 

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

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

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

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

  33. 

  34. using water::CharPointer_UTF8;

  35. using water::File;

  36. using water::MemoryOutputStream;

  37. using water::Result;

  38. using water::String;

  39. using water::XmlDocument;

  40. using water::XmlElement;

  41. 

  42. CARLA_BACKEND_START_NAMESPACE

  43. 

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

  45. // Fallback data

  46. 

  47. static const ParameterData   kParameterDataNull   = { PARAMETER_UNKNOWN, 0x0, PARAMETER_NULL, -1, -1, 0 };

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

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

  50. 

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

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

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

  54. 

  55. // -------------------------------------------------------------------

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

  57. 

  58. struct ParamSymbol {

  59.     int32_t index;

  60.     const char* symbol;

  61. 

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

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

  64.           symbol(carla_strdup(s)) {}

  65. 

  66.     ~ParamSymbol() noexcept

  67.     {

  68.         CARLA_SAFE_ASSERT_RETURN(symbol != nullptr,)

  69. 

  70.         delete[] symbol;

  71.         symbol = nullptr;

  72.     }

  73. 

  74. #ifdef CARLA_PROPER_CPP11_SUPPORT

  75.     ParamSymbol() = delete;

  76.     CARLA_DECLARE_NON_COPY_STRUCT(ParamSymbol)

  77. #endif

  78. };

  79. 

  80. // -------------------------------------------------------------------

  81. // Constructor and destructor

  82. 

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

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

  85. {

  86.     CARLA_SAFE_ASSERT_RETURN(engine != nullptr,);

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

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

  89. 

  90.     switch (engine->getProccessMode())

  91.     {

  92.     case ENGINE_PROCESS_MODE_SINGLE_CLIENT:

  93.     case ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS:

  94.         CARLA_SAFE_ASSERT(id < MAX_DEFAULT_PLUGINS);

  95.         break;

  96. 

  97.     case ENGINE_PROCESS_MODE_CONTINUOUS_RACK:

  98.         CARLA_SAFE_ASSERT(id < MAX_RACK_PLUGINS);

  99.         break;

  100. 

  101.     case ENGINE_PROCESS_MODE_PATCHBAY:

  102.         CARLA_SAFE_ASSERT(id < MAX_PATCHBAY_PLUGINS);

  103.         break;

  104. 

  105.     case ENGINE_PROCESS_MODE_BRIDGE:

  106.         CARLA_SAFE_ASSERT(id == 0);

  107.         break;

  108.     }

  109. }

  110. 

  111. CarlaPlugin::~CarlaPlugin()

  112. {

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

  114. 

  115.     delete pData;

  116. }

  117. 

  118. // -------------------------------------------------------------------

  119. // Information (base)

  120. 

  121. uint CarlaPlugin::getId() const noexcept

  122. {

  123.     return pData->id;

  124. }

  125. 

  126. uint CarlaPlugin::getHints() const noexcept

  127. {

  128.     return pData->hints;

  129. }

  130. 

  131. uint CarlaPlugin::getOptionsEnabled() const noexcept

  132. {

  133.     return pData->options;

  134. }

  135. 

  136. bool CarlaPlugin::isEnabled() const noexcept

  137. {

  138.     return pData->enabled;

  139. }

  140. 

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

  142. {

  143.     return pData->name;

  144. }

  145. 

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

  147. {

  148.     return pData->filename;

  149. }

  150. 

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

  152. {

  153.     return pData->iconName;

  154. }

  155. 

  156. PluginCategory CarlaPlugin::getCategory() const noexcept

  157. {

  158.     return getPluginCategoryFromName(pData->name);

  159. }

  160. 

  161. int64_t CarlaPlugin::getUniqueId() const noexcept

  162. {

  163.     return 0;

  164. }

  165. 

  166. uint32_t CarlaPlugin::getLatencyInFrames() const noexcept

  167. {

  168.     return 0;

  169. }

  170. 

  171. // -------------------------------------------------------------------

  172. // Information (count)

  173. 

  174. uint32_t CarlaPlugin::getAudioInCount() const noexcept

  175. {

  176.     return pData->audioIn.count;

  177. }

  178. 

  179. uint32_t CarlaPlugin::getAudioOutCount() const noexcept

  180. {

  181.     return pData->audioOut.count;

  182. }

  183. 

  184. uint32_t CarlaPlugin::getCVInCount() const noexcept

  185. {

  186.     return pData->cvIn.count;

  187. }

  188. 

  189. uint32_t CarlaPlugin::getCVOutCount() const noexcept

  190. {

  191.     return pData->cvOut.count;

  192. }

  193. 

  194. uint32_t CarlaPlugin::getMidiInCount() const noexcept

  195. {

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

  197. }

  198. 

  199. uint32_t CarlaPlugin::getMidiOutCount() const noexcept

  200. {

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

  202. }

  203. 

  204. uint32_t CarlaPlugin::getParameterCount() const noexcept

  205. {

  206.     return pData->param.count;

  207. }

  208. 

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

  210. {

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

  212.     return 0;

  213. }

  214. 

  215. uint32_t CarlaPlugin::getProgramCount() const noexcept

  216. {

  217.     return pData->prog.count;

  218. }

  219. 

  220. uint32_t CarlaPlugin::getMidiProgramCount() const noexcept

  221. {

  222.     return pData->midiprog.count;

  223. }

  224. 

  225. uint32_t CarlaPlugin::getCustomDataCount() const noexcept

  226. {

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

  228. }

  229. 

  230. // -------------------------------------------------------------------

  231. // Information (current data)

  232. 

  233. int32_t CarlaPlugin::getCurrentProgram() const noexcept

  234. {

  235.     return pData->prog.current;

  236. }

  237. 

  238. int32_t CarlaPlugin::getCurrentMidiProgram() const noexcept

  239. {

  240.     return pData->midiprog.current;

  241. }

  242. 

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

  244. {

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

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

  247. }

  248. 

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

  250. {

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

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

  253. }

  254. 

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

  256. {

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

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

  259. }

  260. 

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

  262. {

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

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

  265. }

  266. 

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

  268. {

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

  270. }

  271. 

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

  273. {

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

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

  276.     return 0;

  277. }

  278. 

  279. // -------------------------------------------------------------------

  280. // Information (per-plugin data)

  281. 

  282. uint CarlaPlugin::getOptionsAvailable() const noexcept

  283. {

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

  285.     return 0x0;

  286. }

  287. 

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

  289. {

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

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

  292.     return 0.0f;

  293. }

  294. 

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

  296. {

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

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

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

  300.     return 0.0f;

  301. }

  302. 

  303. void CarlaPlugin::getLabel(char* const strBuf) const noexcept

  304. {

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

  306. }

  307. 

  308. void CarlaPlugin::getMaker(char* const strBuf) const noexcept

  309. {

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

  311. }

  312. 

  313. void CarlaPlugin::getCopyright(char* const strBuf) const noexcept

  314. {

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

  316. }

  317. 

  318. void CarlaPlugin::getRealName(char* const strBuf) const noexcept

  319. {

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

  321. }

  322. 

  323. void CarlaPlugin::getParameterName(const uint32_t parameterId, char* const strBuf) const noexcept

  324. {

  325.     CARLA_SAFE_ASSERT_RETURN(parameterId < getParameterCount(),);

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

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

  328. }

  329. 

  330. void CarlaPlugin::getParameterSymbol(const uint32_t parameterId, char* const strBuf) const noexcept

  331. {

  332.     CARLA_SAFE_ASSERT_RETURN(parameterId < getParameterCount(),);

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

  334. }

  335. 

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

  337. {

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

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

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

  341. }

  342. 

  343. void CarlaPlugin::getParameterUnit(const uint32_t parameterId, char* const strBuf) const noexcept

  344. {

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

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

  347. }

  348. 

  349. void CarlaPlugin::getParameterScalePointLabel(const uint32_t parameterId, const uint32_t scalePointId, char* const strBuf) const noexcept

  350. {

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

  352.     CARLA_SAFE_ASSERT_RETURN(scalePointId < getParameterScalePointCount(parameterId),);

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

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

  355. }

  356. 

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

  358. {

  359. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  361. 

  362.     switch (parameterId)

  363.     {

  364.     case PARAMETER_ACTIVE:

  365.         return pData->active;

  366.     case PARAMETER_CTRL_CHANNEL:

  367.         return pData->ctrlChannel;

  368.     case PARAMETER_DRYWET:

  369.         return pData->postProc.dryWet;

  370.     case PARAMETER_VOLUME:

  371.         return pData->postProc.volume;

  372.     case PARAMETER_BALANCE_LEFT:

  373.         return pData->postProc.balanceLeft;

  374.     case PARAMETER_BALANCE_RIGHT:

  375.         return pData->postProc.balanceRight;

  376.     case PARAMETER_PANNING:

  377.         return pData->postProc.panning;

  378.     };

  379. #endif

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

  381. 

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

  383. }

  384. 

  385. void CarlaPlugin::getProgramName(const uint32_t index, char* const strBuf) const noexcept

  386. {

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

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

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

  390. }

  391. 

  392. void CarlaPlugin::getMidiProgramName(const uint32_t index, char* const strBuf) const noexcept

  393. {

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

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

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

  397. }

  398. 

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

  400. {

  401.     ins  = 0;

  402.     outs = 0;

  403. 

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

  405.     {

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

  407.             ++ins;

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

  409.             ++outs;

  410.     }

  411. }

  412. 

  413. // -------------------------------------------------------------------

  414. // Set data (state)

  415. 

  416. void CarlaPlugin::prepareForSave()

  417. {

  418. }

  419. 

  420. void CarlaPlugin::resetParameters() noexcept

  421. {

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

  423.     {

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

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

  426. 

  427.         if (paramData.type != PARAMETER_INPUT)

  428.             continue;

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

  430.             continue;

  431. 

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

  433.     }

  434. }

  435. 

  436. void CarlaPlugin::randomizeParameters() noexcept

  437. {

  438.     float value, random;

  439. 

  440.     char strBuf[STR_MAX+1];

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

  442. 

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

  444. 

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

  446.     {

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

  448. 

  449.         if (paramData.type != PARAMETER_INPUT)

  450.             continue;

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

  452.             continue;

  453. 

  454.         getParameterName(i, strBuf);

  455. 

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

  457.             continue;

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

  459.             continue;

  460. 

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

  462. 

  463.         if (paramData.hints & PARAMETER_IS_BOOLEAN)

  464.         {

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

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

  467.         }

  468.         else

  469.         {

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

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

  472. 

  473.             if (paramData.hints & PARAMETER_IS_INTEGER)

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

  475.         }

  476. 

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

  478.     }

  479. }

  480. 

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

  482. {

  483.     if (callPrepareForSave)

  484.         prepareForSave();

  485. 

  486.     pData->stateSave.clear();

  487. 

  488.     const PluginType pluginType(getType());

  489. 

  490.     char strBuf[STR_MAX+1];

  491. 

  492.     // ---------------------------------------------------------------

  493.     // Basic info

  494. 

  495.     getLabel(strBuf);

  496. 

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

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

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

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

  501. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  503. #endif

  504. 

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

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

  507. 

  508. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  509.     // ---------------------------------------------------------------

  510.     // Internals

  511. 

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

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

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

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

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

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

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

  519. #endif

  520. 

  521.     bool usingChunk = false;

  522. 

  523.     // ---------------------------------------------------------------

  524.     // Chunk

  525. 

  526.     if (pData->options & PLUGIN_OPTION_USE_CHUNKS)

  527.     {

  528.         void* data = nullptr;

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

  530. 

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

  532.         {

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

  534. 

  535.             if (pluginType != PLUGIN_INTERNAL)

  536.                 usingChunk = true;

  537.         }

  538.     }

  539. 

  540.     // ---------------------------------------------------------------

  541.     // Current Program

  542. 

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

  544.     {

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

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

  547.     }

  548. 

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

  550.     // Current MIDI Program

  551. 

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

  553.     {

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

  555. 

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

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

  558.     }

  559. 

  560.     // ---------------------------------------------------------------

  561.     // Parameters

  562. 

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

  564. 

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

  566.     {

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

  568. 

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

  570.             continue;

  571. 

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

  573. 

  574.         if (dummy && paramData.midiCC <= -1)

  575.             continue;

  576. 

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

  578. 

  579.         stateParameter->dummy = dummy;

  580.         stateParameter->index = paramData.index;

  581. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  582.         stateParameter->midiCC      = paramData.midiCC;

  583.         stateParameter->midiChannel = paramData.midiChannel;

  584. #endif

  585. 

  586.         getParameterName(i, strBuf);

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

  588. 

  589.         getParameterSymbol(i, strBuf);

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

  591. 

  592.         if (! dummy)

  593.         {

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

  595. 

  596.             if (paramData.hints & PARAMETER_USES_SAMPLERATE)

  597.                 stateParameter->value /= sampleRate;

  598.         }

  599. 

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

  601.     }

  602. 

  603.     // ---------------------------------------------------------------

  604.     // Custom Data

  605. 

  606.     if (pData->hints & PLUGIN_IS_BRIDGE)

  607.         waitForBridgeSaveSignal();

  608. 

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

  610.     {

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

  612.         CARLA_SAFE_ASSERT_CONTINUE(cData.isValid());

  613. 

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

  615. 

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

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

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

  619. 

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

  621.     }

  622. 

  623.     return pData->stateSave;

  624. }

  625. 

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

  627. {

  628.     char strBuf[STR_MAX+1];

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

  630. 

  631.     const PluginType pluginType(getType());

  632. 

  633.     // ---------------------------------------------------------------

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

  635. 

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

  637.     {

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

  639.         CARLA_SAFE_ASSERT_CONTINUE(stateCustomData != nullptr);

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

  641. 

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

  643. 

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

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

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

  647.             pass();

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

  649.             pass();

  650.         else

  651.             continue;

  652. 

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

  654.     }

  655. 

  656.     // ---------------------------------------------------------------

  657.     // Part 2 - set program

  658. 

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

  660.     {

  661.         int32_t programId = -1;

  662. 

  663.         // index < count

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

  665.         {

  666.             programId = stateSave.currentProgramIndex;

  667.         }

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

  669.         else

  670.         {

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

  672.             {

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

  674.                 getProgramName(i, strBuf);

  675. 

  676.                 if (strBuf[0] != '\0' && std::strcmp(stateSave.currentProgramName, strBuf) == 0)

  677.                 {

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

  679.                     break;

  680.                 }

  681.             }

  682.         }

  683. 

  684.         // set program now, if valid

  685.         if (programId >= 0)

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

  687.     }

  688. 

  689.     // ---------------------------------------------------------------

  690.     // Part 3 - set midi program

  691. 

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

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

  694. 

  695.     // ---------------------------------------------------------------

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

  697. 

  698.     LinkedList<ParamSymbol*> paramSymbols;

  699. 

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

  701.     {

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

  703.         {

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

  705.             getParameterSymbol(i, strBuf);

  706. 

  707.             if (strBuf[0] != '\0')

  708.             {

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

  710.                 paramSymbols.append(paramSymbol);

  711.             }

  712.         }

  713.     }

  714. 

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

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

  717. 

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

  719. 

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

  721.     {

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

  723.         CARLA_SAFE_ASSERT_CONTINUE(stateParameter != nullptr);

  724. 

  725.         int32_t index = -1;

  726. 

  727.         if (pluginType == PLUGIN_LADSPA)

  728.         {

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

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

  731.             {

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

  733.                 {

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

  735.                     CARLA_SAFE_ASSERT_CONTINUE(paramSymbol != nullptr);

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

  737. 

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

  739.                     {

  740.                         index = paramSymbol->index;

  741.                         break;

  742.                     }

  743.                 }

  744.                 if (index == -1)

  745.                     index = stateParameter->index;

  746.             }

  747.             else

  748.             {

  749.                 index = stateParameter->index;

  750.             }

  751.         }

  752.         else if (pluginType == PLUGIN_LV2)

  753.         {

  754.             // Symbol only

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

  756.             {

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

  758.                 {

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

  760.                     CARLA_SAFE_ASSERT_CONTINUE(paramSymbol != nullptr);

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

  762. 

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

  764.                     {

  765.                         index = paramSymbol->index;

  766.                         break;

  767.                     }

  768.                 }

  769.                 if (index == -1)

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

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

  772.             }

  773.             else

  774.             {

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

  776.             }

  777.         }

  778.         else

  779.         {

  780.             // Index only

  781.             index = stateParameter->index;

  782.         }

  783. 

  784.         // Now set parameter

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

  786.         {

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

  788. 

  789.             if (! stateParameter->dummy)

  790.             {

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

  792.                     stateParameter->value *= sampleRate;

  793. 

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

  795.             }

  796. 

  797. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  798.             setParameterMidiCC(static_cast<uint32_t>(index), stateParameter->midiCC, true, true);

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

  800. #endif

  801.         }

  802.         else

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

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

  805.     }

  806. 

  807.     // ---------------------------------------------------------------

  808.     // Part 4c - clear

  809. 

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

  811.     {

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

  813.         delete paramSymbol;

  814.     }

  815. 

  816.     paramSymbols.clear();

  817. 

  818.     // ---------------------------------------------------------------

  819.     // Part 5 - set custom data

  820. 

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

  822.     {

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

  824.         CARLA_SAFE_ASSERT_CONTINUE(stateCustomData != nullptr);

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

  826. 

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

  828. 

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

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

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

  832.             continue;

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

  834.             continue;

  835. 

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

  837.     }

  838. 

  839.     // ---------------------------------------------------------------

  840.     // Part 5x - set lv2 state

  841. 

  842.     if (pluginType == PLUGIN_LV2)

  843.     {

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

  845.         {

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

  847.             CARLA_SAFE_ASSERT_CONTINUE(customData.isValid());

  848. 

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

  850.                 continue;

  851. 

  852.             restoreLV2State();

  853.             break;

  854.         }

  855.     }

  856. 

  857.     // ---------------------------------------------------------------

  858.     // Part 6 - set chunk

  859. 

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

  861.     {

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

  863. #ifdef CARLA_PROPER_CPP11_SUPPORT

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

  865. #else

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

  867. #endif

  868.     }

  869. 

  870. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  871.     // ---------------------------------------------------------------

  872.     // Part 6 - set internal stuff

  873. 

  874.     const uint availOptions(getOptionsAvailable());

  875. 

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

  877.     {

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

  879. 

  880.         if (availOptions & option)

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

  882.     }

  883. 

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

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

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

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

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

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

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

  891. 

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

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

  894. #endif

  895. }

  896. 

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

  898. {

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

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

  901. 

  902.     MemoryOutputStream out, streamState;

  903.     getStateSave().dumpToMemoryStream(streamState);

  904. 

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

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

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

  908.     out << streamState;

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

  910. 

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

  912.     File file(jfilename);

  913. 

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

  915.         return true;

  916. 

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

  918.     return false;

  919. }

  920. 

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

  922. {

  923.     // TODO set errors

  924. 

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

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

  927. 

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

  929.     File file(jfilename);

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

  931. 

  932.     XmlDocument xml(file);

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

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

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

  936. 

  937.     // completely load file

  938.     xmlElement = xml.getDocumentElement(false);

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

  940. 

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

  942.     {

  943.         loadStateSave(pData->stateSave);

  944.         return true;

  945.     }

  946. 

  947.     return false;

  948. }

  949. 

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

  951. {

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

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

  954. 

  955.     CarlaString bundlepath(lv2path);

  956. 

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

  958.         bundlepath += ".lv2";

  959. 

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

  961. 

  962.     if (bundlefolder.existsAsFile())

  963.     {

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

  965.         return false;

  966.     }

  967. 

  968.     if (! bundlefolder.exists())

  969.     {

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

  971. 

  972.         if (res.failed())

  973.         {

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

  975.             return false;

  976.         }

  977.     }

  978. 

  979.     CarlaString symbol(pData->name);

  980.     symbol.toBasic();

  981. 

  982.     {

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

  984. 

  985.         if (! saveStateToFile(pluginFilename))

  986.             return false;

  987.     }

  988. 

  989.     {

  990.         MemoryOutputStream manifestStream;

  991. 

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

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

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

  995.         manifestStream << "\n";

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

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

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

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

  1000.         manifestStream << "\n";

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

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

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

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

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

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

  1007.         manifestStream << "\n";

  1008. 

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

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

  1011. 

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

  1013.         {

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

  1015.             return false;

  1016.         }

  1017.     }

  1018. 

  1019.     {

  1020.         MemoryOutputStream mainStream;

  1021. 

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

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

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

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

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

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

  1028.         mainStream << "\n";

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

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

  1031.         mainStream << "\n";

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

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

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

  1035.         mainStream << "\n";

  1036. 

  1037.         if (pData->hints & PLUGIN_HAS_CUSTOM_UI)

  1038.         {

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

  1040.             mainStream << "\n";

  1041.         }

  1042. 

  1043.         const uint32_t midiIns  = getMidiInCount();

  1044.         const uint32_t midiOuts = getMidiOutCount();

  1045. 

  1046.         int portIndex = 0;

  1047. 

  1048.         if (midiIns > 0)

  1049.         {

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

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

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

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

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

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

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

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

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

  1059.             ++portIndex;

  1060. 

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

  1062.             {

  1063.                 const String portIndexNum(portIndex++);

  1064.                 const String portIndexLabel(portIndex);

  1065. 

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

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

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

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

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

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

  1072.             }

  1073.         }

  1074.         else

  1075.         {

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

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

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

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

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

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

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

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

  1084.             ++portIndex;

  1085.         }

  1086. 

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

  1088.         {

  1089.             const String portIndexNum(portIndex++);

  1090.             const String portIndexLabel(portIndex);

  1091. 

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

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

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

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

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

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

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

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

  1100.         }

  1101. 

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

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

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

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

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

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

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

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

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

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

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

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

  1114. 

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

  1116.         {

  1117.             const String portIndexNum(portIndex++);

  1118.             const String portIndexLabel(i+1);

  1119. 

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

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

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

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

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

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

  1126.         }

  1127. 

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

  1129.         {

  1130.             const String portIndexNum(portIndex++);

  1131.             const String portIndexLabel(i+1);

  1132. 

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

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

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

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

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

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

  1139.         }

  1140. 

  1141.         CarlaStringList uniqueSymbolNames;

  1142. 

  1143.         char strBufName[STR_MAX+1];

  1144.         char strBufSymbol[STR_MAX+1];

  1145.         strBufName[STR_MAX] = strBufSymbol[STR_MAX] = '\0';

  1146. 

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

  1148.         {

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

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

  1151. 

  1152.             const String portIndexNum(portIndex++);

  1153. 

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

  1155. 

  1156.             if (paramData.type == PARAMETER_INPUT)

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

  1158.             else

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

  1160. 

  1161.             if (paramData.hints & PARAMETER_IS_BOOLEAN)

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

  1163. 

  1164.             if (paramData.hints & PARAMETER_IS_INTEGER)

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

  1166. 

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

  1168. 

  1169.             strBufName[0] = strBufSymbol[0] = '\0';

  1170.             getParameterName(i, strBufName);

  1171.             getParameterSymbol(i, strBufSymbol);

  1172. 

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

  1174.             {

  1175.                 CarlaString s(strBufName);

  1176.                 s.toBasic();

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

  1178. 

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

  1180.                 {

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

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

  1183.                     strBufSymbol[0]   = '_';

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

  1185.                 }

  1186.             }

  1187. 

  1188.             if (uniqueSymbolNames.contains(strBufSymbol))

  1189.             {

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

  1191.                 strBufSymbol[STR_MAX] = '\0';

  1192.             }

  1193. 

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

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

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

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

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

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

  1200. 

  1201.             // TODO midiCC, midiChannel

  1202. 

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

  1204.         }

  1205. 

  1206.         char strBuf[STR_MAX];

  1207.         getMaker(strBuf);

  1208.         strBuf[STR_MAX-1] = '\0';

  1209. 

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

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

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

  1213.         mainStream << "\n";

  1214. 

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

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

  1217. 

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

  1219.         {

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

  1221.             return false;

  1222.         }

  1223.     }

  1224. 

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

  1226. 

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

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

  1229. 

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

  1231. 

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

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

  1234. 

  1235. #ifdef CARLA_OS_WIN

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

  1237.     {

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

  1239.         return false;

  1240.     }

  1241. 

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

  1243. 

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

  1245.     const File binFolder1(opts.binaryDir);

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

  1247.     binFolder2.createDirectory();

  1248. 

  1249.     static const char* files[] = {

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

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

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

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

  1254.       "libcarla_utils.dll"

  1255.     };

  1256. 

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

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

  1259. #else

  1260.     if (! binaryFileSource.createSymbolicLink(binaryFileTarget, true))

  1261.     {

  1262.         pData->engine->setLastError("Failed to create symbolik link of plugin binary");

  1263.         return false;

  1264.     }

  1265. 

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

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

  1268. #endif

  1269. 

  1270.     return true;

  1271. }

  1272. 

  1273. // -------------------------------------------------------------------

  1274. // Set data (internal stuff)

  1275. 

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

  1277. {

  1278.     pData->id = newId;

  1279. }

  1280. 

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

  1282. {

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

  1284. 

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

  1286.         delete[] pData->name;

  1287. 

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

  1289. }

  1290. 

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

  1292. {

  1293.     CARLA_SAFE_ASSERT_RETURN(getOptionsAvailable() & option,);

  1294. 

  1295.     if (yesNo)

  1296.         pData->options |= option;

  1297.     else

  1298.         pData->options &= ~option;

  1299. 

  1300. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1301.     if (sendCallback)

  1302.         pData->engine->callback(ENGINE_CALLBACK_OPTION_CHANGED, pData->id, static_cast<int>(option), yesNo ? 1 : 0, 0.0f, nullptr);

  1303. #else

  1304.     // unused

  1305.     return; (void)sendCallback;

  1306. #endif

  1307. }

  1308. 

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

  1310. {

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

  1312.         return;

  1313. 

  1314.     pData->masterMutex.lock();

  1315.     pData->enabled = yesNo;

  1316. 

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

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

  1319. 

  1320.     pData->masterMutex.unlock();

  1321. }

  1322. 

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

  1324. {

  1325.     if (pData->engineBridged) {

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

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

  1328.         // nothing here

  1329.     } else {

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

  1331.     }

  1332. 

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

  1334.         return;

  1335. 

  1336.     {

  1337.         const ScopedSingleProcessLocker spl(this, true);

  1338. 

  1339.         if (active)

  1340.             activate();

  1341.         else

  1342.             deactivate();

  1343.     }

  1344. 

  1345.     pData->active = active;

  1346. 

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

  1348. 

  1349. #if defined(HAVE_LIBLO) && ! defined(BUILD_BRIDGE)

  1350.     if (sendOsc && pData->engine->isOscControlRegistered())

  1351.         pData->engine->oscSend_control_set_parameter_value(pData->id, PARAMETER_ACTIVE, value);

  1352. #endif

  1353. 

  1354. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1355.     if (sendCallback)

  1356.         pData->engine->callback(ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED, pData->id, PARAMETER_ACTIVE, 0, value, nullptr);

  1357. #endif

  1358. 

  1359.     // maybe unused

  1360.     return; (void)value;

  1361. }

  1362. 

  1363. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  1365. {

  1366.     if (pData->engineBridged) {

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

  1368.     } else {

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

  1370.     }

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

  1372. 

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

  1374. 

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

  1376.         return;

  1377. 

  1378.     pData->postProc.dryWet = fixedValue;

  1379. 

  1380. # if defined(HAVE_LIBLO) && ! defined(BUILD_BRIDGE)

  1381.     if (sendOsc && pData->engine->isOscControlRegistered())

  1382.         pData->engine->oscSend_control_set_parameter_value(pData->id, PARAMETER_DRYWET, fixedValue);

  1383. # endif

  1384. 

  1385.     if (sendCallback)

  1386.         pData->engine->callback(ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED, pData->id, PARAMETER_DRYWET, 0, fixedValue, nullptr);

  1387. }

  1388. 

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

  1390. {

  1391.     if (pData->engineBridged) {

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

  1393.     } else {

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

  1395.     }

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

  1397. 

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

  1399. 

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

  1401.         return;

  1402. 

  1403.     pData->postProc.volume = fixedValue;

  1404. 

  1405. # if defined(HAVE_LIBLO) && ! defined(BUILD_BRIDGE)

  1406.     if (sendOsc && pData->engine->isOscControlRegistered())

  1407.         pData->engine->oscSend_control_set_parameter_value(pData->id, PARAMETER_VOLUME, fixedValue);

  1408. # endif

  1409. 

  1410.     if (sendCallback)

  1411.         pData->engine->callback(ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED, pData->id, PARAMETER_VOLUME, 0, fixedValue, nullptr);

  1412. }

  1413. 

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

  1415. {

  1416.     if (pData->engineBridged) {

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

  1418.     } else {

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

  1420.     }

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

  1422. 

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

  1424. 

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

  1426.         return;

  1427. 

  1428.     pData->postProc.balanceLeft = fixedValue;

  1429. 

  1430. # if defined(HAVE_LIBLO) && ! defined(BUILD_BRIDGE)

  1431.     if (sendOsc && pData->engine->isOscControlRegistered())

  1432.         pData->engine->oscSend_control_set_parameter_value(pData->id, PARAMETER_BALANCE_LEFT, fixedValue);

  1433. # endif

  1434. 

  1435.     if (sendCallback)

  1436.         pData->engine->callback(ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED, pData->id, PARAMETER_BALANCE_LEFT, 0, fixedValue, nullptr);

  1437. }

  1438. 

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

  1440. {

  1441.     if (pData->engineBridged) {

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

  1443.     } else {

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

  1445.     }

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

  1447. 

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

  1449. 

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

  1451.         return;

  1452. 

  1453.     pData->postProc.balanceRight = fixedValue;

  1454. 

  1455. # if defined(HAVE_LIBLO) && ! defined(BUILD_BRIDGE)

  1456.     if (sendOsc && pData->engine->isOscControlRegistered())

  1457.         pData->engine->oscSend_control_set_parameter_value(pData->id, PARAMETER_BALANCE_RIGHT, fixedValue);

  1458. # endif

  1459. 

  1460.     if (sendCallback)

  1461.         pData->engine->callback(ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED, pData->id, PARAMETER_BALANCE_RIGHT, 0, fixedValue, nullptr);

  1462. }

  1463. 

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

  1465. {

  1466.     if (pData->engineBridged) {

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

  1468.     } else {

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

  1470.     }

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

  1472. 

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

  1474. 

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

  1476.         return;

  1477. 

  1478.     pData->postProc.panning = fixedValue;

  1479. 

  1480. # if defined(HAVE_LIBLO) && ! defined(BUILD_BRIDGE)

  1481.     if (sendOsc && pData->engine->isOscControlRegistered())

  1482.         pData->engine->oscSend_control_set_parameter_value(pData->id, PARAMETER_PANNING, fixedValue);

  1483. # endif

  1484. 

  1485.     if (sendCallback)

  1486.         pData->engine->callback(ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED, pData->id, PARAMETER_PANNING, 0, fixedValue, nullptr);

  1487. }

  1488. 

  1489. void CarlaPlugin::setDryWetRT(const float value) noexcept

  1490. {

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

  1492. 

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

  1494. 

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

  1496.         return;

  1497. 

  1498.     pData->postProc.dryWet = fixedValue;

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

  1500. }

  1501. 

  1502. void CarlaPlugin::setVolumeRT(const float value) noexcept

  1503. {

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

  1505. 

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

  1507. 

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

  1509.         return;

  1510. 

  1511.     pData->postProc.volume = fixedValue;

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

  1513. }

  1514. 

  1515. void CarlaPlugin::setBalanceLeftRT(const float value) noexcept

  1516. {

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

  1518. 

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

  1520. 

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

  1522.         return;

  1523. 

  1524.     pData->postProc.balanceLeft = fixedValue;

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

  1526. }

  1527. 

  1528. void CarlaPlugin::setBalanceRightRT(const float value) noexcept

  1529. {

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

  1531. 

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

  1533. 

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

  1535.         return;

  1536. 

  1537.     pData->postProc.balanceRight = fixedValue;

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

  1539. }

  1540. 

  1541. void CarlaPlugin::setPanningRT(const float value) noexcept

  1542. {

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

  1544. 

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

  1546. 

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

  1548.         return;

  1549. 

  1550.     pData->postProc.panning = fixedValue;

  1551. }

  1552. #endif // ! BUILD_BRIDGE_ALTERNATIVE_ARCH

  1553. 

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

  1555. {

  1556.     if (pData->engineBridged) {

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

  1558.     } else {

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

  1560.     }

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

  1562. 

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

  1564.         return;

  1565. 

  1566.     pData->ctrlChannel = channel;

  1567. 

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

  1569. 

  1570. #if defined(HAVE_LIBLO) && ! defined(BUILD_BRIDGE)

  1571.     if (sendOsc && pData->engine->isOscControlRegistered())

  1572.         pData->engine->oscSend_control_set_parameter_value(pData->id, PARAMETER_CTRL_CHANNEL, channelf);

  1573. #endif

  1574. 

  1575. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1576.     if (sendCallback)

  1577.         pData->engine->callback(ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED, pData->id, PARAMETER_CTRL_CHANNEL, 0, channelf, nullptr);

  1578. #endif

  1579. 

  1580.     // maybe unused

  1581.     return; (void)channelf;

  1582. }

  1583. 

  1584. // -------------------------------------------------------------------

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

  1586. 

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

  1588. {

  1589.     if (pData->engineBridged) {

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

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

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

  1593.         // nothing here

  1594.     } else {

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

  1596.     }

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

  1598. 

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

  1600.         uiParameterChange(parameterId, value);

  1601. 

  1602. #if defined(HAVE_LIBLO) && ! defined(BUILD_BRIDGE)

  1603.     if (sendOsc && pData->engine->isOscControlRegistered())

  1604.         pData->engine->oscSend_control_set_parameter_value(pData->id, static_cast<int32_t>(parameterId), value);

  1605. #endif

  1606. 

  1607.     if (sendCallback)

  1608.         pData->engine->callback(ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED, pData->id, static_cast<int>(parameterId), 0, value, nullptr);

  1609. }

  1610. 

  1611. void CarlaPlugin::setParameterValueRT(const uint32_t parameterId, const float value) noexcept

  1612. {

  1613.     pData->postponeRtEvent(kPluginPostRtEventParameterChange, static_cast<int32_t>(parameterId), 0, value);

  1614. }

  1615. 

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

  1617. {

  1618. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  1620. 

  1621.     switch (rindex)

  1622.     {

  1623.     case PARAMETER_ACTIVE:

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

  1625.     case PARAMETER_CTRL_CHANNEL:

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

  1627.     case PARAMETER_DRYWET:

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

  1629.     case PARAMETER_VOLUME:

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

  1631.     case PARAMETER_BALANCE_LEFT:

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

  1633.     case PARAMETER_BALANCE_RIGHT:

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

  1635.     case PARAMETER_PANNING:

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

  1637.     }

  1638. #endif

  1639.     CARLA_SAFE_ASSERT_RETURN(rindex >= 0,);

  1640. 

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

  1642.     {

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

  1644.         {

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

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

  1647.             break;

  1648.         }

  1649.     }

  1650. }

  1651. 

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

  1653. {

  1654.     if (pData->engineBridged) {

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

  1656.     } else {

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

  1658.     }

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

  1660.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  1661. 

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

  1663. 

  1664. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1665. # if defined(HAVE_LIBLO) && ! defined(BUILD_BRIDGE)

  1666.     if (sendOsc && pData->engine->isOscControlRegistered())

  1667.         pData->engine->oscSend_control_set_parameter_midi_channel(pData->id, parameterId, channel);

  1668. # endif

  1669. 

  1670.     if (sendCallback)

  1671.         pData->engine->callback(ENGINE_CALLBACK_PARAMETER_MIDI_CHANNEL_CHANGED, pData->id, static_cast<int>(parameterId), channel, 0.0f, nullptr);

  1672. #endif

  1673. }

  1674. 

  1675. void CarlaPlugin::setParameterMidiCC(const uint32_t parameterId, const int16_t cc, const bool sendOsc, const bool sendCallback) noexcept

  1676. {

  1677.     if (pData->engineBridged) {

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

  1679.     } else {

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

  1681.     }

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

  1683.     CARLA_SAFE_ASSERT_RETURN(cc >= -1 && cc < MAX_MIDI_CONTROL,);

  1684. 

  1685.     pData->param.data[parameterId].midiCC = cc;

  1686. 

  1687. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1688. # if defined(HAVE_LIBLO) && ! defined(BUILD_BRIDGE)

  1689.     if (sendOsc && pData->engine->isOscControlRegistered())

  1690.         pData->engine->oscSend_control_set_parameter_midi_cc(pData->id, parameterId, cc);

  1691. # endif

  1692. 

  1693.     if (sendCallback)

  1694.         pData->engine->callback(ENGINE_CALLBACK_PARAMETER_MIDI_CC_CHANGED, pData->id, static_cast<int>(parameterId), cc, 0.0f, nullptr);

  1695. #endif

  1696. }

  1697. 

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

  1699. {

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

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

  1702.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

  1703. 

  1704.     // Ignore some keys

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

  1706.     {

  1707.         const PluginType ptype = getType();

  1708. 

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

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

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

  1712.             return;

  1713.     }

  1714. 

  1715.     // Check if we already have this key

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

  1717.     {

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

  1719.         CARLA_SAFE_ASSERT_CONTINUE(customData.isValid());

  1720. 

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

  1722.         {

  1723.             if (customData.value != nullptr)

  1724.                 delete[] customData.value;

  1725. 

  1726.             customData.value = carla_strdup(value);

  1727.             return;

  1728.         }

  1729.     }

  1730. 

  1731.     // Otherwise store it

  1732.     CustomData customData;

  1733.     customData.type  = carla_strdup(type);

  1734.     customData.key   = carla_strdup(key);

  1735.     customData.value = carla_strdup(value);

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

  1737. }

  1738. 

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

  1740. {

  1741.     CARLA_SAFE_ASSERT_RETURN(data != nullptr,);

  1742.     CARLA_SAFE_ASSERT_RETURN(dataSize > 0,);

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

  1744. }

  1745. 

  1746. void CarlaPlugin::setProgram(const int32_t index, const bool sendGui, const bool sendOsc, const bool sendCallback, const bool) noexcept

  1747. {

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

  1749. 

  1750.     pData->prog.current = index;

  1751. 

  1752. #if defined(HAVE_LIBLO) && ! defined(BUILD_BRIDGE)

  1753.     const bool reallySendOsc(sendOsc && pData->engine->isOscControlRegistered());

  1754. 

  1755.     if (reallySendOsc && index < 50)

  1756.         pData->engine->oscSend_control_set_current_program(pData->id, index);

  1757. #else

  1758.     const bool reallySendOsc(false);

  1759. #endif

  1760. 

  1761.     if (sendCallback)

  1762.         pData->engine->callback(ENGINE_CALLBACK_PROGRAM_CHANGED, pData->id, index, 0, 0.0f, nullptr);

  1763. 

  1764.     // Change default parameter values

  1765.     if (index >= 0)

  1766.     {

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

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

  1769. 

  1770.         switch (getType())

  1771.         {

  1772.         case PLUGIN_SF2:

  1773.         case PLUGIN_SFZ:

  1774.             break;

  1775. 

  1776.         default:

  1777.             pData->updateParameterValues(this, reallySendOsc, sendCallback, true);

  1778.             break;

  1779.         }

  1780.     }

  1781. 

  1782.     // may be unused

  1783.     return; (void)sendOsc;

  1784. }

  1785. 

  1786. void CarlaPlugin::setMidiProgram(const int32_t index, const bool sendGui, const bool sendOsc, const bool sendCallback, const bool) noexcept

  1787. {

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

  1789. 

  1790.     pData->midiprog.current = index;

  1791. 

  1792. #if defined(HAVE_LIBLO) && ! defined(BUILD_BRIDGE)

  1793.     const bool reallySendOsc(sendOsc && pData->engine->isOscControlRegistered());

  1794. 

  1795.     if (reallySendOsc && index < 50)

  1796.         pData->engine->oscSend_control_set_current_midi_program(pData->id, index);

  1797. #else

  1798.     const bool reallySendOsc(false);

  1799. #endif

  1800. 

  1801.     if (sendCallback)

  1802.         pData->engine->callback(ENGINE_CALLBACK_MIDI_PROGRAM_CHANGED, pData->id, index, 0, 0.0f, nullptr);

  1803. 

  1804.     // Change default parameter values

  1805.     if (index >= 0)

  1806.     {

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

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

  1809. 

  1810.         switch (getType())

  1811.         {

  1812.         case PLUGIN_SF2:

  1813.         case PLUGIN_SFZ:

  1814.             break;

  1815. 

  1816.         default:

  1817.             pData->updateParameterValues(this, reallySendOsc, sendCallback, true);

  1818.             break;

  1819.         }

  1820.     }

  1821. 

  1822.     // may be unused

  1823.     return; (void)sendOsc;

  1824. }

  1825. 

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

  1827. {

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

  1829.     {

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

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

  1832.     }

  1833. }

  1834. 

  1835. void CarlaPlugin::setProgramRT(const uint32_t uindex) noexcept

  1836. {

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

  1838. 

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

  1840.     pData->prog.current = index;

  1841. 

  1842.     // Change default parameter values

  1843.     switch (getType())

  1844.     {

  1845.     case PLUGIN_SF2:

  1846.     case PLUGIN_SFZ:

  1847.         break;

  1848. 

  1849.     default:

  1850.         pData->updateDefaultParameterValues(this);

  1851.         break;

  1852.     }

  1853. 

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

  1855. }

  1856. 

  1857. void CarlaPlugin::setMidiProgramRT(const uint32_t uindex) noexcept

  1858. {

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

  1860. 

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

  1862.     pData->midiprog.current = index;

  1863. 

  1864.     // Change default parameter values

  1865.     switch (getType())

  1866.     {

  1867.     case PLUGIN_SF2:

  1868.     case PLUGIN_SFZ:

  1869.         break;

  1870. 

  1871.     default:

  1872.         pData->updateDefaultParameterValues(this);

  1873.         break;

  1874.     }

  1875. 

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

  1877. }

  1878. 

  1879. // -------------------------------------------------------------------

  1880. // Plugin state

  1881. 

  1882. void CarlaPlugin::reloadPrograms(const bool)

  1883. {

  1884. }

  1885. 

  1886. // -------------------------------------------------------------------

  1887. // Plugin processing

  1888. 

  1889. void CarlaPlugin::activate() noexcept

  1890. {

  1891.     CARLA_SAFE_ASSERT(! pData->active);

  1892. }

  1893. 

  1894. void CarlaPlugin::deactivate() noexcept

  1895. {

  1896.     CARLA_SAFE_ASSERT(pData->active);

  1897. }

  1898. 

  1899. void CarlaPlugin::bufferSizeChanged(const uint32_t)

  1900. {

  1901. }

  1902. 

  1903. void CarlaPlugin::sampleRateChanged(const double)

  1904. {

  1905. }

  1906. 

  1907. void CarlaPlugin::offlineModeChanged(const bool)

  1908. {

  1909. }

  1910. 

  1911. // -------------------------------------------------------------------

  1912. // Misc

  1913. 

  1914. void CarlaPlugin::idle()

  1915. {

  1916.     if (! pData->enabled)

  1917.         return;

  1918. 

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

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

  1921. #if defined(HAVE_LIBLO) && ! defined(BUILD_BRIDGE)

  1922.     const bool sendOsc(pData->engine->isOscControlRegistered());

  1923. #endif

  1924.     const uint32_t latency(getLatencyInFrames());

  1925. 

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

  1927.     {

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

  1929. 

  1930.         const ScopedSingleProcessLocker sspl(this, true);

  1931. 

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

  1933. #ifndef BUILD_BRIDGE

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

  1935. #else

  1936.         pData->latency.frames = latency;

  1937. #endif

  1938.     }

  1939. 

  1940.     const CarlaMutexLocker sl(pData->postRtEvents.getDataMutex());

  1941. 

  1942.     for (RtLinkedList<PluginPostRtEvent>::Itenerator it = pData->postRtEvents.getDataIterator(); it.valid(); it.next())

  1943.     {

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

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

  1946. 

  1947.         switch (event.type)

  1948.         {

  1949.         case kPluginPostRtEventNull: {

  1950.         } break;

  1951. 

  1952.         case kPluginPostRtEventDebug: {

  1953.             pData->engine->callback(ENGINE_CALLBACK_DEBUG, pData->id, event.value1, event.value2, event.value3, nullptr);

  1954.         } break;

  1955. 

  1956.         case kPluginPostRtEventParameterChange: {

  1957.             // Update UI

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

  1959.             {

  1960.                 if (needsUiMainThread)

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

  1962.                 else

  1963.                     uiParameterChange(static_cast<uint32_t>(event.value1), event.value3);

  1964.             }

  1965. 

  1966.             if (event.value2 != 1)

  1967.             {

  1968. #if defined(HAVE_LIBLO) && ! defined(BUILD_BRIDGE)

  1969.                 // Update OSC control client

  1970.                 if (sendOsc)

  1971.                     pData->engine->oscSend_control_set_parameter_value(pData->id, event.value1, event.value3);

  1972. #endif

  1973.                 // Update Host

  1974.                 pData->engine->callback(ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED, pData->id, event.value1, 0, event.value3, nullptr);

  1975.             }

  1976.         } break;

  1977. 

  1978.         case kPluginPostRtEventProgramChange: {

  1979.             // Update UI

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

  1981.             {

  1982.                 if (needsUiMainThread)

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

  1984.                 else

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

  1986.             }

  1987. 

  1988.             // Update param values

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

  1990.             {

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

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

  1993. 

  1994. #if defined(HAVE_LIBLO) && ! defined(BUILD_BRIDGE)

  1995.                 if (sendOsc && j < 50)

  1996.                 {

  1997.                     pData->engine->oscSend_control_set_parameter_value(pData->id, static_cast<int32_t>(j), paramValue);

  1998.                     pData->engine->oscSend_control_set_default_value(pData->id, j, paramDefault);

  1999.                 }

  2000. #endif

  2001.                 pData->engine->callback(ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED, pData->id, static_cast<int>(j), 0, paramValue, nullptr);

  2002.                 pData->engine->callback(ENGINE_CALLBACK_PARAMETER_DEFAULT_CHANGED, pData->id, static_cast<int>(j), 0, paramDefault, nullptr);

  2003.             }

  2004. 

  2005. #if defined(HAVE_LIBLO) && ! defined(BUILD_BRIDGE)

  2006.             // Update OSC control client

  2007.             if (sendOsc)

  2008.                 pData->engine->oscSend_control_set_current_program(pData->id, event.value1);

  2009. #endif

  2010.             // Update Host

  2011.             pData->engine->callback(ENGINE_CALLBACK_PROGRAM_CHANGED, pData->id, event.value1, 0, 0.0f, nullptr);

  2012. 

  2013.         } break;

  2014. 

  2015.         case kPluginPostRtEventMidiProgramChange: {

  2016.             // Update UI

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

  2018.             {

  2019.                 if (needsUiMainThread)

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

  2021.                 else

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

  2023.             }

  2024. 

  2025.             // Update param values

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

  2027.             {

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

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

  2030. 

  2031. #if defined(HAVE_LIBLO) && ! defined(BUILD_BRIDGE)

  2032.                 if (sendOsc && j < 50)

  2033.                 {

  2034.                     pData->engine->oscSend_control_set_parameter_value(pData->id, static_cast<int32_t>(j), paramValue);

  2035.                     pData->engine->oscSend_control_set_default_value(pData->id, j, paramDefault);

  2036.                 }

  2037. #endif

  2038.                 pData->engine->callback(ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED, pData->id, static_cast<int>(j), 0, paramValue, nullptr);

  2039.                 pData->engine->callback(ENGINE_CALLBACK_PARAMETER_DEFAULT_CHANGED, pData->id, static_cast<int>(j), 0, paramDefault, nullptr);

  2040.             }

  2041. 

  2042. #if defined(HAVE_LIBLO) && ! defined(BUILD_BRIDGE)

  2043.             // Update OSC control client

  2044.             if (sendOsc)

  2045.                 pData->engine->oscSend_control_set_current_midi_program(pData->id, event.value1);

  2046. #endif

  2047.             // Update Host

  2048.             pData->engine->callback(ENGINE_CALLBACK_MIDI_PROGRAM_CHANGED, pData->id, event.value1, 0, 0.0f, nullptr);

  2049. 

  2050.         } break;

  2051. 

  2052.         case kPluginPostRtEventNoteOn: {

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

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

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

  2056. 

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

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

  2059.             const uint8_t velocity = uint8_t(event.value3);

  2060. 

  2061.             // Update UI

  2062.             if (hasUI)

  2063.             {

  2064.                 if (needsUiMainThread)

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

  2066.                 else

  2067.                     uiNoteOn(channel, note, velocity);

  2068.             }

  2069. 

  2070. #if defined(HAVE_LIBLO) && ! defined(BUILD_BRIDGE)

  2071.             // Update OSC control client

  2072.             if (sendOsc)

  2073.                 pData->engine->oscSend_control_note_on(pData->id, channel, note, velocity);

  2074. #endif

  2075.             // Update Host

  2076.             pData->engine->callback(ENGINE_CALLBACK_NOTE_ON, pData->id, event.value1, event.value2, event.value3, nullptr);

  2077. 

  2078.         } break;

  2079. 

  2080.         case kPluginPostRtEventNoteOff: {

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

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

  2083. 

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

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

  2086. 

  2087.             // Update UI

  2088.             if (hasUI)

  2089.             {

  2090.                 if (needsUiMainThread)

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

  2092.                 else

  2093.                     uiNoteOff(channel, note);

  2094.             }

  2095. 

  2096. #if defined(HAVE_LIBLO) && ! defined(BUILD_BRIDGE)

  2097.             // Update OSC control client

  2098.             if (sendOsc)

  2099.                 pData->engine->oscSend_control_note_off(pData->id, channel, note);

  2100. #endif

  2101.             // Update Host

  2102.             pData->engine->callback(ENGINE_CALLBACK_NOTE_OFF, pData->id, event.value1, event.value2, 0.0f, nullptr);

  2103. 

  2104.         } break;

  2105.         }

  2106.     }

  2107. 

  2108.     pData->postRtEvents.clearData();

  2109. }

  2110. 

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

  2112. {

  2113.     if (forcedOffline)

  2114.     {

  2115. #ifndef STOAT_TEST_BUILD

  2116.         pData->masterMutex.lock();

  2117.         return true;

  2118. #endif

  2119.     }

  2120. 

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

  2122. }

  2123. 

  2124. void CarlaPlugin::unlock() noexcept

  2125. {

  2126.     pData->masterMutex.unlock();

  2127. }

  2128. 

  2129. // -------------------------------------------------------------------

  2130. // Plugin buffers

  2131. 

  2132. void CarlaPlugin::initBuffers() const noexcept

  2133. {

  2134.     pData->audioIn.initBuffers();

  2135.     pData->audioOut.initBuffers();

  2136.     pData->cvIn.initBuffers();

  2137.     pData->cvOut.initBuffers();

  2138.     pData->event.initBuffers();

  2139. }

  2140. 

  2141. void CarlaPlugin::clearBuffers() noexcept

  2142. {

  2143.     pData->clearBuffers();

  2144. }

  2145. 

  2146. #if defined(HAVE_LIBLO) && ! defined(BUILD_BRIDGE)

  2147. // -------------------------------------------------------------------

  2148. // OSC stuff

  2149. 

  2150. void CarlaPlugin::registerToOscClient() noexcept

  2151. {

  2152.     if (! pData->engine->isOscControlRegistered())

  2153.         return;

  2154. 

  2155.     pData->engine->oscSend_control_add_plugin_start(pData->id, pData->name);

  2156. 

  2157.     // Base data

  2158.     {

  2159.         char bufName[STR_MAX+1], bufLabel[STR_MAX+1], bufMaker[STR_MAX+1], bufCopyright[STR_MAX+1];

  2160.         carla_zeroChars(bufName, STR_MAX);

  2161.         carla_zeroChars(bufLabel, STR_MAX);

  2162.         carla_zeroChars(bufMaker, STR_MAX);

  2163.         carla_zeroChars(bufCopyright, STR_MAX);

  2164. 

  2165.         getRealName(bufName);

  2166.         getLabel(bufLabel);

  2167.         getMaker(bufMaker);

  2168.         getCopyright(bufCopyright);

  2169. 

  2170.         pData->engine->oscSend_control_set_plugin_info1(pData->id, getType(), getCategory(), pData->hints, getUniqueId());

  2171.         pData->engine->oscSend_control_set_plugin_info2(pData->id, bufName, bufLabel, bufMaker, bufCopyright);

  2172.     }

  2173. 

  2174.     // Base count

  2175.     uint32_t paramIns, paramOuts;

  2176. 

  2177.     {

  2178.         getParameterCountInfo(paramIns, paramOuts);

  2179. 

  2180.         if (paramIns > 49)

  2181.             paramIns = 49;

  2182.         if (paramOuts > 49)

  2183.             paramOuts = 49;

  2184. 

  2185.         pData->engine->oscSend_control_set_audio_count(pData->id, getAudioInCount(), getAudioOutCount());

  2186.         pData->engine->oscSend_control_set_midi_count(pData->id, getMidiInCount(), getMidiOutCount());

  2187.         pData->engine->oscSend_control_set_parameter_count(pData->id, paramIns, paramOuts);

  2188.     }

  2189. 

  2190.     // Plugin Parameters

  2191.     if (const uint32_t count = std::min<uint32_t>(pData->param.count, 98U))

  2192.     {

  2193.         char bufName[STR_MAX+1], bufUnit[STR_MAX+1];

  2194. 

  2195.         for (uint32_t i=0; i<count; ++i)

  2196.         {

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

  2198. 

  2199.             if (paramData.type == PARAMETER_INPUT)

  2200.             {

  2201.                 if (--paramIns == 0)

  2202.                     break;

  2203.             }

  2204.             else if (paramData.type == PARAMETER_INPUT)

  2205.             {

  2206.                 if (--paramOuts == 0)

  2207.                     break;

  2208.             }

  2209.             else

  2210.             {

  2211.                 continue;

  2212.             }

  2213. 

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

  2215. 

  2216.             carla_zeroChars(bufName, STR_MAX);

  2217.             carla_zeroChars(bufUnit, STR_MAX);

  2218. 

  2219.             getParameterName(i, bufName);

  2220.             getParameterUnit(i, bufUnit);

  2221. 

  2222.             pData->engine->oscSend_control_set_parameter_data(pData->id, i, paramData.type, paramData.hints, bufName, bufUnit);

  2223.             pData->engine->oscSend_control_set_parameter_ranges1(pData->id, i, paramRanges.def, paramRanges.min, paramRanges.max);

  2224.             pData->engine->oscSend_control_set_parameter_ranges2(pData->id, i, paramRanges.step, paramRanges.stepSmall, paramRanges.stepLarge);

  2225.             pData->engine->oscSend_control_set_parameter_value(pData->id, static_cast<int32_t>(i), getParameterValue(i));

  2226. 

  2227.             if (paramData.midiCC >= 0)

  2228.                 pData->engine->oscSend_control_set_parameter_midi_cc(pData->id, i, paramData.midiCC);

  2229. 

  2230.             if (paramData.midiChannel != 0)

  2231.                 pData->engine->oscSend_control_set_parameter_midi_channel(pData->id, i, paramData.midiChannel);

  2232.         }

  2233.     }

  2234. 

  2235.     // Programs

  2236.     if (const uint32_t count = std::min<uint32_t>(pData->prog.count, 50U))

  2237.     {

  2238.         pData->engine->oscSend_control_set_program_count(pData->id, count);

  2239. 

  2240.         for (uint32_t i=0; i < count; ++i)

  2241.             pData->engine->oscSend_control_set_program_name(pData->id, i, pData->prog.names[i]);

  2242. 

  2243.         pData->engine->oscSend_control_set_current_program(pData->id, pData->prog.current);

  2244.     }

  2245. 

  2246.     // MIDI Programs

  2247.     if (const uint32_t count = std::min<uint32_t>(pData->midiprog.count, 50U))

  2248.     {

  2249.         pData->engine->oscSend_control_set_midi_program_count(pData->id, count);

  2250. 

  2251.         for (uint32_t i=0; i < count; ++i)

  2252.         {

  2253.             const MidiProgramData& mpData(pData->midiprog.data[i]);

  2254. 

  2255.             pData->engine->oscSend_control_set_midi_program_data(pData->id, i, mpData.bank, mpData.program, mpData.name);

  2256.         }

  2257. 

  2258.         pData->engine->oscSend_control_set_current_midi_program(pData->id, pData->midiprog.current);

  2259.     }

  2260. 

  2261.     pData->engine->oscSend_control_add_plugin_end(pData->id);

  2262. 

  2263.     // Internal Parameters

  2264.     {

  2265.         pData->engine->oscSend_control_set_parameter_value(pData->id, PARAMETER_DRYWET, pData->postProc.dryWet);

  2266.         pData->engine->oscSend_control_set_parameter_value(pData->id, PARAMETER_VOLUME, pData->postProc.volume);

  2267.         pData->engine->oscSend_control_set_parameter_value(pData->id, PARAMETER_BALANCE_LEFT, pData->postProc.balanceLeft);

  2268.         pData->engine->oscSend_control_set_parameter_value(pData->id, PARAMETER_BALANCE_RIGHT, pData->postProc.balanceRight);

  2269.         pData->engine->oscSend_control_set_parameter_value(pData->id, PARAMETER_PANNING, pData->postProc.panning);

  2270.         pData->engine->oscSend_control_set_parameter_value(pData->id, PARAMETER_CTRL_CHANNEL, pData->ctrlChannel);

  2271.         pData->engine->oscSend_control_set_parameter_value(pData->id, PARAMETER_ACTIVE, pData->active ? 1.0f : 0.0f);

  2272.     }

  2273. }

  2274. #endif

  2275. 

  2276. // FIXME

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

  2278. {

  2279.     // do nothing

  2280. }

  2281. //#endif // HAVE_LIBLO && ! BUILD_BRIDGE

  2282. 

  2283. // -------------------------------------------------------------------

  2284. // MIDI events

  2285. 

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

  2287. {

  2288.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2289.     CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

  2290.     CARLA_SAFE_ASSERT_RETURN(velo < MAX_MIDI_VALUE,);

  2291. 

  2292.     if (! pData->active)

  2293.         return;

  2294. 

  2295.     ExternalMidiNote extNote;

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

  2297.     extNote.note    = note;

  2298.     extNote.velo    = velo;

  2299. 

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

  2301. 

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

  2303.     {

  2304.         if (velo > 0)

  2305.             uiNoteOn(channel, note, velo);

  2306.         else

  2307.             uiNoteOff(channel, note);

  2308.     }

  2309. 

  2310. #if defined(HAVE_LIBLO) && ! defined(BUILD_BRIDGE)

  2311.     if (sendOsc && pData->engine->isOscControlRegistered())

  2312.     {

  2313.         if (velo > 0)

  2314.             pData->engine->oscSend_control_note_on(pData->id, channel, note, velo);

  2315.         else

  2316.             pData->engine->oscSend_control_note_off(pData->id, channel, note);

  2317.     }

  2318. #endif

  2319. 

  2320.     if (sendCallback)

  2321.         pData->engine->callback((velo > 0) ? ENGINE_CALLBACK_NOTE_ON : ENGINE_CALLBACK_NOTE_OFF, pData->id, channel, note, velo, nullptr);

  2322. 

  2323.     // may be unused

  2324.     return; (void)sendOsc;

  2325. }

  2326. 

  2327. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2328. void CarlaPlugin::sendMidiAllNotesOffToCallback()

  2329. {

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

  2331.         return;

  2332. 

  2333.     PluginPostRtEvent postEvent;

  2334.     postEvent.type   = kPluginPostRtEventNoteOff;

  2335.     postEvent.value1 = pData->ctrlChannel;

  2336.     postEvent.value2 = 0;

  2337.     postEvent.value3 = 0.0f;

  2338. 

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

  2340.     {

  2341.         postEvent.value2 = i;

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

  2343.     }

  2344. }

  2345. #endif

  2346. 

  2347. // -------------------------------------------------------------------

  2348. // UI Stuff

  2349. 

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

  2351. {

  2352.     if (yesNo) {

  2353.         CARLA_SAFE_ASSERT(false);

  2354.     }

  2355. }

  2356. 

  2357. void CarlaPlugin::uiIdle()

  2358. {

  2359.     if (pData->hints & PLUGIN_NEEDS_UI_MAIN_THREAD)

  2360.     {

  2361.         // Update parameter outputs

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

  2363.         {

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

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

  2366.         }

  2367. 

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

  2369. 

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

  2371.         {

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

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

  2374. 

  2375.             switch (event.type)

  2376.             {

  2377.             case kPluginPostRtEventNull:

  2378.             case kPluginPostRtEventDebug:

  2379.                 break;

  2380. 

  2381.             case kPluginPostRtEventParameterChange:

  2382.                 uiParameterChange(static_cast<uint32_t>(event.value1), event.value3);

  2383.                 break;

  2384. 

  2385.             case kPluginPostRtEventProgramChange:

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

  2387.                 break;

  2388. 

  2389.             case kPluginPostRtEventMidiProgramChange:

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

  2391.                 break;

  2392. 

  2393.             case kPluginPostRtEventNoteOn:

  2394.                 uiNoteOn(static_cast<uint8_t>(event.value1), static_cast<uint8_t>(event.value2), uint8_t(event.value3));

  2395.                 break;

  2396. 

  2397.             case kPluginPostRtEventNoteOff:

  2398.                 uiNoteOff(static_cast<uint8_t>(event.value1), static_cast<uint8_t>(event.value2));

  2399.                 break;

  2400.             }

  2401.         }

  2402. 

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

  2404.     }

  2405. 

  2406. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  2408.         return;

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

  2410.         return;

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

  2412.         return;

  2413. 

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

  2415. 

  2416.     CarlaString uiTitle(pData->name);

  2417.     uiTitle += " (GUI)";

  2418. 

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

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

  2421.     {

  2422.         pData->transientTryCounter = 0;

  2423.         pData->transientFirstTry = false;

  2424.     }

  2425. #endif

  2426. }

  2427. 

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

  2429. {

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

  2431.     return;

  2432. 

  2433.     // unused

  2434.     (void)value;

  2435. }

  2436. 

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

  2438. {

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

  2440. }

  2441. 

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

  2443. {

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

  2445. }

  2446. 

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

  2448. {

  2449.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2450.     CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

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

  2452. }

  2453. 

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

  2455. {

  2456.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2457.     CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

  2458. }

  2459. 

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

  2461. {

  2462.     return pData->engine;

  2463. }

  2464. 

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

  2466. {

  2467.     return pData->client;

  2468. }

  2469. 

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

  2471. {

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

  2473. }

  2474. 

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

  2476. {

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

  2478. }

  2479. 

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

  2481. {

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

  2483. }

  2484. 

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

  2486. {

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

  2488. }

  2489. 

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

  2491. {

  2492.     return pData->event.portIn;

  2493. }

  2494. 

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

  2496. {

  2497.     return pData->event.portOut;

  2498. }

  2499. 

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

  2501. {

  2502.     return nullptr;

  2503. }

  2504. 

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

  2506. {

  2507.     return nullptr;

  2508. }

  2509. 

  2510. uintptr_t CarlaPlugin::getUiBridgeProcessId() const noexcept

  2511. {

  2512.     return 0;

  2513. }

  2514. 

  2515. // -------------------------------------------------------------------

  2516. 

  2517. uint32_t CarlaPlugin::getPatchbayNodeId() const noexcept

  2518. {

  2519.     return pData->nodeId;

  2520. }

  2521. 

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

  2523. {

  2524.     pData->nodeId = nodeId;

  2525. }

  2526. 

  2527. // -------------------------------------------------------------------

  2528. 

  2529. void CarlaPlugin::restoreLV2State() noexcept

  2530. {

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

  2532. }

  2533. 

  2534. void CarlaPlugin::waitForBridgeSaveSignal() noexcept

  2535. {

  2536. }

  2537. 

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

  2539. // Scoped Disabler

  2540. 

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

  2542.     : fPlugin(plugin),

  2543.       fWasEnabled(false)

  2544. {

  2545.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

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

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

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

  2549. 

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

  2551. 

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

  2553.     {

  2554.         fWasEnabled = true;

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

  2556. 

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

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

  2559.     }

  2560. }

  2561. 

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

  2563. {

  2564.     CARLA_SAFE_ASSERT_RETURN(fPlugin != nullptr,);

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

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

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

  2568. 

  2569.     if (fWasEnabled)

  2570.     {

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

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

  2573.     }

  2574. 

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

  2576. }

  2577. 

  2578. // -------------------------------------------------------------------

  2579. // Scoped Process Locker

  2580. 

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

  2582.     : fPlugin(plugin),

  2583.       fBlock(block)

  2584. {

  2585.     CARLA_SAFE_ASSERT_RETURN(fPlugin != nullptr,);

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

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

  2588. 

  2589.     if (! fBlock)

  2590.         return;

  2591. 

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

  2593. }

  2594. 

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

  2596. {

  2597.     CARLA_SAFE_ASSERT_RETURN(fPlugin != nullptr,);

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

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

  2600. 

  2601.     if (! fBlock)

  2602.         return;

  2603. 

  2604. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

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

  2607. #endif

  2608. 

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

  2610. }

  2611. 

  2612. // -------------------------------------------------------------------

  2613. 

  2614. CARLA_BACKEND_END_NAMESPACE