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.
1833 Commits
17 Branches
237MB
Tree: 4082180c1f
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '4082180c1f'
${ noResults }
Carla/source/backend/plugin/LadspaPlugin.cpp

1737 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.         if (getSeparatedParameterNameOrUnit(fDescriptor->PortNames[rindex], strBuf, false))

  354.             return;

  355. 

  356.         nullStrBuf(strBuf);

  357.     }

  358. 

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

  360.     {

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

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

  363. 

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

  365. 

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

  367.         {

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

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

  370. 

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

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

  373. 

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

  375.             return;

  376.         }

  377. 

  378.         nullStrBuf(strBuf);

  379.     }

  380. 

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

  382.     // Set data (state)

  383. 

  384.     // nothing

  385. 

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

  387.     // Set data (internal stuff)

  388. 

  389.     // nothing

  390. 

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

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

  393. 

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

  395.     {

  396.         CARLA_SAFE_ASSERT_RETURN(fParamBuffers != nullptr,);

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

  398. 

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

  400.         fParamBuffers[parameterId] = fixedValue;

  401. 

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

  403.     }

  404. 

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

  406.     // Set ui stuff

  407. 

  408.     // nothing

  409. 

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

  411.     // Plugin state

  412. 

  413.     void reload() override

  414.     {

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

  416.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  417.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

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

  419. 

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

  421. 

  422.         // Safely disable plugin for reload

  423.         const ScopedDisabler sd(this);

  424. 

  425.         if (pData->active)

  426.             deactivate();

  427. 

  428.         clearBuffers();

  429. 

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

  431.         const uint32_t portCount(getSafePortCount());

  432. 

  433.         uint32_t aIns, aOuts, params;

  434.         aIns = aOuts = params = 0;

  435. 

  436.         bool forcedStereoIn, forcedStereoOut;

  437.         forcedStereoIn = forcedStereoOut = false;

  438. 

  439.         bool needsCtrlIn, needsCtrlOut;

  440.         needsCtrlIn = needsCtrlOut = false;

  441. 

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

  443.         {

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

  445. 

  446.             if (LADSPA_IS_PORT_AUDIO(portType))

  447.             {

  448.                 if (LADSPA_IS_PORT_INPUT(portType))

  449.                     aIns += 1;

  450.                 else if (LADSPA_IS_PORT_OUTPUT(portType))

  451.                     aOuts += 1;

  452.             }

  453.             else if (LADSPA_IS_PORT_CONTROL(portType))

  454.                 params += 1;

  455.         }

  456. 

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

  458.         {

  459.             if (fHandle2 == nullptr)

  460.             {

  461.                 try {

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

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

  464.             }

  465. 

  466.             if (fHandle2 != nullptr)

  467.             {

  468.                 if (aIns == 1)

  469.                 {

  470.                     aIns = 2;

  471.                     forcedStereoIn = true;

  472.                 }

  473. 

  474.                 if (aOuts == 1)

  475.                 {

  476.                     aOuts = 2;

  477.                     forcedStereoOut = true;

  478.                 }

  479.             }

  480.         }

  481. 

  482.         if (aIns > 0)

  483.         {

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

  485.             fAudioInBuffers = new float*[aIns];

  486. 

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

  488.                 fAudioInBuffers[i] = nullptr;

  489.         }

  490. 

  491.         if (aOuts > 0)

  492.         {

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

  494.             fAudioOutBuffers = new float*[aOuts];

  495.             needsCtrlIn = true;

  496. 

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

  498.                 fAudioOutBuffers[i] = nullptr;

  499.         }

  500. 

  501.         if (params > 0)

  502.         {

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

  504. 

  505.             fParamBuffers = new float[params];

  506.             FLOAT_CLEAR(fParamBuffers, params);

  507.         }

  508. 

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

  510.         CarlaString portName;

  511. 

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

  513.         {

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

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

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

  517. 

  518.             if (LADSPA_IS_PORT_AUDIO(portType))

  519.             {

  520.                 portName.clear();

  521. 

  522.                 if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  523.                 {

  524.                     portName  = pData->name;

  525.                     portName += ":";

  526.                 }

  527. 

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

  529.                 {

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

  531.                 }

  532.                 else

  533.                 {

  534.                     if (LADSPA_IS_PORT_INPUT(portType))

  535.                     {

  536.                         if (aIns > 1)

  537.                         {

  538.                             portName += "audio-in_";

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

  540.                         }

  541.                         else

  542.                             portName += "audio-in";

  543.                     }

  544.                     else

  545.                     {

  546.                         if (aOuts > 1)

  547.                         {

  548.                             portName += "audio-out_";

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

  550.                         }

  551.                         else

  552.                             portName += "audio-out";

  553.                     }

  554.                 }

  555. 

  556.                 portName.truncate(portNameSize);

  557. 

  558.                 if (LADSPA_IS_PORT_INPUT(portType))

  559.                 {

  560.                     const uint32_t j = iAudioIn++;

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

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

  563. 

  564.                     if (forcedStereoIn)

  565.                     {

  566.                         portName += "_2";

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

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

  569.                     }

  570.                 }

  571.                 else if (LADSPA_IS_PORT_OUTPUT(portType))

  572.                 {

  573.                     const uint32_t j = iAudioOut++;

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

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

  576. 

  577.                     if (forcedStereoOut)

  578.                     {

  579.                         portName += "_2";

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

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

  582.                     }

  583.                 }

  584.                 else

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

  586.             }

  587.             else if (LADSPA_IS_PORT_CONTROL(portType))

  588.             {

  589.                 const uint32_t j = iCtrl++;

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

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

  592. 

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

  594. 

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

  596. 

  597.                 // min value

  598.                 if (LADSPA_IS_HINT_BOUNDED_BELOW(portRangeHints.HintDescriptor))

  599.                     min = portRangeHints.LowerBound;

  600.                 else

  601.                     min = 0.0f;

  602. 

  603.                 // max value

  604.                 if (LADSPA_IS_HINT_BOUNDED_ABOVE(portRangeHints.HintDescriptor))

  605.                     max = portRangeHints.UpperBound;

  606.                 else

  607.                     max = 1.0f;

  608. 

  609.                 if (min > max)

  610.                 {

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

  612.                     min = max - 0.1f;

  613.                 }

  614.                 else if (min == max)

  615.                 {

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

  617.                     max = min + 0.1f;

  618.                 }

  619. 

  620.                 // default value

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

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

  623.                 else

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

  625. 

  626.                 if (def < min)

  627.                     def = min;

  628.                 else if (def > max)

  629.                     def = max;

  630. 

  631.                 if (LADSPA_IS_HINT_SAMPLE_RATE(portRangeHints.HintDescriptor))

  632.                 {

  633.                     min *= sampleRate;

  634.                     max *= sampleRate;

  635.                     def *= sampleRate;

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

  637.                 }

  638. 

  639.                 if (LADSPA_IS_HINT_TOGGLED(portRangeHints.HintDescriptor))

  640.                 {

  641.                     step = max - min;

  642.                     stepSmall = step;

  643.                     stepLarge = step;

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

  645.                 }

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

  647.                 {

  648.                     step = 1.0f;

  649.                     stepSmall = 1.0f;

  650.                     stepLarge = 10.0f;

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

  652.                 }

  653.                 else

  654.                 {

  655.                     const float range = max - min;

  656.                     step = range/100.0f;

  657.                     stepSmall = range/1000.0f;

  658.                     stepLarge = range/10.0f;

  659.                 }

  660. 

  661.                 if (LADSPA_IS_PORT_INPUT(portType))

  662.                 {

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

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

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

  666.                     needsCtrlIn = true;

  667.                 }

  668.                 else if (LADSPA_IS_PORT_OUTPUT(portType))

  669.                 {

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

  671. 

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

  673.                     {

  674.                         min = 0.0f;

  675.                         max = sampleRate;

  676.                         def = 0.0f;

  677.                         step = 1.0f;

  678.                         stepSmall = 1.0f;

  679.                         stepLarge = 1.0f;

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

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

  682.                     }

  683.                     else

  684.                     {

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

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

  687.                         needsCtrlOut = true;

  688.                     }

  689.                 }

  690.                 else

  691.                 {

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

  693.                 }

  694. 

  695.                 // extra parameter hints

  696.                 if (LADSPA_IS_HINT_LOGARITHMIC(portRangeHints.HintDescriptor))

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

  698. 

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

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

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

  702. 

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

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

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

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

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

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

  709. 

  710.                 // Start parameters in their default values

  711.                 fParamBuffers[j] = def;

  712. 

  713.                 try {

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

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

  716. 

  717.                 if (fHandle2 != nullptr)

  718.                 {

  719.                     try {

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

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

  722.                 }

  723.             }

  724.             else

  725.             {

  726.                 // Not Audio or Control

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

  728. 

  729.                 try {

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

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

  732. 

  733.                 if (fHandle2 != nullptr)

  734.                 {

  735.                     try {

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

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

  738.                 }

  739.             }

  740.         }

  741. 

  742.         if (needsCtrlIn)

  743.         {

  744.             portName.clear();

  745. 

  746.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  747.             {

  748.                 portName  = pData->name;

  749.                 portName += ":";

  750.             }

  751. 

  752.             portName += "events-in";

  753.             portName.truncate(portNameSize);

  754. 

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

  756.         }

  757. 

  758.         if (needsCtrlOut)

  759.         {

  760.             portName.clear();

  761. 

  762.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  763.             {

  764.                 portName  = pData->name;

  765.                 portName += ":";

  766.             }

  767. 

  768.             portName += "events-out";

  769.             portName.truncate(portNameSize);

  770. 

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

  772.         }

  773. 

  774.         if (forcedStereoIn || forcedStereoOut)

  775.             pData->options |= PLUGIN_OPTION_FORCE_STEREO;

  776.         else

  777.             pData->options &= ~PLUGIN_OPTION_FORCE_STEREO;

  778. 

  779.         // plugin hints

  780.         pData->hints = 0x0;

  781. 

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

  783.             pData->hints |= PLUGIN_IS_RTSAFE;

  784. 

  785. #ifndef BUILD_BRIDGE

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

  787.             pData->hints |= PLUGIN_CAN_DRYWET;

  788. 

  789.         if (aOuts > 0)

  790.             pData->hints |= PLUGIN_CAN_VOLUME;

  791. 

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

  793.             pData->hints |= PLUGIN_CAN_BALANCE;

  794. #endif

  795. 

  796.         // extra plugin hints

  797.         pData->extraHints = 0x0;

  798. 

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

  800.             pData->extraHints |= PLUGIN_EXTRA_HINT_CAN_RUN_RACK;

  801. 

  802.         // check latency

  803.         if (fLatencyIndex >= 0)

  804.         {

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

  806. 

  807.             float tmpIn[aIns][2];

  808.             float tmpOut[aOuts][2];

  809. 

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

  811.             {

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

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

  814. 

  815.                 try {

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

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

  818.             }

  819. 

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

  821.             {

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

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

  824. 

  825.                 try {

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

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

  828.             }

  829. 

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

  831.             {

  832.                 try {

  833.                     fDescriptor->activate(fHandle);

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

  835.             }

  836. 

  837.             try {

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

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

  840. 

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

  842.             {

  843.                 try {

  844.                     fDescriptor->deactivate(fHandle);

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

  846.             }

  847. 

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

  849. 

  850.             if (latency >= 0)

  851.             {

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

  853. 

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

  855.                 {

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

  857. 

  858.                     pData->latency = ulatency;

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

  860. #ifndef BUILD_BRIDGE

  861.                     pData->recreateLatencyBuffers();

  862. #endif

  863.                 }

  864.             }

  865.             else

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

  867.         }

  868. 

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

  870. 

  871.         if (pData->active)

  872.             activate();

  873. 

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

  875.     }

  876. 

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

  878.     // Plugin processing

  879. 

  880.     void activate() noexcept override

  881.     {

  882.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  883.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  884. 

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

  886.         {

  887.             try {

  888.                 fDescriptor->activate(fHandle);

  889.             } CARLA_SAFE_EXCEPTION("LADSPA activate");

  890. 

  891.             if (fHandle2 != nullptr)

  892.             {

  893.                 try {

  894.                     fDescriptor->activate(fHandle2);

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

  896.             }

  897.         }

  898. 

  899.         if (fLatencyIndex < 0)

  900.             return;

  901. 

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

  903.         CARLA_SAFE_ASSERT_RETURN(latency >= 0,);

  904. 

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

  906. 

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

  908.         {

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

  910. 

  911.             pData->latency = ulatency;

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

  913. #ifndef BUILD_BRIDGE

  914.             pData->recreateLatencyBuffers();

  915. #endif

  916.         }

  917.         else

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

  919.     }

  920. 

  921.     void deactivate() noexcept override

  922.     {

  923.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  924.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  925. 

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

  927.         {

  928.             try {

  929.                 fDescriptor->deactivate(fHandle);

  930.             } CARLA_SAFE_EXCEPTION("LADSPA deactivate");

  931. 

  932.             if (fHandle2 != nullptr)

  933.             {

  934.                 try {

  935.                     fDescriptor->deactivate(fHandle2);

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

  937.             }

  938.         }

  939.     }

  940. 

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

  942.     {

  943.         // --------------------------------------------------------------------------------------------------------

  944.         // Check if active

  945. 

  946.         if (! pData->active)

  947.         {

  948.             // disable any output sound

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

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

  951.             return;

  952.         }

  953. 

  954.         // --------------------------------------------------------------------------------------------------------

  955.         // Check if needs reset

  956. 

  957.         if (pData->needsReset)

  958.         {

  959. #ifndef BUILD_BRIDGE

  960.             if (pData->latency > 0)

  961.             {

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

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

  964.             }

  965. #endif

  966. 

  967.             pData->needsReset = false;

  968.         }

  969. 

  970.         // --------------------------------------------------------------------------------------------------------

  971.         // Event Input and Processing

  972. 

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

  974.         {

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

  976.             // Event Input (System)

  977. 

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

  979. 

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

  981.             uint32_t timeOffset = 0;

  982. 

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

  984.             {

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

  986. 

  987.                 if (event.time >= frames)

  988.                     continue;

  989. 

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

  991. 

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

  993.                 {

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

  995.                         timeOffset = event.time;

  996.                 }

  997. 

  998.                 switch (event.type)

  999.                 {

  1000.                 case kEngineEventTypeNull:

  1001.                     break;

  1002. 

  1003.                 case kEngineEventTypeControl: {

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

  1005. 

  1006.                     switch (ctrlEvent.type)

  1007.                     {

  1008.                     case kEngineControlEventTypeNull:

  1009.                         break;

  1010. 

  1011.                     case kEngineControlEventTypeParameter: {

  1012. #ifndef BUILD_BRIDGE

  1013.                         // Control backend stuff

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

  1015.                         {

  1016.                             float value;

  1017. 

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

  1019.                             {

  1020.                                 value = ctrlEvent.value;

  1021.                                 setDryWet(value, false, false);

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

  1023.                                 break;

  1024.                             }

  1025. 

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

  1027.                             {

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

  1029.                                 setVolume(value, false, false);

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

  1031.                                 break;

  1032.                             }

  1033. 

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

  1035.                             {

  1036.                                 float left, right;

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

  1038. 

  1039.                                 if (value < 0.0f)

  1040.                                 {

  1041.                                     left  = -1.0f;

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

  1043.                                 }

  1044.                                 else if (value > 0.0f)

  1045.                                 {

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

  1047.                                     right = 1.0f;

  1048.                                 }

  1049.                                 else

  1050.                                 {

  1051.                                     left  = -1.0f;

  1052.                                     right = 1.0f;

  1053.                                 }

  1054. 

  1055.                                 setBalanceLeft(left, false, false);

  1056.                                 setBalanceRight(right, false, false);

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

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

  1059.                                 break;

  1060.                             }

  1061.                         }

  1062. #endif

  1063. 

  1064.                         // Control plugin parameters

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

  1066.                         {

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

  1068.                                 continue;

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

  1070.                                 continue;

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

  1072.                                 continue;

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

  1074.                                 continue;

  1075. 

  1076.                             float value;

  1077. 

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

  1079.                             {

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

  1081.                             }

  1082.                             else

  1083.                             {

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

  1085. 

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

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

  1088.                             }

  1089. 

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

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

  1092.                             break;

  1093.                         }

  1094. 

  1095.                         break;

  1096.                     } // case kEngineControlEventTypeParameter

  1097. 

  1098.                     case kEngineControlEventTypeMidiBank:

  1099.                     case kEngineControlEventTypeMidiProgram:

  1100.                     case kEngineControlEventTypeAllSoundOff:

  1101.                     case kEngineControlEventTypeAllNotesOff:

  1102.                         break;

  1103.                     } // switch (ctrlEvent.type)

  1104.                     break;

  1105.                 } // case kEngineEventTypeControl

  1106. 

  1107.                 case kEngineEventTypeMidi:

  1108.                     break;

  1109.                 } // switch (event.type)

  1110.             }

  1111. 

  1112.             pData->postRtEvents.trySplice();

  1113. 

  1114.             if (frames > timeOffset)

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

  1116. 

  1117.         } // End of Event Input and Processing

  1118. 

  1119.         // --------------------------------------------------------------------------------------------------------

  1120.         // Plugin processing (no events)

  1121. 

  1122.         else

  1123.         {

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

  1125. 

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

  1127. 

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

  1129.         // Latency, save values for next callback

  1130. 

  1131.         if (pData->latency > 0)

  1132.         {

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

  1134.             {

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

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

  1137.             }

  1138.             else

  1139.             {

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

  1141.                 {

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

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

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

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

  1146.                 }

  1147.             }

  1148.         }

  1149. 

  1150.         // --------------------------------------------------------------------------------------------------------

  1151.         // Control Output

  1152. 

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

  1154.         {

  1155.             uint8_t  channel;

  1156.             uint16_t param;

  1157.             float    value;

  1158. 

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

  1160.             {

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

  1162.                     continue;

  1163. 

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

  1165. 

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

  1167.                 {

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

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

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

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

  1172.                 }

  1173.             }

  1174.         } // End of Control Output

  1175.     }

  1176. 

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

  1178.     {

  1179.         CARLA_SAFE_ASSERT_RETURN(frames > 0, false);

  1180. 

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

  1182.         {

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

  1184.         }

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

  1186.         {

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

  1188.         }

  1189. 

  1190.         // --------------------------------------------------------------------------------------------------------

  1191.         // Try lock, silence otherwise

  1192. 

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

  1194.         {

  1195.             pData->singleMutex.lock();

  1196.         }

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

  1198.         {

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

  1200.             {

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

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

  1203.             }

  1204. 

  1205.             return false;

  1206.         }

  1207. 

  1208.         // --------------------------------------------------------------------------------------------------------

  1209.         // Reset audio buffers

  1210. 

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

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

  1213. 

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

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

  1216. 

  1217.         // --------------------------------------------------------------------------------------------------------

  1218.         // Run plugin

  1219. 

  1220.         try {

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

  1222.         } CARLA_SAFE_EXCEPTION("LADSPA run");

  1223. 

  1224.         if (fHandle2 != nullptr)

  1225.         {

  1226.             try {

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

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

  1229.         }

  1230. 

  1231. #ifndef BUILD_BRIDGE

  1232.         // --------------------------------------------------------------------------------------------------------

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

  1234. 

  1235.         {

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

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

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

  1239. 

  1240.             bool isPair;

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

  1242. 

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

  1244.             {

  1245.                 // Dry/Wet

  1246.                 if (doDryWet)

  1247.                 {

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

  1249.                     {

  1250.                         if (k < pData->latency)

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

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

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

  1254.                         else

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

  1256. 

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

  1258.                     }

  1259.                 }

  1260. 

  1261.                 // Balance

  1262.                 if (doBalance)

  1263.                 {

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

  1265. 

  1266.                     if (isPair)

  1267.                     {

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

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

  1270.                     }

  1271. 

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

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

  1274. 

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

  1276.                     {

  1277.                         if (isPair)

  1278.                         {

  1279.                             // left

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

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

  1282.                         }

  1283.                         else

  1284.                         {

  1285.                             // right

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

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

  1288.                         }

  1289.                     }

  1290.                 }

  1291. 

  1292.                 // Volume (and buffer copy)

  1293.                 {

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

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

  1296.                 }

  1297.             }

  1298. 

  1299.         } // End of Post-processing

  1300. 

  1301. #else // BUILD_BRIDGE

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

  1303.         {

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

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

  1306.         }

  1307. #endif

  1308. 

  1309.         // --------------------------------------------------------------------------------------------------------

  1310. 

  1311.         pData->singleMutex.unlock();

  1312.         return true;

  1313.     }

  1314. 

  1315.     void bufferSizeChanged(const uint32_t newBufferSize) override

  1316.     {

  1317.         CARLA_ASSERT_INT(newBufferSize > 0, newBufferSize);

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

  1319. 

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

  1321.         {

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

  1323.                 delete[] fAudioInBuffers[i];

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

  1325.         }

  1326. 

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

  1328.         {

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

  1330.                 delete[] fAudioOutBuffers[i];

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

  1332.         }

  1333. 

  1334.         if (fHandle2 == nullptr)

  1335.         {

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

  1337.             {

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

  1339. 

  1340.                 try {

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

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

  1343.             }

  1344. 

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

  1346.             {

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

  1348. 

  1349.                 try {

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

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

  1352.             }

  1353.         }

  1354.         else

  1355.         {

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

  1357.             {

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

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

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

  1361. 

  1362.                 try {

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

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

  1365. 

  1366.                 try {

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

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

  1369.             }

  1370. 

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

  1372.             {

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

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

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

  1376. 

  1377.                 try {

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

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

  1380. 

  1381.                 try {

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

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

  1384.             }

  1385.         }

  1386. 

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

  1388.     }

  1389. 

  1390.     void sampleRateChanged(const double newSampleRate) override

  1391.     {

  1392.         CARLA_ASSERT_INT(newSampleRate > 0.0, newSampleRate);

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

  1394. 

  1395.         // TODO

  1396.         (void)newSampleRate;

  1397. 

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

  1399.     }

  1400. 

  1401.     // -------------------------------------------------------------------

  1402.     // Plugin buffers

  1403. 

  1404.     void clearBuffers() noexcept override

  1405.     {

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

  1407. 

  1408.         if (fAudioInBuffers != nullptr)

  1409.         {

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

  1411.             {

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

  1413.                 {

  1414.                     delete[] fAudioInBuffers[i];

  1415.                     fAudioInBuffers[i] = nullptr;

  1416.                 }

  1417.             }

  1418. 

  1419.             delete[] fAudioInBuffers;

  1420.             fAudioInBuffers = nullptr;

  1421.         }

  1422. 

  1423.         if (fAudioOutBuffers != nullptr)

  1424.         {

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

  1426.             {

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

  1428.                 {

  1429.                     delete[] fAudioOutBuffers[i];

  1430.                     fAudioOutBuffers[i] = nullptr;

  1431.                 }

  1432.             }

  1433. 

  1434.             delete[] fAudioOutBuffers;

  1435.             fAudioOutBuffers = nullptr;

  1436.         }

  1437. 

  1438.         if (fParamBuffers != nullptr)

  1439.         {

  1440.             delete[] fParamBuffers;

  1441.             fParamBuffers = nullptr;

  1442.         }

  1443. 

  1444.         CarlaPlugin::clearBuffers();

  1445. 

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

  1447.     }

  1448. 

  1449.     // -------------------------------------------------------------------

  1450. 

  1451.     const void* getExtraStuff() const noexcept override

  1452.     {

  1453.         return fRdfDescriptor;

  1454.     }

  1455. 

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

  1457.     {

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

  1459. 

  1460.         // ---------------------------------------------------------------

  1461.         // first checks

  1462. 

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

  1464.         {

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

  1466.             return false;

  1467.         }

  1468. 

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

  1470.         {

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

  1472.             return false;

  1473.         }

  1474. 

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

  1476.         {

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

  1478.             return false;

  1479.         }

  1480. 

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

  1482.         // open DLL

  1483. 

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

  1485.         {

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

  1487.             return false;

  1488.         }

  1489. 

  1490.         // ---------------------------------------------------------------

  1491.         // get DLL main entry

  1492. 

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

  1494. 

  1495.         if (descFn == nullptr)

  1496.         {

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

  1498.             return false;

  1499.         }

  1500. 

  1501.         // ---------------------------------------------------------------

  1502.         // get descriptor that matches label

  1503. 

  1504.         ulong i = 0;

  1505. 

  1506.         for (;;)

  1507.         {

  1508.             try {

  1509.                 fDescriptor = descFn(i++);

  1510.             }

  1511.             catch(...) {

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

  1513.                 fDescriptor = nullptr;

  1514.                 break;

  1515.             }

  1516. 

  1517.             if (fDescriptor == nullptr)

  1518.                 break;

  1519. 

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

  1521.             {

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

  1523.                 fDescriptor = nullptr;

  1524.                 break;

  1525.             }

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

  1527.             {

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

  1529.                 fDescriptor = nullptr;

  1530.                 break;

  1531.             }

  1532. 

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

  1534.                 break;

  1535.         }

  1536. 

  1537.         if (fDescriptor == nullptr)

  1538.         {

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

  1540.             return false;

  1541.         }

  1542. 

  1543.         // ---------------------------------------------------------------

  1544.         // get info

  1545. 

  1546.         if (is_ladspa_rdf_descriptor_valid(rdfDescriptor, fDescriptor))

  1547.             fRdfDescriptor = ladspa_rdf_dup(rdfDescriptor);

  1548. 

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

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

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

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

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

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

  1555.         else

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

  1557. 

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

  1559. 

  1560.         // ---------------------------------------------------------------

  1561.         // register client

  1562. 

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

  1564. 

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

  1566.         {

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

  1568.             return false;

  1569.         }

  1570. 

  1571.         // ---------------------------------------------------------------

  1572.         // initialize plugin

  1573. 

  1574.         try {

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

  1576.         } CARLA_SAFE_EXCEPTION("LADSPA instantiate");

  1577. 

  1578.         if (fHandle == nullptr)

  1579.         {

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

  1581.             return false;

  1582.         }

  1583. 

  1584.         // ---------------------------------------------------------------

  1585.         // load plugin settings

  1586. 

  1587.         {

  1588. #ifdef __USE_GNU

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

  1590. #else

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

  1592. #endif

  1593. 

  1594.             // set default options

  1595.             pData->options = 0x0;

  1596. 

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

  1598.                 pData->options |= PLUGIN_OPTION_FIXED_BUFFERS;

  1599. 

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

  1601.                 pData->options |= PLUGIN_OPTION_FORCE_STEREO;

  1602. 

  1603. #ifndef BUILD_BRIDGE

  1604.             // set identifier string

  1605.             CarlaString identifier("LADSPA/");

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

  1607.             identifier += ",";

  1608.             identifier += label;

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

  1610. 

  1611.             // load settings

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

  1613. 

  1614.             // ignore settings, we need this anyway

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

  1616.                 pData->options |= PLUGIN_OPTION_FIXED_BUFFERS;

  1617. #endif

  1618.         }

  1619. 

  1620.         return true;

  1621.     }

  1622. 

  1623.     // -------------------------------------------------------------------

  1624. 

  1625. private:

  1626.     LADSPA_Handle fHandle;

  1627.     LADSPA_Handle fHandle2;

  1628.     const LADSPA_Descriptor*     fDescriptor;

  1629.     const LADSPA_RDF_Descriptor* fRdfDescriptor;

  1630. 

  1631.     float** fAudioInBuffers;

  1632.     float** fAudioOutBuffers;

  1633.     float*  fParamBuffers;

  1634.     int32_t fLatencyIndex; // -1 if invalid

  1635. 

  1636.     uint32_t getSafePortCount() const noexcept

  1637.     {

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

  1639.             return 0;

  1640. 

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

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

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

  1644. 

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

  1646.     }

  1647. 

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

  1649.     {

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

  1651.             return true;

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

  1653.             return true;

  1654.         return false;

  1655.     }

  1656. 

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

  1658.     {

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

  1660. 

  1661.         if (sepBracketStart == nullptr)

  1662.             return false;

  1663. 

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

  1665. 

  1666.         if (sepBracketEnd == nullptr)

  1667.             return false;

  1668. 

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

  1670. 

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

  1672.             return false;

  1673. 

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

  1675. 

  1676.         // just in case

  1677.         if (sepIndex > STR_MAX)

  1678.             return false;

  1679. 

  1680.         if (wantName)

  1681.         {

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

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

  1684.         }

  1685.         else

  1686.         {

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

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

  1689.         }

  1690. 

  1691.         return true;

  1692.     }

  1693. 

  1694.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(LadspaPlugin)

  1695. };

  1696. 

  1697. CARLA_BACKEND_END_NAMESPACE

  1698. 

  1699. #endif // WANT_LADSPA

  1700. 

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

  1702. 

  1703. CARLA_BACKEND_START_NAMESPACE

  1704. 

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

  1706. {

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

  1708. 

  1709. #ifdef WANT_LADSPA

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

  1711. 

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

  1713.     {

  1714.         delete plugin;

  1715.         return nullptr;

  1716.     }

  1717. 

  1718.     plugin->reload();

  1719. 

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

  1721.     {

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

  1723.         delete plugin;

  1724.         return nullptr;

  1725.     }

  1726. 

  1727.     return plugin;

  1728. #else

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

  1730.     return nullptr;

  1731. #endif

  1732. }

  1733. 

  1734. CARLA_BACKEND_END_NAMESPACE

  1735. 

  1736. // -------------------------------------------------------------------------------------------------------------------