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

1643 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 "Lv2AtomQueue.hpp"

  25. 

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

  27. 

  28. extern "C" {

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

  30. }

  31. 

  32. #include <QtCore/QDir>

  33. #include <QtCore/QUrl>

  34. 

  35. // -----------------------------------------------------

  36. 

  37. CARLA_BACKEND_START_NAMESPACE

  38. 

  39. #if 0

  40. }

  41. #endif

  42. 

  43. // Extra Parameter Hints

  44. const unsigned int PARAMETER_IS_STRICT_BOUNDS = 0x1000;

  45. const unsigned int PARAMETER_IS_TRIGGER       = 0x2000;

  46. 

  47. // LV2 Feature Ids

  48. const uint32_t kFeatureCount = 0;

  49. 

  50. // -----------------------------------------------------

  51. 

  52. class Lv2Plugin : public CarlaPlugin

  53. {

  54. public:

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

  56.         : CarlaPlugin(engine, id),

  57.           fHandle(nullptr),

  58.           fHandle2(nullptr),

  59.           fDescriptor(nullptr),

  60.           fRdfDescriptor(nullptr),

  61.           fAudioInBuffers(nullptr),

  62.           fAudioOutBuffers(nullptr),

  63.           fParamBuffers(nullptr)

  64.     {

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

  66. 

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

  68. 

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

  70.     }

  71. 

  72.     ~Lv2Plugin() override

  73.     {

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

  75. 

  76.         pData->singleMutex.lock();

  77.         pData->masterMutex.lock();

  78. 

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

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

  81. 

  82.         if (pData->active)

  83.         {

  84.             deactivate();

  85.             pData->active = false;

  86.         }

  87. 

  88.         if (fDescriptor != nullptr)

  89.         {

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

  91.             {

  92.                 if (fHandle != nullptr)

  93.                     fDescriptor->cleanup(fHandle);

  94.                 if (fHandle2 != nullptr)

  95.                     fDescriptor->cleanup(fHandle2);

  96.             }

  97. 

  98.             fHandle  = nullptr;

  99.             fHandle2 = nullptr;

  100.             fDescriptor = nullptr;

  101.         }

  102. 

  103.         if (fRdfDescriptor != nullptr)

  104.         {

  105.             delete fRdfDescriptor;

  106.             fRdfDescriptor = nullptr;

  107.         }

  108. 

  109.         clearBuffers();

  110.     }

  111. 

  112.     // -------------------------------------------------------------------

  113.     // Information (base)

  114. 

  115.     PluginType getType() const noexcept override

  116.     {

  117.         return PLUGIN_LV2;

  118.     }

  119. 

  120.     PluginCategory getCategory() const noexcept override

  121.     {

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

  123. 

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

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

  126. 

  127.         if (LV2_IS_DELAY(cat1, cat2))

  128.             return PLUGIN_CATEGORY_DELAY;

  129.         if (LV2_IS_DISTORTION(cat1, cat2))

  130.             return PLUGIN_CATEGORY_OTHER;

  131.         if (LV2_IS_DYNAMICS(cat1, cat2))

  132.             return PLUGIN_CATEGORY_DYNAMICS;

  133.         if (LV2_IS_EQ(cat1, cat2))

  134.             return PLUGIN_CATEGORY_EQ;

  135.         if (LV2_IS_FILTER(cat1, cat2))

  136.             return PLUGIN_CATEGORY_FILTER;

  137.         if (LV2_IS_GENERATOR(cat1, cat2))

  138.             return PLUGIN_CATEGORY_SYNTH;

  139.         if (LV2_IS_MODULATOR(cat1, cat2))

  140.             return PLUGIN_CATEGORY_MODULATOR;

  141.         if (LV2_IS_REVERB(cat1, cat2))

  142.             return PLUGIN_CATEGORY_DELAY;

  143.         if (LV2_IS_SIMULATOR(cat1, cat2))

  144.             return PLUGIN_CATEGORY_OTHER;

  145.         if (LV2_IS_SPATIAL(cat1, cat2))

  146.             return PLUGIN_CATEGORY_OTHER;

  147.         if (LV2_IS_SPECTRAL(cat1, cat2))

  148.             return PLUGIN_CATEGORY_UTILITY;

  149.         if (LV2_IS_UTILITY(cat1, cat2))

  150.             return PLUGIN_CATEGORY_UTILITY;

  151. 

  152.         return CarlaPlugin::getCategory();

  153.     }

  154. 

  155.     long getUniqueId() const noexcept override

  156.     {

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

  158. 

  159.         return fRdfDescriptor->UniqueID;

  160.     }

  161. 

  162.     // -------------------------------------------------------------------

  163.     // Information (count)

  164. 

  165.     uint32_t getMidiInCount() const noexcept override

  166.     {

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

  168. 

  169.         uint32_t count = 0;

  170. 

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

  172.         {

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

  174. 

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

  176.                 count += 1;

  177.         }

  178. 

  179.         return count;

  180.     }

  181. 

  182.     uint32_t getMidiOutCount() const noexcept override

  183.     {

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

  185. 

  186.         uint32_t count = 0;

  187. 

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

  189.         {

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

  191. 

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

  193.                 count += 1;

  194.         }

  195. 

  196.         return count;

  197.     }

  198. 

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

  200.     {

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

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

  203. 

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

  205. 

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

  207.         {

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

  209.             return port.ScalePointCount;

  210.         }

  211. 

  212.         return 0;

  213.     }

  214. 

  215.     // -------------------------------------------------------------------

  216.     // Information (current data)

  217. 

  218.     // nothing

  219. 

  220.     // -------------------------------------------------------------------

  221.     // Information (per-plugin data)

  222. 

  223.     unsigned int getOptionsAvailable() const noexcept override

  224.     {

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

  226. 

  227.         unsigned int options = 0x0;

  228. 

  229.         options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  230. 

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

  232.             options |= PLUGIN_OPTION_FIXED_BUFFERS;

  233. 

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

  235.         {

  236.             if (pData->options & PLUGIN_OPTION_FORCE_STEREO)

  237.                 options |= PLUGIN_OPTION_FORCE_STEREO;

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

  239.                 options |= PLUGIN_OPTION_FORCE_STEREO;

  240.         }

  241. 

  242.         if (hasMidiIn)

  243.         {

  244.             options |= PLUGIN_OPTION_SEND_CONTROL_CHANGES;

  245.             options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  246.             options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

  247.             options |= PLUGIN_OPTION_SEND_PITCHBEND;

  248.             options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  249.         }

  250. 

  251.         return options;

  252.     }

  253. 

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

  255.     {

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

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

  258. 

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

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

  261. 

  262.         return fParamBuffers[parameterId];

  263.     }

  264. 

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

  266.     {

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

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

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

  270. 

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

  272. 

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

  274.         {

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

  276. 

  277.             if (scalePointId < port.ScalePointCount)

  278.             {

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

  280.                 return portScalePoint.Value;

  281.             }

  282.         }

  283. 

  284.         return 0.0f;

  285.     }

  286. 

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

  288.     {

  289.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr,);

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

  291. 

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

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

  294.         else

  295.             CarlaPlugin::getLabel(strBuf);

  296.     }

  297. 

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

  299.     {

  300.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr,);

  301. 

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

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

  304.         else

  305.             CarlaPlugin::getMaker(strBuf);

  306.     }

  307. 

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

  309.     {

  310.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr,);

  311. 

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

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

  314.         else

  315.             CarlaPlugin::getCopyright(strBuf);

  316.     }

  317. 

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

  319.     {

  320.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr,);

  321. 

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

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

  324.         else

  325.             CarlaPlugin::getRealName(strBuf);

  326.     }

  327. 

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

  329.     {

  330.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr,);

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

  332. 

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

  334. 

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

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

  337.         else

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

  339.     }

  340. 

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

  342.     {

  343.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr,);

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

  345. 

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

  347. 

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

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

  350.         else

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

  352.     }

  353. 

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

  355.     {

  356.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr,);

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

  358. 

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

  360. 

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

  362.         {

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

  364. 

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

  366.             {

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

  368.                 return;

  369.             }

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

  371.             {

  372.                 switch (port.Unit.Unit)

  373.                 {

  374.                 case LV2_PORT_UNIT_BAR:

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

  376.                     return;

  377.                 case LV2_PORT_UNIT_BEAT:

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

  379.                     return;

  380.                 case LV2_PORT_UNIT_BPM:

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

  382.                     return;

  383.                 case LV2_PORT_UNIT_CENT:

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

  385.                     return;

  386.                 case LV2_PORT_UNIT_CM:

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

  388.                     return;

  389.                 case LV2_PORT_UNIT_COEF:

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

  391.                     return;

  392.                 case LV2_PORT_UNIT_DB:

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

  394.                     return;

  395.                 case LV2_PORT_UNIT_DEGREE:

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

  397.                     return;

  398.                 case LV2_PORT_UNIT_FRAME:

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

  400.                     return;

  401.                 case LV2_PORT_UNIT_HZ:

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

  403.                     return;

  404.                 case LV2_PORT_UNIT_INCH:

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

  406.                     return;

  407.                 case LV2_PORT_UNIT_KHZ:

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

  409.                     return;

  410.                 case LV2_PORT_UNIT_KM:

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

  412.                     return;

  413.                 case LV2_PORT_UNIT_M:

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

  415.                     return;

  416.                 case LV2_PORT_UNIT_MHZ:

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

  418.                     return;

  419.                 case LV2_PORT_UNIT_MIDINOTE:

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

  421.                     return;

  422.                 case LV2_PORT_UNIT_MILE:

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

  424.                     return;

  425.                 case LV2_PORT_UNIT_MIN:

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

  427.                     return;

  428.                 case LV2_PORT_UNIT_MM:

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

  430.                     return;

  431.                 case LV2_PORT_UNIT_MS:

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

  433.                     return;

  434.                 case LV2_PORT_UNIT_OCT:

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

  436.                     return;

  437.                 case LV2_PORT_UNIT_PC:

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

  439.                     return;

  440.                 case LV2_PORT_UNIT_S:

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

  442.                     return;

  443.                 case LV2_PORT_UNIT_SEMITONE:

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

  445.                     return;

  446.                 }

  447.             }

  448.         }

  449. 

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

  451.     }

  452. 

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

  454.     {

  455.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr,);

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

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

  458. 

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

  460. 

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

  462.         {

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

  464. 

  465.             if (scalePointId < port.ScalePointCount)

  466.             {

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

  468. 

  469.                 if (portScalePoint.Label != nullptr)

  470.                 {

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

  472.                     return;

  473.                 }

  474.             }

  475.         }

  476. 

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

  478.     }

  479. 

  480.     // -------------------------------------------------------------------

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

  482. 

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

  484.     {

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

  486. 

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

  488.         fParamBuffers[parameterId] = fixedValue;

  489. 

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

  491.     }

  492. 

  493.     // -------------------------------------------------------------------

  494.     // Plugin state

  495. 

  496.     void reload() override

  497.     {

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

  499.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  500.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  501.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr,);

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

  503. 

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

  505. 

  506.         // Safely disable plugin for reload

  507.         const ScopedDisabler sd(this);

  508. 

  509.         if (pData->active)

  510.             deactivate();

  511. 

  512.         clearBuffers();

  513. 

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

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

  516. 

  517.         uint32_t aIns, aOuts, params, j;

  518.         aIns = aOuts = params = 0;

  519. 

  520.         bool forcedStereoIn, forcedStereoOut;

  521.         forcedStereoIn = forcedStereoOut = false;

  522. 

  523.         bool needsCtrlIn, needsCtrlOut;

  524.         needsCtrlIn = needsCtrlOut = false;

  525. 

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

  527.         {

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

  529. 

  530.             if (LV2_IS_PORT_AUDIO(portTypes))

  531.             {

  532.                 if (LV2_IS_PORT_INPUT(portTypes))

  533.                     aIns += 1;

  534.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  535.                     aOuts += 1;

  536.             }

  537.             else if (LV2_IS_PORT_CONTROL(portTypes))

  538.                 params += 1;

  539.         }

  540. 

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

  542.         {

  543.             if (fHandle2 == nullptr)

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

  545. 

  546.             if (fHandle2 != nullptr)

  547.             {

  548.                 if (aIns == 1)

  549.                 {

  550.                     aIns = 2;

  551.                     forcedStereoIn = true;

  552.                 }

  553. 

  554.                 if (aOuts == 1)

  555.                 {

  556.                     aOuts = 2;

  557.                     forcedStereoOut = true;

  558.                 }

  559.             }

  560.         }

  561. 

  562.         if (aIns > 0)

  563.         {

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

  565.             fAudioInBuffers = new float*[aIns];

  566. 

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

  568.                 fAudioInBuffers[i] = nullptr;

  569.         }

  570. 

  571.         if (aOuts > 0)

  572.         {

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

  574.             fAudioOutBuffers = new float*[aOuts];

  575.             needsCtrlIn = true;

  576. 

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

  578.                 fAudioOutBuffers[i] = nullptr;

  579.         }

  580. 

  581.         if (params > 0)

  582.         {

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

  584. 

  585.             fParamBuffers = new float[params];

  586.             FLOAT_CLEAR(fParamBuffers, params);

  587.         }

  588. 

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

  590.         CarlaString portName;

  591. 

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

  593.         {

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

  595. 

  596.             portName.clear();

  597. 

  598.             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))

  599.             {

  600.                 if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  601.                 {

  602.                     portName  = pData->name;

  603.                     portName += ":";

  604.                 }

  605. 

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

  607.                 portName.truncate(portNameSize);

  608.             }

  609. 

  610.             if (LV2_IS_PORT_AUDIO(portTypes))

  611.             {

  612.                 if (LV2_IS_PORT_INPUT(portTypes))

  613.                 {

  614.                     j = iAudioIn++;

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

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

  617. 

  618.                     if (forcedStereoIn)

  619.                     {

  620.                         portName += "_2";

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

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

  623.                     }

  624.                 }

  625.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  626.                 {

  627.                     j = iAudioOut++;

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

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

  630. 

  631.                     if (forcedStereoOut)

  632.                     {

  633.                         portName += "_2";

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

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

  636.                     }

  637.                 }

  638.                 else

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

  640.             }

  641.             else if (LV2_IS_PORT_CONTROL(portTypes))

  642.             {

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

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

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

  646. 

  647.                 j = iCtrl++;

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

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

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

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

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

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

  654. 

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

  656. 

  657.                 // min value

  658.                 if (LV2_HAVE_MINIMUM_PORT_POINT(portPoints.Hints))

  659.                     min = portPoints.Minimum;

  660.                 else

  661.                     min = 0.0f;

  662. 

  663.                 // max value

  664.                 if (LV2_HAVE_MAXIMUM_PORT_POINT(portPoints.Hints))

  665.                     max = portPoints.Maximum;

  666.                 else

  667.                     max = 1.0f;

  668. 

  669.                 if (min > max)

  670.                     max = min;

  671.                 else if (max < min)

  672.                     min = max;

  673. 

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

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

  676.                 {

  677.                     min = 0.0f;

  678.                     max = (float)0xffffff;

  679.                 }

  680. 

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

  682.                 {

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

  684.                     max = min + 0.1f;

  685.                 }

  686. 

  687.                 // default value

  688.                 if (LV2_HAVE_DEFAULT_PORT_POINT(portPoints.Hints))

  689.                 {

  690.                     def = portPoints.Default;

  691.                 }

  692.                 else

  693.                 {

  694.                     // no default value

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

  696.                         def = 0.0f;

  697.                     else

  698.                         def = min;

  699.                 }

  700. 

  701.                 if (def < min)

  702.                     def = min;

  703.                 else if (def > max)

  704.                     def = max;

  705. 

  706.                 if (LV2_IS_PORT_SAMPLE_RATE(portProps))

  707.                 {

  708.                     min *= sampleRate;

  709.                     max *= sampleRate;

  710.                     def *= sampleRate;

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

  712.                 }

  713. 

  714.                 if (LV2_IS_PORT_TOGGLED(portProps))

  715.                 {

  716.                     step = max - min;

  717.                     stepSmall = step;

  718.                     stepLarge = step;

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

  720.                 }

  721.                 else if (LV2_IS_PORT_INTEGER(portProps))

  722.                 {

  723.                     step = 1.0f;

  724.                     stepSmall = 1.0f;

  725.                     stepLarge = 10.0f;

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

  727.                 }

  728.                 else

  729.                 {

  730.                     float range = max - min;

  731.                     step = range/100.0f;

  732.                     stepSmall = range/1000.0f;

  733.                     stepLarge = range/10.0f;

  734.                 }

  735. 

  736.                 if (LV2_IS_PORT_INPUT(portTypes))

  737.                 {

  738.                     if (LV2_IS_PORT_DESIGNATION_LATENCY(portDesignation))

  739.                     {

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

  741.                     }

  742.                     else if (LV2_IS_PORT_DESIGNATION_SAMPLE_RATE(portDesignation))

  743.                     {

  744.                         def = sampleRate;

  745.                         step = 1.0f;

  746.                         stepSmall = 1.0f;

  747.                         stepLarge = 1.0f;

  748. 

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

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

  751.                     }

  752.                     else if (LV2_IS_PORT_DESIGNATION_FREEWHEELING(portDesignation))

  753.                     {

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

  755.                     }

  756.                     else if (LV2_IS_PORT_DESIGNATION_TIME(portDesignation))

  757.                     {

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

  759.                     }

  760.                     else

  761.                     {

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

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

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

  765.                         needsCtrlIn = true;

  766.                     }

  767. 

  768.                     // MIDI CC value

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

  770. 

  771.                     if (LV2_IS_PORT_MIDI_MAP_CC(portMidiMap.Type))

  772.                     {

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

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

  775.                     }

  776.                 }

  777.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  778.                 {

  779.                     if (LV2_IS_PORT_DESIGNATION_LATENCY(portDesignation))

  780.                     {

  781.                         min = 0.0f;

  782.                         max = sampleRate;

  783.                         def = 0.0f;

  784.                         step = 1.0f;

  785.                         stepSmall = 1.0f;

  786.                         stepLarge = 1.0f;

  787. 

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

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

  790.                     }

  791.                     else if (LV2_IS_PORT_DESIGNATION_SAMPLE_RATE(portDesignation))

  792.                     {

  793.                         def = sampleRate;

  794.                         step = 1.0f;

  795.                         stepSmall = 1.0f;

  796.                         stepLarge = 1.0f;

  797. 

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

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

  800.                     }

  801.                     else if (LV2_IS_PORT_DESIGNATION_FREEWHEELING(portDesignation))

  802.                     {

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

  804.                     }

  805.                     else if (LV2_IS_PORT_DESIGNATION_TIME(portDesignation))

  806.                     {

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

  808.                     }

  809.                     else

  810.                     {

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

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

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

  814.                         needsCtrlOut = true;

  815.                     }

  816.                 }

  817.                 else

  818.                 {

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

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

  821.                 }

  822. 

  823.                 // extra parameter hints

  824.                 if (LV2_IS_PORT_ENUMERATION(portProps))

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

  826. 

  827.                 if (LV2_IS_PORT_LOGARITHMIC(portProps))

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

  829. 

  830.                 if (LV2_IS_PORT_TRIGGER(portProps))

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

  832. 

  833.                 if (LV2_IS_PORT_STRICT_BOUNDS(portProps))

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

  835. 

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

  837.                 if (LV2_IS_PORT_NOT_ON_GUI(portProps))

  838.                 {

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

  840.                 }

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

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

  843. 

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

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

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

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

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

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

  850. 

  851.                 // Start parameters in their default values

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

  853.                     fParamBuffers[j] = def;

  854.                 //else

  855.                 //    fParamBuffers[j] = min;

  856. 

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

  858. 

  859.                 if (fHandle2 != nullptr)

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

  861.             }

  862.             else

  863.             {

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

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

  866. 

  867.                 if (fHandle2 != nullptr)

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

  869.             }

  870.         }

  871. 

  872.         if (needsCtrlIn)

  873.         {

  874.             portName.clear();

  875. 

  876.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  877.             {

  878.                 portName  = pData->name;

  879.                 portName += ":";

  880.             }

  881. 

  882.             portName += "events-in";

  883.             portName.truncate(portNameSize);

  884. 

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

  886.         }

  887. 

  888.         if (needsCtrlOut)

  889.         {

  890.             portName.clear();

  891. 

  892.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  893.             {

  894.                 portName  = pData->name;

  895.                 portName += ":";

  896.             }

  897. 

  898.             portName += "events-out";

  899.             portName.truncate(portNameSize);

  900. 

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

  902.         }

  903. 

  904.         if (forcedStereoIn || forcedStereoOut)

  905.             pData->options |= PLUGIN_OPTION_FORCE_STEREO;

  906.         else

  907.             pData->options &= ~PLUGIN_OPTION_FORCE_STEREO;

  908. 

  909.         // plugin hints

  910.         pData->hints = 0x0;

  911. 

  912.         if (isRealtimeSafe())

  913.             pData->hints |= PLUGIN_IS_RTSAFE;

  914. 

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

  916.             pData->hints |= PLUGIN_IS_SYNTH;

  917. 

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

  919.             pData->hints |= PLUGIN_CAN_DRYWET;

  920. 

  921.         if (aOuts > 0)

  922.             pData->hints |= PLUGIN_CAN_VOLUME;

  923. 

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

  925.             pData->hints |= PLUGIN_CAN_BALANCE;

  926. 

  927.         // extra plugin hints

  928.         pData->extraHints &= ~PLUGIN_EXTRA_HINT_CAN_RUN_RACK;

  929. 

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

  931.         reloadPrograms(true);

  932. 

  933.         if (pData->active)

  934.             activate();

  935. 

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

  937.     }

  938. 

  939.     // -------------------------------------------------------------------

  940.     // Plugin processing

  941. 

  942.     void activate() noexcept override

  943.     {

  944.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  945.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  946. 

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

  948.         {

  949.             try {

  950.                 fDescriptor->activate(fHandle);

  951.             } catch(...) {}

  952. 

  953.             if (fHandle2 != nullptr)

  954.             {

  955.                 try {

  956.                     fDescriptor->activate(fHandle2);

  957.                 } catch(...) {}

  958.             }

  959.         }

  960.     }

  961. 

  962.     void deactivate() noexcept override

  963.     {

  964.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  965.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  966. 

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

  968.         {

  969.             try {

  970.                 fDescriptor->deactivate(fHandle);

  971.             } catch(...) {}

  972. 

  973.             if (fHandle2 != nullptr)

  974.             {

  975.                 try {

  976.                     fDescriptor->deactivate(fHandle2);

  977.                 } catch(...) {}

  978.             }

  979.         }

  980.     }

  981. 

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

  983.     {

  984.         uint32_t i, k;

  985. 

  986.         // --------------------------------------------------------------------------------------------------------

  987.         // Check if active

  988. 

  989.         if (! pData->active)

  990.         {

  991.             // disable any output sound

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

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

  994.             return;

  995.         }

  996. 

  997.         // --------------------------------------------------------------------------------------------------------

  998.         // Plugin processing (no events)

  999. 

  1000.         {

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

  1002. 

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

  1004. 

  1005.         // --------------------------------------------------------------------------------------------------------

  1006.         // Control Output

  1007. 

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

  1009.         {

  1010.             uint8_t  channel;

  1011.             uint16_t param;

  1012.             float    value;

  1013. 

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

  1015.             {

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

  1017.                     continue;

  1018. 

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

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

  1021. 

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

  1023.                 {

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

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

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

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

  1028.                 }

  1029.             }

  1030. 

  1031.         } // End of Control Output

  1032. 

  1033.         CARLA_PROCESS_CONTINUE_CHECK;

  1034. 

  1035.         // --------------------------------------------------------------------------------------------------------

  1036.     }

  1037. 

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

  1039.     {

  1040.         CARLA_SAFE_ASSERT_RETURN(frames > 0, false);

  1041. 

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

  1043.         {

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

  1045.         }

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

  1047.         {

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

  1049.         }

  1050. 

  1051.         uint32_t i, k;

  1052. 

  1053.         // --------------------------------------------------------------------------------------------------------

  1054.         // Try lock, silence otherwise

  1055. 

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

  1057.         {

  1058.             pData->singleMutex.lock();

  1059.         }

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

  1061.         {

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

  1063.             {

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

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

  1066.             }

  1067. 

  1068.             return false;

  1069.         }

  1070. 

  1071.         // --------------------------------------------------------------------------------------------------------

  1072.         // Reset audio buffers

  1073. 

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

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

  1076. 

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

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

  1079. 

  1080.         // --------------------------------------------------------------------------------------------------------

  1081.         // Run plugin

  1082. 

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

  1084. 

  1085.         if (fHandle2 != nullptr)

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

  1087. 

  1088.         // --------------------------------------------------------------------------------------------------------

  1089.         // Special Parameters

  1090. 

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

  1092.         {

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

  1094.                 continue;

  1095. 

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

  1097.             {

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

  1099.                 {

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

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

  1102.                 }

  1103.             }

  1104.         }

  1105. 

  1106.         pData->postRtEvents.trySplice();

  1107. 

  1108. #ifndef BUILD_BRIDGE

  1109.         // --------------------------------------------------------------------------------------------------------

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

  1111. 

  1112.         {

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

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

  1115. 

  1116.             bool isPair;

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

  1118. 

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

  1120.             {

  1121.                 // Dry/Wet

  1122.                 if (doDryWet)

  1123.                 {

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

  1125.                     {

  1126.                         // TODO

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

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

  1129.                         //else

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

  1131. 

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

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

  1134.                     }

  1135.                 }

  1136. 

  1137.                 // Balance

  1138.                 if (doBalance)

  1139.                 {

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

  1141. 

  1142.                     if (isPair)

  1143.                     {

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

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

  1146.                     }

  1147. 

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

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

  1150. 

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

  1152.                     {

  1153.                         if (isPair)

  1154.                         {

  1155.                             // left

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

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

  1158.                         }

  1159.                         else

  1160.                         {

  1161.                             // right

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

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

  1164.                         }

  1165.                     }

  1166.                 }

  1167. 

  1168.                 // Volume (and buffer copy)

  1169.                 {

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

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

  1172.                 }

  1173.             }

  1174.         } // End of Post-processing

  1175. #else

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

  1177.         {

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

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

  1180.         }

  1181. #endif

  1182. 

  1183.         // --------------------------------------------------------------------------------------------------------

  1184. 

  1185.         pData->singleMutex.unlock();

  1186.         return true;

  1187.     }

  1188. 

  1189.     void bufferSizeChanged(const uint32_t newBufferSize) override

  1190.     {

  1191.         CARLA_ASSERT_INT(newBufferSize > 0, newBufferSize);

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

  1193. 

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

  1195.         {

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

  1197.                 delete[] fAudioInBuffers[i];

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

  1199.         }

  1200. 

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

  1202.         {

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

  1204.                 delete[] fAudioOutBuffers[i];

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

  1206.         }

  1207. 

  1208.         if (fHandle2 == nullptr)

  1209.         {

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

  1211.             {

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

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

  1214.             }

  1215. 

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

  1217.             {

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

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

  1220.             }

  1221.         }

  1222.         else

  1223.         {

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

  1225.             {

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

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

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

  1229. 

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

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

  1232.             }

  1233. 

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

  1235.             {

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

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

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

  1239. 

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

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

  1242.             }

  1243.         }

  1244. 

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

  1246.     }

  1247. 

  1248.     void sampleRateChanged(const double newSampleRate) override

  1249.     {

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

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

  1252. 

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

  1254.         {

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

  1256.             {

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

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

  1259.                 break;

  1260.             }

  1261.         }

  1262. 

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

  1264.     }

  1265. 

  1266.     void offlineModeChanged(const bool isOffline) override

  1267.     {

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

  1269.         {

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

  1271.             {

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

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

  1274.                 break;

  1275.             }

  1276.         }

  1277.     }

  1278. 

  1279.     // -------------------------------------------------------------------

  1280.     // Plugin buffers

  1281. 

  1282.     void clearBuffers() override

  1283.     {

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

  1285. 

  1286.         if (fAudioInBuffers != nullptr)

  1287.         {

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

  1289.             {

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

  1291.                 {

  1292.                     delete[] fAudioInBuffers[i];

  1293.                     fAudioInBuffers[i] = nullptr;

  1294.                 }

  1295.             }

  1296. 

  1297.             delete[] fAudioInBuffers;

  1298.             fAudioInBuffers = nullptr;

  1299.         }

  1300. 

  1301.         if (fAudioOutBuffers != nullptr)

  1302.         {

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

  1304.             {

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

  1306.                 {

  1307.                     delete[] fAudioOutBuffers[i];

  1308.                     fAudioOutBuffers[i] = nullptr;

  1309.                 }

  1310.             }

  1311. 

  1312.             delete[] fAudioOutBuffers;

  1313.             fAudioOutBuffers = nullptr;

  1314.         }

  1315. 

  1316.         if (fParamBuffers != nullptr)

  1317.         {

  1318.             delete[] fParamBuffers;

  1319.             fParamBuffers = nullptr;

  1320.         }

  1321. 

  1322.         CarlaPlugin::clearBuffers();

  1323. 

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

  1325.     }

  1326. 

  1327.     // -------------------------------------------------------------------

  1328. 

  1329.     bool isRealtimeSafe() const

  1330.     {

  1331.         CARLA_ASSERT(fRdfDescriptor != nullptr);

  1332. 

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

  1334.         {

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

  1336.                 return true;

  1337.         }

  1338. 

  1339.         return false;

  1340.     }

  1341. 

  1342.     bool needsFixedBuffer() const

  1343.     {

  1344.         CARLA_ASSERT(fRdfDescriptor != nullptr);

  1345. 

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

  1347.         {

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

  1349.                 return true;

  1350.         }

  1351. 

  1352.         return false;

  1353.     }

  1354. 

  1355.     // -------------------------------------------------------------------

  1356. 

  1357. public:

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

  1359.     {

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

  1361. 

  1362.         // ---------------------------------------------------------------

  1363.         // first checks

  1364. 

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

  1366.         {

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

  1368.             return false;

  1369.         }

  1370. 

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

  1372.         {

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

  1374.             return false;

  1375.         }

  1376. 

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

  1378.         {

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

  1380.             return false;

  1381.         }

  1382. 

  1383.         // ---------------------------------------------------------------

  1384.         // get plugin from lv2_rdf (lilv)

  1385. 

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

  1387. 

  1388.         // Convert bundle filename to URI

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

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

  1391.             qBundle += OS_SEP_STR;

  1392. 

  1393.         // Load bundle

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

  1395.         lv2World.load_bundle(lilvBundle);

  1396. 

  1397.         fRdfDescriptor = lv2_rdf_new(uri, true);

  1398. 

  1399.         if (fRdfDescriptor == nullptr)

  1400.         {

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

  1402.             return false;

  1403.         }

  1404. 

  1405.         // ---------------------------------------------------------------

  1406.         // open DLL

  1407. 

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

  1409.         {

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

  1411.             return false;

  1412.         }

  1413. 

  1414.         // ---------------------------------------------------------------

  1415.         // get DLL main entry

  1416. 

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

  1418. 

  1419.         if (descFn == nullptr)

  1420.         {

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

  1422.             return false;

  1423.         }

  1424. 

  1425.         // -----------------------------------------------------------

  1426.         // get descriptor that matches URI

  1427. 

  1428.         uint32_t i = 0;

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

  1430.         {

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

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

  1433.                 break;

  1434.         }

  1435. 

  1436.         if (fDescriptor == nullptr)

  1437.         {

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

  1439.             return false;

  1440.         }

  1441. 

  1442.         // ---------------------------------------------------------------

  1443.         // check supported port-types and features

  1444. 

  1445.         bool canContinue = true;

  1446. 

  1447.         // Check supported ports

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

  1449.         {

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

  1451. 

  1452.             if (! is_lv2_port_supported(portTypes))

  1453.             {

  1454.                 if (! LV2_IS_PORT_OPTIONAL(fRdfDescriptor->Ports[i].Properties))

  1455.                 {

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

  1457.                     canContinue = false;

  1458.                     break;

  1459.                 }

  1460.             }

  1461.         }

  1462. 

  1463.         // Check supported features

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

  1465.         {

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

  1467.             {

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

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

  1470.                 canContinue = false;

  1471.                 break;

  1472.             }

  1473.         }

  1474. 

  1475.         if (! canContinue)

  1476.         {

  1477.             // error already set

  1478.             return false;

  1479.         }

  1480. 

  1481.         // ---------------------------------------------------------------

  1482.         // get info

  1483. 

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

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

  1486.         else

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

  1488. 

  1489.         // ---------------------------------------------------------------

  1490.         // register client

  1491. 

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

  1493. 

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

  1495.         {

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

  1497.             return false;

  1498.         }

  1499. 

  1500.         // ---------------------------------------------------------------

  1501.         // initialize plugin

  1502. 

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

  1504. 

  1505.         if (fHandle == nullptr)

  1506.         {

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

  1508.             return false;

  1509.         }

  1510. 

  1511.         // ---------------------------------------------------------------

  1512.         // load plugin settings

  1513. 

  1514.         {

  1515.             // set default options

  1516.             pData->options = 0x0;

  1517. 

  1518.             pData->options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  1519. 

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

  1521.                 pData->options |= PLUGIN_OPTION_FIXED_BUFFERS;

  1522. 

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

  1524.                 pData->options |= PLUGIN_OPTION_FORCE_STEREO;

  1525. 

  1526.             if (getMidiInCount() > 0)

  1527.             {

  1528.                 pData->options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  1529.                 pData->options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

  1530.                 pData->options |= PLUGIN_OPTION_SEND_PITCHBEND;

  1531.                 pData->options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  1532.             }

  1533. 

  1534.             // set identifier string

  1535.             CarlaString identifier("V2/");

  1536.             identifier += uri;

  1537. 

  1538.             // load settings

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

  1540. 

  1541.             // ignore settings, we need this anyway

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

  1543.                 pData->options |= PLUGIN_OPTION_FIXED_BUFFERS;

  1544.         }

  1545. 

  1546.         // ---------------------------------------------------------------

  1547.         // gui stuff

  1548. 

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

  1550.             return true;

  1551. 

  1552.         return true;

  1553.     }

  1554. 

  1555.     // -------------------------------------------------------------------

  1556. 

  1557. private:

  1558.     LV2_Handle   fHandle;

  1559.     LV2_Handle   fHandle2;

  1560.     LV2_Feature* fFeatures[kFeatureCount+1];

  1561.     const LV2_Descriptor*     fDescriptor;

  1562.     const LV2_RDF_Descriptor* fRdfDescriptor;

  1563. 

  1564.     float** fAudioInBuffers;

  1565.     float** fAudioOutBuffers;

  1566.     float*  fParamBuffers;

  1567. 

  1568.     // -------------------------------------------------------------------

  1569. 

  1570.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(Lv2Plugin)

  1571. };

  1572. 

  1573. // -------------------------------------------------------------------------------------------------------------------

  1574. 

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

  1576. 

  1577. int CarlaEngineOsc::handleMsgLv2AtomTransfer(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  1578. {

  1579.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "is");

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

  1581. 

  1582.     return 0;

  1583. 

  1584.     // unused for now

  1585.     (void)argv;

  1586.     (void)plugin;

  1587. }

  1588. 

  1589. int CarlaEngineOsc::handleMsgLv2UridMap(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  1590. {

  1591.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "is");

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

  1593. 

  1594.     return 0;

  1595. 

  1596.     // unused for now

  1597.     (void)argv;

  1598.     (void)plugin;

  1599. }

  1600. 

  1601. #undef lv2PluginPtr

  1602. 

  1603. CARLA_BACKEND_END_NAMESPACE

  1604. 

  1605. #endif // WANT_LV2

  1606. 

  1607. // -------------------------------------------------------------------------------------------------------------------

  1608. 

  1609. CARLA_BACKEND_START_NAMESPACE

  1610. 

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

  1612. {

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

  1614. 

  1615. #ifdef WANT_LV2

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

  1617. 

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

  1619.     {

  1620.         delete plugin;

  1621.         return nullptr;

  1622.     }

  1623. 

  1624.     plugin->reload();

  1625. 

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

  1627.     {

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

  1629.         delete plugin;

  1630.         return nullptr;

  1631.     }

  1632. 

  1633.     return plugin;

  1634. #else

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

  1636.     return nullptr;

  1637. #endif

  1638. }

  1639. 

  1640. CARLA_BACKEND_END_NAMESPACE

  1641. 

  1642. // -------------------------------------------------------------------------------------------------------------------