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.
1181 Commits
16 Branches
318MB
Tree: ce9eaedb4a
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'ce9eaedb4a'
${ noResults }
Carla/source/backend/plugin/LadspaPlugin.cpp

1532 lines
53KB
Raw Blame History 

  1. /*

  2.  * Carla LADSPA 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. 

  20. #ifdef WANT_LADSPA

  21. 

  22. #include "CarlaLadspaUtils.hpp"

  23. 

  24. CARLA_BACKEND_START_NAMESPACE

  25. 

  26. #if 0

  27. }

  28. #endif

  29. 

  30. class LadspaPlugin : public CarlaPlugin

  31. {

  32. public:

  33.     LadspaPlugin(CarlaEngine* const engine, const unsigned int id)

  34.         : CarlaPlugin(engine, id),

  35.           fHandle(nullptr),

  36.           fHandle2(nullptr),

  37.           fDescriptor(nullptr),

  38.           fRdfDescriptor(nullptr),

  39.           fAudioInBuffers(nullptr),

  40.           fAudioOutBuffers(nullptr),

  41.           fParamBuffers(nullptr)

  42.     {

  43.         carla_debug("LadspaPlugin::LadspaPlugin(%p, %i)", engine, id);

  44.     }

  45. 

  46.     ~LadspaPlugin() override

  47.     {

  48.         carla_debug("LadspaPlugin::~LadspaPlugin()");

  49. 

  50.         pData->singleMutex.lock();

  51.         pData->masterMutex.lock();

  52. 

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

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

  55. 

  56.         if (pData->active)

  57.         {

  58.             deactivate();

  59.             pData->active = false;

  60.         }

  61. 

  62.         if (fDescriptor != nullptr)

  63.         {

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

  65.             {

  66.                 if (fHandle != nullptr)

  67.                     fDescriptor->cleanup(fHandle);

  68.                 if (fHandle2 != nullptr)

  69.                     fDescriptor->cleanup(fHandle2);

  70.             }

  71. 

  72.             fHandle  = nullptr;

  73.             fHandle2 = nullptr;

  74.             fDescriptor = nullptr;

  75.         }

  76. 

  77.         if (fRdfDescriptor != nullptr)

  78.         {

  79.             delete fRdfDescriptor;

  80.             fRdfDescriptor = nullptr;

  81.         }

  82. 

  83.         clearBuffers();

  84.     }

  85. 

  86.     // -------------------------------------------------------------------

  87.     // Information (base)

  88. 

  89.     PluginType getType() const noexcept override

  90.     {

  91.         return PLUGIN_LADSPA;

  92.     }

  93. 

  94.     PluginCategory getCategory() const noexcept override

  95.     {

  96.         if (fRdfDescriptor != nullptr)

  97.         {

  98.             const LADSPA_PluginType category(fRdfDescriptor->Type);

  99. 

  100.             // Specific Types

  101.             if (category & (LADSPA_PLUGIN_DELAY|LADSPA_PLUGIN_REVERB))

  102.                 return PLUGIN_CATEGORY_DELAY;

  103.             if (category & (LADSPA_PLUGIN_PHASER|LADSPA_PLUGIN_FLANGER|LADSPA_PLUGIN_CHORUS))

  104.                 return PLUGIN_CATEGORY_MODULATOR;

  105.             if (category & (LADSPA_PLUGIN_AMPLIFIER))

  106.                 return PLUGIN_CATEGORY_DYNAMICS;

  107.             if (category & (LADSPA_PLUGIN_UTILITY|LADSPA_PLUGIN_SPECTRAL|LADSPA_PLUGIN_FREQUENCY_METER))

  108.                 return PLUGIN_CATEGORY_UTILITY;

  109. 

  110.             // Pre-set LADSPA Types

  111.             if (LADSPA_IS_PLUGIN_DYNAMICS(category))

  112.                 return PLUGIN_CATEGORY_DYNAMICS;

  113.             if (LADSPA_IS_PLUGIN_AMPLITUDE(category))

  114.                 return PLUGIN_CATEGORY_MODULATOR;

  115.             if (LADSPA_IS_PLUGIN_EQ(category))

  116.                 return PLUGIN_CATEGORY_EQ;

  117.             if (LADSPA_IS_PLUGIN_FILTER(category))

  118.                 return PLUGIN_CATEGORY_FILTER;

  119.             if (LADSPA_IS_PLUGIN_FREQUENCY(category))

  120.                 return PLUGIN_CATEGORY_UTILITY;

  121.             if (LADSPA_IS_PLUGIN_SIMULATOR(category))

  122.                 return PLUGIN_CATEGORY_OTHER;

  123.             if (LADSPA_IS_PLUGIN_TIME(category))

  124.                 return PLUGIN_CATEGORY_DELAY;

  125.             if (LADSPA_IS_PLUGIN_GENERATOR(category))

  126.                 return PLUGIN_CATEGORY_SYNTH;

  127.         }

  128. 

  129.         return CarlaPlugin::getCategory();

  130.     }

  131. 

  132.     long getUniqueId() const noexcept override

  133.     {

  134.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr, 0);

  135. 

  136.         return fDescriptor->UniqueID;

  137.     }

  138. 

  139.     // -------------------------------------------------------------------

  140.     // Information (count)

  141. 

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

  143.     {

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

  145. 

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

  147. 

  148.         if (fRdfDescriptor != nullptr && rindex < static_cast<int32_t>(fRdfDescriptor->PortCount))

  149.         {

  150.             const LADSPA_RDF_Port* const port(&fRdfDescriptor->Ports[rindex]);

  151.             return static_cast<uint32_t>(port->ScalePointCount);

  152.         }

  153. 

  154.         return 0;

  155.     }

  156. 

  157.     // -------------------------------------------------------------------

  158.     // Information (current data)

  159. 

  160.     // nothing

  161. 

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

  163.     // Information (per-plugin data)

  164. 

  165.     unsigned int getOptionsAvailable() const noexcept override

  166.     {

  167. #ifdef __USE_GNU

  168.         const bool isDssiVst(strcasestr(pData->filename, "dssi-vst"));

  169. #else

  170.         const bool isDssiVst(std::strstr(pData->filename, "dssi-vst"));

  171. #endif

  172. 

  173.         unsigned int options = 0x0;

  174. 

  175.         if (! isDssiVst)

  176.         {

  177.             options |= PLUGIN_OPTION_FIXED_BUFFERS;

  178. 

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

  180.             {

  181.                 if (pData->options & PLUGIN_OPTION_FORCE_STEREO)

  182.                     options |= PLUGIN_OPTION_FORCE_STEREO;

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

  184.                     options |= PLUGIN_OPTION_FORCE_STEREO;

  185.             }

  186.         }

  187. 

  188.         return options;

  189.     }

  190. 

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

  192.     {

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

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

  195. 

  196.         return fParamBuffers[parameterId];

  197.     }

  198. 

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

  200.     {

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

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

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

  204. 

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

  206. 

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

  208.         {

  209.             const LADSPA_RDF_Port* const port(&fRdfDescriptor->Ports[rindex]);

  210. 

  211.             if (scalePointId < port->ScalePointCount)

  212.             {

  213.                 const LADSPA_RDF_ScalePoint* const scalePoint(&port->ScalePoints[scalePointId]);

  214.                 return scalePoint->Value;

  215.             }

  216.         }

  217. 

  218.         return 0.0f;

  219.     }

  220. 

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

  222.     {

  223.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  224. 

  225.         if (fDescriptor->Label != nullptr)

  226.             std::strncpy(strBuf, fDescriptor->Label, STR_MAX);

  227.         else

  228.             CarlaPlugin::getLabel(strBuf);

  229.     }

  230. 

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

  232.     {

  233.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  234. 

  235.         if (fRdfDescriptor != nullptr && fRdfDescriptor->Creator != nullptr)

  236.             std::strncpy(strBuf, fRdfDescriptor->Creator, STR_MAX);

  237.         else if (fDescriptor->Maker != nullptr)

  238.             std::strncpy(strBuf, fDescriptor->Maker, STR_MAX);

  239.         else

  240.             CarlaPlugin::getMaker(strBuf);

  241.     }

  242. 

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

  244.     {

  245.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  246. 

  247.         if (fDescriptor->Copyright != nullptr)

  248.             std::strncpy(strBuf, fDescriptor->Copyright, STR_MAX);

  249.         else

  250.             CarlaPlugin::getCopyright(strBuf);

  251.     }

  252. 

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

  254.     {

  255.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  256. 

  257.         if (fRdfDescriptor != nullptr && fRdfDescriptor->Title != nullptr)

  258.             std::strncpy(strBuf, fRdfDescriptor->Title, STR_MAX);

  259.         else if (fDescriptor->Name != nullptr)

  260.             std::strncpy(strBuf, fDescriptor->Name, STR_MAX);

  261.         else

  262.             CarlaPlugin::getRealName(strBuf);

  263.     }

  264. 

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

  266.     {

  267.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

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

  269. 

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

  271. 

  272.         if (rindex < static_cast<int32_t>(fDescriptor->PortCount))

  273.             std::strncpy(strBuf, fDescriptor->PortNames[rindex], STR_MAX);

  274.         else

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

  276.     }

  277. 

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

  279.     {

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

  281. 

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

  283. 

  284.         if (fRdfDescriptor != nullptr && rindex < static_cast<int32_t>(fRdfDescriptor->PortCount))

  285.         {

  286.             const LADSPA_RDF_Port* const port(&fRdfDescriptor->Ports[rindex]);

  287. 

  288.             if (LADSPA_PORT_HAS_LABEL(port->Hints) && port->Label != nullptr)

  289.             {

  290.                 std::strncpy(strBuf, port->Label, STR_MAX);

  291.                 return;

  292.             }

  293.         }

  294. 

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

  296.     }

  297. 

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

  299.     {

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

  301. 

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

  303. 

  304.         if (fRdfDescriptor != nullptr && rindex < static_cast<int32_t>(fRdfDescriptor->PortCount))

  305.         {

  306.             const LADSPA_RDF_Port* const port(&fRdfDescriptor->Ports[rindex]);

  307. 

  308.             if (LADSPA_PORT_HAS_UNIT(port->Hints))

  309.             {

  310.                 switch (port->Unit)

  311.                 {

  312.                 case LADSPA_UNIT_DB:

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

  314.                     return;

  315.                 case LADSPA_UNIT_COEF:

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

  317.                     return;

  318.                 case LADSPA_UNIT_HZ:

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

  320.                     return;

  321.                 case LADSPA_UNIT_S:

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

  323.                     return;

  324.                 case LADSPA_UNIT_MS:

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

  326.                     return;

  327.                 case LADSPA_UNIT_MIN:

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

  329.                     return;

  330.                 }

  331.             }

  332.         }

  333. 

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

  335.     }

  336. 

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

  338.     {

  339.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr,);

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

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

  342. 

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

  344. 

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

  346.         {

  347.             const LADSPA_RDF_Port* const port(&fRdfDescriptor->Ports[rindex]);

  348. 

  349.             if (scalePointId < port->ScalePointCount)

  350.             {

  351.                 const LADSPA_RDF_ScalePoint* const scalePoint(&port->ScalePoints[scalePointId]);

  352. 

  353.                 if (scalePoint->Label != nullptr)

  354.                 {

  355.                     std::strncpy(strBuf, scalePoint->Label, STR_MAX);

  356.                     return;

  357.                 }

  358.             }

  359.         }

  360. 

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

  362.     }

  363. 

  364.     // -------------------------------------------------------------------

  365.     // Set data (state)

  366. 

  367.     // nothing

  368. 

  369.     // -------------------------------------------------------------------

  370.     // Set data (internal stuff)

  371. 

  372.     // nothing

  373. 

  374.     // -------------------------------------------------------------------

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

  376. 

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

  378.     {

  379.         CARLA_SAFE_ASSERT_RETURN(fParamBuffers != nullptr,);

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

  381. 

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

  383.         fParamBuffers[parameterId] = fixedValue;

  384. 

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

  386.     }

  387. 

  388.     // -------------------------------------------------------------------

  389.     // Set ui stuff

  390. 

  391.     // nothing

  392. 

  393.     // -------------------------------------------------------------------

  394.     // Plugin state

  395. 

  396.     void reload() override

  397.     {

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

  399.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  400.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  401.         carla_debug("LadspaPlugin::reload() - start");

  402. 

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

  404. 

  405.         // Safely disable plugin for reload

  406.         const ScopedDisabler sd(this);

  407. 

  408.         if (pData->active)

  409.             deactivate();

  410. 

  411.         clearBuffers();

  412. 

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

  414.         const uint32_t portCount(static_cast<uint32_t>(fDescriptor->PortCount));

  415. 

  416.         uint32_t aIns, aOuts, params, j;

  417.         aIns = aOuts = params = 0;

  418. 

  419.         bool forcedStereoIn, forcedStereoOut;

  420.         forcedStereoIn = forcedStereoOut = false;

  421. 

  422.         bool needsCtrlIn, needsCtrlOut;

  423.         needsCtrlIn = needsCtrlOut = false;

  424. 

  425.         if (portCount > 0)

  426.         {

  427.             CARLA_ASSERT(fDescriptor->PortDescriptors != nullptr);

  428.             CARLA_ASSERT(fDescriptor->PortRangeHints != nullptr);

  429.             CARLA_ASSERT(fDescriptor->PortNames != nullptr);

  430. 

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

  432.             {

  433.                 const LADSPA_PortDescriptor portType = fDescriptor->PortDescriptors[i];

  434. 

  435.                 if (LADSPA_IS_PORT_AUDIO(portType))

  436.                 {

  437.                     if (LADSPA_IS_PORT_INPUT(portType))

  438.                         aIns += 1;

  439.                     else if (LADSPA_IS_PORT_OUTPUT(portType))

  440.                         aOuts += 1;

  441.                 }

  442.                 else if (LADSPA_IS_PORT_CONTROL(portType))

  443.                     params += 1;

  444.             }

  445.         }

  446. 

  447.         if ((pData->options & PLUGIN_OPTION_FORCE_STEREO) != 0 && (aIns == 1 || aOuts == 1))

  448.         {

  449.             if (fHandle2 == nullptr)

  450.                 fHandle2 = fDescriptor->instantiate(fDescriptor, (unsigned long)sampleRate);

  451. 

  452.             if (fHandle2 != nullptr)

  453.             {

  454.                 if (aIns == 1)

  455.                 {

  456.                     aIns = 2;

  457.                     forcedStereoIn = true;

  458.                 }

  459. 

  460.                 if (aOuts == 1)

  461.                 {

  462.                     aOuts = 2;

  463.                     forcedStereoOut = true;

  464.                 }

  465.             }

  466.         }

  467. 

  468.         if (aIns > 0)

  469.         {

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

  471.             fAudioInBuffers = new float*[aIns];

  472. 

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

  474.                 fAudioInBuffers[i] = nullptr;

  475.         }

  476. 

  477.         if (aOuts > 0)

  478.         {

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

  480.             fAudioOutBuffers = new float*[aOuts];

  481.             needsCtrlIn = true;

  482. 

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

  484.                 fAudioOutBuffers[i] = nullptr;

  485.         }

  486. 

  487.         if (params > 0)

  488.         {

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

  490. 

  491.             fParamBuffers = new float[params];

  492.             FLOAT_CLEAR(fParamBuffers, params);

  493.         }

  494. 

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

  496.         CarlaString portName;

  497. 

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

  499.         {

  500.             const LADSPA_PortDescriptor portType      = fDescriptor->PortDescriptors[i];

  501.             const LADSPA_PortRangeHint portRangeHints = fDescriptor->PortRangeHints[i];

  502.             const bool hasPortRDF = (fRdfDescriptor != nullptr && i < fRdfDescriptor->PortCount);

  503. 

  504.             CARLA_ASSERT(fDescriptor->PortNames[i] != nullptr);

  505. 

  506.             if (LADSPA_IS_PORT_AUDIO(portType))

  507.             {

  508.                 portName.clear();

  509. 

  510.                 if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  511.                 {

  512.                     portName  = pData->name;

  513.                     portName += ":";

  514.                 }

  515. 

  516.                 portName += fDescriptor->PortNames[i];

  517.                 portName.truncate(portNameSize);

  518. 

  519.                 if (LADSPA_IS_PORT_INPUT(portType))

  520.                 {

  521.                     j = iAudioIn++;

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

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

  524. 

  525.                     if (forcedStereoIn)

  526.                     {

  527.                         portName += "_2";

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

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

  530.                     }

  531.                 }

  532.                 else if (LADSPA_IS_PORT_OUTPUT(portType))

  533.                 {

  534.                     j = iAudioOut++;

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

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

  537. 

  538.                     if (forcedStereoOut)

  539.                     {

  540.                         portName += "_2";

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

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

  543.                     }

  544.                 }

  545.                 else

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

  547.             }

  548.             else if (LADSPA_IS_PORT_CONTROL(portType))

  549.             {

  550.                 j = iCtrl++;

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

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

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

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

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

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

  557.                 pData->param.special[j] = PARAMETER_SPECIAL_NULL;

  558. 

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

  560. 

  561.                 // min value

  562.                 if (LADSPA_IS_HINT_BOUNDED_BELOW(portRangeHints.HintDescriptor))

  563.                     min = portRangeHints.LowerBound;

  564.                 else

  565.                     min = 0.0f;

  566. 

  567.                 // max value

  568.                 if (LADSPA_IS_HINT_BOUNDED_ABOVE(portRangeHints.HintDescriptor))

  569.                     max = portRangeHints.UpperBound;

  570.                 else

  571.                     max = 1.0f;

  572. 

  573.                 if (min > max)

  574.                     max = min;

  575.                 else if (max < min)

  576.                     min = max;

  577. 

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

  579.                 {

  580.                     carla_stderr2("WARNING - Broken plugin parameter '%s': max - min == 0.0f", fDescriptor->PortNames[i]);

  581.                     max = min + 0.1f;

  582.                 }

  583. 

  584.                 // default value

  585.                 if (hasPortRDF && LADSPA_PORT_HAS_DEFAULT(fRdfDescriptor->Ports[i].Hints))

  586.                     def = fRdfDescriptor->Ports[i].Default;

  587.                 else

  588.                     def = get_default_ladspa_port_value(portRangeHints.HintDescriptor, min, max);

  589. 

  590.                 if (def < min)

  591.                     def = min;

  592.                 else if (def > max)

  593.                     def = max;

  594. 

  595.                 if (LADSPA_IS_HINT_SAMPLE_RATE(portRangeHints.HintDescriptor))

  596.                 {

  597.                     min *= sampleRate;

  598.                     max *= sampleRate;

  599.                     def *= sampleRate;

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

  601.                 }

  602. 

  603.                 if (LADSPA_IS_HINT_TOGGLED(portRangeHints.HintDescriptor))

  604.                 {

  605.                     step = max - min;

  606.                     stepSmall = step;

  607.                     stepLarge = step;

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

  609.                 }

  610.                 else if (LADSPA_IS_HINT_INTEGER(portRangeHints.HintDescriptor))

  611.                 {

  612.                     step = 1.0f;

  613.                     stepSmall = 1.0f;

  614.                     stepLarge = 10.0f;

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

  616.                 }

  617.                 else

  618.                 {

  619.                     float range = max - min;

  620.                     step = range/100.0f;

  621.                     stepSmall = range/1000.0f;

  622.                     stepLarge = range/10.0f;

  623.                 }

  624. 

  625.                 if (LADSPA_IS_PORT_INPUT(portType))

  626.                 {

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

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

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

  630.                     needsCtrlIn = true;

  631.                 }

  632.                 else if (LADSPA_IS_PORT_OUTPUT(portType))

  633.                 {

  634.                     if (std::strcmp(fDescriptor->PortNames[i], "latency") == 0 || std::strcmp(fDescriptor->PortNames[i], "_latency") == 0)

  635.                     {

  636.                         min = 0.0f;

  637.                         max = sampleRate;

  638.                         def = 0.0f;

  639.                         step = 1.0f;

  640.                         stepSmall = 1.0f;

  641.                         stepLarge = 1.0f;

  642. 

  643.                         pData->param.data[j].type = PARAMETER_SPECIAL;

  644.                         pData->param.special[j]   = PARAMETER_SPECIAL_LATENCY;

  645.                     }

  646.                     else if (std::strcmp(fDescriptor->PortNames[i], "_sample-rate") == 0)

  647.                     {

  648.                         def = sampleRate;

  649.                         step = 1.0f;

  650.                         stepSmall = 1.0f;

  651.                         stepLarge = 1.0f;

  652. 

  653.                         pData->param.data[j].type = PARAMETER_SPECIAL;

  654.                         pData->param.special[j]   = PARAMETER_SPECIAL_SAMPLE_RATE;

  655.                     }

  656.                     else

  657.                     {

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

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

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

  661.                         needsCtrlOut = true;

  662.                     }

  663.                 }

  664.                 else

  665.                 {

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

  667.                 }

  668. 

  669.                 // extra parameter hints

  670.                 if (LADSPA_IS_HINT_LOGARITHMIC(portRangeHints.HintDescriptor))

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

  672. 

  673.                 // check for scalepoints, require at least 2 to make it useful

  674.                 if (hasPortRDF && fRdfDescriptor->Ports[i].ScalePointCount > 1)

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

  676. 

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

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

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

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

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

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

  683. 

  684.                 // Start parameters in their default values

  685.                 fParamBuffers[j] = def;

  686. 

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

  688. 

  689.                 if (fHandle2 != nullptr)

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

  691.             }

  692.             else

  693.             {

  694.                 // Not Audio or Control

  695.                 carla_stderr2("ERROR - Got a broken Port (neither Audio or Control)");

  696. 

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

  698. 

  699.                 if (fHandle2 != nullptr)

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

  701.             }

  702.         }

  703. 

  704.         if (needsCtrlIn)

  705.         {

  706.             portName.clear();

  707. 

  708.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  709.             {

  710.                 portName  = pData->name;

  711.                 portName += ":";

  712.             }

  713. 

  714.             portName += "events-in";

  715.             portName.truncate(portNameSize);

  716. 

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

  718.         }

  719. 

  720.         if (needsCtrlOut)

  721.         {

  722.             portName.clear();

  723. 

  724.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  725.             {

  726.                 portName  = pData->name;

  727.                 portName += ":";

  728.             }

  729. 

  730.             portName += "events-out";

  731.             portName.truncate(portNameSize);

  732. 

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

  734.         }

  735. 

  736.         if (forcedStereoIn || forcedStereoOut)

  737.             pData->options |= PLUGIN_OPTION_FORCE_STEREO;

  738.         else

  739.             pData->options &= ~PLUGIN_OPTION_FORCE_STEREO;

  740. 

  741.         // plugin hints

  742.         pData->hints = 0x0;

  743. 

  744.         if (LADSPA_IS_HARD_RT_CAPABLE(fDescriptor->Properties))

  745.             pData->hints |= PLUGIN_IS_RTSAFE;

  746. 

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

  748.             pData->hints |= PLUGIN_CAN_DRYWET;

  749. 

  750.         if (aOuts > 0)

  751.             pData->hints |= PLUGIN_CAN_VOLUME;

  752. 

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

  754.             pData->hints |= PLUGIN_CAN_BALANCE;

  755. 

  756.         // extra plugin hints

  757.         pData->extraHints = 0x0;

  758. 

  759.         if (aIns <= 2 && aOuts <= 2 && (aIns == aOuts || aIns == 0 || aOuts == 0))

  760.             pData->extraHints |= PLUGIN_EXTRA_HINT_CAN_RUN_RACK;

  761. 

  762.         // check latency

  763.         if (pData->hints & PLUGIN_CAN_DRYWET)

  764.         {

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

  766.             {

  767.                 if (pData->param.special[i] != PARAMETER_SPECIAL_LATENCY)

  768.                    continue;

  769. 

  770.                 // we need to pre-run the plugin so it can update its latency control-port

  771. 

  772.                 float tmpIn[aIns][2];

  773.                 float tmpOut[aOuts][2];

  774. 

  775.                 for (j=0; j < aIns; ++j)

  776.                 {

  777.                     tmpIn[j][0] = 0.0f;

  778.                     tmpIn[j][1] = 0.0f;

  779. 

  780.                     fDescriptor->connect_port(fHandle, pData->audioIn.ports[j].rindex, tmpIn[j]);

  781.                 }

  782. 

  783.                 for (j=0; j < aOuts; ++j)

  784.                 {

  785.                     tmpOut[j][0] = 0.0f;

  786.                     tmpOut[j][1] = 0.0f;

  787. 

  788.                     fDescriptor->connect_port(fHandle, pData->audioOut.ports[j].rindex, tmpOut[j]);

  789.                 }

  790. 

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

  792.                     fDescriptor->activate(fHandle);

  793. 

  794.                 fDescriptor->run(fHandle, 2);

  795. 

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

  797.                     fDescriptor->deactivate(fHandle);

  798. 

  799.                 const uint32_t latency = (uint32_t)fParamBuffers[i];

  800. 

  801.                 if (pData->latency != latency)

  802.                 {

  803.                     pData->latency = latency;

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

  805.                     pData->recreateLatencyBuffers();

  806.                 }

  807. 

  808.                 break;

  809.             }

  810.         }

  811. 

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

  813. 

  814.         if (pData->active)

  815.             activate();

  816. 

  817.         carla_debug("LadspaPlugin::reload() - end");

  818.     }

  819. 

  820.     // -------------------------------------------------------------------

  821.     // Plugin processing

  822. 

  823.     void activate() noexcept override

  824.     {

  825.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  826.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  827. 

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

  829.         {

  830.             try {

  831.                 fDescriptor->activate(fHandle);

  832.             } catch(...) {}

  833. 

  834.             if (fHandle2 != nullptr)

  835.             {

  836.                 try {

  837.                     fDescriptor->activate(fHandle2);

  838.                 } catch(...) {}

  839.             }

  840.         }

  841.     }

  842. 

  843.     void deactivate() noexcept override

  844.     {

  845.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  846.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  847. 

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

  849.         {

  850.             try {

  851.                 fDescriptor->deactivate(fHandle);

  852.             } catch(...) {}

  853. 

  854.             if (fHandle2 != nullptr)

  855.             {

  856.                 try {

  857.                     fDescriptor->deactivate(fHandle2);

  858.                 } catch(...) {}

  859.             }

  860.         }

  861.     }

  862. 

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

  864.     {

  865.         // --------------------------------------------------------------------------------------------------------

  866.         // Check if active

  867. 

  868.         if (! pData->active)

  869.         {

  870.             // disable any output sound

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

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

  873. 

  874.             return;

  875.         }

  876. 

  877.         // --------------------------------------------------------------------------------------------------------

  878.         // Check if needs reset

  879. 

  880.         if (pData->needsReset)

  881.         {

  882.             if (pData->latency > 0)

  883.             {

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

  885.                     FLOAT_CLEAR(pData->latencyBuffers[i], pData->latency);

  886.             }

  887. 

  888.             pData->needsReset = false;

  889.         }

  890. 

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

  892.         // Event Input and Processing

  893. 

  894.         if (pData->event.portIn != nullptr)

  895.         {

  896.             // ----------------------------------------------------------------------------------------------------

  897.             // Event Input (System)

  898. 

  899.             bool isSampleAccurate  = (pData->options & PLUGIN_OPTION_FIXED_BUFFERS) == 0;

  900. 

  901.             uint32_t time, numEvents = pData->event.portIn->getEventCount();

  902.             uint32_t timeOffset = 0;

  903. 

  904.             for (uint32_t i=0; i < numEvents; ++i)

  905.             {

  906.                 const EngineEvent& event(pData->event.portIn->getEvent(i));

  907. 

  908.                 time = event.time;

  909. 

  910.                 if (time >= frames)

  911.                     continue;

  912. 

  913.                 CARLA_ASSERT_INT2(time >= timeOffset, time, timeOffset);

  914. 

  915.                 if (time > timeOffset && isSampleAccurate)

  916.                 {

  917.                     if (processSingle(inBuffer, outBuffer, time - timeOffset, timeOffset))

  918.                         timeOffset = time;

  919.                 }

  920. 

  921.                 // Control change

  922.                 switch (event.type)

  923.                 {

  924.                 case kEngineEventTypeNull:

  925.                     break;

  926. 

  927.                 case kEngineEventTypeControl:

  928.                 {

  929.                     const EngineControlEvent& ctrlEvent(event.ctrl);

  930. 

  931.                     switch (ctrlEvent.type)

  932.                     {

  933.                     case kEngineControlEventTypeNull:

  934.                         break;

  935. 

  936.                     case kEngineControlEventTypeParameter:

  937.                     {

  938. #ifndef BUILD_BRIDGE

  939.                         // Control backend stuff

  940.                         if (event.channel == pData->ctrlChannel)

  941.                         {

  942.                             float value;

  943. 

  944.                             if (MIDI_IS_CONTROL_BREATH_CONTROLLER(ctrlEvent.param) && (pData->hints & PLUGIN_CAN_DRYWET) != 0)

  945.                             {

  946.                                 value = ctrlEvent.value;

  947.                                 setDryWet(value, false, false);

  948.                                 pData->postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_DRYWET, 0, value);

  949.                             }

  950. 

  951.                             if (MIDI_IS_CONTROL_CHANNEL_VOLUME(ctrlEvent.param) && (pData->hints & PLUGIN_CAN_VOLUME) != 0)

  952.                             {

  953.                                 value = ctrlEvent.value*127.0f/100.0f;

  954.                                 setVolume(value, false, false);

  955.                                 pData->postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_VOLUME, 0, value);

  956.                             }

  957. 

  958.                             if (MIDI_IS_CONTROL_BALANCE(ctrlEvent.param) && (pData->hints & PLUGIN_CAN_BALANCE) != 0)

  959.                             {

  960.                                 float left, right;

  961.                                 value = ctrlEvent.value/0.5f - 1.0f;

  962. 

  963.                                 if (value < 0.0f)

  964.                                 {

  965.                                     left  = -1.0f;

  966.                                     right = (value*2.0f)+1.0f;

  967.                                 }

  968.                                 else if (value > 0.0f)

  969.                                 {

  970.                                     left  = (value*2.0f)-1.0f;

  971.                                     right = 1.0f;

  972.                                 }

  973.                                 else

  974.                                 {

  975.                                     left  = -1.0f;

  976.                                     right = 1.0f;

  977.                                 }

  978. 

  979.                                 setBalanceLeft(left, false, false);

  980.                                 setBalanceRight(right, false, false);

  981.                                 pData->postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_BALANCE_LEFT, 0, left);

  982.                                 pData->postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_BALANCE_RIGHT, 0, right);

  983.                             }

  984.                         }

  985. #endif

  986. 

  987.                         // Control plugin parameters

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

  989.                         {

  990.                             if (pData->param.data[k].midiChannel != event.channel)

  991.                                 continue;

  992.                             if (pData->param.data[k].midiCC != ctrlEvent.param)

  993.                                 continue;

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

  995.                                 continue;

  996.                             if ((pData->param.data[k].hints & PARAMETER_IS_AUTOMABLE) == 0)

  997.                                 continue;

  998. 

  999.                             float value;

  1000. 

  1001.                             if (pData->param.data[k].hints & PARAMETER_IS_BOOLEAN)

  1002.                             {

  1003.                                 value = (ctrlEvent.value < 0.5f) ? pData->param.ranges[k].min : pData->param.ranges[k].max;

  1004.                             }

  1005.                             else

  1006.                             {

  1007.                                 value = pData->param.ranges[k].getUnnormalizedValue(ctrlEvent.value);

  1008. 

  1009.                                 if (pData->param.data[k].hints & PARAMETER_IS_INTEGER)

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

  1011.                             }

  1012. 

  1013.                             setParameterValue(k, value, false, false, false);

  1014.                             pData->postponeRtEvent(kPluginPostRtEventParameterChange, static_cast<int32_t>(k), 0, value);

  1015.                         }

  1016. 

  1017.                         break;

  1018.                     }

  1019. 

  1020.                     case kEngineControlEventTypeMidiBank:

  1021.                     case kEngineControlEventTypeMidiProgram:

  1022.                     case kEngineControlEventTypeAllSoundOff:

  1023.                     case kEngineControlEventTypeAllNotesOff:

  1024.                         break;

  1025.                     }

  1026. 

  1027.                     break;

  1028.                 }

  1029. 

  1030.                 case kEngineEventTypeMidi:

  1031.                     // ignored in LADSPA

  1032.                     break;

  1033.                 }

  1034.             }

  1035. 

  1036.             pData->postRtEvents.trySplice();

  1037. 

  1038.             if (frames > timeOffset)

  1039.                 processSingle(inBuffer, outBuffer, frames - timeOffset, timeOffset);

  1040. 

  1041.         } // End of Event Input and Processing

  1042. 

  1043.         // --------------------------------------------------------------------------------------------------------

  1044.         // Plugin processing (no events)

  1045. 

  1046.         else

  1047.         {

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

  1049. 

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

  1051. 

  1052.         CARLA_PROCESS_CONTINUE_CHECK;

  1053. 

  1054.         // --------------------------------------------------------------------------------------------------------

  1055.         // Control Output

  1056. 

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

  1058.         {

  1059.             uint8_t  channel;

  1060.             uint16_t param;

  1061.             float    value;

  1062. 

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

  1064.             {

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

  1066.                     continue;

  1067. 

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

  1069. 

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

  1071.                 {

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

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

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

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

  1076.                 }

  1077.             }

  1078. 

  1079.         } // End of Control Output

  1080.     }

  1081. 

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

  1083.     {

  1084.         CARLA_SAFE_ASSERT_RETURN(frames > 0, false);

  1085. 

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

  1087.         {

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

  1089.         }

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

  1091.         {

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

  1093.         }

  1094. 

  1095.         // --------------------------------------------------------------------------------------------------------

  1096.         // Try lock, silence otherwise

  1097. 

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

  1099.         {

  1100.             pData->singleMutex.lock();

  1101.         }

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

  1103.         {

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

  1105.             {

  1106.                 for (uint32_t k=0; k < frames; ++k)

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

  1108.             }

  1109. 

  1110.             return false;

  1111.         }

  1112. 

  1113.         // --------------------------------------------------------------------------------------------------------

  1114.         // Reset audio buffers

  1115. 

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

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

  1118. 

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

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

  1121. 

  1122.         // --------------------------------------------------------------------------------------------------------

  1123.         // Run plugin

  1124. 

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

  1126. 

  1127.         if (fHandle2 != nullptr)

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

  1129. 

  1130. #ifndef BUILD_BRIDGE

  1131.         // --------------------------------------------------------------------------------------------------------

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

  1133. 

  1134.         {

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

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

  1137. 

  1138.             bool isPair;

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

  1140. 

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

  1142.             {

  1143.                 // Dry/Wet

  1144.                 if (doDryWet)

  1145.                 {

  1146.                     for (uint32_t k=0; k < frames; ++k)

  1147.                     {

  1148.                         // TODO

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

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

  1151.                         //else

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

  1153. 

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

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

  1156.                     }

  1157.                 }

  1158. 

  1159.                 // Balance

  1160.                 if (doBalance)

  1161.                 {

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

  1163. 

  1164.                     if (isPair)

  1165.                     {

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

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

  1168.                     }

  1169. 

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

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

  1172. 

  1173.                     for (uint32_t k=0; k < frames; ++k)

  1174.                     {

  1175.                         if (isPair)

  1176.                         {

  1177.                             // left

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

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

  1180.                         }

  1181.                         else

  1182.                         {

  1183.                             // right

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

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

  1186.                         }

  1187.                     }

  1188.                 }

  1189. 

  1190.                 // Volume (and buffer copy)

  1191.                 {

  1192.                     for (uint32_t k=0; k < frames; ++k)

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

  1194.                 }

  1195.             }

  1196. 

  1197. #if 0

  1198.             // Latency, save values for next callback, TODO

  1199.             if (pData->latency > 0 && pData->latency < frames)

  1200.             {

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

  1202.                     FloatVectorOperations::copy(pData->latencyBuffers[i], inBuffer[i] + (frames - pData->latency), pData->latency);

  1203.             }

  1204. #endif

  1205.         } // End of Post-processing

  1206. 

  1207. #else // BUILD_BRIDGE

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

  1209.         {

  1210.             for (uint32_t k=0; k < frames; ++k)

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

  1212.         }

  1213. #endif

  1214. 

  1215.         // --------------------------------------------------------------------------------------------------------

  1216. 

  1217.         pData->singleMutex.unlock();

  1218.         return true;

  1219.     }

  1220. 

  1221.     void bufferSizeChanged(const uint32_t newBufferSize) override

  1222.     {

  1223.         CARLA_ASSERT_INT(newBufferSize > 0, newBufferSize);

  1224.         carla_debug("LadspaPlugin::bufferSizeChanged(%i) - start", newBufferSize);

  1225. 

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

  1227.         {

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

  1229.                 delete[] fAudioInBuffers[i];

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

  1231.         }

  1232. 

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

  1234.         {

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

  1236.                 delete[] fAudioOutBuffers[i];

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

  1238.         }

  1239. 

  1240.         if (fHandle2 == nullptr)

  1241.         {

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

  1243.             {

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

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

  1246.             }

  1247. 

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

  1249.             {

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

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

  1252.             }

  1253.         }

  1254.         else

  1255.         {

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

  1257.             {

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

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

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

  1261. 

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

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

  1264.             }

  1265. 

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

  1267.             {

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

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

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

  1271. 

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

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

  1274.             }

  1275.         }

  1276. 

  1277.         carla_debug("LadspaPlugin::bufferSizeChanged(%i) - end", newBufferSize);

  1278.     }

  1279. 

  1280.     void sampleRateChanged(const double newSampleRate) override

  1281.     {

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

  1283.         carla_debug("LadspaPlugin::sampleRateChanged(%g) - start", newSampleRate);

  1284. 

  1285.         // TODO

  1286.         (void)newSampleRate;

  1287. 

  1288.         carla_debug("LadspaPlugin::sampleRateChanged(%g) - end", newSampleRate);

  1289.     }

  1290. 

  1291.     // -------------------------------------------------------------------

  1292.     // Plugin buffers

  1293. 

  1294.     void clearBuffers() override

  1295.     {

  1296.         carla_debug("LadspaPlugin::clearBuffers() - start");

  1297. 

  1298.         if (fAudioInBuffers != nullptr)

  1299.         {

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

  1301.             {

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

  1303.                 {

  1304.                     delete[] fAudioInBuffers[i];

  1305.                     fAudioInBuffers[i] = nullptr;

  1306.                 }

  1307.             }

  1308. 

  1309.             delete[] fAudioInBuffers;

  1310.             fAudioInBuffers = nullptr;

  1311.         }

  1312. 

  1313.         if (fAudioOutBuffers != nullptr)

  1314.         {

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

  1316.             {

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

  1318.                 {

  1319.                     delete[] fAudioOutBuffers[i];

  1320.                     fAudioOutBuffers[i] = nullptr;

  1321.                 }

  1322.             }

  1323. 

  1324.             delete[] fAudioOutBuffers;

  1325.             fAudioOutBuffers = nullptr;

  1326.         }

  1327. 

  1328.         if (fParamBuffers != nullptr)

  1329.         {

  1330.             delete[] fParamBuffers;

  1331.             fParamBuffers = nullptr;

  1332.         }

  1333. 

  1334.         CarlaPlugin::clearBuffers();

  1335. 

  1336.         carla_debug("LadspaPlugin::clearBuffers() - end");

  1337.     }

  1338. 

  1339.     // -------------------------------------------------------------------

  1340. 

  1341.     const void* getExtraStuff() const noexcept override

  1342.     {

  1343.         return fRdfDescriptor;

  1344.     }

  1345. 

  1346.     bool init(const char* const filename, const char* const name, const char* const label, const LADSPA_RDF_Descriptor* const rdfDescriptor)

  1347.     {

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

  1349. 

  1350.         // ---------------------------------------------------------------

  1351.         // first checks

  1352. 

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

  1354.         {

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

  1356.             return false;

  1357.         }

  1358. 

  1359.         if (filename == nullptr || filename[0] == '\0')

  1360.         {

  1361.             pData->engine->setLastError("null filename");

  1362.             return false;

  1363.         }

  1364. 

  1365.         if (label == nullptr || label[0] == '\0')

  1366.         {

  1367.             pData->engine->setLastError("null label");

  1368.             return false;

  1369.         }

  1370. 

  1371.         // ---------------------------------------------------------------

  1372.         // open DLL

  1373. 

  1374.         if (! pData->libOpen(filename))

  1375.         {

  1376.             pData->engine->setLastError(pData->libError(filename));

  1377.             return false;

  1378.         }

  1379. 

  1380.         // ---------------------------------------------------------------

  1381.         // get DLL main entry

  1382. 

  1383.         const LADSPA_Descriptor_Function descFn = (LADSPA_Descriptor_Function)pData->libSymbol("ladspa_descriptor");

  1384. 

  1385.         if (descFn == nullptr)

  1386.         {

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

  1388.             return false;

  1389.         }

  1390. 

  1391.         // ---------------------------------------------------------------

  1392.         // get descriptor that matches label

  1393. 

  1394.         unsigned long i = 0;

  1395.         while ((fDescriptor = descFn(i++)) != nullptr)

  1396.         {

  1397.             if (fDescriptor->Label != nullptr && std::strcmp(fDescriptor->Label, label) == 0)

  1398.                 break;

  1399.         }

  1400. 

  1401.         if (fDescriptor == nullptr)

  1402.         {

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

  1404.             return false;

  1405.         }

  1406. 

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

  1408.         // get info

  1409. 

  1410.         if (is_ladspa_rdf_descriptor_valid(rdfDescriptor, fDescriptor))

  1411.             fRdfDescriptor = ladspa_rdf_dup(rdfDescriptor);

  1412. 

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

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

  1415.         else if (fRdfDescriptor != nullptr && fRdfDescriptor->Title != nullptr && fRdfDescriptor->Title[0] != '\0')

  1416.             pData->name = pData->engine->getUniquePluginName(fRdfDescriptor->Title);

  1417.         else if (fDescriptor->Name != nullptr && fDescriptor->Name[0] != '\0')

  1418.             pData->name = pData->engine->getUniquePluginName(fDescriptor->Name);

  1419.         else

  1420.             pData->name = pData->engine->getUniquePluginName(fDescriptor->Label);

  1421. 

  1422.         pData->filename = carla_strdup(filename);

  1423. 

  1424.         // ---------------------------------------------------------------

  1425.         // register client

  1426. 

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

  1428. 

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

  1430.         {

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

  1432.             return false;

  1433.         }

  1434. 

  1435.         // ---------------------------------------------------------------

  1436.         // initialize plugin

  1437. 

  1438.         fHandle = fDescriptor->instantiate(fDescriptor, (unsigned long)pData->engine->getSampleRate());

  1439. 

  1440.         if (fHandle == nullptr)

  1441.         {

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

  1443.             return false;

  1444.         }

  1445. 

  1446.         // ---------------------------------------------------------------

  1447.         // load plugin settings

  1448. 

  1449.         {

  1450. #ifdef __USE_GNU

  1451.             const bool isDssiVst(strcasestr(pData->filename, "dssi-vst"));

  1452. #else

  1453.             const bool isDssiVst(std::strstr(pData->filename, "dssi-vst"));

  1454. #endif

  1455. 

  1456.             // set default options

  1457.             pData->options = 0x0;

  1458. 

  1459.             if (isDssiVst)

  1460.                 pData->options |= PLUGIN_OPTION_FIXED_BUFFERS;

  1461. 

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

  1463.                 pData->options |= PLUGIN_OPTION_FORCE_STEREO;

  1464. 

  1465.             // set identifier string

  1466.             CarlaString identifier("LADSPA/");

  1467.             identifier += CarlaString(getUniqueId());

  1468.             identifier += ",";

  1469.             identifier += label;

  1470.             pData->identifier = identifier.dup();

  1471. 

  1472.             // load settings

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

  1474. 

  1475.             // ignore settings, we need this anyway

  1476.             if (isDssiVst)

  1477.                 pData->options |= PLUGIN_OPTION_FIXED_BUFFERS;

  1478.         }

  1479. 

  1480.         return true;

  1481.     }

  1482. 

  1483. private:

  1484.     LADSPA_Handle fHandle;

  1485.     LADSPA_Handle fHandle2;

  1486.     const LADSPA_Descriptor*     fDescriptor;

  1487.     const LADSPA_RDF_Descriptor* fRdfDescriptor;

  1488. 

  1489.     float** fAudioInBuffers;

  1490.     float** fAudioOutBuffers;

  1491.     float*  fParamBuffers;

  1492. 

  1493.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(LadspaPlugin)

  1494. };

  1495. 

  1496. CARLA_BACKEND_END_NAMESPACE

  1497. 

  1498. #endif

  1499. 

  1500. CARLA_BACKEND_START_NAMESPACE

  1501. 

  1502. CarlaPlugin* CarlaPlugin::newLADSPA(const Initializer& init, const LADSPA_RDF_Descriptor* const rdfDescriptor)

  1503. {

  1504.     carla_debug("CarlaPlugin::newLADSPA({%p, \"%s\", \"%s\", \"%s\"}, %p)", init.engine, init.filename, init.name, init.label, rdfDescriptor);

  1505. 

  1506. #ifdef WANT_LADSPA

  1507.     LadspaPlugin* const plugin(new LadspaPlugin(init.engine, init.id));

  1508. 

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

  1510.     {

  1511.         delete plugin;

  1512.         return nullptr;

  1513.     }

  1514. 

  1515.     plugin->reload();

  1516. 

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

  1518.     {

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

  1520.         delete plugin;

  1521.         return nullptr;

  1522.     }

  1523. 

  1524.     return plugin;

  1525. #else

  1526.     init.engine->setLastError("LADSPA support not available");

  1527.     return nullptr;

  1528. #endif

  1529. }

  1530. 

  1531. CARLA_BACKEND_END_NAMESPACE