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.
1221 Commits
16 Branches
229MB
Tree: 38bcdbcb29
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '38bcdbcb29'
${ noResults }
Carla/source/backend/plugin/Lv2Plugin.cpp

1645 lines
55KB
Raw Blame History 

  1. /*

  2.  * Carla LV2 Plugin

  3.  * Copyright (C) 2011-2013 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. #ifdef WANT_LV2

  22. 

  23. #include "CarlaLv2Utils.hpp"

  24. #include "CarlaMathUtils.hpp"

  25. 

  26. #include "Lv2AtomQueue.hpp"

  27. 

  28. #include "../engine/CarlaEngineOsc.hpp"

  29. 

  30. extern "C" {

  31. #include "rtmempool/rtmempool-lv2.h"

  32. }

  33. 

  34. #include <QtCore/QDir>

  35. #include <QtCore/QUrl>

  36. 

  37. // -----------------------------------------------------

  38. 

  39. CARLA_BACKEND_START_NAMESPACE

  40. 

  41. #if 0

  42. }

  43. #endif

  44. 

  45. // Extra Parameter Hints

  46. const unsigned int PARAMETER_IS_STRICT_BOUNDS = 0x1000;

  47. const unsigned int PARAMETER_IS_TRIGGER       = 0x2000;

  48. 

  49. // LV2 Feature Ids

  50. const uint32_t kFeatureCount = 0;

  51. 

  52. // -----------------------------------------------------

  53. 

  54. class Lv2Plugin : public CarlaPlugin

  55. {

  56. public:

  57.     Lv2Plugin(CarlaEngine* const engine, const unsigned int id)

  58.         : CarlaPlugin(engine, id),

  59.           fHandle(nullptr),

  60.           fHandle2(nullptr),

  61.           fDescriptor(nullptr),

  62.           fRdfDescriptor(nullptr),

  63.           fAudioInBuffers(nullptr),

  64.           fAudioOutBuffers(nullptr),

  65.           fParamBuffers(nullptr)

  66.     {

  67.         carla_debug("Lv2Plugin::Lv2Plugin(%p, %i)", engine, id);

  68. 

  69.         carla_fill<LV2_Feature*>(fFeatures, kFeatureCount+1, nullptr);

  70. 

  71.         pData->osc.thread.setMode(CarlaPluginThread::PLUGIN_THREAD_LV2_GUI);

  72.     }

  73. 

  74.     ~Lv2Plugin() override

  75.     {

  76.         carla_debug("Lv2Plugin::~Lv2Plugin()");

  77. 

  78.         pData->singleMutex.lock();

  79.         pData->masterMutex.lock();

  80. 

  81.         if (pData->client != nullptr && pData->client->isActive())

  82.             pData->client->deactivate();

  83. 

  84.         if (pData->active)

  85.         {

  86.             deactivate();

  87.             pData->active = false;

  88.         }

  89. 

  90.         if (fDescriptor != nullptr)

  91.         {

  92.             if (fDescriptor->cleanup != nullptr)

  93.             {

  94.                 if (fHandle != nullptr)

  95.                     fDescriptor->cleanup(fHandle);

  96.                 if (fHandle2 != nullptr)

  97.                     fDescriptor->cleanup(fHandle2);

  98.             }

  99. 

  100.             fHandle  = nullptr;

  101.             fHandle2 = nullptr;

  102.             fDescriptor = nullptr;

  103.         }

  104. 

  105.         if (fRdfDescriptor != nullptr)

  106.         {

  107.             delete fRdfDescriptor;

  108.             fRdfDescriptor = nullptr;

  109.         }

  110. 

  111.         clearBuffers();

  112.     }

  113. 

  114.     // -------------------------------------------------------------------

  115.     // Information (base)

  116. 

  117.     PluginType getType() const noexcept override

  118.     {

  119.         return PLUGIN_LV2;

  120.     }

  121. 

  122.     PluginCategory getCategory() const noexcept override

  123.     {

  124.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr, CarlaPlugin::getCategory());

  125. 

  126.         const LV2_Property cat1(fRdfDescriptor->Type[0]);

  127.         const LV2_Property cat2(fRdfDescriptor->Type[1]);

  128. 

  129.         if (LV2_IS_DELAY(cat1, cat2))

  130.             return PLUGIN_CATEGORY_DELAY;

  131.         if (LV2_IS_DISTORTION(cat1, cat2))

  132.             return PLUGIN_CATEGORY_OTHER;

  133.         if (LV2_IS_DYNAMICS(cat1, cat2))

  134.             return PLUGIN_CATEGORY_DYNAMICS;

  135.         if (LV2_IS_EQ(cat1, cat2))

  136.             return PLUGIN_CATEGORY_EQ;

  137.         if (LV2_IS_FILTER(cat1, cat2))

  138.             return PLUGIN_CATEGORY_FILTER;

  139.         if (LV2_IS_GENERATOR(cat1, cat2))

  140.             return PLUGIN_CATEGORY_SYNTH;

  141.         if (LV2_IS_MODULATOR(cat1, cat2))

  142.             return PLUGIN_CATEGORY_MODULATOR;

  143.         if (LV2_IS_REVERB(cat1, cat2))

  144.             return PLUGIN_CATEGORY_DELAY;

  145.         if (LV2_IS_SIMULATOR(cat1, cat2))

  146.             return PLUGIN_CATEGORY_OTHER;

  147.         if (LV2_IS_SPATIAL(cat1, cat2))

  148.             return PLUGIN_CATEGORY_OTHER;

  149.         if (LV2_IS_SPECTRAL(cat1, cat2))

  150.             return PLUGIN_CATEGORY_UTILITY;

  151.         if (LV2_IS_UTILITY(cat1, cat2))

  152.             return PLUGIN_CATEGORY_UTILITY;

  153. 

  154.         return CarlaPlugin::getCategory();

  155.     }

  156. 

  157.     long getUniqueId() const noexcept override

  158.     {

  159.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr, 0);

  160. 

  161.         return fRdfDescriptor->UniqueID;

  162.     }

  163. 

  164.     // -------------------------------------------------------------------

  165.     // Information (count)

  166. 

  167.     uint32_t getMidiInCount() const noexcept override

  168.     {

  169.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr, 0);

  170. 

  171.         uint32_t count = 0;

  172. 

  173.         for (uint32_t i=0; i < fRdfDescriptor->PortCount; ++i)

  174.         {

  175.             const LV2_Property portTypes(fRdfDescriptor->Ports[i].Types);

  176. 

  177.             if (LV2_IS_PORT_INPUT(portTypes) && LV2_PORT_SUPPORTS_MIDI_EVENT(portTypes))

  178.                 count += 1;

  179.         }

  180. 

  181.         return count;

  182.     }

  183. 

  184.     uint32_t getMidiOutCount() const noexcept override

  185.     {

  186.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr, 0);

  187. 

  188.         uint32_t count = 0;

  189. 

  190.         for (uint32_t i=0; i < fRdfDescriptor->PortCount; ++i)

  191.         {

  192.             const LV2_Property portTypes(fRdfDescriptor->Ports[i].Types);

  193. 

  194.             if (LV2_IS_PORT_OUTPUT(portTypes) && LV2_PORT_SUPPORTS_MIDI_EVENT(portTypes))

  195.                 count += 1;

  196.         }

  197. 

  198.         return count;

  199.     }

  200. 

  201.     uint32_t getParameterScalePointCount(const uint32_t parameterId) const noexcept override

  202.     {

  203.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr, 0);

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

  205. 

  206.         const int32_t rindex(pData->param.data[parameterId].rindex);

  207. 

  208.         if (rindex < static_cast<int32_t>(fRdfDescriptor->PortCount))

  209.         {

  210.             const LV2_RDF_Port& port(fRdfDescriptor->Ports[rindex]);

  211.             return port.ScalePointCount;

  212.         }

  213. 

  214.         return 0;

  215.     }

  216. 

  217.     // -------------------------------------------------------------------

  218.     // Information (current data)

  219. 

  220.     // nothing

  221. 

  222.     // -------------------------------------------------------------------

  223.     // Information (per-plugin data)

  224. 

  225.     unsigned int getOptionsAvailable() const noexcept override

  226.     {

  227.         const uint32_t hasMidiIn(getMidiInCount() > 0);

  228. 

  229.         unsigned int options = 0x0;

  230. 

  231.         options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  232. 

  233.         if (! (hasMidiIn || needsFixedBuffer()))

  234.             options |= PLUGIN_OPTION_FIXED_BUFFERS;

  235. 

  236.         if (pData->engine->getProccessMode() != ENGINE_PROCESS_MODE_CONTINUOUS_RACK)

  237.         {

  238.             if (pData->options & PLUGIN_OPTION_FORCE_STEREO)

  239.                 options |= PLUGIN_OPTION_FORCE_STEREO;

  240.             else if (pData->audioIn.count <= 1 && pData->audioOut.count <= 1 && (pData->audioIn.count != 0 || pData->audioOut.count != 0))

  241.                 options |= PLUGIN_OPTION_FORCE_STEREO;

  242.         }

  243. 

  244.         if (hasMidiIn)

  245.         {

  246.             options |= PLUGIN_OPTION_SEND_CONTROL_CHANGES;

  247.             options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  248.             options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

  249.             options |= PLUGIN_OPTION_SEND_PITCHBEND;

  250.             options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  251.         }

  252. 

  253.         return options;

  254.     }

  255. 

  256.     float getParameterValue(const uint32_t parameterId) const noexcept override

  257.     {

  258.         CARLA_SAFE_ASSERT_RETURN(fParamBuffers != nullptr, 0.0f);

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

  260. 

  261.         if (pData->param.data[parameterId].hints & PARAMETER_IS_STRICT_BOUNDS)

  262.             pData->param.ranges[parameterId].fixValue(fParamBuffers[parameterId]);

  263. 

  264.         return fParamBuffers[parameterId];

  265.     }

  266. 

  267.     float getParameterScalePointValue(const uint32_t parameterId, const uint32_t scalePointId) const noexcept override

  268.     {

  269.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr, 0.0f);

  270.         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, 0.0f);

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

  272. 

  273.         const int32_t rindex(pData->param.data[parameterId].rindex);

  274. 

  275.         if (rindex < static_cast<int32_t>(fRdfDescriptor->PortCount))

  276.         {

  277.             const LV2_RDF_Port& port(fRdfDescriptor->Ports[rindex]);

  278. 

  279.             if (scalePointId < port.ScalePointCount)

  280.             {

  281.                 const LV2_RDF_PortScalePoint& portScalePoint(port.ScalePoints[scalePointId]);

  282.                 return portScalePoint.Value;

  283.             }

  284.         }

  285. 

  286.         return 0.0f;

  287.     }

  288. 

  289.     void getLabel(char* const strBuf) const noexcept override

  290.     {

  291.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr,);

  292.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor->URI != nullptr,);

  293. 

  294.         if (fRdfDescriptor->URI != nullptr)

  295.             std::strncpy(strBuf, fRdfDescriptor->URI, STR_MAX);

  296.         else

  297.             CarlaPlugin::getLabel(strBuf);

  298.     }

  299. 

  300.     void getMaker(char* const strBuf) const noexcept override

  301.     {

  302.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr,);

  303. 

  304.         if (fRdfDescriptor->Author != nullptr)

  305.             std::strncpy(strBuf, fRdfDescriptor->Author, STR_MAX);

  306.         else

  307.             CarlaPlugin::getMaker(strBuf);

  308.     }

  309. 

  310.     void getCopyright(char* const strBuf) const noexcept override

  311.     {

  312.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr,);

  313. 

  314.         if (fRdfDescriptor->License != nullptr)

  315.             std::strncpy(strBuf, fRdfDescriptor->License, STR_MAX);

  316.         else

  317.             CarlaPlugin::getCopyright(strBuf);

  318.     }

  319. 

  320.     void getRealName(char* const strBuf) const noexcept override

  321.     {

  322.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr,);

  323. 

  324.         if (fRdfDescriptor->Name != nullptr)

  325.             std::strncpy(strBuf, fRdfDescriptor->Name, STR_MAX);

  326.         else

  327.             CarlaPlugin::getRealName(strBuf);

  328.     }

  329. 

  330.     void getParameterName(const uint32_t parameterId, char* const strBuf) const noexcept override

  331.     {

  332.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr,);

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

  334. 

  335.         const int32_t rindex(pData->param.data[parameterId].rindex);

  336. 

  337.         if (rindex < static_cast<int32_t>(fRdfDescriptor->PortCount))

  338.             std::strncpy(strBuf, fRdfDescriptor->Ports[rindex].Name, STR_MAX);

  339.         else

  340.             CarlaPlugin::getParameterName(parameterId, strBuf);

  341.     }

  342. 

  343.     void getParameterSymbol(const uint32_t parameterId, char* const strBuf) const noexcept override

  344.     {

  345.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr,);

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

  347. 

  348.         const int32_t rindex(pData->param.data[parameterId].rindex);

  349. 

  350.         if (rindex < static_cast<int32_t>(fRdfDescriptor->PortCount))

  351.             std::strncpy(strBuf, fRdfDescriptor->Ports[rindex].Symbol, STR_MAX);

  352.         else

  353.             CarlaPlugin::getParameterSymbol(parameterId, strBuf);

  354.     }

  355. 

  356.     void getParameterUnit(const uint32_t parameterId, char* const strBuf) const noexcept override

  357.     {

  358.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr,);

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

  360. 

  361.         const int32_t rindex(pData->param.data[parameterId].rindex);

  362. 

  363.         if (rindex < static_cast<int32_t>(fRdfDescriptor->PortCount))

  364.         {

  365.             const LV2_RDF_Port& port(fRdfDescriptor->Ports[rindex]);

  366. 

  367.             if (LV2_HAVE_PORT_UNIT_SYMBOL(port.Unit.Hints) && port.Unit.Symbol != nullptr)

  368.             {

  369.                 std::strncpy(strBuf, port.Unit.Symbol, STR_MAX);

  370.                 return;

  371.             }

  372.             else if (LV2_HAVE_PORT_UNIT_UNIT(port.Unit.Hints))

  373.             {

  374.                 switch (port.Unit.Unit)

  375.                 {

  376.                 case LV2_PORT_UNIT_BAR:

  377.                     std::strncpy(strBuf, "bars", STR_MAX);

  378.                     return;

  379.                 case LV2_PORT_UNIT_BEAT:

  380.                     std::strncpy(strBuf, "beats", STR_MAX);

  381.                     return;

  382.                 case LV2_PORT_UNIT_BPM:

  383.                     std::strncpy(strBuf, "BPM", STR_MAX);

  384.                     return;

  385.                 case LV2_PORT_UNIT_CENT:

  386.                     std::strncpy(strBuf, "ct", STR_MAX);

  387.                     return;

  388.                 case LV2_PORT_UNIT_CM:

  389.                     std::strncpy(strBuf, "cm", STR_MAX);

  390.                     return;

  391.                 case LV2_PORT_UNIT_COEF:

  392.                     std::strncpy(strBuf, "(coef)", STR_MAX);

  393.                     return;

  394.                 case LV2_PORT_UNIT_DB:

  395.                     std::strncpy(strBuf, "dB", STR_MAX);

  396.                     return;

  397.                 case LV2_PORT_UNIT_DEGREE:

  398.                     std::strncpy(strBuf, "deg", STR_MAX);

  399.                     return;

  400.                 case LV2_PORT_UNIT_FRAME:

  401.                     std::strncpy(strBuf, "frames", STR_MAX);

  402.                     return;

  403.                 case LV2_PORT_UNIT_HZ:

  404.                     std::strncpy(strBuf, "Hz", STR_MAX);

  405.                     return;

  406.                 case LV2_PORT_UNIT_INCH:

  407.                     std::strncpy(strBuf, "in", STR_MAX);

  408.                     return;

  409.                 case LV2_PORT_UNIT_KHZ:

  410.                     std::strncpy(strBuf, "kHz", STR_MAX);

  411.                     return;

  412.                 case LV2_PORT_UNIT_KM:

  413.                     std::strncpy(strBuf, "km", STR_MAX);

  414.                     return;

  415.                 case LV2_PORT_UNIT_M:

  416.                     std::strncpy(strBuf, "m", STR_MAX);

  417.                     return;

  418.                 case LV2_PORT_UNIT_MHZ:

  419.                     std::strncpy(strBuf, "MHz", STR_MAX);

  420.                     return;

  421.                 case LV2_PORT_UNIT_MIDINOTE:

  422.                     std::strncpy(strBuf, "note", STR_MAX);

  423.                     return;

  424.                 case LV2_PORT_UNIT_MILE:

  425.                     std::strncpy(strBuf, "mi", STR_MAX);

  426.                     return;

  427.                 case LV2_PORT_UNIT_MIN:

  428.                     std::strncpy(strBuf, "min", STR_MAX);

  429.                     return;

  430.                 case LV2_PORT_UNIT_MM:

  431.                     std::strncpy(strBuf, "mm", STR_MAX);

  432.                     return;

  433.                 case LV2_PORT_UNIT_MS:

  434.                     std::strncpy(strBuf, "ms", STR_MAX);

  435.                     return;

  436.                 case LV2_PORT_UNIT_OCT:

  437.                     std::strncpy(strBuf, "oct", STR_MAX);

  438.                     return;

  439.                 case LV2_PORT_UNIT_PC:

  440.                     std::strncpy(strBuf, "%", STR_MAX);

  441.                     return;

  442.                 case LV2_PORT_UNIT_S:

  443.                     std::strncpy(strBuf, "s", STR_MAX);

  444.                     return;

  445.                 case LV2_PORT_UNIT_SEMITONE:

  446.                     std::strncpy(strBuf, "semi", STR_MAX);

  447.                     return;

  448.                 }

  449.             }

  450.         }

  451. 

  452.         CarlaPlugin::getParameterUnit(parameterId, strBuf);

  453.     }

  454. 

  455.     void getParameterScalePointLabel(const uint32_t parameterId, const uint32_t scalePointId, char* const strBuf) const noexcept override

  456.     {

  457.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr,);

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

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

  460. 

  461.         const int32_t rindex(pData->param.data[parameterId].rindex);

  462. 

  463.         if (rindex < static_cast<int32_t>(fRdfDescriptor->PortCount))

  464.         {

  465.             const LV2_RDF_Port& port(fRdfDescriptor->Ports[rindex]);

  466. 

  467.             if (scalePointId < port.ScalePointCount)

  468.             {

  469.                 const LV2_RDF_PortScalePoint& portScalePoint(port.ScalePoints[scalePointId]);

  470. 

  471.                 if (portScalePoint.Label != nullptr)

  472.                 {

  473.                     std::strncpy(strBuf, portScalePoint.Label, STR_MAX);

  474.                     return;

  475.                 }

  476.             }

  477.         }

  478. 

  479.         CarlaPlugin::getParameterScalePointLabel(parameterId, scalePointId, strBuf);

  480.     }

  481. 

  482.     // -------------------------------------------------------------------

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

  484. 

  485.     void setParameterValue(const uint32_t parameterId, const float value, const bool sendGui, const bool sendOsc, const bool sendCallback) noexcept override

  486.     {

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

  488. 

  489.         const float fixedValue(pData->param.getFixedValue(parameterId, value));

  490.         fParamBuffers[parameterId] = fixedValue;

  491. 

  492.         CarlaPlugin::setParameterValue(parameterId, fixedValue, sendGui, sendOsc, sendCallback);

  493.     }

  494. 

  495.     // -------------------------------------------------------------------

  496.     // Plugin state

  497. 

  498.     void reload() override

  499.     {

  500.         CARLA_SAFE_ASSERT_RETURN(pData->engine != nullptr,);

  501.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  502.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  503.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr,);

  504.         carla_debug("Lv2Plugin::reload() - start");

  505. 

  506.         const EngineProcessMode processMode(pData->engine->getProccessMode());

  507. 

  508.         // Safely disable plugin for reload

  509.         const ScopedDisabler sd(this);

  510. 

  511.         if (pData->active)

  512.             deactivate();

  513. 

  514.         clearBuffers();

  515. 

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

  517.         const uint32_t portCount(static_cast<uint32_t>(fRdfDescriptor->PortCount));

  518. 

  519.         uint32_t aIns, aOuts, params, j;

  520.         aIns = aOuts = params = 0;

  521. 

  522.         bool forcedStereoIn, forcedStereoOut;

  523.         forcedStereoIn = forcedStereoOut = false;

  524. 

  525.         bool needsCtrlIn, needsCtrlOut;

  526.         needsCtrlIn = needsCtrlOut = false;

  527. 

  528.         for (uint32_t i=0; i < portCount; ++i)

  529.         {

  530.             const LV2_Property portTypes(fRdfDescriptor->Ports[i].Types);

  531. 

  532.             if (LV2_IS_PORT_AUDIO(portTypes))

  533.             {

  534.                 if (LV2_IS_PORT_INPUT(portTypes))

  535.                     aIns += 1;

  536.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  537.                     aOuts += 1;

  538.             }

  539.             else if (LV2_IS_PORT_CONTROL(portTypes))

  540.                 params += 1;

  541.         }

  542. 

  543.         if ((pData->options & PLUGIN_OPTION_FORCE_STEREO) != 0 && (aIns == 1 || aOuts == 1) /*&& fExt.state == nullptr && fExt.worker == nullptr*/)

  544.         {

  545.             if (fHandle2 == nullptr)

  546.                 fHandle2 = fDescriptor->instantiate(fDescriptor, sampleRate, fRdfDescriptor->Bundle, fFeatures);

  547. 

  548.             if (fHandle2 != nullptr)

  549.             {

  550.                 if (aIns == 1)

  551.                 {

  552.                     aIns = 2;

  553.                     forcedStereoIn = true;

  554.                 }

  555. 

  556.                 if (aOuts == 1)

  557.                 {

  558.                     aOuts = 2;

  559.                     forcedStereoOut = true;

  560.                 }

  561.             }

  562.         }

  563. 

  564.         if (aIns > 0)

  565.         {

  566.             pData->audioIn.createNew(aIns);

  567.             fAudioInBuffers = new float*[aIns];

  568. 

  569.             for (uint32_t i=0; i < aIns; ++i)

  570.                 fAudioInBuffers[i] = nullptr;

  571.         }

  572. 

  573.         if (aOuts > 0)

  574.         {

  575.             pData->audioOut.createNew(aOuts);

  576.             fAudioOutBuffers = new float*[aOuts];

  577.             needsCtrlIn = true;

  578. 

  579.             for (uint32_t i=0; i < aOuts; ++i)

  580.                 fAudioOutBuffers[i] = nullptr;

  581.         }

  582. 

  583.         if (params > 0)

  584.         {

  585.             pData->param.createNew(params, true);

  586. 

  587.             fParamBuffers = new float[params];

  588.             FLOAT_CLEAR(fParamBuffers, params);

  589.         }

  590. 

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

  592.         CarlaString portName;

  593. 

  594.         for (uint32_t i=0, iAudioIn=0, iAudioOut=0, iCtrl=0; i < portCount; ++i)

  595.         {

  596.             const LV2_Property portTypes(fRdfDescriptor->Ports[i].Types);

  597. 

  598.             portName.clear();

  599. 

  600.             if (LV2_IS_PORT_AUDIO(portTypes) || LV2_IS_PORT_ATOM_SEQUENCE(portTypes) || LV2_IS_PORT_CV(portTypes) || LV2_IS_PORT_EVENT(portTypes) || LV2_IS_PORT_MIDI_LL(portTypes))

  601.             {

  602.                 if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  603.                 {

  604.                     portName  = pData->name;

  605.                     portName += ":";

  606.                 }

  607. 

  608.                 portName += fRdfDescriptor->Ports[i].Name;

  609.                 portName.truncate(portNameSize);

  610.             }

  611. 

  612.             if (LV2_IS_PORT_AUDIO(portTypes))

  613.             {

  614.                 if (LV2_IS_PORT_INPUT(portTypes))

  615.                 {

  616.                     j = iAudioIn++;

  617.                     pData->audioIn.ports[j].port   = (CarlaEngineAudioPort*)pData->client->addPort(kEnginePortTypeAudio, portName, true);

  618.                     pData->audioIn.ports[j].rindex = i;

  619. 

  620.                     if (forcedStereoIn)

  621.                     {

  622.                         portName += "_2";

  623.                         pData->audioIn.ports[1].port   = (CarlaEngineAudioPort*)pData->client->addPort(kEnginePortTypeAudio, portName, true);

  624.                         pData->audioIn.ports[1].rindex = i;

  625.                     }

  626.                 }

  627.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  628.                 {

  629.                     j = iAudioOut++;

  630.                     pData->audioOut.ports[j].port   = (CarlaEngineAudioPort*)pData->client->addPort(kEnginePortTypeAudio, portName, false);

  631.                     pData->audioOut.ports[j].rindex = i;

  632. 

  633.                     if (forcedStereoOut)

  634.                     {

  635.                         portName += "_2";

  636.                         pData->audioOut.ports[1].port   = (CarlaEngineAudioPort*)pData->client->addPort(kEnginePortTypeAudio, portName, false);

  637.                         pData->audioOut.ports[1].rindex = i;

  638.                     }

  639.                 }

  640.                 else

  641.                     carla_stderr("WARNING - Got a broken Port (Audio, but not input or output)");

  642.             }

  643.             else if (LV2_IS_PORT_CONTROL(portTypes))

  644.             {

  645.                 const LV2_Property portProps(fRdfDescriptor->Ports[i].Properties);

  646.                 const LV2_Property portDesignation(fRdfDescriptor->Ports[i].Designation);

  647.                 const LV2_RDF_PortPoints portPoints(fRdfDescriptor->Ports[i].Points);

  648. 

  649.                 j = iCtrl++;

  650.                 pData->param.data[j].type   = PARAMETER_UNKNOWN;

  651.                 pData->param.data[j].hints  = 0x0;

  652.                 pData->param.data[j].index  = j;

  653.                 pData->param.data[j].rindex = i;

  654.                 pData->param.data[j].midiCC = -1;

  655.                 pData->param.data[j].midiChannel = 0;

  656. 

  657.                 float min, max, def, step, stepSmall, stepLarge;

  658. 

  659.                 // min value

  660.                 if (LV2_HAVE_MINIMUM_PORT_POINT(portPoints.Hints))

  661.                     min = portPoints.Minimum;

  662.                 else

  663.                     min = 0.0f;

  664. 

  665.                 // max value

  666.                 if (LV2_HAVE_MAXIMUM_PORT_POINT(portPoints.Hints))

  667.                     max = portPoints.Maximum;

  668.                 else

  669.                     max = 1.0f;

  670. 

  671.                 if (min > max)

  672.                     max = min;

  673.                 else if (max < min)

  674.                     min = max;

  675. 

  676.                 // stupid hack for ir.lv2 (broken plugin)

  677.                 if (std::strcmp(fRdfDescriptor->URI, "http://factorial.hu/plugins/lv2/ir") == 0 && std::strncmp(fRdfDescriptor->Ports[i].Name, "FileHash", 8) == 0)

  678.                 {

  679.                     min = 0.0f;

  680.                     max = (float)0xffffff;

  681.                 }

  682. 

  683.                 if (max - min == 0.0f)

  684.                 {

  685.                     carla_stderr2("WARNING - Broken plugin parameter '%s': max - min == 0.0f", fRdfDescriptor->Ports[i].Name);

  686.                     max = min + 0.1f;

  687.                 }

  688. 

  689.                 // default value

  690.                 if (LV2_HAVE_DEFAULT_PORT_POINT(portPoints.Hints))

  691.                 {

  692.                     def = portPoints.Default;

  693.                 }

  694.                 else

  695.                 {

  696.                     // no default value

  697.                     if (min < 0.0f && max > 0.0f)

  698.                         def = 0.0f;

  699.                     else

  700.                         def = min;

  701.                 }

  702. 

  703.                 if (def < min)

  704.                     def = min;

  705.                 else if (def > max)

  706.                     def = max;

  707. 

  708.                 if (LV2_IS_PORT_SAMPLE_RATE(portProps))

  709.                 {

  710.                     min *= sampleRate;

  711.                     max *= sampleRate;

  712.                     def *= sampleRate;

  713.                     pData->param.data[j].hints |= PARAMETER_USES_SAMPLERATE;

  714.                 }

  715. 

  716.                 if (LV2_IS_PORT_TOGGLED(portProps))

  717.                 {

  718.                     step = max - min;

  719.                     stepSmall = step;

  720.                     stepLarge = step;

  721.                     pData->param.data[j].hints |= PARAMETER_IS_BOOLEAN;

  722.                 }

  723.                 else if (LV2_IS_PORT_INTEGER(portProps))

  724.                 {

  725.                     step = 1.0f;

  726.                     stepSmall = 1.0f;

  727.                     stepLarge = 10.0f;

  728.                     pData->param.data[j].hints |= PARAMETER_IS_INTEGER;

  729.                 }

  730.                 else

  731.                 {

  732.                     float range = max - min;

  733.                     step = range/100.0f;

  734.                     stepSmall = range/1000.0f;

  735.                     stepLarge = range/10.0f;

  736.                 }

  737. 

  738.                 if (LV2_IS_PORT_INPUT(portTypes))

  739.                 {

  740.                     if (LV2_IS_PORT_DESIGNATION_LATENCY(portDesignation))

  741.                     {

  742.                         carla_stderr("Plugin has latency input port, this should not happen!");

  743.                     }

  744.                     else if (LV2_IS_PORT_DESIGNATION_SAMPLE_RATE(portDesignation))

  745.                     {

  746.                         def = sampleRate;

  747.                         step = 1.0f;

  748.                         stepSmall = 1.0f;

  749.                         stepLarge = 1.0f;

  750. 

  751.                         //pData->param.data[j].type  = PARAMETER_SAMPLE_RATE;

  752.                         pData->param.data[j].hints = 0x0;

  753.                     }

  754.                     else if (LV2_IS_PORT_DESIGNATION_FREEWHEELING(portDesignation))

  755.                     {

  756.                         //pData->param.data[j].type = PARAMETER_LV2_FREEWHEEL;

  757.                     }

  758.                     else if (LV2_IS_PORT_DESIGNATION_TIME(portDesignation))

  759.                     {

  760.                         //pData->param.data[j].type = PARAMETER_LV2_TIME;

  761.                     }

  762.                     else

  763.                     {

  764.                         pData->param.data[j].type   = PARAMETER_INPUT;

  765.                         pData->param.data[j].hints |= PARAMETER_IS_ENABLED;

  766.                         pData->param.data[j].hints |= PARAMETER_IS_AUTOMABLE;

  767.                         needsCtrlIn = true;

  768.                     }

  769. 

  770.                     // MIDI CC value

  771.                     const LV2_RDF_PortMidiMap& portMidiMap(fRdfDescriptor->Ports[i].MidiMap);

  772. 

  773.                     if (LV2_IS_PORT_MIDI_MAP_CC(portMidiMap.Type))

  774.                     {

  775.                         if (portMidiMap.Number < 0x5F && ! MIDI_IS_CONTROL_BANK_SELECT(portMidiMap.Number))

  776.                             pData->param.data[j].midiCC = int16_t(portMidiMap.Number);

  777.                     }

  778.                 }

  779.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  780.                 {

  781.                     if (LV2_IS_PORT_DESIGNATION_LATENCY(portDesignation))

  782.                     {

  783.                         min = 0.0f;

  784.                         max = sampleRate;

  785.                         def = 0.0f;

  786.                         step = 1.0f;

  787.                         stepSmall = 1.0f;

  788.                         stepLarge = 1.0f;

  789. 

  790.                         //pData->param.data[j].type  = PARAMETER_LATENCY;

  791.                         pData->param.data[j].hints = 0x0;

  792.                     }

  793.                     else if (LV2_IS_PORT_DESIGNATION_SAMPLE_RATE(portDesignation))

  794.                     {

  795.                         def = sampleRate;

  796.                         step = 1.0f;

  797.                         stepSmall = 1.0f;

  798.                         stepLarge = 1.0f;

  799. 

  800.                         //pData->param.data[j].type  = PARAMETER_SAMPLE_RATE;

  801.                         pData->param.data[j].hints = 0x0;

  802.                     }

  803.                     else if (LV2_IS_PORT_DESIGNATION_FREEWHEELING(portDesignation))

  804.                     {

  805.                         carla_stderr("Plugin has freewheeling output port, this should not happen!");

  806.                     }

  807.                     else if (LV2_IS_PORT_DESIGNATION_TIME(portDesignation))

  808.                     {

  809.                         //pData->param.data[j].type = PARAMETER_LV2_TIME;

  810.                     }

  811.                     else

  812.                     {

  813.                         pData->param.data[j].type   = PARAMETER_OUTPUT;

  814.                         pData->param.data[j].hints |= PARAMETER_IS_ENABLED;

  815.                         pData->param.data[j].hints |= PARAMETER_IS_AUTOMABLE;

  816.                         needsCtrlOut = true;

  817.                     }

  818.                 }

  819.                 else

  820.                 {

  821.                     pData->param.data[j].type = PARAMETER_UNKNOWN;

  822.                     carla_stderr2("WARNING - Got a broken Port (Control, but not input or output)");

  823.                 }

  824. 

  825.                 // extra parameter hints

  826.                 if (LV2_IS_PORT_ENUMERATION(portProps))

  827.                     pData->param.data[j].hints |= PARAMETER_USES_SCALEPOINTS;

  828. 

  829.                 if (LV2_IS_PORT_LOGARITHMIC(portProps))

  830.                     pData->param.data[j].hints |= PARAMETER_IS_LOGARITHMIC;

  831. 

  832.                 if (LV2_IS_PORT_TRIGGER(portProps))

  833.                     pData->param.data[j].hints |= PARAMETER_IS_TRIGGER;

  834. 

  835.                 if (LV2_IS_PORT_STRICT_BOUNDS(portProps))

  836.                     pData->param.data[j].hints |= PARAMETER_IS_STRICT_BOUNDS;

  837. 

  838.                 // check if parameter is not enabled or automable

  839.                 if (LV2_IS_PORT_NOT_ON_GUI(portProps))

  840.                 {

  841.                     pData->param.data[j].hints &= ~(PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE);

  842.                 }

  843.                 else if (LV2_IS_PORT_CAUSES_ARTIFACTS(portProps) || LV2_IS_PORT_EXPENSIVE(portProps) || LV2_IS_PORT_NOT_AUTOMATIC(portProps))

  844.                     pData->param.data[j].hints &= ~PARAMETER_IS_AUTOMABLE;

  845. 

  846.                 pData->param.ranges[j].min = min;

  847.                 pData->param.ranges[j].max = max;

  848.                 pData->param.ranges[j].def = def;

  849.                 pData->param.ranges[j].step = step;

  850.                 pData->param.ranges[j].stepSmall = stepSmall;

  851.                 pData->param.ranges[j].stepLarge = stepLarge;

  852. 

  853.                 // Start parameters in their default values

  854.                 //if (pData->param.data[j].type != PARAMETER_LV2_FREEWHEEL)

  855.                     fParamBuffers[j] = def;

  856.                 //else

  857.                 //    fParamBuffers[j] = min;

  858. 

  859.                 fDescriptor->connect_port(fHandle, i, &fParamBuffers[j]);

  860. 

  861.                 if (fHandle2 != nullptr)

  862.                     fDescriptor->connect_port(fHandle2, i, &fParamBuffers[j]);

  863.             }

  864.             else

  865.             {

  866.                 // Port Type not supported, but it's optional anyway

  867.                 fDescriptor->connect_port(fHandle, i, nullptr);

  868. 

  869.                 if (fHandle2 != nullptr)

  870.                     fDescriptor->connect_port(fHandle2, i, nullptr);

  871.             }

  872.         }

  873. 

  874.         if (needsCtrlIn)

  875.         {

  876.             portName.clear();

  877. 

  878.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  879.             {

  880.                 portName  = pData->name;

  881.                 portName += ":";

  882.             }

  883. 

  884.             portName += "events-in";

  885.             portName.truncate(portNameSize);

  886. 

  887.             pData->event.portIn = (CarlaEngineEventPort*)pData->client->addPort(kEnginePortTypeEvent, portName, true);

  888.         }

  889. 

  890.         if (needsCtrlOut)

  891.         {

  892.             portName.clear();

  893. 

  894.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  895.             {

  896.                 portName  = pData->name;

  897.                 portName += ":";

  898.             }

  899. 

  900.             portName += "events-out";

  901.             portName.truncate(portNameSize);

  902. 

  903.             pData->event.portOut = (CarlaEngineEventPort*)pData->client->addPort(kEnginePortTypeEvent, portName, false);

  904.         }

  905. 

  906.         if (forcedStereoIn || forcedStereoOut)

  907.             pData->options |= PLUGIN_OPTION_FORCE_STEREO;

  908.         else

  909.             pData->options &= ~PLUGIN_OPTION_FORCE_STEREO;

  910. 

  911.         // plugin hints

  912.         pData->hints = 0x0;

  913. 

  914.         if (isRealtimeSafe())

  915.             pData->hints |= PLUGIN_IS_RTSAFE;

  916. 

  917.         if (LV2_IS_GENERATOR(fRdfDescriptor->Type[0], fRdfDescriptor->Type[1]))

  918.             pData->hints |= PLUGIN_IS_SYNTH;

  919. 

  920.         if (aOuts > 0 && (aIns == aOuts || aIns == 1))

  921.             pData->hints |= PLUGIN_CAN_DRYWET;

  922. 

  923.         if (aOuts > 0)

  924.             pData->hints |= PLUGIN_CAN_VOLUME;

  925. 

  926.         if (aOuts >= 2 && aOuts % 2 == 0)

  927.             pData->hints |= PLUGIN_CAN_BALANCE;

  928. 

  929.         // extra plugin hints

  930.         pData->extraHints &= ~PLUGIN_EXTRA_HINT_CAN_RUN_RACK;

  931. 

  932.         bufferSizeChanged(pData->engine->getBufferSize());

  933.         reloadPrograms(true);

  934. 

  935.         if (pData->active)

  936.             activate();

  937. 

  938.         carla_debug("Lv2Plugin::reload() - end");

  939.     }

  940. 

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

  942.     // Plugin processing

  943. 

  944.     void activate() noexcept override

  945.     {

  946.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  947.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  948. 

  949.         if (fDescriptor->activate != nullptr)

  950.         {

  951.             try {

  952.                 fDescriptor->activate(fHandle);

  953.             } catch(...) {}

  954. 

  955.             if (fHandle2 != nullptr)

  956.             {

  957.                 try {

  958.                     fDescriptor->activate(fHandle2);

  959.                 } catch(...) {}

  960.             }

  961.         }

  962.     }

  963. 

  964.     void deactivate() noexcept override

  965.     {

  966.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  967.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  968. 

  969.         if (fDescriptor->deactivate != nullptr)

  970.         {

  971.             try {

  972.                 fDescriptor->deactivate(fHandle);

  973.             } catch(...) {}

  974. 

  975.             if (fHandle2 != nullptr)

  976.             {

  977.                 try {

  978.                     fDescriptor->deactivate(fHandle2);

  979.                 } catch(...) {}

  980.             }

  981.         }

  982.     }

  983. 

  984.     void process(float** const inBuffer, float** const outBuffer, const uint32_t frames) override

  985.     {

  986.         uint32_t i, k;

  987. 

  988.         // --------------------------------------------------------------------------------------------------------

  989.         // Check if active

  990. 

  991.         if (! pData->active)

  992.         {

  993.             // disable any output sound

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

  995.                 FLOAT_CLEAR(outBuffer[i], frames);

  996.             return;

  997.         }

  998. 

  999.         // --------------------------------------------------------------------------------------------------------

  1000.         // Plugin processing (no events)

  1001. 

  1002.         {

  1003.             processSingle(inBuffer, outBuffer, frames, 0);

  1004. 

  1005.         } // End of Plugin processing (no events)

  1006. 

  1007.         // --------------------------------------------------------------------------------------------------------

  1008.         // Control Output

  1009. 

  1010.         if (pData->event.portOut != nullptr)

  1011.         {

  1012.             uint8_t  channel;

  1013.             uint16_t param;

  1014.             float    value;

  1015. 

  1016.             for (k=0; k < pData->param.count; ++k)

  1017.             {

  1018.                 if (pData->param.data[k].type != PARAMETER_OUTPUT)

  1019.                     continue;

  1020. 

  1021.                 if (pData->param.data[k].hints & PARAMETER_IS_STRICT_BOUNDS)

  1022.                     pData->param.ranges[k].fixValue(fParamBuffers[k]);

  1023. 

  1024.                 if (pData->param.data[k].midiCC > 0)

  1025.                 {

  1026.                     channel = pData->param.data[k].midiChannel;

  1027.                     param   = static_cast<uint16_t>(pData->param.data[k].midiCC);

  1028.                     value   = pData->param.ranges[k].getNormalizedValue(fParamBuffers[k]);

  1029.                     pData->event.portOut->writeControlEvent(0, channel, kEngineControlEventTypeParameter, param, value);

  1030.                 }

  1031.             }

  1032. 

  1033.         } // End of Control Output

  1034. 

  1035.         CARLA_PROCESS_CONTINUE_CHECK;

  1036. 

  1037.         // --------------------------------------------------------------------------------------------------------

  1038.     }

  1039. 

  1040.     bool processSingle(float** const inBuffer, float** const outBuffer, const uint32_t frames, const uint32_t timeOffset)

  1041.     {

  1042.         CARLA_SAFE_ASSERT_RETURN(frames > 0, false);

  1043. 

  1044.         if (pData->audioIn.count > 0)

  1045.         {

  1046.             CARLA_SAFE_ASSERT_RETURN(inBuffer != nullptr, false);

  1047.         }

  1048.         if (pData->audioOut.count > 0)

  1049.         {

  1050.             CARLA_SAFE_ASSERT_RETURN(outBuffer != nullptr, false);

  1051.         }

  1052. 

  1053.         uint32_t i, k;

  1054. 

  1055.         // --------------------------------------------------------------------------------------------------------

  1056.         // Try lock, silence otherwise

  1057. 

  1058.         if (pData->engine->isOffline())

  1059.         {

  1060.             pData->singleMutex.lock();

  1061.         }

  1062.         else if (! pData->singleMutex.tryLock())

  1063.         {

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

  1065.             {

  1066.                 for (k=0; k < frames; ++k)

  1067.                     outBuffer[i][k+timeOffset] = 0.0f;

  1068.             }

  1069. 

  1070.             return false;

  1071.         }

  1072. 

  1073.         // --------------------------------------------------------------------------------------------------------

  1074.         // Reset audio buffers

  1075. 

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

  1077.             FLOAT_COPY(fAudioInBuffers[i], inBuffer[i]+timeOffset, frames);

  1078. 

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

  1080.             FLOAT_CLEAR(fAudioOutBuffers[i], frames);

  1081. 

  1082.         // --------------------------------------------------------------------------------------------------------

  1083.         // Run plugin

  1084. 

  1085.         fDescriptor->run(fHandle, frames);

  1086. 

  1087.         if (fHandle2 != nullptr)

  1088.             fDescriptor->run(fHandle2, frames);

  1089. 

  1090.         // --------------------------------------------------------------------------------------------------------

  1091.         // Special Parameters

  1092. 

  1093.         for (k=0; k < pData->param.count; ++k)

  1094.         {

  1095.             if (pData->param.data[k].type != PARAMETER_INPUT)

  1096.                 continue;

  1097. 

  1098.             if (pData->param.data[k].hints & PARAMETER_IS_TRIGGER)

  1099.             {

  1100.                 if (fParamBuffers[k] != pData->param.ranges[k].def)

  1101.                 {

  1102.                     fParamBuffers[k] = pData->param.ranges[k].def;

  1103.                     pData->postponeRtEvent(kPluginPostRtEventParameterChange, static_cast<int32_t>(k), 0, fParamBuffers[k]);

  1104.                 }

  1105.             }

  1106.         }

  1107. 

  1108.         pData->postRtEvents.trySplice();

  1109. 

  1110. #ifndef BUILD_BRIDGE

  1111.         // --------------------------------------------------------------------------------------------------------

  1112.         // Post-processing (dry/wet, volume and balance)

  1113. 

  1114.         {

  1115.             const bool doDryWet  = (pData->hints & PLUGIN_CAN_DRYWET) != 0 && pData->postProc.dryWet != 1.0f;

  1116.             const bool doBalance = (pData->hints & PLUGIN_CAN_BALANCE) != 0 && (pData->postProc.balanceLeft != -1.0f || pData->postProc.balanceRight != 1.0f);

  1117. 

  1118.             bool isPair;

  1119.             float bufValue, oldBufLeft[doBalance ? frames : 1];

  1120. 

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

  1122.             {

  1123.                 // Dry/Wet

  1124.                 if (doDryWet)

  1125.                 {

  1126.                     for (k=0; k < frames; ++k)

  1127.                     {

  1128.                         // TODO

  1129.                         //if (k < pData->latency && pData->latency < frames)

  1130.                         //    bufValue = (pData->audioIn.count == 1) ? pData->latencyBuffers[0][k] : pData->latencyBuffers[i][k];

  1131.                         //else

  1132.                         //    bufValue = (pData->audioIn.count == 1) ? inBuffer[0][k-m_latency] : inBuffer[i][k-m_latency];

  1133. 

  1134.                         bufValue = fAudioInBuffers[(pData->audioIn.count == 1) ? 0 : i][k];

  1135.                         fAudioOutBuffers[i][k] = (fAudioOutBuffers[i][k] * pData->postProc.dryWet) + (bufValue * (1.0f - pData->postProc.dryWet));

  1136.                     }

  1137.                 }

  1138. 

  1139.                 // Balance

  1140.                 if (doBalance)

  1141.                 {

  1142.                     isPair = (i % 2 == 0);

  1143. 

  1144.                     if (isPair)

  1145.                     {

  1146.                         CARLA_ASSERT(i+1 < pData->audioOut.count);

  1147.                         FLOAT_COPY(oldBufLeft, fAudioOutBuffers[i], frames);

  1148.                     }

  1149. 

  1150.                     float balRangeL = (pData->postProc.balanceLeft  + 1.0f)/2.0f;

  1151.                     float balRangeR = (pData->postProc.balanceRight + 1.0f)/2.0f;

  1152. 

  1153.                     for (k=0; k < frames; ++k)

  1154.                     {

  1155.                         if (isPair)

  1156.                         {

  1157.                             // left

  1158.                             fAudioOutBuffers[i][k]  = oldBufLeft[k]            * (1.0f - balRangeL);

  1159.                             fAudioOutBuffers[i][k] += fAudioOutBuffers[i+1][k] * (1.0f - balRangeR);

  1160.                         }

  1161.                         else

  1162.                         {

  1163.                             // right

  1164.                             fAudioOutBuffers[i][k]  = fAudioOutBuffers[i][k] * balRangeR;

  1165.                             fAudioOutBuffers[i][k] += oldBufLeft[k]          * balRangeL;

  1166.                         }

  1167.                     }

  1168.                 }

  1169. 

  1170.                 // Volume (and buffer copy)

  1171.                 {

  1172.                     for (k=0; k < frames; ++k)

  1173.                         outBuffer[i][k+timeOffset] = fAudioOutBuffers[i][k] * pData->postProc.volume;

  1174.                 }

  1175.             }

  1176.         } // End of Post-processing

  1177. #else

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

  1179.         {

  1180.             for (k=0; k < frames; ++k)

  1181.                 outBuffer[i][k+timeOffset] = fAudioOutBuffers[i][k];

  1182.         }

  1183. #endif

  1184. 

  1185.         // --------------------------------------------------------------------------------------------------------

  1186. 

  1187.         pData->singleMutex.unlock();

  1188.         return true;

  1189.     }

  1190. 

  1191.     void bufferSizeChanged(const uint32_t newBufferSize) override

  1192.     {

  1193.         CARLA_ASSERT_INT(newBufferSize > 0, newBufferSize);

  1194.         carla_debug("Lv2Plugin::bufferSizeChanged(%i) - start", newBufferSize);

  1195. 

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

  1197.         {

  1198.             if (fAudioInBuffers[i] != nullptr)

  1199.                 delete[] fAudioInBuffers[i];

  1200.             fAudioInBuffers[i] = new float[newBufferSize];

  1201.         }

  1202. 

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

  1204.         {

  1205.             if (fAudioOutBuffers[i] != nullptr)

  1206.                 delete[] fAudioOutBuffers[i];

  1207.             fAudioOutBuffers[i] = new float[newBufferSize];

  1208.         }

  1209. 

  1210.         if (fHandle2 == nullptr)

  1211.         {

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

  1213.             {

  1214.                 CARLA_ASSERT(fAudioInBuffers[i] != nullptr);

  1215.                 fDescriptor->connect_port(fHandle, pData->audioIn.ports[i].rindex, fAudioInBuffers[i]);

  1216.             }

  1217. 

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

  1219.             {

  1220.                 CARLA_ASSERT(fAudioOutBuffers[i] != nullptr);

  1221.                 fDescriptor->connect_port(fHandle, pData->audioOut.ports[i].rindex, fAudioOutBuffers[i]);

  1222.             }

  1223.         }

  1224.         else

  1225.         {

  1226.             if (pData->audioIn.count > 0)

  1227.             {

  1228.                 CARLA_ASSERT(pData->audioIn.count == 2);

  1229.                 CARLA_ASSERT(fAudioInBuffers[0] != nullptr);

  1230.                 CARLA_ASSERT(fAudioInBuffers[1] != nullptr);

  1231. 

  1232.                 fDescriptor->connect_port(fHandle,  pData->audioIn.ports[0].rindex, fAudioInBuffers[0]);

  1233.                 fDescriptor->connect_port(fHandle2, pData->audioIn.ports[1].rindex, fAudioInBuffers[1]);

  1234.             }

  1235. 

  1236.             if (pData->audioOut.count > 0)

  1237.             {

  1238.                 CARLA_ASSERT(pData->audioOut.count == 2);

  1239.                 CARLA_ASSERT(fAudioOutBuffers[0] != nullptr);

  1240.                 CARLA_ASSERT(fAudioOutBuffers[1] != nullptr);

  1241. 

  1242.                 fDescriptor->connect_port(fHandle,  pData->audioOut.ports[0].rindex, fAudioOutBuffers[0]);

  1243.                 fDescriptor->connect_port(fHandle2, pData->audioOut.ports[1].rindex, fAudioOutBuffers[1]);

  1244.             }

  1245.         }

  1246. 

  1247.         carla_debug("Lv2Plugin::bufferSizeChanged(%i) - end", newBufferSize);

  1248.     }

  1249. 

  1250.     void sampleRateChanged(const double newSampleRate) override

  1251.     {

  1252.         CARLA_ASSERT_INT(newSampleRate > 0.0, int(newSampleRate));

  1253.         carla_debug("Lv2Plugin::sampleRateChanged(%g) - start", newSampleRate);

  1254. 

  1255.         for (uint32_t k=0; k < pData->param.count; ++k)

  1256.         {

  1257.             if (pData->param.data[k].type == PARAMETER_INPUT && pData->param.special[k] == PARAMETER_SPECIAL_SAMPLE_RATE)

  1258.             {

  1259.                 fParamBuffers[k] = float(newSampleRate);

  1260.                 pData->postponeRtEvent(kPluginPostRtEventParameterChange, static_cast<int32_t>(k), 1, fParamBuffers[k]);

  1261.                 break;

  1262.             }

  1263.         }

  1264. 

  1265.         carla_debug("Lv2Plugin::sampleRateChanged(%g) - end", newSampleRate);

  1266.     }

  1267. 

  1268.     void offlineModeChanged(const bool isOffline) override

  1269.     {

  1270.         for (uint32_t k=0; k < pData->param.count; ++k)

  1271.         {

  1272.             if (pData->param.data[k].type == PARAMETER_INPUT && pData->param.special[k] == PARAMETER_SPECIAL_LV2_FREEWHEEL)

  1273.             {

  1274.                 fParamBuffers[k] = isOffline ? pData->param.ranges[k].max : pData->param.ranges[k].min;

  1275.                 pData->postponeRtEvent(kPluginPostRtEventParameterChange, static_cast<int32_t>(k), 1, fParamBuffers[k]);

  1276.                 break;

  1277.             }

  1278.         }

  1279.     }

  1280. 

  1281.     // -------------------------------------------------------------------

  1282.     // Plugin buffers

  1283. 

  1284.     void clearBuffers() override

  1285.     {

  1286.         carla_debug("Lv2Plugin::clearBuffers() - start");

  1287. 

  1288.         if (fAudioInBuffers != nullptr)

  1289.         {

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

  1291.             {

  1292.                 if (fAudioInBuffers[i] != nullptr)

  1293.                 {

  1294.                     delete[] fAudioInBuffers[i];

  1295.                     fAudioInBuffers[i] = nullptr;

  1296.                 }

  1297.             }

  1298. 

  1299.             delete[] fAudioInBuffers;

  1300.             fAudioInBuffers = nullptr;

  1301.         }

  1302. 

  1303.         if (fAudioOutBuffers != nullptr)

  1304.         {

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

  1306.             {

  1307.                 if (fAudioOutBuffers[i] != nullptr)

  1308.                 {

  1309.                     delete[] fAudioOutBuffers[i];

  1310.                     fAudioOutBuffers[i] = nullptr;

  1311.                 }

  1312.             }

  1313. 

  1314.             delete[] fAudioOutBuffers;

  1315.             fAudioOutBuffers = nullptr;

  1316.         }

  1317. 

  1318.         if (fParamBuffers != nullptr)

  1319.         {

  1320.             delete[] fParamBuffers;

  1321.             fParamBuffers = nullptr;

  1322.         }

  1323. 

  1324.         CarlaPlugin::clearBuffers();

  1325. 

  1326.         carla_debug("Lv2Plugin::clearBuffers() - end");

  1327.     }

  1328. 

  1329.     // -------------------------------------------------------------------

  1330. 

  1331.     bool isRealtimeSafe() const

  1332.     {

  1333.         CARLA_ASSERT(fRdfDescriptor != nullptr);

  1334. 

  1335.         for (uint32_t i=0; i < fRdfDescriptor->FeatureCount; ++i)

  1336.         {

  1337.             if (std::strcmp(fRdfDescriptor->Features[i].URI, LV2_CORE__hardRTCapable) == 0)

  1338.                 return true;

  1339.         }

  1340. 

  1341.         return false;

  1342.     }

  1343. 

  1344.     bool needsFixedBuffer() const

  1345.     {

  1346.         CARLA_ASSERT(fRdfDescriptor != nullptr);

  1347. 

  1348.         for (uint32_t i=0; i < fRdfDescriptor->FeatureCount; ++i)

  1349.         {

  1350.             if (std::strcmp(fRdfDescriptor->Features[i].URI, LV2_BUF_SIZE__fixedBlockLength) == 0)

  1351.                 return true;

  1352.         }

  1353. 

  1354.         return false;

  1355.     }

  1356. 

  1357.     // -------------------------------------------------------------------

  1358. 

  1359. public:

  1360.     bool init(const char* const bundle, const char* const name, const char* const uri)

  1361.     {

  1362.         CARLA_SAFE_ASSERT_RETURN(pData->engine != nullptr, false);

  1363. 

  1364.         // ---------------------------------------------------------------

  1365.         // first checks

  1366. 

  1367.         if (pData->client != nullptr)

  1368.         {

  1369.             pData->engine->setLastError("Plugin client is already registered");

  1370.             return false;

  1371.         }

  1372. 

  1373.         if (bundle == nullptr || bundle[0] == '\0')

  1374.         {

  1375.             pData->engine->setLastError("null bundle");

  1376.             return false;

  1377.         }

  1378. 

  1379.         if (uri == nullptr || uri[0] == '\0')

  1380.         {

  1381.             pData->engine->setLastError("null uri");

  1382.             return false;

  1383.         }

  1384. 

  1385.         // ---------------------------------------------------------------

  1386.         // get plugin from lv2_rdf (lilv)

  1387. 

  1388.         Lv2WorldClass& lv2World(Lv2WorldClass::getInstance());

  1389. 

  1390.         // Convert bundle filename to URI

  1391.         QString qBundle(QUrl::fromLocalFile(bundle).toString());

  1392.         if (! qBundle.endsWith(OS_SEP_STR))

  1393.             qBundle += OS_SEP_STR;

  1394. 

  1395.         // Load bundle

  1396.         Lilv::Node lilvBundle(lv2World.new_uri(qBundle.toUtf8().constData()));

  1397.         lv2World.load_bundle(lilvBundle);

  1398. 

  1399.         fRdfDescriptor = lv2_rdf_new(uri, true);

  1400. 

  1401.         if (fRdfDescriptor == nullptr)

  1402.         {

  1403.             pData->engine->setLastError("Failed to find the requested plugin in the LV2 Bundle");

  1404.             return false;

  1405.         }

  1406. 

  1407.         // ---------------------------------------------------------------

  1408.         // open DLL

  1409. 

  1410.         if (! pData->libOpen(fRdfDescriptor->Binary))

  1411.         {

  1412.             pData->engine->setLastError(pData->libError(fRdfDescriptor->Binary));

  1413.             return false;

  1414.         }

  1415. 

  1416.         // ---------------------------------------------------------------

  1417.         // get DLL main entry

  1418. 

  1419.         const LV2_Descriptor_Function descFn = (LV2_Descriptor_Function)pData->libSymbol("lv2_descriptor");

  1420. 

  1421.         if (descFn == nullptr)

  1422.         {

  1423.             pData->engine->setLastError("Could not find the LV2 Descriptor in the plugin library");

  1424.             return false;

  1425.         }

  1426. 

  1427.         // -----------------------------------------------------------

  1428.         // get descriptor that matches URI

  1429. 

  1430.         uint32_t i = 0;

  1431.         while ((fDescriptor = descFn(i++)))

  1432.         {

  1433.             carla_debug("LV2 Init @%i => '%s' vs '%s'", i, fDescriptor->URI, uri);

  1434.             if (std::strcmp(fDescriptor->URI, uri) == 0)

  1435.                 break;

  1436.         }

  1437. 

  1438.         if (fDescriptor == nullptr)

  1439.         {

  1440.             pData->engine->setLastError("Could not find the requested plugin URI in the plugin library");

  1441.             return false;

  1442.         }

  1443. 

  1444.         // ---------------------------------------------------------------

  1445.         // check supported port-types and features

  1446. 

  1447.         bool canContinue = true;

  1448. 

  1449.         // Check supported ports

  1450.         for (uint32_t j=0; j < fRdfDescriptor->PortCount; ++j)

  1451.         {

  1452.             const LV2_Property portTypes(fRdfDescriptor->Ports[j].Types);

  1453. 

  1454.             if (! is_lv2_port_supported(portTypes))

  1455.             {

  1456.                 if (! LV2_IS_PORT_OPTIONAL(fRdfDescriptor->Ports[j].Properties))

  1457.                 {

  1458.                     pData->engine->setLastError("Plugin requires a port type that is not currently supported");

  1459.                     canContinue = false;

  1460.                     break;

  1461.                 }

  1462.             }

  1463.         }

  1464. 

  1465.         // Check supported features

  1466.         for (uint32_t j=0; j < fRdfDescriptor->FeatureCount && canContinue; ++j)

  1467.         {

  1468.             if (LV2_IS_FEATURE_REQUIRED(fRdfDescriptor->Features[j].Type) && ! is_lv2_feature_supported(fRdfDescriptor->Features[j].URI))

  1469.             {

  1470. //                 QString msg(QString("Plugin requires a feature that is not supported:\n%1").arg(fRdfDescriptor->Features[j].URI));

  1471. //                 pData->engine->setLastError(msg.toUtf8().constData());

  1472.                 canContinue = false;

  1473.                 break;

  1474.             }

  1475.         }

  1476. 

  1477.         if (! canContinue)

  1478.         {

  1479.             // error already set

  1480.             return false;

  1481.         }

  1482. 

  1483.         // ---------------------------------------------------------------

  1484.         // get info

  1485. 

  1486.         if (name != nullptr && name[0] != '\0')

  1487.             pData->name = pData->engine->getUniquePluginName(name);

  1488.         else

  1489.             pData->name = pData->engine->getUniquePluginName(fRdfDescriptor->Name);

  1490. 

  1491.         // ---------------------------------------------------------------

  1492.         // register client

  1493. 

  1494.         pData->client = pData->engine->addClient(this);

  1495. 

  1496.         if (pData->client == nullptr || ! pData->client->isOk())

  1497.         {

  1498.             pData->engine->setLastError("Failed to register plugin client");

  1499.             return false;

  1500.         }

  1501. 

  1502.         // ---------------------------------------------------------------

  1503.         // initialize plugin

  1504. 

  1505.         fHandle = fDescriptor->instantiate(fDescriptor, pData->engine->getSampleRate(), fRdfDescriptor->Bundle, fFeatures);

  1506. 

  1507.         if (fHandle == nullptr)

  1508.         {

  1509.             pData->engine->setLastError("Plugin failed to initialize");

  1510.             return false;

  1511.         }

  1512. 

  1513.         // ---------------------------------------------------------------

  1514.         // load plugin settings

  1515. 

  1516.         {

  1517.             // set default options

  1518.             pData->options = 0x0;

  1519. 

  1520.             pData->options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  1521. 

  1522.             if (getMidiInCount() > 0 || needsFixedBuffer())

  1523.                 pData->options |= PLUGIN_OPTION_FIXED_BUFFERS;

  1524. 

  1525.             if (pData->engine->getOptions().forceStereo)

  1526.                 pData->options |= PLUGIN_OPTION_FORCE_STEREO;

  1527. 

  1528.             if (getMidiInCount() > 0)

  1529.             {

  1530.                 pData->options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  1531.                 pData->options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

  1532.                 pData->options |= PLUGIN_OPTION_SEND_PITCHBEND;

  1533.                 pData->options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  1534.             }

  1535. 

  1536.             // set identifier string

  1537.             CarlaString identifier("V2/");

  1538.             identifier += uri;

  1539. 

  1540.             // load settings

  1541.             pData->options = pData->loadSettings(pData->options, getOptionsAvailable());

  1542. 

  1543.             // ignore settings, we need this anyway

  1544.             if (getMidiInCount() > 0 || needsFixedBuffer())

  1545.                 pData->options |= PLUGIN_OPTION_FIXED_BUFFERS;

  1546.         }

  1547. 

  1548.         // ---------------------------------------------------------------

  1549.         // gui stuff

  1550. 

  1551.         if (fRdfDescriptor->UICount == 0)

  1552.             return true;

  1553. 

  1554.         return true;

  1555.     }

  1556. 

  1557.     // -------------------------------------------------------------------

  1558. 

  1559. private:

  1560.     LV2_Handle   fHandle;

  1561.     LV2_Handle   fHandle2;

  1562.     LV2_Feature* fFeatures[kFeatureCount+1];

  1563.     const LV2_Descriptor*     fDescriptor;

  1564.     const LV2_RDF_Descriptor* fRdfDescriptor;

  1565. 

  1566.     float** fAudioInBuffers;

  1567.     float** fAudioOutBuffers;

  1568.     float*  fParamBuffers;

  1569. 

  1570.     // -------------------------------------------------------------------

  1571. 

  1572.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(Lv2Plugin)

  1573. };

  1574. 

  1575. // -------------------------------------------------------------------------------------------------------------------

  1576. 

  1577. #define lv2PluginPtr ((Lv2Plugin*)plugin)

  1578. 

  1579. int CarlaEngineOsc::handleMsgLv2AtomTransfer(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  1580. {

  1581.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "is");

  1582.     carla_debug("CarlaOsc::handleMsgLv2AtomTransfer()");

  1583. 

  1584.     return 0;

  1585. 

  1586.     // unused for now

  1587.     (void)argv;

  1588.     (void)plugin;

  1589. }

  1590. 

  1591. int CarlaEngineOsc::handleMsgLv2UridMap(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  1592. {

  1593.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "is");

  1594.     carla_debug("CarlaOsc::handleMsgLv2EventTransfer()");

  1595. 

  1596.     return 0;

  1597. 

  1598.     // unused for now

  1599.     (void)argv;

  1600.     (void)plugin;

  1601. }

  1602. 

  1603. #undef lv2PluginPtr

  1604. 

  1605. CARLA_BACKEND_END_NAMESPACE

  1606. 

  1607. #endif // WANT_LV2

  1608. 

  1609. // -------------------------------------------------------------------------------------------------------------------

  1610. 

  1611. CARLA_BACKEND_START_NAMESPACE

  1612. 

  1613. CarlaPlugin* CarlaPlugin::newLV2(const Initializer& init)

  1614. {

  1615.     carla_debug("CarlaPlugin::newLV2({%p, \"%s\", \"%s\"})", init.engine, init.name, init.label);

  1616. 

  1617. #ifdef WANT_LV2

  1618.     Lv2Plugin* const plugin(new Lv2Plugin(init.engine, init.id));

  1619. 

  1620.     if (! plugin->init(init.filename, init.name, init.label))

  1621.     {

  1622.         delete plugin;

  1623.         return nullptr;

  1624.     }

  1625. 

  1626.     plugin->reload();

  1627. 

  1628.     if (init.engine->getProccessMode() == ENGINE_PROCESS_MODE_CONTINUOUS_RACK && ! plugin->canRunInRack())

  1629.     {

  1630.         init.engine->setLastError("Carla's rack mode can only work with Mono or Stereo LV2 plugins, sorry!");

  1631.         delete plugin;

  1632.         return nullptr;

  1633.     }

  1634. 

  1635.     return plugin;

  1636. #else

  1637.     init.engine->setLastError("LV2 support not available");

  1638.     return nullptr;

  1639. #endif

  1640. }

  1641. 

  1642. CARLA_BACKEND_END_NAMESPACE

  1643. 

  1644. // -------------------------------------------------------------------------------------------------------------------