falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 43 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.
1831 Commits
17 Branches
166MB
Tree: 11c6945e54
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '11c6945e54'
${ noResults }
Carla/source/backend/plugin/LadspaPlugin.cpp

1706 lines
59KB
Raw Blame History 

  1. /*

  2.  * Carla LADSPA Plugin

  3.  * Copyright (C) 2011-2014 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_LADSPA

  22. 

  23. #include "CarlaLadspaUtils.hpp"

  24. #include "CarlaMathUtils.hpp"

  25. 

  26. // -----------------------------------------------------

  27. 

  28. CARLA_BACKEND_START_NAMESPACE

  29. 

  30. #if 0

  31. }

  32. #endif

  33. 

  34. // -----------------------------------------------------

  35. 

  36. class LadspaPlugin : public CarlaPlugin

  37. {

  38. public:

  39.     LadspaPlugin(CarlaEngine* const engine, const uint id) noexcept

  40.         : CarlaPlugin(engine, id),

  41.           fHandle(nullptr),

  42.           fHandle2(nullptr),

  43.           fDescriptor(nullptr),

  44.           fRdfDescriptor(nullptr),

  45.           fAudioInBuffers(nullptr),

  46.           fAudioOutBuffers(nullptr),

  47.           fParamBuffers(nullptr),

  48.           fLatencyIndex(-1)

  49.     {

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

  51.     }

  52. 

  53.     ~LadspaPlugin() noexcept override

  54.     {

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

  56. 

  57.         pData->singleMutex.lock();

  58.         pData->masterMutex.lock();

  59. 

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

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

  62. 

  63.         if (pData->active)

  64.         {

  65.             deactivate();

  66.             pData->active = false;

  67.         }

  68. 

  69.         if (fDescriptor != nullptr)

  70.         {

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

  72.             {

  73.                 if (fHandle != nullptr)

  74.                 {

  75.                     try {

  76.                         fDescriptor->cleanup(fHandle);

  77.                     } CARLA_SAFE_EXCEPTION("LADSPA cleanup");

  78.                 }

  79. 

  80.                 if (fHandle2 != nullptr)

  81.                 {

  82.                     try {

  83.                         fDescriptor->cleanup(fHandle2);

  84.                     } CARLA_SAFE_EXCEPTION("LADSPA cleanup #2");

  85.                 }

  86.             }

  87. 

  88.             fHandle     = nullptr;

  89.             fHandle2    = nullptr;

  90.             fDescriptor = nullptr;

  91.         }

  92. 

  93.         if (fRdfDescriptor != nullptr)

  94.         {

  95.             delete fRdfDescriptor;

  96.             fRdfDescriptor = nullptr;

  97.         }

  98. 

  99.         clearBuffers();

  100.     }

  101. 

  102.     // -------------------------------------------------------------------

  103.     // Information (base)

  104. 

  105.     PluginType getType() const noexcept override

  106.     {

  107.         return PLUGIN_LADSPA;

  108.     }

  109. 

  110.     PluginCategory getCategory() const noexcept override

  111.     {

  112.         if (fRdfDescriptor != nullptr)

  113.         {

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

  115. 

  116.             // Specific Types

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

  118.                 return PLUGIN_CATEGORY_DELAY;

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

  120.                 return PLUGIN_CATEGORY_MODULATOR;

  121.             if (category & (LADSPA_PLUGIN_AMPLIFIER))

  122.                 return PLUGIN_CATEGORY_DYNAMICS;

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

  124.                 return PLUGIN_CATEGORY_UTILITY;

  125. 

  126.             // Pre-set LADSPA Types

  127.             if (LADSPA_IS_PLUGIN_DYNAMICS(category))

  128.                 return PLUGIN_CATEGORY_DYNAMICS;

  129.             if (LADSPA_IS_PLUGIN_AMPLITUDE(category))

  130.                 return PLUGIN_CATEGORY_MODULATOR;

  131.             if (LADSPA_IS_PLUGIN_EQ(category))

  132.                 return PLUGIN_CATEGORY_EQ;

  133.             if (LADSPA_IS_PLUGIN_FILTER(category))

  134.                 return PLUGIN_CATEGORY_FILTER;

  135.             if (LADSPA_IS_PLUGIN_FREQUENCY(category))

  136.                 return PLUGIN_CATEGORY_UTILITY;

  137.             if (LADSPA_IS_PLUGIN_SIMULATOR(category))

  138.                 return PLUGIN_CATEGORY_OTHER;

  139.             if (LADSPA_IS_PLUGIN_TIME(category))

  140.                 return PLUGIN_CATEGORY_DELAY;

  141.             if (LADSPA_IS_PLUGIN_GENERATOR(category))

  142.                 return PLUGIN_CATEGORY_SYNTH;

  143.         }

  144. 

  145.         return CarlaPlugin::getCategory();

  146.     }

  147. 

  148.     int64_t getUniqueId() const noexcept override

  149.     {

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

  151. 

  152.         return static_cast<int64_t>(fDescriptor->UniqueID);

  153.     }

  154. 

  155.     // -------------------------------------------------------------------

  156.     // Information (count)

  157. 

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

  159.     {

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

  161. 

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

  163. 

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

  165.         {

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

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

  168.         }

  169. 

  170.         return 0;

  171.     }

  172. 

  173.     // -------------------------------------------------------------------

  174.     // Information (current data)

  175. 

  176.     // nothing

  177. 

  178.     // -------------------------------------------------------------------

  179.     // Information (per-plugin data)

  180. 

  181.     uint getOptionsAvailable() const noexcept override

  182.     {

  183. #ifdef __USE_GNU

  184.         const bool isDssiVst(strcasestr(pData->filename, "dssi-vst") != nullptr);

  185. #else

  186.         const bool isDssiVst(std::strstr(pData->filename, "dssi-vst") != nullptr);

  187. #endif

  188. 

  189.         uint options = 0x0;

  190. 

  191.         if (! isDssiVst)

  192.         {

  193.             if (fLatencyIndex == -1)

  194.                 options |= PLUGIN_OPTION_FIXED_BUFFERS;

  195. 

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

  197.             {

  198.                 if (pData->options & PLUGIN_OPTION_FORCE_STEREO)

  199.                     options |= PLUGIN_OPTION_FORCE_STEREO;

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

  201.                     options |= PLUGIN_OPTION_FORCE_STEREO;

  202.             }

  203.         }

  204. 

  205.         return options;

  206.     }

  207. 

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

  209.     {

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

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

  212. 

  213.         return fParamBuffers[parameterId];

  214.     }

  215. 

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

  217.     {

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

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

  220. 

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

  222. 

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

  224.         {

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

  226.             CARLA_SAFE_ASSERT_RETURN(scalePointId < port->ScalePointCount, 0.0f);

  227. 

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

  229.             return scalePoint->Value;

  230.         }

  231. 

  232.         return 0.0f;

  233.     }

  234. 

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

  236.     {

  237.         CARLA_SAFE_ASSERT_RETURN(fDescriptor        != nullptr, nullStrBuf(strBuf));

  238.         CARLA_SAFE_ASSERT_RETURN(fDescriptor->Label != nullptr, nullStrBuf(strBuf));

  239. 

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

  241.     }

  242. 

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

  244.     {

  245.         CARLA_SAFE_ASSERT_RETURN(fDescriptor        != nullptr, nullStrBuf(strBuf));

  246.         CARLA_SAFE_ASSERT_RETURN(fDescriptor->Maker != nullptr, nullStrBuf(strBuf));

  247. 

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

  249.         {

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

  251.             return;

  252.         }

  253. 

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

  255.     }

  256. 

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

  258.     {

  259.         CARLA_SAFE_ASSERT_RETURN(fDescriptor            != nullptr, nullStrBuf(strBuf));

  260.         CARLA_SAFE_ASSERT_RETURN(fDescriptor->Copyright != nullptr, nullStrBuf(strBuf));

  261. 

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

  263.     }

  264. 

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

  266.     {

  267.         CARLA_SAFE_ASSERT_RETURN(fDescriptor       != nullptr, nullStrBuf(strBuf));

  268.         CARLA_SAFE_ASSERT_RETURN(fDescriptor->Name != nullptr, nullStrBuf(strBuf));

  269. 

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

  271.         {

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

  273.             return;

  274.         }

  275. 

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

  277.     }

  278. 

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

  280.     {

  281.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,           nullStrBuf(strBuf));

  282.         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, nullStrBuf(strBuf));

  283. 

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

  285. 

  286.         CARLA_SAFE_ASSERT_RETURN(rindex < static_cast<int32_t>(fDescriptor->PortCount), nullStrBuf(strBuf));

  287.         CARLA_SAFE_ASSERT_RETURN(fDescriptor->PortNames[rindex] != nullptr,             nullStrBuf(strBuf));

  288. 

  289.         if (getSeparatedParameterNameOrUnit(fDescriptor->PortNames[rindex], strBuf, true))

  290.             return;

  291. 

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

  293.     }

  294. 

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

  296.     {

  297.         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, nullStrBuf(strBuf));

  298. 

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

  300. 

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

  302.         {

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

  304. 

  305.             if (LADSPA_PORT_HAS_LABEL(port->Hints))

  306.             {

  307.                 CARLA_SAFE_ASSERT_RETURN(port->Label != nullptr, nullStrBuf(strBuf));

  308. 

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

  310.                 return;

  311.             }

  312.         }

  313. 

  314.         nullStrBuf(strBuf);

  315.     }

  316. 

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

  318.     {

  319.         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, nullStrBuf(strBuf));

  320. 

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

  322. 

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

  324.         {

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

  326. 

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

  328.             {

  329.                 switch (port->Unit)

  330.                 {

  331.                 case LADSPA_UNIT_DB:

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

  333.                     return;

  334.                 case LADSPA_UNIT_COEF:

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

  336.                     return;

  337.                 case LADSPA_UNIT_HZ:

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

  339.                     return;

  340.                 case LADSPA_UNIT_S:

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

  342.                     return;

  343.                 case LADSPA_UNIT_MS:

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

  345.                     return;

  346.                 case LADSPA_UNIT_MIN:

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

  348.                     return;

  349.                 }

  350.             }

  351.         }

  352. 

  353.         if (getSeparatedParameterNameOrUnit(fDescriptor->PortNames[rindex], strBuf, false))

  354.             return;

  355. 

  356.         nullStrBuf(strBuf);

  357.     }

  358. 

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

  360.     {

  361.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr,        nullStrBuf(strBuf));

  362.         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, nullStrBuf(strBuf));

  363. 

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

  365. 

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

  367.         {

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

  369.             CARLA_SAFE_ASSERT_RETURN(scalePointId < port->ScalePointCount, nullStrBuf(strBuf));

  370. 

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

  372.             CARLA_SAFE_ASSERT_RETURN(scalePoint->Label != nullptr,         nullStrBuf(strBuf));

  373. 

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

  375.             return;

  376.         }

  377. 

  378.         nullStrBuf(strBuf);

  379.     }

  380. 

  381.     // -------------------------------------------------------------------

  382.     // Set data (state)

  383. 

  384.     // nothing

  385. 

  386.     // -------------------------------------------------------------------

  387.     // Set data (internal stuff)

  388. 

  389.     // nothing

  390. 

  391.     // -------------------------------------------------------------------

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

  393. 

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

  395.     {

  396.         CARLA_SAFE_ASSERT_RETURN(fParamBuffers != nullptr,);

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

  398. 

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

  400.         fParamBuffers[parameterId] = fixedValue;

  401. 

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

  403.     }

  404. 

  405.     // -------------------------------------------------------------------

  406.     // Set ui stuff

  407. 

  408.     // nothing

  409. 

  410.     // -------------------------------------------------------------------

  411.     // Plugin state

  412. 

  413.     void reload() override

  414.     {

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

  416.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  417.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

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

  419. 

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

  421. 

  422.         // Safely disable plugin for reload

  423.         const ScopedDisabler sd(this);

  424. 

  425.         if (pData->active)

  426.             deactivate();

  427. 

  428.         clearBuffers();

  429. 

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

  431.         const uint32_t portCount(getSafePortCount());

  432. 

  433.         uint32_t aIns, aOuts, params;

  434.         aIns = aOuts = params = 0;

  435. 

  436.         bool forcedStereoIn, forcedStereoOut;

  437.         forcedStereoIn = forcedStereoOut = false;

  438. 

  439.         bool needsCtrlIn, needsCtrlOut;

  440.         needsCtrlIn = needsCtrlOut = false;

  441. 

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

  443.         {

  444.             const LADSPA_PortDescriptor portType(fDescriptor->PortDescriptors[i]);

  445. 

  446.             if (LADSPA_IS_PORT_AUDIO(portType))

  447.             {

  448.                 if (LADSPA_IS_PORT_INPUT(portType))

  449.                     aIns += 1;

  450.                 else if (LADSPA_IS_PORT_OUTPUT(portType))

  451.                     aOuts += 1;

  452.             }

  453.             else if (LADSPA_IS_PORT_CONTROL(portType))

  454.                 params += 1;

  455.         }

  456. 

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

  458.         {

  459.             if (fHandle2 == nullptr)

  460.             {

  461.                 try {

  462.                     fHandle2 = fDescriptor->instantiate(fDescriptor, static_cast<ulong>(sampleRate));

  463.                 } CARLA_SAFE_EXCEPTION("LADSPA instantiate #2");

  464.             }

  465. 

  466.             if (fHandle2 != nullptr)

  467.             {

  468.                 if (aIns == 1)

  469.                 {

  470.                     aIns = 2;

  471.                     forcedStereoIn = true;

  472.                 }

  473. 

  474.                 if (aOuts == 1)

  475.                 {

  476.                     aOuts = 2;

  477.                     forcedStereoOut = true;

  478.                 }

  479.             }

  480.         }

  481. 

  482.         if (aIns > 0)

  483.         {

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

  485.             fAudioInBuffers = new float*[aIns];

  486. 

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

  488.                 fAudioInBuffers[i] = nullptr;

  489.         }

  490. 

  491.         if (aOuts > 0)

  492.         {

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

  494.             fAudioOutBuffers = new float*[aOuts];

  495.             needsCtrlIn = true;

  496. 

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

  498.                 fAudioOutBuffers[i] = nullptr;

  499.         }

  500. 

  501.         if (params > 0)

  502.         {

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

  504. 

  505.             fParamBuffers = new float[params];

  506.             FLOAT_CLEAR(fParamBuffers, params);

  507.         }

  508. 

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

  510.         CarlaString portName;

  511. 

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

  513.         {

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

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

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

  517. 

  518.             if (LADSPA_IS_PORT_AUDIO(portType))

  519.             {

  520.                 portName.clear();

  521. 

  522.                 if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  523.                 {

  524.                     portName  = pData->name;

  525.                     portName += ":";

  526.                 }

  527. 

  528.                 if (fDescriptor->PortNames[i] != nullptr && fDescriptor->PortNames[i][0] != '\0')

  529.                 {

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

  531.                 }

  532.                 else

  533.                 {

  534.                     if (LADSPA_IS_PORT_INPUT(portType))

  535.                     {

  536.                         if (aIns > 1)

  537.                         {

  538.                             portName += "audio-in_";

  539.                             portName += CarlaString(iAudioIn+1);

  540.                         }

  541.                         else

  542.                             portName += "audio-in";

  543.                     }

  544.                     else

  545.                     {

  546.                         if (aOuts > 1)

  547.                         {

  548.                             portName += "audio-out_";

  549.                             portName += CarlaString(iAudioOut+1);

  550.                         }

  551.                         else

  552.                             portName += "audio-out";

  553.                     }

  554.                 }

  555. 

  556.                 portName.truncate(portNameSize);

  557. 

  558.                 if (LADSPA_IS_PORT_INPUT(portType))

  559.                 {

  560.                     const uint32_t j = iAudioIn++;

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

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

  563. 

  564.                     if (forcedStereoIn)

  565.                     {

  566.                         portName += "_2";

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

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

  569.                     }

  570.                 }

  571.                 else if (LADSPA_IS_PORT_OUTPUT(portType))

  572.                 {

  573.                     const uint32_t j = iAudioOut++;

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

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

  576. 

  577.                     if (forcedStereoOut)

  578.                     {

  579.                         portName += "_2";

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

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

  582.                     }

  583.                 }

  584.                 else

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

  586.             }

  587.             else if (LADSPA_IS_PORT_CONTROL(portType))

  588.             {

  589.                 const uint32_t j = iCtrl++;

  590.                 pData->param.data[j].index  = static_cast<int32_t>(j);

  591.                 pData->param.data[j].rindex = static_cast<int32_t>(i);

  592. 

  593.                 const char* const paramName(fDescriptor->PortNames[i] != nullptr ? fDescriptor->PortNames[i] : "unknown");

  594. 

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

  596. 

  597.                 // min value

  598.                 if (LADSPA_IS_HINT_BOUNDED_BELOW(portRangeHints.HintDescriptor))

  599.                     min = portRangeHints.LowerBound;

  600.                 else

  601.                     min = 0.0f;

  602. 

  603.                 // max value

  604.                 if (LADSPA_IS_HINT_BOUNDED_ABOVE(portRangeHints.HintDescriptor))

  605.                     max = portRangeHints.UpperBound;

  606.                 else

  607.                     max = 1.0f;

  608. 

  609.                 if (min > max)

  610.                 {

  611.                     carla_stderr2("WARNING - Broken plugin parameter '%s': min > max", paramName);

  612.                     min = max - 0.1f;

  613.                 }

  614.                 else if (min == max)

  615.                 {

  616.                     carla_stderr2("WARNING - Broken plugin parameter '%s': min == maxf", paramName);

  617.                     max = min + 0.1f;

  618.                 }

  619. 

  620.                 // default value

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

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

  623.                 else

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

  625. 

  626.                 if (def < min)

  627.                     def = min;

  628.                 else if (def > max)

  629.                     def = max;

  630. 

  631.                 if (LADSPA_IS_HINT_SAMPLE_RATE(portRangeHints.HintDescriptor))

  632.                 {

  633.                     min *= sampleRate;

  634.                     max *= sampleRate;

  635.                     def *= sampleRate;

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

  637.                 }

  638. 

  639.                 if (LADSPA_IS_HINT_TOGGLED(portRangeHints.HintDescriptor))

  640.                 {

  641.                     step = max - min;

  642.                     stepSmall = step;

  643.                     stepLarge = step;

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

  645.                 }

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

  647.                 {

  648.                     step = 1.0f;

  649.                     stepSmall = 1.0f;

  650.                     stepLarge = 10.0f;

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

  652.                 }

  653.                 else

  654.                 {

  655.                     const float range = max - min;

  656.                     step = range/100.0f;

  657.                     stepSmall = range/1000.0f;

  658.                     stepLarge = range/10.0f;

  659.                 }

  660. 

  661.                 if (LADSPA_IS_PORT_INPUT(portType))

  662.                 {

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

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

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

  666.                     needsCtrlIn = true;

  667.                 }

  668.                 else if (LADSPA_IS_PORT_OUTPUT(portType))

  669.                 {

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

  671. 

  672.                     if (std::strcmp(paramName, "latency") == 0 || std::strcmp(paramName, "_latency") == 0)

  673.                     {

  674.                         min = 0.0f;

  675.                         max = sampleRate;

  676.                         def = 0.0f;

  677.                         step = 1.0f;

  678.                         stepSmall = 1.0f;

  679.                         stepLarge = 1.0f;

  680.                         fLatencyIndex = static_cast<int32_t>(j);

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

  682.                     }

  683.                     else

  684.                     {

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

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

  687.                         needsCtrlOut = true;

  688.                     }

  689.                 }

  690.                 else

  691.                 {

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

  693.                 }

  694. 

  695.                 // extra parameter hints

  696.                 if (LADSPA_IS_HINT_LOGARITHMIC(portRangeHints.HintDescriptor))

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

  698. 

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

  700.                 if (hasPortRDF && fRdfDescriptor->Ports[i].ScalePointCount >= 2)

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

  702. 

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

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

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

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

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

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

  709. 

  710.                 // Start parameters in their default values

  711.                 fParamBuffers[j] = def;

  712. 

  713.                 try {

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

  715.                 } CARLA_SAFE_EXCEPTION("LADSPA connect_port parameter");

  716. 

  717.                 if (fHandle2 != nullptr)

  718.                 {

  719.                     try {

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

  721.                     } CARLA_SAFE_EXCEPTION("LADSPA connect_port parameter #2");

  722.                 }

  723.             }

  724.             else

  725.             {

  726.                 // Not Audio or Control

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

  728. 

  729.                 try {

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

  731.                 } CARLA_SAFE_EXCEPTION("LADSPA connect_port null");

  732. 

  733.                 if (fHandle2 != nullptr)

  734.                 {

  735.                     try {

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

  737.                     } CARLA_SAFE_EXCEPTION("LADSPA connect_port null #2");

  738.                 }

  739.             }

  740.         }

  741. 

  742.         if (needsCtrlIn)

  743.         {

  744.             portName.clear();

  745. 

  746.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  747.             {

  748.                 portName  = pData->name;

  749.                 portName += ":";

  750.             }

  751. 

  752.             portName += "events-in";

  753.             portName.truncate(portNameSize);

  754. 

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

  756.         }

  757. 

  758.         if (needsCtrlOut)

  759.         {

  760.             portName.clear();

  761. 

  762.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  763.             {

  764.                 portName  = pData->name;

  765.                 portName += ":";

  766.             }

  767. 

  768.             portName += "events-out";

  769.             portName.truncate(portNameSize);

  770. 

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

  772.         }

  773. 

  774.         if (forcedStereoIn || forcedStereoOut)

  775.             pData->options |= PLUGIN_OPTION_FORCE_STEREO;

  776.         else

  777.             pData->options &= ~PLUGIN_OPTION_FORCE_STEREO;

  778. 

  779.         // plugin hints

  780.         pData->hints = 0x0;

  781. 

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

  783.             pData->hints |= PLUGIN_IS_RTSAFE;

  784. 

  785. #ifndef BUILD_BRIDGE

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

  787.             pData->hints |= PLUGIN_CAN_DRYWET;

  788. 

  789.         if (aOuts > 0)

  790.             pData->hints |= PLUGIN_CAN_VOLUME;

  791. 

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

  793.             pData->hints |= PLUGIN_CAN_BALANCE;

  794. #endif

  795. 

  796.         // extra plugin hints

  797.         pData->extraHints = 0x0;

  798. 

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

  800.             pData->extraHints |= PLUGIN_EXTRA_HINT_CAN_RUN_RACK;

  801. 

  802.         // check latency

  803.         if (fLatencyIndex >= 0)

  804.         {

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

  806. 

  807.             float tmpIn[aIns][2];

  808.             float tmpOut[aOuts][2];

  809. 

  810.             for (uint32_t j=0; j < aIns; ++j)

  811.             {

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

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

  814. 

  815.                 try {

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

  817.                 } CARLA_SAFE_EXCEPTION("LADSPA connect_port latency input");

  818.             }

  819. 

  820.             for (uint32_t j=0; j < aOuts; ++j)

  821.             {

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

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

  824. 

  825.                 try {

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

  827.                 } CARLA_SAFE_EXCEPTION("LADSPA connect_port latency output");

  828.             }

  829. 

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

  831.             {

  832.                 try {

  833.                     fDescriptor->activate(fHandle);

  834.                 } CARLA_SAFE_EXCEPTION("LADSPA latency activate");

  835.             }

  836. 

  837.             try {

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

  839.             } CARLA_SAFE_EXCEPTION("LADSPA latency run");

  840. 

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

  842.             {

  843.                 try {

  844.                     fDescriptor->deactivate(fHandle);

  845.                 } CARLA_SAFE_EXCEPTION("LADSPA latency deactivate");

  846.             }

  847. 

  848.             const int32_t latency(static_cast<int32_t>(fParamBuffers[fLatencyIndex]));

  849. 

  850.             if (latency >= 0)

  851.             {

  852.                 const uint32_t ulatency(static_cast<uint32_t>(latency));

  853. 

  854.                 if (pData->latency != ulatency)

  855.                 {

  856.                     pData->latency = ulatency;

  857.                     pData->client->setLatency(ulatency);

  858.                     carla_stdout("latency = %i", latency);

  859. #ifndef BUILD_BRIDGE

  860.                     pData->recreateLatencyBuffers();

  861. #endif

  862.                 }

  863.             }

  864.             else

  865.                 carla_safe_assert_int("latency >= 0", __FILE__, __LINE__, latency);

  866.         }

  867. 

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

  869. 

  870.         if (pData->active)

  871.             activate();

  872. 

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

  874.     }

  875. 

  876.     // -------------------------------------------------------------------

  877.     // Plugin processing

  878. 

  879.     void activate() noexcept override

  880.     {

  881.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  882.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  883. 

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

  885.         {

  886.             try {

  887.                 fDescriptor->activate(fHandle);

  888.             } CARLA_SAFE_EXCEPTION("LADSPA activate");

  889. 

  890.             if (fHandle2 != nullptr)

  891.             {

  892.                 try {

  893.                     fDescriptor->activate(fHandle2);

  894.                 } CARLA_SAFE_EXCEPTION("LADSPA activate #2");

  895.             }

  896.         }

  897.     }

  898. 

  899.     void deactivate() noexcept override

  900.     {

  901.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  902.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  903. 

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

  905.         {

  906.             try {

  907.                 fDescriptor->deactivate(fHandle);

  908.             } CARLA_SAFE_EXCEPTION("LADSPA deactivate");

  909. 

  910.             if (fHandle2 != nullptr)

  911.             {

  912.                 try {

  913.                     fDescriptor->deactivate(fHandle2);

  914.                 } CARLA_SAFE_EXCEPTION("LADSPA deactivate #2");

  915.             }

  916.         }

  917.     }

  918. 

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

  920.     {

  921.         // --------------------------------------------------------------------------------------------------------

  922.         // Check if active

  923. 

  924.         if (! pData->active)

  925.         {

  926.             // disable any output sound

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

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

  929.             return;

  930.         }

  931. 

  932.         // --------------------------------------------------------------------------------------------------------

  933.         // Check if needs reset

  934. 

  935.         if (pData->needsReset)

  936.         {

  937. #ifndef BUILD_BRIDGE

  938.             if (pData->latency > 0)

  939.             {

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

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

  942.             }

  943. #endif

  944. 

  945.             pData->needsReset = false;

  946.         }

  947. 

  948.         // --------------------------------------------------------------------------------------------------------

  949.         // Event Input and Processing

  950. 

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

  952.         {

  953.             // ----------------------------------------------------------------------------------------------------

  954.             // Event Input (System)

  955. 

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

  957. 

  958.             uint32_t numEvents  = pData->event.portIn->getEventCount();

  959.             uint32_t timeOffset = 0;

  960. 

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

  962.             {

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

  964. 

  965.                 if (event.time >= frames)

  966.                     continue;

  967. 

  968.                 CARLA_ASSERT_INT2(event.time >= timeOffset, event.time, timeOffset);

  969. 

  970.                 if (isSampleAccurate && event.time > timeOffset)

  971.                 {

  972.                     if (processSingle(inBuffer, outBuffer, event.time - timeOffset, timeOffset))

  973.                         timeOffset = event.time;

  974.                 }

  975. 

  976.                 switch (event.type)

  977.                 {

  978.                 case kEngineEventTypeNull:

  979.                     break;

  980. 

  981.                 case kEngineEventTypeControl: {

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

  983. 

  984.                     switch (ctrlEvent.type)

  985.                     {

  986.                     case kEngineControlEventTypeNull:

  987.                         break;

  988. 

  989.                     case kEngineControlEventTypeParameter: {

  990. #ifndef BUILD_BRIDGE

  991.                         // Control backend stuff

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

  993.                         {

  994.                             float value;

  995. 

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

  997.                             {

  998.                                 value = ctrlEvent.value;

  999.                                 setDryWet(value, false, false);

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

  1001.                                 break;

  1002.                             }

  1003. 

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

  1005.                             {

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

  1007.                                 setVolume(value, false, false);

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

  1009.                                 break;

  1010.                             }

  1011. 

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

  1013.                             {

  1014.                                 float left, right;

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

  1016. 

  1017.                                 if (value < 0.0f)

  1018.                                 {

  1019.                                     left  = -1.0f;

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

  1021.                                 }

  1022.                                 else if (value > 0.0f)

  1023.                                 {

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

  1025.                                     right = 1.0f;

  1026.                                 }

  1027.                                 else

  1028.                                 {

  1029.                                     left  = -1.0f;

  1030.                                     right = 1.0f;

  1031.                                 }

  1032. 

  1033.                                 setBalanceLeft(left, false, false);

  1034.                                 setBalanceRight(right, false, false);

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

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

  1037.                                 break;

  1038.                             }

  1039.                         }

  1040. #endif

  1041. 

  1042.                         // Control plugin parameters

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

  1044.                         {

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

  1046.                                 continue;

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

  1048.                                 continue;

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

  1050.                                 continue;

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

  1052.                                 continue;

  1053. 

  1054.                             float value;

  1055. 

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

  1057.                             {

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

  1059.                             }

  1060.                             else

  1061.                             {

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

  1063. 

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

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

  1066.                             }

  1067. 

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

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

  1070.                             break;

  1071.                         }

  1072. 

  1073.                         break;

  1074.                     } // case kEngineControlEventTypeParameter

  1075. 

  1076.                     case kEngineControlEventTypeMidiBank:

  1077.                     case kEngineControlEventTypeMidiProgram:

  1078.                     case kEngineControlEventTypeAllSoundOff:

  1079.                     case kEngineControlEventTypeAllNotesOff:

  1080.                         break;

  1081.                     } // switch (ctrlEvent.type)

  1082.                     break;

  1083.                 } // case kEngineEventTypeControl

  1084. 

  1085.                 case kEngineEventTypeMidi:

  1086.                     break;

  1087.                 } // switch (event.type)

  1088.             }

  1089. 

  1090.             pData->postRtEvents.trySplice();

  1091. 

  1092.             if (frames > timeOffset)

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

  1094. 

  1095.         } // End of Event Input and Processing

  1096. 

  1097.         // --------------------------------------------------------------------------------------------------------

  1098.         // Plugin processing (no events)

  1099. 

  1100.         else

  1101.         {

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

  1103. 

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

  1105. 

  1106.         // --------------------------------------------------------------------------------------------------------

  1107.         // Latency, save values for next callback

  1108. 

  1109.         if (pData->latency > 0)

  1110.         {

  1111.             if (pData->latency <= frames)

  1112.             {

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

  1114.                     FLOAT_COPY(pData->latencyBuffers[i], inBuffer[i]+(frames-pData->latency), pData->latency);

  1115.             }

  1116.             else

  1117.             {

  1118.                 for (uint32_t i=0, j, k; i < pData->audioIn.count; ++i)

  1119.                 {

  1120.                     for (k=0; k < pData->latency-frames; ++k)

  1121.                         pData->latencyBuffers[i][k] = pData->latencyBuffers[i][k+frames];

  1122.                     for (j=0; k < pData->latency; ++j, ++k)

  1123.                         pData->latencyBuffers[i][k] = inBuffer[i][j];

  1124.                 }

  1125.             }

  1126.         }

  1127. 

  1128.         // --------------------------------------------------------------------------------------------------------

  1129.         // Control Output

  1130. 

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

  1132.         {

  1133.             uint8_t  channel;

  1134.             uint16_t param;

  1135.             float    value;

  1136. 

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

  1138.             {

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

  1140.                     continue;

  1141. 

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

  1143. 

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

  1145.                 {

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

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

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

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

  1150.                 }

  1151.             }

  1152.         } // End of Control Output

  1153.     }

  1154. 

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

  1156.     {

  1157.         CARLA_SAFE_ASSERT_RETURN(frames > 0, false);

  1158. 

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

  1160.         {

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

  1162.         }

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

  1164.         {

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

  1166.         }

  1167. 

  1168.         // --------------------------------------------------------------------------------------------------------

  1169.         // Try lock, silence otherwise

  1170. 

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

  1172.         {

  1173.             pData->singleMutex.lock();

  1174.         }

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

  1176.         {

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

  1178.             {

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

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

  1181.             }

  1182. 

  1183.             return false;

  1184.         }

  1185. 

  1186.         // --------------------------------------------------------------------------------------------------------

  1187.         // Reset audio buffers

  1188. 

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

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

  1191. 

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

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

  1194. 

  1195.         // --------------------------------------------------------------------------------------------------------

  1196.         // Run plugin

  1197. 

  1198.         try {

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

  1200.         } CARLA_SAFE_EXCEPTION("LADSPA run");

  1201. 

  1202.         if (fHandle2 != nullptr)

  1203.         {

  1204.             try {

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

  1206.             } CARLA_SAFE_EXCEPTION("LADSPA run #2");

  1207.         }

  1208. 

  1209. #ifndef BUILD_BRIDGE

  1210.         // --------------------------------------------------------------------------------------------------------

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

  1212. 

  1213.         {

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

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

  1216.             const bool isMono    = (pData->audioIn.count == 1);

  1217. 

  1218.             bool isPair;

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

  1220. 

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

  1222.             {

  1223.                 // Dry/Wet

  1224.                 if (doDryWet)

  1225.                 {

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

  1227.                     {

  1228.                         if (k < pData->latency)

  1229.                             bufValue = pData->latencyBuffers[isMono ? 0 : i][k];

  1230.                         else if (pData->latency < frames)

  1231.                             bufValue = fAudioInBuffers[isMono ? 0 : i][k-pData->latency];

  1232.                         else

  1233.                             bufValue = fAudioInBuffers[isMono ? 0 : i][k];

  1234. 

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

  1236.                     }

  1237.                 }

  1238. 

  1239.                 // Balance

  1240.                 if (doBalance)

  1241.                 {

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

  1243. 

  1244.                     if (isPair)

  1245.                     {

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

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

  1248.                     }

  1249. 

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

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

  1252. 

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

  1254.                     {

  1255.                         if (isPair)

  1256.                         {

  1257.                             // left

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

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

  1260.                         }

  1261.                         else

  1262.                         {

  1263.                             // right

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

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

  1266.                         }

  1267.                     }

  1268.                 }

  1269. 

  1270.                 // Volume (and buffer copy)

  1271.                 {

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

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

  1274.                 }

  1275.             }

  1276. 

  1277.         } // End of Post-processing

  1278. 

  1279. #else // BUILD_BRIDGE

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

  1281.         {

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

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

  1284.         }

  1285. #endif

  1286. 

  1287.         // --------------------------------------------------------------------------------------------------------

  1288. 

  1289.         pData->singleMutex.unlock();

  1290.         return true;

  1291.     }

  1292. 

  1293.     void bufferSizeChanged(const uint32_t newBufferSize) override

  1294.     {

  1295.         CARLA_ASSERT_INT(newBufferSize > 0, newBufferSize);

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

  1297. 

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

  1299.         {

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

  1301.                 delete[] fAudioInBuffers[i];

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

  1303.         }

  1304. 

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

  1306.         {

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

  1308.                 delete[] fAudioOutBuffers[i];

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

  1310.         }

  1311. 

  1312.         if (fHandle2 == nullptr)

  1313.         {

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

  1315.             {

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

  1317. 

  1318.                 try {

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

  1320.                 } CARLA_SAFE_EXCEPTION("LADSPA connect_port audio input");

  1321.             }

  1322. 

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

  1324.             {

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

  1326. 

  1327.                 try {

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

  1329.                 } CARLA_SAFE_EXCEPTION("LADSPA connect_port audio output");

  1330.             }

  1331.         }

  1332.         else

  1333.         {

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

  1335.             {

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

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

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

  1339. 

  1340.                 try {

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

  1342.                 } CARLA_SAFE_EXCEPTION("LADSPA connect_port audio input #1");

  1343. 

  1344.                 try {

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

  1346.                 } CARLA_SAFE_EXCEPTION("LADSPA connect_port audio input #2");

  1347.             }

  1348. 

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

  1350.             {

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

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

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

  1354. 

  1355.                 try {

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

  1357.                 } CARLA_SAFE_EXCEPTION("LADSPA connect_port audio output #1");

  1358. 

  1359.                 try {

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

  1361.                 } CARLA_SAFE_EXCEPTION("LADSPA connect_port audio output #2");

  1362.             }

  1363.         }

  1364. 

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

  1366.     }

  1367. 

  1368.     void sampleRateChanged(const double newSampleRate) override

  1369.     {

  1370.         CARLA_ASSERT_INT(newSampleRate > 0.0, newSampleRate);

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

  1372. 

  1373.         // TODO

  1374.         (void)newSampleRate;

  1375. 

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

  1377.     }

  1378. 

  1379.     // -------------------------------------------------------------------

  1380.     // Plugin buffers

  1381. 

  1382.     void clearBuffers() noexcept override

  1383.     {

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

  1385. 

  1386.         if (fAudioInBuffers != nullptr)

  1387.         {

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

  1389.             {

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

  1391.                 {

  1392.                     delete[] fAudioInBuffers[i];

  1393.                     fAudioInBuffers[i] = nullptr;

  1394.                 }

  1395.             }

  1396. 

  1397.             delete[] fAudioInBuffers;

  1398.             fAudioInBuffers = nullptr;

  1399.         }

  1400. 

  1401.         if (fAudioOutBuffers != nullptr)

  1402.         {

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

  1404.             {

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

  1406.                 {

  1407.                     delete[] fAudioOutBuffers[i];

  1408.                     fAudioOutBuffers[i] = nullptr;

  1409.                 }

  1410.             }

  1411. 

  1412.             delete[] fAudioOutBuffers;

  1413.             fAudioOutBuffers = nullptr;

  1414.         }

  1415. 

  1416.         if (fParamBuffers != nullptr)

  1417.         {

  1418.             delete[] fParamBuffers;

  1419.             fParamBuffers = nullptr;

  1420.         }

  1421. 

  1422.         CarlaPlugin::clearBuffers();

  1423. 

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

  1425.     }

  1426. 

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

  1428. 

  1429.     const void* getExtraStuff() const noexcept override

  1430.     {

  1431.         return fRdfDescriptor;

  1432.     }

  1433. 

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

  1435.     {

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

  1437. 

  1438.         // ---------------------------------------------------------------

  1439.         // first checks

  1440. 

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

  1442.         {

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

  1444.             return false;

  1445.         }

  1446. 

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

  1448.         {

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

  1450.             return false;

  1451.         }

  1452. 

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

  1454.         {

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

  1456.             return false;

  1457.         }

  1458. 

  1459.         // ---------------------------------------------------------------

  1460.         // open DLL

  1461. 

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

  1463.         {

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

  1465.             return false;

  1466.         }

  1467. 

  1468.         // ---------------------------------------------------------------

  1469.         // get DLL main entry

  1470. 

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

  1472. 

  1473.         if (descFn == nullptr)

  1474.         {

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

  1476.             return false;

  1477.         }

  1478. 

  1479.         // ---------------------------------------------------------------

  1480.         // get descriptor that matches label

  1481. 

  1482.         ulong i = 0;

  1483. 

  1484.         for (;;)

  1485.         {

  1486.             try {

  1487.                 fDescriptor = descFn(i++);

  1488.             }

  1489.             catch(...) {

  1490.                 carla_stderr2("Caught exception when trying to get LADSPA descriptor");

  1491.                 fDescriptor = nullptr;

  1492.                 break;

  1493.             }

  1494. 

  1495.             if (fDescriptor == nullptr)

  1496.                 break;

  1497. 

  1498.             if (fDescriptor->Label == nullptr || fDescriptor->Label[0] == '\0')

  1499.             {

  1500.                 carla_stderr2("WARNING - Got an invalid label, will not use this plugin");

  1501.                 fDescriptor = nullptr;

  1502.                 break;

  1503.             }

  1504.             if (fDescriptor->run == nullptr)

  1505.             {

  1506.                 carla_stderr2("WARNING - Plugin has no run, cannot use it");

  1507.                 fDescriptor = nullptr;

  1508.                 break;

  1509.             }

  1510. 

  1511.             if (std::strcmp(fDescriptor->Label, label) == 0)

  1512.                 break;

  1513.         }

  1514. 

  1515.         if (fDescriptor == nullptr)

  1516.         {

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

  1518.             return false;

  1519.         }

  1520. 

  1521.         // ---------------------------------------------------------------

  1522.         // get info

  1523. 

  1524.         if (is_ladspa_rdf_descriptor_valid(rdfDescriptor, fDescriptor))

  1525.             fRdfDescriptor = ladspa_rdf_dup(rdfDescriptor);

  1526. 

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

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

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

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

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

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

  1533.         else

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

  1535. 

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

  1537. 

  1538.         // ---------------------------------------------------------------

  1539.         // register client

  1540. 

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

  1542. 

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

  1544.         {

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

  1546.             return false;

  1547.         }

  1548. 

  1549.         // ---------------------------------------------------------------

  1550.         // initialize plugin

  1551. 

  1552.         try {

  1553.             fHandle = fDescriptor->instantiate(fDescriptor, static_cast<ulong>(pData->engine->getSampleRate()));

  1554.         } CARLA_SAFE_EXCEPTION("LADSPA instantiate");

  1555. 

  1556.         if (fHandle == nullptr)

  1557.         {

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

  1559.             return false;

  1560.         }

  1561. 

  1562.         // ---------------------------------------------------------------

  1563.         // load plugin settings

  1564. 

  1565.         {

  1566. #ifdef __USE_GNU

  1567.             const bool isDssiVst(strcasestr(pData->filename, "dssi-vst") != nullptr);

  1568. #else

  1569.             const bool isDssiVst(std::strstr(pData->filename, "dssi-vst") != nullptr);

  1570. #endif

  1571. 

  1572.             // set default options

  1573.             pData->options = 0x0;

  1574. 

  1575.             if (fLatencyIndex >= 0 || isDssiVst)

  1576.                 pData->options |= PLUGIN_OPTION_FIXED_BUFFERS;

  1577. 

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

  1579.                 pData->options |= PLUGIN_OPTION_FORCE_STEREO;

  1580. 

  1581. #ifndef BUILD_BRIDGE

  1582.             // set identifier string

  1583.             CarlaString identifier("LADSPA/");

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

  1585.             identifier += ",";

  1586.             identifier += label;

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

  1588. 

  1589.             // load settings

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

  1591. 

  1592.             // ignore settings, we need this anyway

  1593.             if (fLatencyIndex >= 0 || isDssiVst)

  1594.                 pData->options |= PLUGIN_OPTION_FIXED_BUFFERS;

  1595. #endif

  1596.         }

  1597. 

  1598.         return true;

  1599.     }

  1600. 

  1601.     // -------------------------------------------------------------------

  1602. 

  1603. private:

  1604.     LADSPA_Handle fHandle;

  1605.     LADSPA_Handle fHandle2;

  1606.     const LADSPA_Descriptor*     fDescriptor;

  1607.     const LADSPA_RDF_Descriptor* fRdfDescriptor;

  1608. 

  1609.     float** fAudioInBuffers;

  1610.     float** fAudioOutBuffers;

  1611.     float*  fParamBuffers;

  1612.     int32_t fLatencyIndex; // -1 if invalid

  1613. 

  1614.     uint32_t getSafePortCount() const noexcept

  1615.     {

  1616.         if (fDescriptor->PortCount == 0)

  1617.             return 0;

  1618. 

  1619.         CARLA_SAFE_ASSERT_RETURN(fDescriptor->PortDescriptors != nullptr, 0);

  1620.         CARLA_SAFE_ASSERT_RETURN(fDescriptor->PortRangeHints != nullptr, 0);

  1621.         CARLA_SAFE_ASSERT_RETURN(fDescriptor->PortNames != nullptr, 0);

  1622. 

  1623.         return static_cast<uint32_t>(fDescriptor->PortCount);

  1624.     }

  1625. 

  1626.     bool getSeparatedParameterNameOrUnit(const char* const paramName, char* const strBuf, const bool wantName) const noexcept

  1627.     {

  1628.         const char* const sepBracketStart = std::strstr(paramName, " [");

  1629. 

  1630.         if (sepBracketStart == nullptr)

  1631.             return false;

  1632. 

  1633.         const char* const sepBracketEnd = std::strstr(sepBracketStart, "]");

  1634. 

  1635.         if (sepBracketEnd == nullptr)

  1636.             return false;

  1637. 

  1638.         const size_t unitSize = static_cast<size_t>(sepBracketEnd-sepBracketStart-2);

  1639. 

  1640.         if (unitSize > 4) // very unlikely to have such big unit

  1641.             return false;

  1642. 

  1643.         const size_t sepIndex(std::strlen(paramName) - unitSize - 3);

  1644. 

  1645.         // just in case

  1646.         if (sepIndex > STR_MAX)

  1647.             return false;

  1648. 

  1649.         if (wantName)

  1650.         {

  1651.             std::strncpy(strBuf, paramName, sepIndex);

  1652.             strBuf[sepIndex] = '\0';

  1653.         }

  1654.         else

  1655.         {

  1656.             std::strncpy(strBuf, paramName+(sepIndex+2), unitSize);

  1657.             strBuf[unitSize] = '\0';

  1658.         }

  1659. 

  1660.         return true;

  1661.     }

  1662. 

  1663.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(LadspaPlugin)

  1664. };

  1665. 

  1666. CARLA_BACKEND_END_NAMESPACE

  1667. 

  1668. #endif // WANT_LADSPA

  1669. 

  1670. // -------------------------------------------------------------------------------------------------------------------

  1671. 

  1672. CARLA_BACKEND_START_NAMESPACE

  1673. 

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

  1675. {

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

  1677. 

  1678. #ifdef WANT_LADSPA

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

  1680. 

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

  1682.     {

  1683.         delete plugin;

  1684.         return nullptr;

  1685.     }

  1686. 

  1687.     plugin->reload();

  1688. 

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

  1690.     {

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

  1692.         delete plugin;

  1693.         return nullptr;

  1694.     }

  1695. 

  1696.     return plugin;

  1697. #else

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

  1699.     return nullptr;

  1700. #endif

  1701. }

  1702. 

  1703. CARLA_BACKEND_END_NAMESPACE

  1704. 

  1705. // -------------------------------------------------------------------------------------------------------------------