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

1746 lines
60KB
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.         CARLA_SAFE_ASSERT_RETURN(rindex < static_cast<int32_t>(fDescriptor->PortCount), nullStrBuf(strBuf));

  354. 

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

  356.             return;

  357. 

  358.         nullStrBuf(strBuf);

  359.     }

  360. 

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

  362.     {

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

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

  365. 

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

  367. 

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

  369.         {

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

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

  372. 

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

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

  375. 

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

  377.             return;

  378.         }

  379. 

  380.         nullStrBuf(strBuf);

  381.     }

  382. 

  383.     // -------------------------------------------------------------------

  384.     // Set data (state)

  385. 

  386.     // nothing

  387. 

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

  389.     // Set data (internal stuff)

  390. 

  391.     // nothing

  392. 

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

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

  395. 

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

  397.     {

  398.         CARLA_SAFE_ASSERT_RETURN(fParamBuffers != nullptr,);

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

  400. 

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

  402.         fParamBuffers[parameterId] = fixedValue;

  403. 

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

  405.     }

  406. 

  407.     // -------------------------------------------------------------------

  408.     // Set ui stuff

  409. 

  410.     // nothing

  411. 

  412.     // -------------------------------------------------------------------

  413.     // Plugin state

  414. 

  415.     void reload() override

  416.     {

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

  418.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  419.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

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

  421. 

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

  423. 

  424.         // Safely disable plugin for reload

  425.         const ScopedDisabler sd(this);

  426. 

  427.         if (pData->active)

  428.             deactivate();

  429. 

  430.         clearBuffers();

  431. 

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

  433.         const uint32_t portCount(getSafePortCount());

  434. 

  435.         uint32_t aIns, aOuts, params;

  436.         aIns = aOuts = params = 0;

  437. 

  438.         bool forcedStereoIn, forcedStereoOut;

  439.         forcedStereoIn = forcedStereoOut = false;

  440. 

  441.         bool needsCtrlIn, needsCtrlOut;

  442.         needsCtrlIn = needsCtrlOut = false;

  443. 

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

  445.         {

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

  447. 

  448.             if (LADSPA_IS_PORT_AUDIO(portType))

  449.             {

  450.                 if (LADSPA_IS_PORT_INPUT(portType))

  451.                     aIns += 1;

  452.                 else if (LADSPA_IS_PORT_OUTPUT(portType))

  453.                     aOuts += 1;

  454.             }

  455.             else if (LADSPA_IS_PORT_CONTROL(portType))

  456.                 params += 1;

  457.         }

  458. 

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

  460.         {

  461.             if (fHandle2 == nullptr)

  462.             {

  463.                 try {

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

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

  466.             }

  467. 

  468.             if (fHandle2 != nullptr)

  469.             {

  470.                 if (aIns == 1)

  471.                 {

  472.                     aIns = 2;

  473.                     forcedStereoIn = true;

  474.                 }

  475. 

  476.                 if (aOuts == 1)

  477.                 {

  478.                     aOuts = 2;

  479.                     forcedStereoOut = true;

  480.                 }

  481.             }

  482.         }

  483. 

  484.         if (aIns > 0)

  485.         {

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

  487.             fAudioInBuffers = new float*[aIns];

  488. 

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

  490.                 fAudioInBuffers[i] = nullptr;

  491.         }

  492. 

  493.         if (aOuts > 0)

  494.         {

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

  496.             fAudioOutBuffers = new float*[aOuts];

  497.             needsCtrlIn = true;

  498. 

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

  500.                 fAudioOutBuffers[i] = nullptr;

  501.         }

  502. 

  503.         if (params > 0)

  504.         {

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

  506. 

  507.             fParamBuffers = new float[params];

  508.             FLOAT_CLEAR(fParamBuffers, params);

  509.         }

  510. 

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

  512.         CarlaString portName;

  513. 

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

  515.         {

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

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

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

  519. 

  520.             if (LADSPA_IS_PORT_AUDIO(portType))

  521.             {

  522.                 portName.clear();

  523. 

  524.                 if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  525.                 {

  526.                     portName  = pData->name;

  527.                     portName += ":";

  528.                 }

  529. 

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

  531.                 {

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

  533.                 }

  534.                 else

  535.                 {

  536.                     if (LADSPA_IS_PORT_INPUT(portType))

  537.                     {

  538.                         if (aIns > 1)

  539.                         {

  540.                             portName += "audio-in_";

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

  542.                         }

  543.                         else

  544.                             portName += "audio-in";

  545.                     }

  546.                     else

  547.                     {

  548.                         if (aOuts > 1)

  549.                         {

  550.                             portName += "audio-out_";

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

  552.                         }

  553.                         else

  554.                             portName += "audio-out";

  555.                     }

  556.                 }

  557. 

  558.                 portName.truncate(portNameSize);

  559. 

  560.                 if (LADSPA_IS_PORT_INPUT(portType))

  561.                 {

  562.                     const uint32_t j = iAudioIn++;

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

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

  565. 

  566.                     if (forcedStereoIn)

  567.                     {

  568.                         portName += "_2";

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

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

  571.                     }

  572.                 }

  573.                 else if (LADSPA_IS_PORT_OUTPUT(portType))

  574.                 {

  575.                     const uint32_t j = iAudioOut++;

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

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

  578. 

  579.                     if (forcedStereoOut)

  580.                     {

  581.                         portName += "_2";

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

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

  584.                     }

  585.                 }

  586.                 else

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

  588.             }

  589.             else if (LADSPA_IS_PORT_CONTROL(portType))

  590.             {

  591.                 const uint32_t j = iCtrl++;

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

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

  594. 

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

  596. 

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

  598. 

  599.                 // min value

  600.                 if (LADSPA_IS_HINT_BOUNDED_BELOW(portRangeHints.HintDescriptor))

  601.                     min = portRangeHints.LowerBound;

  602.                 else

  603.                     min = 0.0f;

  604. 

  605.                 // max value

  606.                 if (LADSPA_IS_HINT_BOUNDED_ABOVE(portRangeHints.HintDescriptor))

  607.                     max = portRangeHints.UpperBound;

  608.                 else

  609.                     max = 1.0f;

  610. 

  611.                 if (min > max)

  612.                 {

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

  614.                     min = max - 0.1f;

  615.                 }

  616.                 else if (min == max)

  617.                 {

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

  619.                     max = min + 0.1f;

  620.                 }

  621. 

  622.                 // default value

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

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

  625.                 else

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

  627. 

  628.                 if (def < min)

  629.                     def = min;

  630.                 else if (def > max)

  631.                     def = max;

  632. 

  633.                 if (LADSPA_IS_HINT_SAMPLE_RATE(portRangeHints.HintDescriptor))

  634.                 {

  635.                     min *= sampleRate;

  636.                     max *= sampleRate;

  637.                     def *= sampleRate;

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

  639.                 }

  640. 

  641.                 if (LADSPA_IS_HINT_TOGGLED(portRangeHints.HintDescriptor))

  642.                 {

  643.                     step = max - min;

  644.                     stepSmall = step;

  645.                     stepLarge = step;

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

  647.                 }

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

  649.                 {

  650.                     step = 1.0f;

  651.                     stepSmall = 1.0f;

  652.                     stepLarge = 10.0f;

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

  654.                 }

  655.                 else

  656.                 {

  657.                     const float range = max - min;

  658.                     step = range/100.0f;

  659.                     stepSmall = range/1000.0f;

  660.                     stepLarge = range/10.0f;

  661.                 }

  662. 

  663.                 if (LADSPA_IS_PORT_INPUT(portType))

  664.                 {

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

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

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

  668.                     needsCtrlIn = true;

  669.                 }

  670.                 else if (LADSPA_IS_PORT_OUTPUT(portType))

  671.                 {

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

  673. 

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

  675.                     {

  676.                         min = 0.0f;

  677.                         max = sampleRate;

  678.                         def = 0.0f;

  679.                         step = 1.0f;

  680.                         stepSmall = 1.0f;

  681.                         stepLarge = 1.0f;

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

  683.                         CARLA_SAFE_ASSERT(fLatencyIndex == -1);

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

  685.                     }

  686.                     else

  687.                     {

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

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

  690.                         needsCtrlOut = true;

  691.                     }

  692.                 }

  693.                 else

  694.                 {

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

  696.                 }

  697. 

  698.                 // extra parameter hints

  699.                 if (LADSPA_IS_HINT_LOGARITHMIC(portRangeHints.HintDescriptor))

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

  701. 

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

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

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

  705. 

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

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

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

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

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

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

  712. 

  713.                 // Start parameters in their default values

  714.                 fParamBuffers[j] = def;

  715. 

  716.                 try {

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

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

  719. 

  720.                 if (fHandle2 != nullptr)

  721.                 {

  722.                     try {

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

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

  725.                 }

  726.             }

  727.             else

  728.             {

  729.                 // Not Audio or Control

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

  731. 

  732.                 try {

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

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

  735. 

  736.                 if (fHandle2 != nullptr)

  737.                 {

  738.                     try {

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

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

  741.                 }

  742.             }

  743.         }

  744. 

  745.         if (needsCtrlIn)

  746.         {

  747.             portName.clear();

  748. 

  749.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  750.             {

  751.                 portName  = pData->name;

  752.                 portName += ":";

  753.             }

  754. 

  755.             portName += "events-in";

  756.             portName.truncate(portNameSize);

  757. 

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

  759.         }

  760. 

  761.         if (needsCtrlOut)

  762.         {

  763.             portName.clear();

  764. 

  765.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  766.             {

  767.                 portName  = pData->name;

  768.                 portName += ":";

  769.             }

  770. 

  771.             portName += "events-out";

  772.             portName.truncate(portNameSize);

  773. 

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

  775.         }

  776. 

  777.         if (forcedStereoIn || forcedStereoOut)

  778.             pData->options |= PLUGIN_OPTION_FORCE_STEREO;

  779.         else

  780.             pData->options &= ~PLUGIN_OPTION_FORCE_STEREO;

  781. 

  782.         // plugin hints

  783.         pData->hints = 0x0;

  784. 

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

  786.             pData->hints |= PLUGIN_IS_RTSAFE;

  787. 

  788. #ifndef BUILD_BRIDGE

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

  790.             pData->hints |= PLUGIN_CAN_DRYWET;

  791. 

  792.         if (aOuts > 0)

  793.             pData->hints |= PLUGIN_CAN_VOLUME;

  794. 

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

  796.             pData->hints |= PLUGIN_CAN_BALANCE;

  797. #endif

  798. 

  799.         // extra plugin hints

  800.         pData->extraHints = 0x0;

  801. 

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

  803.             pData->extraHints |= PLUGIN_EXTRA_HINT_CAN_RUN_RACK;

  804. 

  805.         // check latency

  806.         if (fLatencyIndex >= 0)

  807.         {

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

  809. 

  810.             float tmpIn[aIns][2];

  811.             float tmpOut[aOuts][2];

  812. 

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

  814.             {

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

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

  817. 

  818.                 try {

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

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

  821.             }

  822. 

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

  824.             {

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

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

  827. 

  828.                 try {

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

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

  831.             }

  832. 

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

  834.             {

  835.                 try {

  836.                     fDescriptor->activate(fHandle);

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

  838.             }

  839. 

  840.             try {

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

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

  843. 

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

  845.             {

  846.                 try {

  847.                     fDescriptor->deactivate(fHandle);

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

  849.             }

  850. 

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

  852. 

  853.             if (latency >= 0)

  854.             {

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

  856. 

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

  858.                 {

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

  860. 

  861.                     pData->latency = ulatency;

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

  863. #ifndef BUILD_BRIDGE

  864.                     pData->recreateLatencyBuffers();

  865. #endif

  866.                 }

  867.             }

  868.             else

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

  870.         }

  871. 

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

  873. 

  874.         if (pData->active)

  875.             activate();

  876. 

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

  878.     }

  879. 

  880.     // -------------------------------------------------------------------

  881.     // Plugin processing

  882. 

  883.     void activate() noexcept override

  884.     {

  885.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  886.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  887. 

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

  889.         {

  890.             try {

  891.                 fDescriptor->activate(fHandle);

  892.             } CARLA_SAFE_EXCEPTION("LADSPA activate");

  893. 

  894.             if (fHandle2 != nullptr)

  895.             {

  896.                 try {

  897.                     fDescriptor->activate(fHandle2);

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

  899.             }

  900.         }

  901. 

  902.         if (fLatencyIndex < 0)

  903.             return;

  904. 

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

  906.         CARLA_SAFE_ASSERT_RETURN(latency >= 0,);

  907. 

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

  909. 

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

  911.         {

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

  913. 

  914.             pData->latency = ulatency;

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

  916. #ifndef BUILD_BRIDGE

  917.             try {

  918.                 pData->recreateLatencyBuffers(); // FIXME

  919.             } CARLA_SAFE_EXCEPTION("LADSPA recreateLatencyBuffers()");

  920. #endif

  921.         }

  922.         else

  923.             carla_stdout("latency still the same %i", latency);

  924.     }

  925. 

  926.     void deactivate() noexcept override

  927.     {

  928.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  929.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  930. 

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

  932.         {

  933.             try {

  934.                 fDescriptor->deactivate(fHandle);

  935.             } CARLA_SAFE_EXCEPTION("LADSPA deactivate");

  936. 

  937.             if (fHandle2 != nullptr)

  938.             {

  939.                 try {

  940.                     fDescriptor->deactivate(fHandle2);

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

  942.             }

  943.         }

  944.     }

  945. 

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

  947.     {

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

  949.         // Check if active

  950. 

  951.         if (! pData->active)

  952.         {

  953.             // disable any output sound

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

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

  956.             return;

  957.         }

  958. 

  959.         // --------------------------------------------------------------------------------------------------------

  960.         // Check if needs reset

  961. 

  962.         if (pData->needsReset)

  963.         {

  964. #ifndef BUILD_BRIDGE

  965.             if (pData->latency > 0)

  966.             {

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

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

  969.             }

  970. #endif

  971. 

  972.             pData->needsReset = false;

  973.         }

  974. 

  975.         // --------------------------------------------------------------------------------------------------------

  976.         // Event Input and Processing

  977. 

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

  979.         {

  980.             // ----------------------------------------------------------------------------------------------------

  981.             // Event Input (System)

  982. 

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

  984. 

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

  986.             uint32_t timeOffset = 0;

  987. 

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

  989.             {

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

  991. 

  992.                 if (event.time >= frames)

  993.                     continue;

  994. 

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

  996. 

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

  998.                 {

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

  1000.                         timeOffset = event.time;

  1001.                 }

  1002. 

  1003.                 switch (event.type)

  1004.                 {

  1005.                 case kEngineEventTypeNull:

  1006.                     break;

  1007. 

  1008.                 case kEngineEventTypeControl: {

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

  1010. 

  1011.                     switch (ctrlEvent.type)

  1012.                     {

  1013.                     case kEngineControlEventTypeNull:

  1014.                         break;

  1015. 

  1016.                     case kEngineControlEventTypeParameter: {

  1017. #ifndef BUILD_BRIDGE

  1018.                         // Control backend stuff

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

  1020.                         {

  1021.                             float value;

  1022. 

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

  1024.                             {

  1025.                                 value = ctrlEvent.value;

  1026.                                 setDryWet(value, false, false);

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

  1028.                                 break;

  1029.                             }

  1030. 

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

  1032.                             {

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

  1034.                                 setVolume(value, false, false);

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

  1036.                                 break;

  1037.                             }

  1038. 

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

  1040.                             {

  1041.                                 float left, right;

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

  1043. 

  1044.                                 if (value < 0.0f)

  1045.                                 {

  1046.                                     left  = -1.0f;

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

  1048.                                 }

  1049.                                 else if (value > 0.0f)

  1050.                                 {

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

  1052.                                     right = 1.0f;

  1053.                                 }

  1054.                                 else

  1055.                                 {

  1056.                                     left  = -1.0f;

  1057.                                     right = 1.0f;

  1058.                                 }

  1059. 

  1060.                                 setBalanceLeft(left, false, false);

  1061.                                 setBalanceRight(right, false, false);

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

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

  1064.                                 break;

  1065.                             }

  1066.                         }

  1067. #endif

  1068. 

  1069.                         // Control plugin parameters

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

  1071.                         {

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

  1073.                                 continue;

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

  1075.                                 continue;

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

  1077.                                 continue;

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

  1079.                                 continue;

  1080. 

  1081.                             float value;

  1082. 

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

  1084.                             {

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

  1086.                             }

  1087.                             else

  1088.                             {

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

  1090. 

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

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

  1093.                             }

  1094. 

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

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

  1097.                             break;

  1098.                         }

  1099. 

  1100.                         break;

  1101.                     } // case kEngineControlEventTypeParameter

  1102. 

  1103.                     case kEngineControlEventTypeMidiBank:

  1104.                     case kEngineControlEventTypeMidiProgram:

  1105.                     case kEngineControlEventTypeAllSoundOff:

  1106.                     case kEngineControlEventTypeAllNotesOff:

  1107.                         break;

  1108.                     } // switch (ctrlEvent.type)

  1109.                     break;

  1110.                 } // case kEngineEventTypeControl

  1111. 

  1112.                 case kEngineEventTypeMidi:

  1113.                     break;

  1114.                 } // switch (event.type)

  1115.             }

  1116. 

  1117.             pData->postRtEvents.trySplice();

  1118. 

  1119.             if (frames > timeOffset)

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

  1121. 

  1122.         } // End of Event Input and Processing

  1123. 

  1124.         // --------------------------------------------------------------------------------------------------------

  1125.         // Plugin processing (no events)

  1126. 

  1127.         else

  1128.         {

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

  1130. 

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

  1132. 

  1133.         // --------------------------------------------------------------------------------------------------------

  1134.         // Latency, save values for next callback

  1135. 

  1136.         if (pData->latency > 0)

  1137.         {

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

  1139.             {

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

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

  1142.             }

  1143.             else

  1144.             {

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

  1146.                 {

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

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

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

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

  1151.                 }

  1152.             }

  1153.         }

  1154. 

  1155.         // --------------------------------------------------------------------------------------------------------

  1156.         // Control Output

  1157. 

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

  1159.         {

  1160.             uint8_t  channel;

  1161.             uint16_t param;

  1162.             float    value;

  1163. 

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

  1165.             {

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

  1167.                     continue;

  1168. 

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

  1170. 

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

  1172.                 {

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

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

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

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

  1177.                 }

  1178.             }

  1179.         } // End of Control Output

  1180.     }

  1181. 

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

  1183.     {

  1184.         CARLA_SAFE_ASSERT_RETURN(frames > 0, false);

  1185. 

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

  1187.         {

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

  1189.         }

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

  1191.         {

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

  1193.         }

  1194. 

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

  1196.         // Try lock, silence otherwise

  1197. 

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

  1199.         {

  1200.             pData->singleMutex.lock();

  1201.         }

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

  1203.         {

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

  1205.             {

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

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

  1208.             }

  1209. 

  1210.             return false;

  1211.         }

  1212. 

  1213.         // --------------------------------------------------------------------------------------------------------

  1214.         // Reset audio buffers

  1215. 

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

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

  1218. 

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

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

  1221. 

  1222.         // --------------------------------------------------------------------------------------------------------

  1223.         // Run plugin

  1224. 

  1225.         try {

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

  1227.         } CARLA_SAFE_EXCEPTION("LADSPA run");

  1228. 

  1229.         if (fHandle2 != nullptr)

  1230.         {

  1231.             try {

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

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

  1234.         }

  1235. 

  1236. #ifndef BUILD_BRIDGE

  1237.         // --------------------------------------------------------------------------------------------------------

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

  1239. 

  1240.         {

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

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

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

  1244. 

  1245.             bool isPair;

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

  1247. 

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

  1249.             {

  1250.                 // Dry/Wet

  1251.                 if (doDryWet)

  1252.                 {

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

  1254.                     {

  1255.                         if (k < pData->latency)

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

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

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

  1259.                         else

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

  1261. 

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

  1263.                     }

  1264.                 }

  1265. 

  1266.                 // Balance

  1267.                 if (doBalance)

  1268.                 {

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

  1270. 

  1271.                     if (isPair)

  1272.                     {

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

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

  1275.                     }

  1276. 

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

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

  1279. 

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

  1281.                     {

  1282.                         if (isPair)

  1283.                         {

  1284.                             // left

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

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

  1287.                         }

  1288.                         else

  1289.                         {

  1290.                             // right

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

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

  1293.                         }

  1294.                     }

  1295.                 }

  1296. 

  1297.                 // Volume (and buffer copy)

  1298.                 {

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

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

  1301.                 }

  1302.             }

  1303. 

  1304.         } // End of Post-processing

  1305. 

  1306. #else // BUILD_BRIDGE

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

  1308.         {

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

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

  1311.         }

  1312. #endif

  1313. 

  1314.         // --------------------------------------------------------------------------------------------------------

  1315. 

  1316.         pData->singleMutex.unlock();

  1317.         return true;

  1318.     }

  1319. 

  1320.     void bufferSizeChanged(const uint32_t newBufferSize) override

  1321.     {

  1322.         CARLA_ASSERT_INT(newBufferSize > 0, newBufferSize);

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

  1324. 

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

  1326.         {

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

  1328.                 delete[] fAudioInBuffers[i];

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

  1330.         }

  1331. 

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

  1333.         {

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

  1335.                 delete[] fAudioOutBuffers[i];

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

  1337.         }

  1338. 

  1339.         if (fHandle2 == nullptr)

  1340.         {

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

  1342.             {

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

  1344. 

  1345.                 try {

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

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

  1348.             }

  1349. 

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

  1351.             {

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

  1353. 

  1354.                 try {

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

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

  1357.             }

  1358.         }

  1359.         else

  1360.         {

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

  1362.             {

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

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

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

  1366. 

  1367.                 try {

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

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

  1370. 

  1371.                 try {

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

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

  1374.             }

  1375. 

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

  1377.             {

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

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

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

  1381. 

  1382.                 try {

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

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

  1385. 

  1386.                 try {

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

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

  1389.             }

  1390.         }

  1391. 

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

  1393.     }

  1394. 

  1395.     void sampleRateChanged(const double newSampleRate) override

  1396.     {

  1397.         CARLA_ASSERT_INT(newSampleRate > 0.0, newSampleRate);

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

  1399. 

  1400.         // TODO

  1401.         (void)newSampleRate;

  1402. 

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

  1404.     }

  1405. 

  1406.     // -------------------------------------------------------------------

  1407.     // Plugin buffers

  1408. 

  1409.     void clearBuffers() noexcept override

  1410.     {

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

  1412. 

  1413.         if (fAudioInBuffers != nullptr)

  1414.         {

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

  1416.             {

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

  1418.                 {

  1419.                     delete[] fAudioInBuffers[i];

  1420.                     fAudioInBuffers[i] = nullptr;

  1421.                 }

  1422.             }

  1423. 

  1424.             delete[] fAudioInBuffers;

  1425.             fAudioInBuffers = nullptr;

  1426.         }

  1427. 

  1428.         if (fAudioOutBuffers != nullptr)

  1429.         {

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

  1431.             {

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

  1433.                 {

  1434.                     delete[] fAudioOutBuffers[i];

  1435.                     fAudioOutBuffers[i] = nullptr;

  1436.                 }

  1437.             }

  1438. 

  1439.             delete[] fAudioOutBuffers;

  1440.             fAudioOutBuffers = nullptr;

  1441.         }

  1442. 

  1443.         if (fParamBuffers != nullptr)

  1444.         {

  1445.             delete[] fParamBuffers;

  1446.             fParamBuffers = nullptr;

  1447.         }

  1448. 

  1449.         CarlaPlugin::clearBuffers();

  1450. 

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

  1452.     }

  1453. 

  1454.     // -------------------------------------------------------------------

  1455. 

  1456.     const void* getExtraStuff() const noexcept override

  1457.     {

  1458.         return fRdfDescriptor;

  1459.     }

  1460. 

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

  1462.     {

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

  1464. 

  1465.         // ---------------------------------------------------------------

  1466.         // first checks

  1467. 

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

  1469.         {

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

  1471.             return false;

  1472.         }

  1473. 

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

  1475.         {

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

  1477.             return false;

  1478.         }

  1479. 

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

  1481.         {

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

  1483.             return false;

  1484.         }

  1485. 

  1486.         // ---------------------------------------------------------------

  1487.         // open DLL

  1488. 

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

  1490.         {

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

  1492.             return false;

  1493.         }

  1494. 

  1495.         // ---------------------------------------------------------------

  1496.         // get DLL main entry

  1497. 

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

  1499. 

  1500.         if (descFn == nullptr)

  1501.         {

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

  1503.             return false;

  1504.         }

  1505. 

  1506.         // ---------------------------------------------------------------

  1507.         // get descriptor that matches label

  1508. 

  1509.         ulong i = 0;

  1510. 

  1511.         for (;;)

  1512.         {

  1513.             try {

  1514.                 fDescriptor = descFn(i++);

  1515.             }

  1516.             catch(...) {

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

  1518.                 fDescriptor = nullptr;

  1519.                 break;

  1520.             }

  1521. 

  1522.             if (fDescriptor == nullptr)

  1523.                 break;

  1524. 

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

  1526.             {

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

  1528.                 fDescriptor = nullptr;

  1529.                 break;

  1530.             }

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

  1532.             {

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

  1534.                 fDescriptor = nullptr;

  1535.                 break;

  1536.             }

  1537. 

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

  1539.                 break;

  1540.         }

  1541. 

  1542.         if (fDescriptor == nullptr)

  1543.         {

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

  1545.             return false;

  1546.         }

  1547. 

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

  1549.         // get info

  1550. 

  1551.         if (is_ladspa_rdf_descriptor_valid(rdfDescriptor, fDescriptor))

  1552.             fRdfDescriptor = ladspa_rdf_dup(rdfDescriptor);

  1553. 

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

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

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

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

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

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

  1560.         else

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

  1562. 

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

  1564. 

  1565.         // ---------------------------------------------------------------

  1566.         // register client

  1567. 

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

  1569. 

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

  1571.         {

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

  1573.             return false;

  1574.         }

  1575. 

  1576.         // ---------------------------------------------------------------

  1577.         // initialize plugin

  1578. 

  1579.         try {

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

  1581.         } CARLA_SAFE_EXCEPTION("LADSPA instantiate");

  1582. 

  1583.         if (fHandle == nullptr)

  1584.         {

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

  1586.             return false;

  1587.         }

  1588. 

  1589.         // ---------------------------------------------------------------

  1590.         // load plugin settings

  1591. 

  1592.         {

  1593. #ifdef __USE_GNU

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

  1595. #else

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

  1597. #endif

  1598. 

  1599.             // set default options

  1600.             pData->options = 0x0;

  1601. 

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

  1603.                 pData->options |= PLUGIN_OPTION_FIXED_BUFFERS;

  1604. 

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

  1606.                 pData->options |= PLUGIN_OPTION_FORCE_STEREO;

  1607. 

  1608. #ifndef BUILD_BRIDGE

  1609.             // set identifier string

  1610.             CarlaString identifier("LADSPA/");

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

  1612.             identifier += ",";

  1613.             identifier += label;

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

  1615. 

  1616.             // load settings

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

  1618. 

  1619.             // ignore settings, we need this anyway

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

  1621.                 pData->options |= PLUGIN_OPTION_FIXED_BUFFERS;

  1622. #endif

  1623.         }

  1624. 

  1625.         return true;

  1626.     }

  1627. 

  1628.     // -------------------------------------------------------------------

  1629. 

  1630. private:

  1631.     LADSPA_Handle fHandle;

  1632.     LADSPA_Handle fHandle2;

  1633.     const LADSPA_Descriptor*     fDescriptor;

  1634.     const LADSPA_RDF_Descriptor* fRdfDescriptor;

  1635. 

  1636.     float** fAudioInBuffers;

  1637.     float** fAudioOutBuffers;

  1638.     float*  fParamBuffers;

  1639.     int32_t fLatencyIndex; // -1 if invalid

  1640. 

  1641.     // -------------------------------------------------------------------

  1642. 

  1643.     uint32_t getSafePortCount() const noexcept

  1644.     {

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

  1646.             return 0;

  1647. 

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

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

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

  1651. 

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

  1653.     }

  1654. 

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

  1656.     {

  1657.         if (_getSeparatedParameterNameOrUnitImpl(paramName, strBuf, wantName, true))

  1658.             return true;

  1659.         if (_getSeparatedParameterNameOrUnitImpl(paramName, strBuf, wantName, false))

  1660.             return true;

  1661.         return false;

  1662.     }

  1663. 

  1664.     bool _getSeparatedParameterNameOrUnitImpl(const char* const paramName, char* const strBuf, const bool wantName, const bool useBracket) const noexcept

  1665.     {

  1666.         const char* const sepBracketStart(std::strstr(paramName, useBracket ? " [" : " ("));

  1667. 

  1668.         if (sepBracketStart == nullptr)

  1669.             return false;

  1670. 

  1671.         const char* const sepBracketEnd(std::strstr(sepBracketStart, useBracket ? "]" : ")"));

  1672. 

  1673.         if (sepBracketEnd == nullptr)

  1674.             return false;

  1675. 

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

  1677. 

  1678.         if (unitSize > 7) // very unlikely to have such big unit

  1679.             return false;

  1680. 

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

  1682. 

  1683.         // just in case

  1684.         if (sepIndex > STR_MAX)

  1685.             return false;

  1686. 

  1687.         if (wantName)

  1688.         {

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

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

  1691.         }

  1692.         else

  1693.         {

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

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

  1696.         }

  1697. 

  1698.         return true;

  1699.     }

  1700. 

  1701.     // -------------------------------------------------------------------

  1702. 

  1703.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(LadspaPlugin)

  1704. };

  1705. 

  1706. CARLA_BACKEND_END_NAMESPACE

  1707. 

  1708. #endif // WANT_LADSPA

  1709. 

  1710. // -------------------------------------------------------------------------------------------------------------------

  1711. 

  1712. CARLA_BACKEND_START_NAMESPACE

  1713. 

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

  1715. {

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

  1717. 

  1718. #ifdef WANT_LADSPA

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

  1720. 

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

  1722.     {

  1723.         delete plugin;

  1724.         return nullptr;

  1725.     }

  1726. 

  1727.     plugin->reload();

  1728. 

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

  1730.     {

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

  1732.         delete plugin;

  1733.         return nullptr;

  1734.     }

  1735. 

  1736.     return plugin;

  1737. #else

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

  1739.     return nullptr;

  1740. #endif

  1741. }

  1742. 

  1743. CARLA_BACKEND_END_NAMESPACE

  1744. 

  1745. // -------------------------------------------------------------------------------------------------------------------