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.
1834 Commits
17 Branches
1.6GB
Tree: 6b2db1b42e
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '6b2db1b42e'
${ noResults }
Carla/source/backend/plugin/LadspaPlugin.cpp

1745 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.                         fLatencyIndex = static_cast<int32_t>(j);

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

  684.                     }

  685.                     else

  686.                     {

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

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

  689.                         needsCtrlOut = true;

  690.                     }

  691.                 }

  692.                 else

  693.                 {

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

  695.                 }

  696. 

  697.                 // extra parameter hints

  698.                 if (LADSPA_IS_HINT_LOGARITHMIC(portRangeHints.HintDescriptor))

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

  700. 

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

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

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

  704. 

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

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

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

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

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

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

  711. 

  712.                 // Start parameters in their default values

  713.                 fParamBuffers[j] = def;

  714. 

  715.                 try {

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

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

  718. 

  719.                 if (fHandle2 != nullptr)

  720.                 {

  721.                     try {

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

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

  724.                 }

  725.             }

  726.             else

  727.             {

  728.                 // Not Audio or Control

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

  730. 

  731.                 try {

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

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

  734. 

  735.                 if (fHandle2 != nullptr)

  736.                 {

  737.                     try {

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

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

  740.                 }

  741.             }

  742.         }

  743. 

  744.         if (needsCtrlIn)

  745.         {

  746.             portName.clear();

  747. 

  748.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  749.             {

  750.                 portName  = pData->name;

  751.                 portName += ":";

  752.             }

  753. 

  754.             portName += "events-in";

  755.             portName.truncate(portNameSize);

  756. 

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

  758.         }

  759. 

  760.         if (needsCtrlOut)

  761.         {

  762.             portName.clear();

  763. 

  764.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  765.             {

  766.                 portName  = pData->name;

  767.                 portName += ":";

  768.             }

  769. 

  770.             portName += "events-out";

  771.             portName.truncate(portNameSize);

  772. 

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

  774.         }

  775. 

  776.         if (forcedStereoIn || forcedStereoOut)

  777.             pData->options |= PLUGIN_OPTION_FORCE_STEREO;

  778.         else

  779.             pData->options &= ~PLUGIN_OPTION_FORCE_STEREO;

  780. 

  781.         // plugin hints

  782.         pData->hints = 0x0;

  783. 

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

  785.             pData->hints |= PLUGIN_IS_RTSAFE;

  786. 

  787. #ifndef BUILD_BRIDGE

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

  789.             pData->hints |= PLUGIN_CAN_DRYWET;

  790. 

  791.         if (aOuts > 0)

  792.             pData->hints |= PLUGIN_CAN_VOLUME;

  793. 

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

  795.             pData->hints |= PLUGIN_CAN_BALANCE;

  796. #endif

  797. 

  798.         // extra plugin hints

  799.         pData->extraHints = 0x0;

  800. 

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

  802.             pData->extraHints |= PLUGIN_EXTRA_HINT_CAN_RUN_RACK;

  803. 

  804.         // check latency

  805.         if (fLatencyIndex >= 0)

  806.         {

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

  808. 

  809.             float tmpIn[aIns][2];

  810.             float tmpOut[aOuts][2];

  811. 

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

  813.             {

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

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

  816. 

  817.                 try {

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

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

  820.             }

  821. 

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

  823.             {

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

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

  826. 

  827.                 try {

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

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

  830.             }

  831. 

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

  833.             {

  834.                 try {

  835.                     fDescriptor->activate(fHandle);

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

  837.             }

  838. 

  839.             try {

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

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

  842. 

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

  844.             {

  845.                 try {

  846.                     fDescriptor->deactivate(fHandle);

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

  848.             }

  849. 

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

  851. 

  852.             if (latency >= 0)

  853.             {

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

  855. 

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

  857.                 {

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

  859. 

  860.                     pData->latency = ulatency;

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

  862. #ifndef BUILD_BRIDGE

  863.                     pData->recreateLatencyBuffers();

  864. #endif

  865.                 }

  866.             }

  867.             else

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

  869.         }

  870. 

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

  872. 

  873.         if (pData->active)

  874.             activate();

  875. 

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

  877.     }

  878. 

  879.     // -------------------------------------------------------------------

  880.     // Plugin processing

  881. 

  882.     void activate() noexcept override

  883.     {

  884.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  885.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  886. 

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

  888.         {

  889.             try {

  890.                 fDescriptor->activate(fHandle);

  891.             } CARLA_SAFE_EXCEPTION("LADSPA activate");

  892. 

  893.             if (fHandle2 != nullptr)

  894.             {

  895.                 try {

  896.                     fDescriptor->activate(fHandle2);

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

  898.             }

  899.         }

  900. 

  901.         if (fLatencyIndex < 0)

  902.             return;

  903. 

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

  905.         CARLA_SAFE_ASSERT_RETURN(latency >= 0,);

  906. 

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

  908. 

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

  910.         {

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

  912. 

  913.             pData->latency = ulatency;

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

  915. #ifndef BUILD_BRIDGE

  916.             try {

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

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

  919. #endif

  920.         }

  921.         else

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

  923.     }

  924. 

  925.     void deactivate() noexcept override

  926.     {

  927.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  928.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  929. 

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

  931.         {

  932.             try {

  933.                 fDescriptor->deactivate(fHandle);

  934.             } CARLA_SAFE_EXCEPTION("LADSPA deactivate");

  935. 

  936.             if (fHandle2 != nullptr)

  937.             {

  938.                 try {

  939.                     fDescriptor->deactivate(fHandle2);

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

  941.             }

  942.         }

  943.     }

  944. 

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

  946.     {

  947.         // --------------------------------------------------------------------------------------------------------

  948.         // Check if active

  949. 

  950.         if (! pData->active)

  951.         {

  952.             // disable any output sound

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

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

  955.             return;

  956.         }

  957. 

  958.         // --------------------------------------------------------------------------------------------------------

  959.         // Check if needs reset

  960. 

  961.         if (pData->needsReset)

  962.         {

  963. #ifndef BUILD_BRIDGE

  964.             if (pData->latency > 0)

  965.             {

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

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

  968.             }

  969. #endif

  970. 

  971.             pData->needsReset = false;

  972.         }

  973. 

  974.         // --------------------------------------------------------------------------------------------------------

  975.         // Event Input and Processing

  976. 

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

  978.         {

  979.             // ----------------------------------------------------------------------------------------------------

  980.             // Event Input (System)

  981. 

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

  983. 

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

  985.             uint32_t timeOffset = 0;

  986. 

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

  988.             {

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

  990. 

  991.                 if (event.time >= frames)

  992.                     continue;

  993. 

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

  995. 

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

  997.                 {

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

  999.                         timeOffset = event.time;

  1000.                 }

  1001. 

  1002.                 switch (event.type)

  1003.                 {

  1004.                 case kEngineEventTypeNull:

  1005.                     break;

  1006. 

  1007.                 case kEngineEventTypeControl: {

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

  1009. 

  1010.                     switch (ctrlEvent.type)

  1011.                     {

  1012.                     case kEngineControlEventTypeNull:

  1013.                         break;

  1014. 

  1015.                     case kEngineControlEventTypeParameter: {

  1016. #ifndef BUILD_BRIDGE

  1017.                         // Control backend stuff

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

  1019.                         {

  1020.                             float value;

  1021. 

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

  1023.                             {

  1024.                                 value = ctrlEvent.value;

  1025.                                 setDryWet(value, false, false);

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

  1027.                                 break;

  1028.                             }

  1029. 

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

  1031.                             {

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

  1033.                                 setVolume(value, false, false);

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

  1035.                                 break;

  1036.                             }

  1037. 

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

  1039.                             {

  1040.                                 float left, right;

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

  1042. 

  1043.                                 if (value < 0.0f)

  1044.                                 {

  1045.                                     left  = -1.0f;

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

  1047.                                 }

  1048.                                 else if (value > 0.0f)

  1049.                                 {

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

  1051.                                     right = 1.0f;

  1052.                                 }

  1053.                                 else

  1054.                                 {

  1055.                                     left  = -1.0f;

  1056.                                     right = 1.0f;

  1057.                                 }

  1058. 

  1059.                                 setBalanceLeft(left, false, false);

  1060.                                 setBalanceRight(right, false, false);

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

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

  1063.                                 break;

  1064.                             }

  1065.                         }

  1066. #endif

  1067. 

  1068.                         // Control plugin parameters

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

  1070.                         {

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

  1072.                                 continue;

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

  1074.                                 continue;

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

  1076.                                 continue;

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

  1078.                                 continue;

  1079. 

  1080.                             float value;

  1081. 

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

  1083.                             {

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

  1085.                             }

  1086.                             else

  1087.                             {

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

  1089. 

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

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

  1092.                             }

  1093. 

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

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

  1096.                             break;

  1097.                         }

  1098. 

  1099.                         break;

  1100.                     } // case kEngineControlEventTypeParameter

  1101. 

  1102.                     case kEngineControlEventTypeMidiBank:

  1103.                     case kEngineControlEventTypeMidiProgram:

  1104.                     case kEngineControlEventTypeAllSoundOff:

  1105.                     case kEngineControlEventTypeAllNotesOff:

  1106.                         break;

  1107.                     } // switch (ctrlEvent.type)

  1108.                     break;

  1109.                 } // case kEngineEventTypeControl

  1110. 

  1111.                 case kEngineEventTypeMidi:

  1112.                     break;

  1113.                 } // switch (event.type)

  1114.             }

  1115. 

  1116.             pData->postRtEvents.trySplice();

  1117. 

  1118.             if (frames > timeOffset)

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

  1120. 

  1121.         } // End of Event Input and Processing

  1122. 

  1123.         // --------------------------------------------------------------------------------------------------------

  1124.         // Plugin processing (no events)

  1125. 

  1126.         else

  1127.         {

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

  1129. 

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

  1131. 

  1132.         // --------------------------------------------------------------------------------------------------------

  1133.         // Latency, save values for next callback

  1134. 

  1135.         if (pData->latency > 0)

  1136.         {

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

  1138.             {

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

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

  1141.             }

  1142.             else

  1143.             {

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

  1145.                 {

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

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

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

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

  1150.                 }

  1151.             }

  1152.         }

  1153. 

  1154.         // --------------------------------------------------------------------------------------------------------

  1155.         // Control Output

  1156. 

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

  1158.         {

  1159.             uint8_t  channel;

  1160.             uint16_t param;

  1161.             float    value;

  1162. 

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

  1164.             {

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

  1166.                     continue;

  1167. 

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

  1169. 

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

  1171.                 {

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

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

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

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

  1176.                 }

  1177.             }

  1178.         } // End of Control Output

  1179.     }

  1180. 

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

  1182.     {

  1183.         CARLA_SAFE_ASSERT_RETURN(frames > 0, false);

  1184. 

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

  1186.         {

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

  1188.         }

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

  1190.         {

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

  1192.         }

  1193. 

  1194.         // --------------------------------------------------------------------------------------------------------

  1195.         // Try lock, silence otherwise

  1196. 

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

  1198.         {

  1199.             pData->singleMutex.lock();

  1200.         }

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

  1202.         {

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

  1204.             {

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

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

  1207.             }

  1208. 

  1209.             return false;

  1210.         }

  1211. 

  1212.         // --------------------------------------------------------------------------------------------------------

  1213.         // Reset audio buffers

  1214. 

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

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

  1217. 

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

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

  1220. 

  1221.         // --------------------------------------------------------------------------------------------------------

  1222.         // Run plugin

  1223. 

  1224.         try {

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

  1226.         } CARLA_SAFE_EXCEPTION("LADSPA run");

  1227. 

  1228.         if (fHandle2 != nullptr)

  1229.         {

  1230.             try {

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

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

  1233.         }

  1234. 

  1235. #ifndef BUILD_BRIDGE

  1236.         // --------------------------------------------------------------------------------------------------------

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

  1238. 

  1239.         {

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

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

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

  1243. 

  1244.             bool isPair;

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

  1246. 

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

  1248.             {

  1249.                 // Dry/Wet

  1250.                 if (doDryWet)

  1251.                 {

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

  1253.                     {

  1254.                         if (k < pData->latency)

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

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

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

  1258.                         else

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

  1260. 

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

  1262.                     }

  1263.                 }

  1264. 

  1265.                 // Balance

  1266.                 if (doBalance)

  1267.                 {

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

  1269. 

  1270.                     if (isPair)

  1271.                     {

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

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

  1274.                     }

  1275. 

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

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

  1278. 

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

  1280.                     {

  1281.                         if (isPair)

  1282.                         {

  1283.                             // left

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

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

  1286.                         }

  1287.                         else

  1288.                         {

  1289.                             // right

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

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

  1292.                         }

  1293.                     }

  1294.                 }

  1295. 

  1296.                 // Volume (and buffer copy)

  1297.                 {

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

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

  1300.                 }

  1301.             }

  1302. 

  1303.         } // End of Post-processing

  1304. 

  1305. #else // BUILD_BRIDGE

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

  1307.         {

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

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

  1310.         }

  1311. #endif

  1312. 

  1313.         // --------------------------------------------------------------------------------------------------------

  1314. 

  1315.         pData->singleMutex.unlock();

  1316.         return true;

  1317.     }

  1318. 

  1319.     void bufferSizeChanged(const uint32_t newBufferSize) override

  1320.     {

  1321.         CARLA_ASSERT_INT(newBufferSize > 0, newBufferSize);

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

  1323. 

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

  1325.         {

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

  1327.                 delete[] fAudioInBuffers[i];

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

  1329.         }

  1330. 

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

  1332.         {

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

  1334.                 delete[] fAudioOutBuffers[i];

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

  1336.         }

  1337. 

  1338.         if (fHandle2 == nullptr)

  1339.         {

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

  1341.             {

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

  1343. 

  1344.                 try {

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

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

  1347.             }

  1348. 

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

  1350.             {

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

  1352. 

  1353.                 try {

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

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

  1356.             }

  1357.         }

  1358.         else

  1359.         {

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

  1361.             {

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

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

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

  1365. 

  1366.                 try {

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

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

  1369. 

  1370.                 try {

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

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

  1373.             }

  1374. 

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

  1376.             {

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

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

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

  1380. 

  1381.                 try {

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

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

  1384. 

  1385.                 try {

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

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

  1388.             }

  1389.         }

  1390. 

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

  1392.     }

  1393. 

  1394.     void sampleRateChanged(const double newSampleRate) override

  1395.     {

  1396.         CARLA_ASSERT_INT(newSampleRate > 0.0, newSampleRate);

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

  1398. 

  1399.         // TODO

  1400.         (void)newSampleRate;

  1401. 

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

  1403.     }

  1404. 

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

  1406.     // Plugin buffers

  1407. 

  1408.     void clearBuffers() noexcept override

  1409.     {

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

  1411. 

  1412.         if (fAudioInBuffers != nullptr)

  1413.         {

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

  1415.             {

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

  1417.                 {

  1418.                     delete[] fAudioInBuffers[i];

  1419.                     fAudioInBuffers[i] = nullptr;

  1420.                 }

  1421.             }

  1422. 

  1423.             delete[] fAudioInBuffers;

  1424.             fAudioInBuffers = nullptr;

  1425.         }

  1426. 

  1427.         if (fAudioOutBuffers != nullptr)

  1428.         {

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

  1430.             {

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

  1432.                 {

  1433.                     delete[] fAudioOutBuffers[i];

  1434.                     fAudioOutBuffers[i] = nullptr;

  1435.                 }

  1436.             }

  1437. 

  1438.             delete[] fAudioOutBuffers;

  1439.             fAudioOutBuffers = nullptr;

  1440.         }

  1441. 

  1442.         if (fParamBuffers != nullptr)

  1443.         {

  1444.             delete[] fParamBuffers;

  1445.             fParamBuffers = nullptr;

  1446.         }

  1447. 

  1448.         CarlaPlugin::clearBuffers();

  1449. 

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

  1451.     }

  1452. 

  1453.     // -------------------------------------------------------------------

  1454. 

  1455.     const void* getExtraStuff() const noexcept override

  1456.     {

  1457.         return fRdfDescriptor;

  1458.     }

  1459. 

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

  1461.     {

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

  1463. 

  1464.         // ---------------------------------------------------------------

  1465.         // first checks

  1466. 

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

  1468.         {

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

  1470.             return false;

  1471.         }

  1472. 

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

  1474.         {

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

  1476.             return false;

  1477.         }

  1478. 

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

  1480.         {

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

  1482.             return false;

  1483.         }

  1484. 

  1485.         // ---------------------------------------------------------------

  1486.         // open DLL

  1487. 

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

  1489.         {

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

  1491.             return false;

  1492.         }

  1493. 

  1494.         // ---------------------------------------------------------------

  1495.         // get DLL main entry

  1496. 

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

  1498. 

  1499.         if (descFn == nullptr)

  1500.         {

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

  1502.             return false;

  1503.         }

  1504. 

  1505.         // ---------------------------------------------------------------

  1506.         // get descriptor that matches label

  1507. 

  1508.         ulong i = 0;

  1509. 

  1510.         for (;;)

  1511.         {

  1512.             try {

  1513.                 fDescriptor = descFn(i++);

  1514.             }

  1515.             catch(...) {

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

  1517.                 fDescriptor = nullptr;

  1518.                 break;

  1519.             }

  1520. 

  1521.             if (fDescriptor == nullptr)

  1522.                 break;

  1523. 

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

  1525.             {

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

  1527.                 fDescriptor = nullptr;

  1528.                 break;

  1529.             }

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

  1531.             {

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

  1533.                 fDescriptor = nullptr;

  1534.                 break;

  1535.             }

  1536. 

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

  1538.                 break;

  1539.         }

  1540. 

  1541.         if (fDescriptor == nullptr)

  1542.         {

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

  1544.             return false;

  1545.         }

  1546. 

  1547.         // ---------------------------------------------------------------

  1548.         // get info

  1549. 

  1550.         if (is_ladspa_rdf_descriptor_valid(rdfDescriptor, fDescriptor))

  1551.             fRdfDescriptor = ladspa_rdf_dup(rdfDescriptor);

  1552. 

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

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

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

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

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

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

  1559.         else

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

  1561. 

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

  1563. 

  1564.         // ---------------------------------------------------------------

  1565.         // register client

  1566. 

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

  1568. 

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

  1570.         {

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

  1572.             return false;

  1573.         }

  1574. 

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

  1576.         // initialize plugin

  1577. 

  1578.         try {

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

  1580.         } CARLA_SAFE_EXCEPTION("LADSPA instantiate");

  1581. 

  1582.         if (fHandle == nullptr)

  1583.         {

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

  1585.             return false;

  1586.         }

  1587. 

  1588.         // ---------------------------------------------------------------

  1589.         // load plugin settings

  1590. 

  1591.         {

  1592. #ifdef __USE_GNU

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

  1594. #else

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

  1596. #endif

  1597. 

  1598.             // set default options

  1599.             pData->options = 0x0;

  1600. 

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

  1602.                 pData->options |= PLUGIN_OPTION_FIXED_BUFFERS;

  1603. 

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

  1605.                 pData->options |= PLUGIN_OPTION_FORCE_STEREO;

  1606. 

  1607. #ifndef BUILD_BRIDGE

  1608.             // set identifier string

  1609.             CarlaString identifier("LADSPA/");

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

  1611.             identifier += ",";

  1612.             identifier += label;

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

  1614. 

  1615.             // load settings

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

  1617. 

  1618.             // ignore settings, we need this anyway

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

  1620.                 pData->options |= PLUGIN_OPTION_FIXED_BUFFERS;

  1621. #endif

  1622.         }

  1623. 

  1624.         return true;

  1625.     }

  1626. 

  1627.     // -------------------------------------------------------------------

  1628. 

  1629. private:

  1630.     LADSPA_Handle fHandle;

  1631.     LADSPA_Handle fHandle2;

  1632.     const LADSPA_Descriptor*     fDescriptor;

  1633.     const LADSPA_RDF_Descriptor* fRdfDescriptor;

  1634. 

  1635.     float** fAudioInBuffers;

  1636.     float** fAudioOutBuffers;

  1637.     float*  fParamBuffers;

  1638.     int32_t fLatencyIndex; // -1 if invalid

  1639. 

  1640.     // -------------------------------------------------------------------

  1641. 

  1642.     uint32_t getSafePortCount() const noexcept

  1643.     {

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

  1645.             return 0;

  1646. 

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

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

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

  1650. 

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

  1652.     }

  1653. 

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

  1655.     {

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

  1657.             return true;

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

  1659.             return true;

  1660.         return false;

  1661.     }

  1662. 

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

  1664.     {

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

  1666. 

  1667.         if (sepBracketStart == nullptr)

  1668.             return false;

  1669. 

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

  1671. 

  1672.         if (sepBracketEnd == nullptr)

  1673.             return false;

  1674. 

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

  1676. 

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

  1678.             return false;

  1679. 

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

  1681. 

  1682.         // just in case

  1683.         if (sepIndex > STR_MAX)

  1684.             return false;

  1685. 

  1686.         if (wantName)

  1687.         {

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

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

  1690.         }

  1691.         else

  1692.         {

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

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

  1695.         }

  1696. 

  1697.         return true;

  1698.     }

  1699. 

  1700.     // -------------------------------------------------------------------

  1701. 

  1702.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(LadspaPlugin)

  1703. };

  1704. 

  1705. CARLA_BACKEND_END_NAMESPACE

  1706. 

  1707. #endif // WANT_LADSPA

  1708. 

  1709. // -------------------------------------------------------------------------------------------------------------------

  1710. 

  1711. CARLA_BACKEND_START_NAMESPACE

  1712. 

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

  1714. {

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

  1716. 

  1717. #ifdef WANT_LADSPA

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

  1719. 

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

  1721.     {

  1722.         delete plugin;

  1723.         return nullptr;

  1724.     }

  1725. 

  1726.     plugin->reload();

  1727. 

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

  1729.     {

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

  1731.         delete plugin;

  1732.         return nullptr;

  1733.     }

  1734. 

  1735.     return plugin;

  1736. #else

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

  1738.     return nullptr;

  1739. #endif

  1740. }

  1741. 

  1742. CARLA_BACKEND_END_NAMESPACE

  1743. 

  1744. // -------------------------------------------------------------------------------------------------------------------