falkTX
/
Cadence
mirror of https://github.com/falkTX/Cadence
1
0
Fork 0
Code Releases 3 Activity
Collection of tools useful for audio production
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.
785 Commits
2 Branches
142MB
Tree: 721a95d7ac
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '721a95d7ac'
${ noResults }
Cadence/c++/carla-plugin/ladspa.cpp

1275 lines
41KB
Raw Blame History 

  1. /*

  2.  * Carla LADSPA Plugin

  3.  * Copyright (C) 2011-2012 Filipe Coelho <falktx@falktx.com>

  4.  *

  5.  * This program is free software; you can redistribute it and/or modify

  6.  * it under the terms of the GNU General Public License as published by

  7.  * the Free Software Foundation; either version 2 of the License, or

  8.  * 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 COPYING file

  16.  */

  17. 

  18. #include "carla_plugin.hpp"

  19. 

  20. #ifdef WANT_LADSPA

  21. 

  22. #include "carla_ladspa_utils.hpp"

  23. 

  24. CARLA_BACKEND_START_NAMESPACE

  25. 

  26. /*!

  27.  * @defgroup CarlaBackendLadspaPlugin Carla Backend LADSPA Plugin

  28.  *

  29.  * The Carla Backend LADSPA Plugin.\n

  30.  * http://www.ladspa.org/

  31.  * @{

  32.  */

  33. 

  34. class LadspaPlugin : public CarlaPlugin

  35. {

  36. public:

  37.     LadspaPlugin(CarlaEngine* const engine, const unsigned short id)

  38.         : CarlaPlugin(engine, id)

  39.     {

  40.         qDebug("LadspaPlugin::LadspaPlugin()");

  41. 

  42.         m_type = PLUGIN_LADSPA;

  43. 

  44.         handle = h2 = nullptr;

  45.         descriptor  = nullptr;

  46.         rdf_descriptor = nullptr;

  47. 

  48.         paramBuffers = nullptr;

  49.     }

  50. 

  51.     ~LadspaPlugin()

  52.     {

  53.         qDebug("LadspaPlugin::~LadspaPlugin()");

  54. 

  55.         if (descriptor)

  56.         {

  57.             if (descriptor->deactivate && m_activeBefore)

  58.             {

  59.                 if (handle)

  60.                     descriptor->deactivate(handle);

  61.                 if (h2)

  62.                     descriptor->deactivate(h2);

  63.             }

  64. 

  65.             if (descriptor->cleanup)

  66.             {

  67.                 if (handle)

  68.                     descriptor->cleanup(handle);

  69.                 if (h2)

  70.                     descriptor->cleanup(h2);

  71.             }

  72.         }

  73. 

  74.         if (rdf_descriptor)

  75.             delete rdf_descriptor;

  76.     }

  77. 

  78.     // -------------------------------------------------------------------

  79.     // Information (base)

  80. 

  81.     PluginCategory category()

  82.     {

  83.         if (rdf_descriptor)

  84.         {

  85.             const LADSPA_Properties category = rdf_descriptor->Type;

  86. 

  87.             // Specific Types

  88.             if (category & (LADSPA_CLASS_DELAY|LADSPA_CLASS_REVERB))

  89.                 return PLUGIN_CATEGORY_DELAY;

  90.             if (category & (LADSPA_CLASS_PHASER|LADSPA_CLASS_FLANGER|LADSPA_CLASS_CHORUS))

  91.                 return PLUGIN_CATEGORY_MODULATOR;

  92.             if (category & (LADSPA_CLASS_AMPLIFIER))

  93.                 return PLUGIN_CATEGORY_DYNAMICS;

  94.             if (category & (LADSPA_CLASS_UTILITY|LADSPA_CLASS_SPECTRAL|LADSPA_CLASS_FREQUENCY_METER))

  95.                 return PLUGIN_CATEGORY_UTILITY;

  96. 

  97.             // Pre-set LADSPA Types

  98.             if (LADSPA_IS_PLUGIN_DYNAMICS(category))

  99.                 return PLUGIN_CATEGORY_DYNAMICS;

  100.             if (LADSPA_IS_PLUGIN_AMPLITUDE(category))

  101.                 return PLUGIN_CATEGORY_MODULATOR;

  102.             if (LADSPA_IS_PLUGIN_EQ(category))

  103.                 return PLUGIN_CATEGORY_EQ;

  104.             if (LADSPA_IS_PLUGIN_FILTER(category))

  105.                 return PLUGIN_CATEGORY_FILTER;

  106.             if (LADSPA_IS_PLUGIN_FREQUENCY(category))

  107.                 return PLUGIN_CATEGORY_UTILITY;

  108.             if (LADSPA_IS_PLUGIN_SIMULATOR(category))

  109.                 return PLUGIN_CATEGORY_OTHER;

  110.             if (LADSPA_IS_PLUGIN_TIME(category))

  111.                 return PLUGIN_CATEGORY_DELAY;

  112.             if (LADSPA_IS_PLUGIN_GENERATOR(category))

  113.                 return PLUGIN_CATEGORY_SYNTH;

  114.         }

  115. 

  116.         return getPluginCategoryFromName(m_name);

  117.     }

  118. 

  119.     long uniqueId()

  120.     {

  121.         CARLA_ASSERT(descriptor);

  122. 

  123.         return descriptor->UniqueID;

  124.     }

  125. 

  126.     // -------------------------------------------------------------------

  127.     // Information (count)

  128. 

  129.     uint32_t parameterScalePointCount(const uint32_t parameterId)

  130.     {

  131.         CARLA_ASSERT(parameterId < param.count);

  132. 

  133.         int32_t rindex = param.data[parameterId].rindex;

  134. 

  135.         if (rdf_descriptor && rindex < (int32_t)rdf_descriptor->PortCount)

  136.         {

  137.             const LADSPA_RDF_Port* const port = &rdf_descriptor->Ports[rindex];

  138. 

  139.             if (port)

  140.                 return port->ScalePointCount;

  141.         }

  142. 

  143.         return 0;

  144.     }

  145. 

  146.     // -------------------------------------------------------------------

  147.     // Information (per-plugin data)

  148. 

  149.     double getParameterValue(const uint32_t parameterId)

  150.     {

  151.         CARLA_ASSERT(parameterId < param.count);

  152. 

  153.         return paramBuffers[parameterId];

  154.     }

  155. 

  156.     double getParameterScalePointValue(const uint32_t parameterId, const uint32_t scalePointId)

  157.     {

  158.         CARLA_ASSERT(parameterId < param.count);

  159.         CARLA_ASSERT(scalePointId < parameterScalePointCount(parameterId));

  160. 

  161.         int32_t rindex = param.data[parameterId].rindex;

  162. 

  163.         if (rdf_descriptor && rindex < (int32_t)rdf_descriptor->PortCount)

  164.         {

  165.             const LADSPA_RDF_Port* const port = &rdf_descriptor->Ports[rindex];

  166. 

  167.             if (port && scalePointId < port->ScalePointCount)

  168.             {

  169.                 const LADSPA_RDF_ScalePoint* const scalePoint = &port->ScalePoints[scalePointId];

  170. 

  171.                 if (scalePoint)

  172.                     return scalePoint->Value;

  173.             }

  174.         }

  175. 

  176.         return 0.0;

  177.     }

  178. 

  179.     void getLabel(char* const strBuf)

  180.     {

  181.         CARLA_ASSERT(descriptor);

  182. 

  183.         if (descriptor && descriptor->Label)

  184.             strncpy(strBuf, descriptor->Label, STR_MAX);

  185.         else

  186.             CarlaPlugin::getLabel(strBuf);

  187.     }

  188. 

  189.     void getMaker(char* const strBuf)

  190.     {

  191.         CARLA_ASSERT(descriptor);

  192. 

  193.         if (rdf_descriptor && rdf_descriptor->Creator)

  194.             strncpy(strBuf, rdf_descriptor->Creator, STR_MAX);

  195.         else if (descriptor && descriptor->Maker)

  196.             strncpy(strBuf, descriptor->Maker, STR_MAX);

  197.         else

  198.             CarlaPlugin::getMaker(strBuf);

  199.     }

  200. 

  201.     void getCopyright(char* const strBuf)

  202.     {

  203.         CARLA_ASSERT(descriptor);

  204. 

  205.         if (descriptor && descriptor->Copyright)

  206.             strncpy(strBuf, descriptor->Copyright, STR_MAX);

  207.         else

  208.             CarlaPlugin::getCopyright(strBuf);

  209.     }

  210. 

  211.     void getRealName(char* const strBuf)

  212.     {

  213.         CARLA_ASSERT(descriptor);

  214. 

  215.         if (rdf_descriptor && rdf_descriptor->Title)

  216.             strncpy(strBuf, rdf_descriptor->Title, STR_MAX);

  217.         else if (descriptor && descriptor->Name)

  218.             strncpy(strBuf, descriptor->Name, STR_MAX);

  219.         else

  220.             CarlaPlugin::getRealName(strBuf);

  221.     }

  222. 

  223.     void getParameterName(const uint32_t parameterId, char* const strBuf)

  224.     {

  225.         CARLA_ASSERT(descriptor);

  226.         CARLA_ASSERT(parameterId < param.count);

  227. 

  228.         int32_t rindex = param.data[parameterId].rindex;

  229. 

  230.         if (descriptor && rindex < (int32_t)descriptor->PortCount)

  231.             strncpy(strBuf, descriptor->PortNames[rindex], STR_MAX);

  232.         else

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

  234.     }

  235. 

  236.     void getParameterSymbol(const uint32_t parameterId, char* const strBuf)

  237.     {

  238.         CARLA_ASSERT(parameterId < param.count);

  239. 

  240.         int32_t rindex = param.data[parameterId].rindex;

  241. 

  242.         if (rdf_descriptor && rindex < (int32_t)rdf_descriptor->PortCount)

  243.         {

  244.             const LADSPA_RDF_Port* const port = &rdf_descriptor->Ports[rindex];

  245. 

  246.             if (LADSPA_PORT_HAS_LABEL(port->Hints) && port->Label)

  247.             {

  248.                 strncpy(strBuf, port->Label, STR_MAX);

  249.                 return;

  250.             }

  251.         }

  252. 

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

  254.     }

  255. 

  256.     void getParameterUnit(const uint32_t parameterId, char* const strBuf)

  257.     {

  258.         CARLA_ASSERT(parameterId < param.count);

  259. 

  260.         int32_t rindex = param.data[parameterId].rindex;

  261. 

  262.         if (rdf_descriptor && rindex < (int32_t)rdf_descriptor->PortCount)

  263.         {

  264.             const LADSPA_RDF_Port* const port = &rdf_descriptor->Ports[rindex];

  265. 

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

  267.             {

  268.                 switch (port->Unit)

  269.                 {

  270.                 case LADSPA_UNIT_DB:

  271.                     strncpy(strBuf, "dB", STR_MAX);

  272.                     return;

  273.                 case LADSPA_UNIT_COEF:

  274.                     strncpy(strBuf, "(coef)", STR_MAX);

  275.                     return;

  276.                 case LADSPA_UNIT_HZ:

  277.                     strncpy(strBuf, "Hz", STR_MAX);

  278.                     return;

  279.                 case LADSPA_UNIT_S:

  280.                     strncpy(strBuf, "s", STR_MAX);

  281.                     return;

  282.                 case LADSPA_UNIT_MS:

  283.                     strncpy(strBuf, "ms", STR_MAX);

  284.                     return;

  285.                 case LADSPA_UNIT_MIN:

  286.                     strncpy(strBuf, "min", STR_MAX);

  287.                     return;

  288.                 }

  289.             }

  290.         }

  291. 

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

  293.     }

  294. 

  295.     void getParameterScalePointLabel(const uint32_t parameterId, const uint32_t scalePointId, char* const strBuf)

  296.     {

  297.         CARLA_ASSERT(parameterId < param.count);

  298.         CARLA_ASSERT(scalePointId < parameterScalePointCount(parameterId));

  299. 

  300.         int32_t rindex = param.data[parameterId].rindex;

  301. 

  302.         if (rdf_descriptor && rindex < (int32_t)rdf_descriptor->PortCount)

  303.         {

  304.             const LADSPA_RDF_Port* const port = &rdf_descriptor->Ports[rindex];

  305. 

  306.             if (port && scalePointId < port->ScalePointCount)

  307.             {

  308.                 const LADSPA_RDF_ScalePoint* const scalePoint = &port->ScalePoints[scalePointId];

  309. 

  310.                 if (scalePoint && scalePoint->Label)

  311.                 {

  312.                     strncpy(strBuf, scalePoint->Label, STR_MAX);

  313.                     return;

  314.                 }

  315.             }

  316.         }

  317. 

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

  319.     }

  320. 

  321.     // -------------------------------------------------------------------

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

  323. 

  324.     void setParameterValue(const uint32_t parameterId, double value, const bool sendGui, const bool sendOsc, const bool sendCallback)

  325.     {

  326.         CARLA_ASSERT(parameterId < param.count);

  327. 

  328.         paramBuffers[parameterId] = fixParameterValue(value, param.ranges[parameterId]);

  329. 

  330.         CarlaPlugin::setParameterValue(parameterId, value, sendGui, sendOsc, sendCallback);

  331.     }

  332. 

  333.     // -------------------------------------------------------------------

  334.     // Plugin state

  335. 

  336.     void reload()

  337.     {

  338.         qDebug("LadspaPlugin::reload() - start");

  339.         CARLA_ASSERT(descriptor);

  340. 

  341. #ifndef BUILD_BRIDGE

  342.         const ProcessMode processMode(x_engine->getOptions().processMode);

  343. #endif

  344. 

  345.         // Safely disable plugin for reload

  346.         const ScopedDisabler m(this);

  347. 

  348.         if (x_client->isActive())

  349.             x_client->deactivate();

  350. 

  351.         // Remove client ports

  352.         removeClientPorts();

  353. 

  354.         // Delete old data

  355.         deleteBuffers();

  356. 

  357.         uint32_t aIns, aOuts, params, j;

  358.         aIns = aOuts = params = 0;

  359. 

  360.         const double sampleRate = x_engine->getSampleRate();

  361.         const unsigned long portCount = descriptor->PortCount;

  362. 

  363.         bool forcedStereoIn, forcedStereoOut;

  364.         forcedStereoIn = forcedStereoOut = false;

  365. 

  366.         for (unsigned long i=0; i < portCount; i++)

  367.         {

  368.             const LADSPA_PortDescriptor portType = descriptor->PortDescriptors[i];

  369. 

  370.             if (LADSPA_IS_PORT_AUDIO(portType))

  371.             {

  372.                 if (LADSPA_IS_PORT_INPUT(portType))

  373.                     aIns += 1;

  374.                 else if (LADSPA_IS_PORT_OUTPUT(portType))

  375.                     aOuts += 1;

  376.             }

  377.             else if (LADSPA_IS_PORT_CONTROL(portType))

  378.                 params += 1;

  379.         }

  380. 

  381. #ifndef BUILD_BRIDGE

  382.         if (x_engine->getOptions().forceStereo && (aIns == 1 || aOuts == 1) && ! h2)

  383.         {

  384.             h2 = descriptor->instantiate(descriptor, sampleRate);

  385. 

  386.             if (aIns == 1)

  387.             {

  388.                 aIns = 2;

  389.                 forcedStereoIn = true;

  390.             }

  391. 

  392.             if (aOuts == 1)

  393.             {

  394.                 aOuts = 2;

  395.                 forcedStereoOut = true;

  396.             }

  397.         }

  398. #endif

  399. 

  400.         if (aIns > 0)

  401.         {

  402.             aIn.ports    = new CarlaEngineAudioPort*[aIns];

  403.             aIn.rindexes = new uint32_t[aIns];

  404.         }

  405. 

  406.         if (aOuts > 0)

  407.         {

  408.             aOut.ports    = new CarlaEngineAudioPort*[aOuts];

  409.             aOut.rindexes = new uint32_t[aOuts];

  410.         }

  411. 

  412.         if (params > 0)

  413.         {

  414.             param.data   = new ParameterData[params];

  415.             param.ranges = new ParameterRanges[params];

  416.             paramBuffers = new float[params];

  417.         }

  418. 

  419.         bool needsCtrlIn  = false;

  420.         bool needsCtrlOut = false;

  421. 

  422.         const int   portNameSize = x_engine->maxPortNameSize();

  423.         CarlaString portName;

  424. 

  425.         for (unsigned long i=0; i < portCount; i++)

  426.         {

  427.             const LADSPA_PortDescriptor portType = descriptor->PortDescriptors[i];

  428.             const LADSPA_PortRangeHint portHints = descriptor->PortRangeHints[i];

  429.             const bool hasPortRDF = (rdf_descriptor && i < rdf_descriptor->PortCount);

  430. 

  431.             if (LADSPA_IS_PORT_AUDIO(portType))

  432.             {

  433.                 portName.clear();

  434. 

  435. #ifndef BUILD_BRIDGE

  436.                 if (processMode == PROCESS_MODE_SINGLE_CLIENT)

  437.                 {

  438.                     portName  = m_name;

  439.                     portName += ":";

  440.                 }

  441. #endif

  442.                 portName += descriptor->PortNames[i];

  443.                 portName.truncate(portNameSize);

  444. 

  445.                 if (LADSPA_IS_PORT_INPUT(portType))

  446.                 {

  447.                     j = aIn.count++;

  448.                     aIn.ports[j]    = (CarlaEngineAudioPort*)x_client->addPort(CarlaEnginePortTypeAudio, portName, true);

  449.                     aIn.rindexes[j] = i;

  450. 

  451.                     if (forcedStereoIn)

  452.                     {

  453.                         portName += "_2";

  454.                         aIn.ports[1]    = (CarlaEngineAudioPort*)x_client->addPort(CarlaEnginePortTypeAudio, portName, true);

  455.                         aIn.rindexes[1] = i;

  456.                     }

  457.                 }

  458.                 else if (LADSPA_IS_PORT_OUTPUT(portType))

  459.                 {

  460.                     j = aOut.count++;

  461.                     aOut.ports[j]    = (CarlaEngineAudioPort*)x_client->addPort(CarlaEnginePortTypeAudio, portName, false);

  462.                     aOut.rindexes[j] = i;

  463.                     needsCtrlIn = true;

  464. 

  465.                     if (forcedStereoOut)

  466.                     {

  467.                         portName += "_2";

  468.                         aOut.ports[1]    = (CarlaEngineAudioPort*)x_client->addPort(CarlaEnginePortTypeAudio, portName, false);

  469.                         aOut.rindexes[1] = i;

  470.                     }

  471.                 }

  472.                 else

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

  474.             }

  475.             else if (LADSPA_IS_PORT_CONTROL(portType))

  476.             {

  477.                 j = param.count++;

  478.                 param.data[j].index  = j;

  479.                 param.data[j].rindex = i;

  480.                 param.data[j].hints  = 0;

  481.                 param.data[j].midiChannel = 0;

  482.                 param.data[j].midiCC = -1;

  483. 

  484.                 double min, max, def, step, stepSmall, stepLarge;

  485. 

  486.                 // min value

  487.                 if (LADSPA_IS_HINT_BOUNDED_BELOW(portHints.HintDescriptor))

  488.                     min = portHints.LowerBound;

  489.                 else

  490.                     min = 0.0;

  491. 

  492.                 // max value

  493.                 if (LADSPA_IS_HINT_BOUNDED_ABOVE(portHints.HintDescriptor))

  494.                     max = portHints.UpperBound;

  495.                 else

  496.                     max = 1.0;

  497. 

  498.                 if (min > max)

  499.                     max = min;

  500.                 else if (max < min)

  501.                     min = max;

  502. 

  503.                 if (max - min == 0.0)

  504.                 {

  505.                     qWarning("Broken plugin parameter: max - min == 0");

  506.                     max = min + 0.1;

  507.                 }

  508. 

  509.                 // default value

  510.                 if (hasPortRDF && LADSPA_PORT_HAS_DEFAULT(rdf_descriptor->Ports[i].Hints))

  511.                     def = rdf_descriptor->Ports[i].Default;

  512.                 else

  513.                     def = get_default_ladspa_port_value(portHints.HintDescriptor, min, max);

  514. 

  515.                 if (def < min)

  516.                     def = min;

  517.                 else if (def > max)

  518.                     def = max;

  519. 

  520.                 if (LADSPA_IS_HINT_SAMPLE_RATE(portHints.HintDescriptor))

  521.                 {

  522.                     min *= sampleRate;

  523.                     max *= sampleRate;

  524.                     def *= sampleRate;

  525.                     param.data[j].hints |= PARAMETER_USES_SAMPLERATE;

  526.                 }

  527. 

  528.                 if (LADSPA_IS_HINT_TOGGLED(portHints.HintDescriptor))

  529.                 {

  530.                     step = max - min;

  531.                     stepSmall = step;

  532.                     stepLarge = step;

  533.                     param.data[j].hints |= PARAMETER_IS_BOOLEAN;

  534.                 }

  535.                 else if (LADSPA_IS_HINT_INTEGER(portHints.HintDescriptor))

  536.                 {

  537.                     step = 1.0;

  538.                     stepSmall = 1.0;

  539.                     stepLarge = 10.0;

  540.                     param.data[j].hints |= PARAMETER_IS_INTEGER;

  541.                 }

  542.                 else

  543.                 {

  544.                     double range = max - min;

  545.                     step = range/100.0;

  546.                     stepSmall = range/1000.0;

  547.                     stepLarge = range/10.0;

  548.                 }

  549. 

  550.                 if (LADSPA_IS_PORT_INPUT(portType))

  551.                 {

  552.                     param.data[j].type   = PARAMETER_INPUT;

  553.                     param.data[j].hints |= PARAMETER_IS_ENABLED;

  554.                     param.data[j].hints |= PARAMETER_IS_AUTOMABLE;

  555.                     needsCtrlIn = true;

  556.                 }

  557.                 else if (LADSPA_IS_PORT_OUTPUT(portType))

  558.                 {

  559.                     if (strcmp(descriptor->PortNames[i], "latency") == 0 || strcmp(descriptor->PortNames[i], "_latency") == 0)

  560.                     {

  561.                         min = 0.0;

  562.                         max = sampleRate;

  563.                         def = 0.0;

  564.                         step = 1.0;

  565.                         stepSmall = 1.0;

  566.                         stepLarge = 1.0;

  567. 

  568.                         param.data[j].type  = PARAMETER_LATENCY;

  569.                         param.data[j].hints = 0;

  570.                     }

  571.                     else if (strcmp(descriptor->PortNames[i], "_sample-rate") == 0)

  572.                     {

  573.                         def = sampleRate;

  574.                         step = 1.0;

  575.                         stepSmall = 1.0;

  576.                         stepLarge = 1.0;

  577. 

  578.                         param.data[j].type  = PARAMETER_SAMPLE_RATE;

  579.                         param.data[j].hints = 0;

  580.                     }

  581.                     else

  582.                     {

  583.                         param.data[j].type   = PARAMETER_OUTPUT;

  584.                         param.data[j].hints |= PARAMETER_IS_ENABLED;

  585.                         param.data[j].hints |= PARAMETER_IS_AUTOMABLE;

  586.                         needsCtrlOut = true;

  587.                     }

  588.                 }

  589.                 else

  590.                 {

  591.                     param.data[j].type = PARAMETER_UNKNOWN;

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

  593.                 }

  594. 

  595.                 // extra parameter hints

  596.                 if (LADSPA_IS_HINT_LOGARITHMIC(portHints.HintDescriptor))

  597.                     param.data[j].hints |= PARAMETER_IS_LOGARITHMIC;

  598. 

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

  600.                 if (hasPortRDF && rdf_descriptor->Ports[i].ScalePointCount > 1)

  601.                     param.data[j].hints |= PARAMETER_USES_SCALEPOINTS;

  602. 

  603.                 param.ranges[j].min = min;

  604.                 param.ranges[j].max = max;

  605.                 param.ranges[j].def = def;

  606.                 param.ranges[j].step = step;

  607.                 param.ranges[j].stepSmall = stepSmall;

  608.                 param.ranges[j].stepLarge = stepLarge;

  609. 

  610.                 // Start parameters in their default values

  611.                 paramBuffers[j] = def;

  612. 

  613.                 descriptor->connect_port(handle, i, &paramBuffers[j]);

  614.                 if (h2) descriptor->connect_port(h2, i, &paramBuffers[j]);

  615.             }

  616.             else

  617.             {

  618.                 // Not Audio or Control

  619.                 qCritical("ERROR - Got a broken Port (neither Audio or Control)");

  620.                 descriptor->connect_port(handle, i, nullptr);

  621.                 if (h2) descriptor->connect_port(h2, i, nullptr);

  622.             }

  623.         }

  624. 

  625.         if (needsCtrlIn)

  626.         {

  627.             portName.clear();

  628. 

  629. #ifndef BUILD_BRIDGE

  630.             if (processMode == PROCESS_MODE_SINGLE_CLIENT)

  631.             {

  632.                 portName  = m_name;

  633.                 portName += ":";

  634.             }

  635. #endif

  636.             portName += "control-in";

  637.             portName.truncate(portNameSize);

  638. 

  639.             param.portCin = (CarlaEngineControlPort*)x_client->addPort(CarlaEnginePortTypeControl, portName, true);

  640.         }

  641. 

  642.         if (needsCtrlOut)

  643.         {

  644.             portName.clear();

  645. 

  646. #ifndef BUILD_BRIDGE

  647.             if (processMode == PROCESS_MODE_SINGLE_CLIENT)

  648.             {

  649.                 portName  = m_name;

  650.                 portName += ":";

  651.             }

  652. #endif

  653.             portName += "control-out";

  654.             portName.truncate(portNameSize);

  655. 

  656.             param.portCout = (CarlaEngineControlPort*)x_client->addPort(CarlaEnginePortTypeControl, portName, false);

  657.         }

  658. 

  659.         aIn.count   = aIns;

  660.         aOut.count  = aOuts;

  661.         param.count = params;

  662. 

  663.         // plugin checks

  664.         m_hints &= ~(PLUGIN_IS_SYNTH | PLUGIN_USES_CHUNKS | PLUGIN_CAN_DRYWET | PLUGIN_CAN_VOLUME | PLUGIN_CAN_BALANCE | PLUGIN_CAN_FORCE_STEREO);

  665. 

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

  667.             m_hints |= PLUGIN_CAN_DRYWET;

  668. 

  669.         if (aOuts > 0)

  670.             m_hints |= PLUGIN_CAN_VOLUME;

  671. 

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

  673.             m_hints |= PLUGIN_CAN_BALANCE;

  674. 

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

  676.             m_hints |= PLUGIN_CAN_FORCE_STEREO;

  677. 

  678.         // check latency

  679.         if (m_hints & PLUGIN_CAN_DRYWET)

  680.         {

  681.             bool hasLatency = false;

  682.             m_latency = 0;

  683. 

  684.             for (uint32_t i=0; i < param.count; i++)

  685.             {

  686.                 if (param.data[i].type == PARAMETER_LATENCY)

  687.                 {

  688.                     // pre-run so plugin can update latency control-port

  689.                     float tmpIn[2][aIns];

  690.                     float tmpOut[2][aOuts];

  691. 

  692.                     for (j=0; j < aIn.count; j++)

  693.                     {

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

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

  696. 

  697.                         if (j == 0 || ! h2)

  698.                             descriptor->connect_port(handle, aIn.rindexes[j], tmpIn[j]);

  699.                     }

  700. 

  701.                     for (j=0; j < aOut.count; j++)

  702.                     {

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

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

  705. 

  706.                         if (j == 0 || ! h2)

  707.                             descriptor->connect_port(handle, aOut.rindexes[j], tmpOut[j]);

  708.                     }

  709. 

  710.                     if (descriptor->activate)

  711.                         descriptor->activate(handle);

  712. 

  713.                     descriptor->run(handle, 2);

  714. 

  715.                     if (descriptor->deactivate)

  716.                         descriptor->deactivate(handle);

  717. 

  718.                     m_latency = rint(paramBuffers[i]);

  719.                     hasLatency = true;

  720.                     break;

  721.                 }

  722.             }

  723. 

  724.             if (hasLatency)

  725.             {

  726.                 x_client->setLatency(m_latency);

  727.                 recreateLatencyBuffers();

  728.             }

  729.         }

  730. 

  731.         x_client->activate();

  732. 

  733.         qDebug("LadspaPlugin::reload() - end");

  734.     }

  735. 

  736.     // -------------------------------------------------------------------

  737.     // Plugin processing

  738. 

  739.     void process(float** const inBuffer, float** const outBuffer, const uint32_t frames, const uint32_t framesOffset)

  740.     {

  741.         uint32_t i, k;

  742. 

  743.         double aInsPeak[2]  = { 0.0 };

  744.         double aOutsPeak[2] = { 0.0 };

  745. 

  746.         CARLA_PROCESS_CONTINUE_CHECK;

  747. 

  748.         // --------------------------------------------------------------------------------------------------------

  749.         // Input VU

  750. 

  751. #ifndef BUILD_BRIDGE

  752.         if (aIn.count > 0 && x_engine->getOptions().processMode != PROCESS_MODE_CONTINUOUS_RACK)

  753. #else

  754.         if (aIn.count > 0)

  755. #endif

  756.         {

  757.             if (aIn.count == 1)

  758.             {

  759.                 for (k=0; k < frames; k++)

  760.                 {

  761.                     if (std::abs(inBuffer[0][k]) > aInsPeak[0])

  762.                         aInsPeak[0] = std::abs(inBuffer[0][k]);

  763.                 }

  764.             }

  765.             else if (aIn.count > 1)

  766.             {

  767.                 for (k=0; k < frames; k++)

  768.                 {

  769.                     if (std::abs(inBuffer[0][k]) > aInsPeak[0])

  770.                         aInsPeak[0] = std::abs(inBuffer[0][k]);

  771. 

  772.                     if (std::abs(inBuffer[1][k]) > aInsPeak[1])

  773.                         aInsPeak[1] = std::abs(inBuffer[1][k]);

  774.                 }

  775.             }

  776.         }

  777. 

  778.         CARLA_PROCESS_CONTINUE_CHECK;

  779. 

  780.         // --------------------------------------------------------------------------------------------------------

  781.         // Parameters Input [Automation]

  782. 

  783.         if (param.portCin && m_active && m_activeBefore)

  784.         {

  785.             const CarlaEngineControlEvent* cinEvent;

  786.             uint32_t time, nEvents = param.portCin->getEventCount();

  787. 

  788.             for (i=0; i < nEvents; i++)

  789.             {

  790.                 cinEvent = param.portCin->getEvent(i);

  791. 

  792.                 if (! cinEvent)

  793.                     continue;

  794. 

  795.                 time = cinEvent->time - framesOffset;

  796. 

  797.                 if (time >= frames)

  798.                     continue;

  799. 

  800.                 // Control change

  801.                 switch (cinEvent->type)

  802.                 {

  803.                 case CarlaEngineNullEvent:

  804.                     break;

  805. 

  806.                 case CarlaEngineParameterChangeEvent:

  807.                 {

  808.                     double value;

  809. 

  810.                     // Control backend stuff

  811.                     if (cinEvent->channel == m_ctrlInChannel)

  812.                     {

  813.                         if (MIDI_IS_CONTROL_BREATH_CONTROLLER(cinEvent->parameter) && (m_hints & PLUGIN_CAN_DRYWET) > 0)

  814.                         {

  815.                             value = cinEvent->value;

  816.                             setDryWet(value, false, false);

  817.                             postponeEvent(PluginPostEventParameterChange, PARAMETER_DRYWET, 0, value);

  818.                             continue;

  819.                         }

  820. 

  821.                         if (MIDI_IS_CONTROL_CHANNEL_VOLUME(cinEvent->parameter) && (m_hints & PLUGIN_CAN_VOLUME) > 0)

  822.                         {

  823.                             value = cinEvent->value*127/100;

  824.                             setVolume(value, false, false);

  825.                             postponeEvent(PluginPostEventParameterChange, PARAMETER_VOLUME, 0, value);

  826.                             continue;

  827.                         }

  828. 

  829.                         if (MIDI_IS_CONTROL_BALANCE(cinEvent->parameter) && (m_hints & PLUGIN_CAN_BALANCE) > 0)

  830.                         {

  831.                             double left, right;

  832.                             value = cinEvent->value/0.5 - 1.0;

  833. 

  834.                             if (value < 0.0)

  835.                             {

  836.                                 left  = -1.0;

  837.                                 right = (value*2)+1.0;

  838.                             }

  839.                             else if (value > 0.0)

  840.                             {

  841.                                 left  = (value*2)-1.0;

  842.                                 right = 1.0;

  843.                             }

  844.                             else

  845.                             {

  846.                                 left  = -1.0;

  847.                                 right = 1.0;

  848.                             }

  849. 

  850.                             setBalanceLeft(left, false, false);

  851.                             setBalanceRight(right, false, false);

  852.                             postponeEvent(PluginPostEventParameterChange, PARAMETER_BALANCE_LEFT, 0, left);

  853.                             postponeEvent(PluginPostEventParameterChange, PARAMETER_BALANCE_RIGHT, 0, right);

  854.                             continue;

  855.                         }

  856.                     }

  857. 

  858.                     // Control plugin parameters

  859.                     for (k=0; k < param.count; k++)

  860.                     {

  861.                         if (param.data[k].midiChannel != cinEvent->channel)

  862.                             continue;

  863.                         if (param.data[k].midiCC != cinEvent->parameter)

  864.                             continue;

  865.                         if (param.data[k].type != PARAMETER_INPUT)

  866.                             continue;

  867. 

  868.                         if (param.data[k].hints & PARAMETER_IS_AUTOMABLE)

  869.                         {

  870.                             if (param.data[k].hints & PARAMETER_IS_BOOLEAN)

  871.                             {

  872.                                 value = cinEvent->value < 0.5 ? param.ranges[k].min : param.ranges[k].max;

  873.                             }

  874.                             else

  875.                             {

  876.                                 value = cinEvent->value * (param.ranges[k].max - param.ranges[k].min) + param.ranges[k].min;

  877. 

  878.                                 if (param.data[k].hints & PARAMETER_IS_INTEGER)

  879.                                     value = rint(value);

  880.                             }

  881. 

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

  883.                             postponeEvent(PluginPostEventParameterChange, k, 0, value);

  884.                         }

  885.                     }

  886. 

  887.                     break;

  888.                 }

  889. 

  890.                 case CarlaEngineMidiBankChangeEvent:

  891.                 case CarlaEngineMidiProgramChangeEvent:

  892.                     break;

  893. 

  894.                 case CarlaEngineAllSoundOffEvent:

  895.                     if (cinEvent->channel == m_ctrlInChannel)

  896.                     {

  897.                         if (descriptor->deactivate)

  898.                         {

  899.                             descriptor->deactivate(handle);

  900.                             if (h2) descriptor->deactivate(h2);

  901.                         }

  902. 

  903.                         if (descriptor->activate)

  904.                         {

  905.                             descriptor->activate(handle);

  906.                             if (h2) descriptor->activate(h2);

  907.                         }

  908. 

  909.                         postponeEvent(PluginPostEventParameterChange, PARAMETER_ACTIVE, 0, 0.0);

  910.                         postponeEvent(PluginPostEventParameterChange, PARAMETER_ACTIVE, 0, 1.0);

  911.                     }

  912.                     break;

  913. 

  914.                 case CarlaEngineAllNotesOffEvent:

  915.                     break;

  916.                 }

  917.             }

  918.         } // End of Parameters Input

  919. 

  920.         CARLA_PROCESS_CONTINUE_CHECK;

  921. 

  922.         // --------------------------------------------------------------------------------------------------------

  923.         // Special Parameters

  924. 

  925. #if 0

  926.         for (k=0; k < param.count; k++)

  927.         {

  928.             if (param.data[k].type == PARAMETER_LATENCY)

  929.             {

  930.                 // TODO: ladspa special params

  931.             }

  932.         }

  933. 

  934.         CARLA_PROCESS_CONTINUE_CHECK;

  935. #endif

  936. 

  937.         // --------------------------------------------------------------------------------------------------------

  938.         // Plugin processing

  939. 

  940.         if (m_active)

  941.         {

  942.             if (! m_activeBefore)

  943.             {

  944.                 if (m_latency > 0)

  945.                 {

  946.                     for (i=0; i < aIn.count; i++)

  947.                         memset(m_latencyBuffers[i], 0, sizeof(float)*m_latency);

  948.                 }

  949. 

  950.                 if (descriptor->activate)

  951.                 {

  952.                     descriptor->activate(handle);

  953.                     if (h2) descriptor->activate(h2);

  954.                 }

  955.             }

  956. 

  957.             for (i=0; i < aIn.count; i++)

  958.             {

  959.                 if (i == 0 || ! h2) descriptor->connect_port(handle, aIn.rindexes[i], inBuffer[i]);

  960.                 else if (i == 1)    descriptor->connect_port(h2, aIn.rindexes[i], inBuffer[i]);

  961.             }

  962. 

  963.             for (i=0; i < aOut.count; i++)

  964.             {

  965.                 if (i == 0 || ! h2) descriptor->connect_port(handle, aOut.rindexes[i], outBuffer[i]);

  966.                 else if (i == 1)    descriptor->connect_port(h2, aOut.rindexes[i], outBuffer[i]);

  967.             }

  968. 

  969.             descriptor->run(handle, frames);

  970.             if (h2) descriptor->run(h2, frames);

  971.         }

  972.         else

  973.         {

  974.             if (m_activeBefore)

  975.             {

  976.                 if (descriptor->deactivate)

  977.                 {

  978.                     descriptor->deactivate(handle);

  979.                     if (h2) descriptor->deactivate(h2);

  980.                 }

  981.             }

  982.         }

  983. 

  984.         CARLA_PROCESS_CONTINUE_CHECK;

  985. 

  986.         // --------------------------------------------------------------------------------------------------------

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

  988. 

  989.         if (m_active)

  990.         {

  991.             bool do_drywet  = (m_hints & PLUGIN_CAN_DRYWET) > 0 && x_dryWet != 1.0;

  992.             bool do_volume  = (m_hints & PLUGIN_CAN_VOLUME) > 0 && x_volume != 1.0;

  993.             bool do_balance = (m_hints & PLUGIN_CAN_BALANCE) > 0 && (x_balanceLeft != -1.0 || x_balanceRight != 1.0);

  994. 

  995.             double bal_rangeL, bal_rangeR;

  996.             float bufValue, oldBufLeft[do_balance ? frames : 0];

  997. 

  998.             for (i=0; i < aOut.count; i++)

  999.             {

  1000.                 // Dry/Wet

  1001.                 if (do_drywet)

  1002.                 {

  1003.                     for (k=0; k < frames; k++)

  1004.                     {

  1005.                         if (k < m_latency && m_latency < frames)

  1006.                             bufValue = (aIn.count == 1) ? m_latencyBuffers[0][k] : m_latencyBuffers[i][k];

  1007.                         else

  1008.                             bufValue = (aIn.count == 1) ? inBuffer[0][k-m_latency] : inBuffer[i][k-m_latency];

  1009. 

  1010.                         outBuffer[i][k] = (outBuffer[i][k]*x_dryWet)+(bufValue*(1.0-x_dryWet));

  1011.                     }

  1012.                 }

  1013. 

  1014.                 // Balance

  1015.                 if (do_balance)

  1016.                 {

  1017.                     if (i%2 == 0)

  1018.                         memcpy(&oldBufLeft, outBuffer[i], sizeof(float)*frames);

  1019. 

  1020.                     bal_rangeL = (x_balanceLeft+1.0)/2;

  1021.                     bal_rangeR = (x_balanceRight+1.0)/2;

  1022. 

  1023.                     for (k=0; k < frames; k++)

  1024.                     {

  1025.                         if (i%2 == 0)

  1026.                         {

  1027.                             // left output

  1028.                             outBuffer[i][k]  = oldBufLeft[k]*(1.0-bal_rangeL);

  1029.                             outBuffer[i][k] += outBuffer[i+1][k]*(1.0-bal_rangeR);

  1030.                         }

  1031.                         else

  1032.                         {

  1033.                             // right

  1034.                             outBuffer[i][k]  = outBuffer[i][k]*bal_rangeR;

  1035.                             outBuffer[i][k] += oldBufLeft[k]*bal_rangeL;

  1036.                         }

  1037.                     }

  1038.                 }

  1039. 

  1040.                 // Volume

  1041.                 if (do_volume)

  1042.                 {

  1043.                     for (k=0; k < frames; k++)

  1044.                         outBuffer[i][k] *= x_volume;

  1045.                 }

  1046. 

  1047.                 // Output VU

  1048. #ifndef BUILD_BRIDGE

  1049.                 if (x_engine->getOptions().processMode != PROCESS_MODE_CONTINUOUS_RACK)

  1050. #endif

  1051.                 {

  1052.                     for (k=0; i < 2 && k < frames; k++)

  1053.                     {

  1054.                         if (abs(outBuffer[i][k]) > aOutsPeak[i])

  1055.                             aOutsPeak[i] = abs(outBuffer[i][k]);

  1056.                     }

  1057.                 }

  1058.             }

  1059. 

  1060.             // Latency, save values for next callback

  1061.             if (m_latency > 0 && m_latency < frames)

  1062.             {

  1063.                 for (i=0; i < aIn.count; i++)

  1064.                     memcpy(m_latencyBuffers[i], inBuffer[i] + (frames - m_latency), sizeof(float)*m_latency);

  1065.             }

  1066.         }

  1067.         else

  1068.         {

  1069.             // disable any output sound if not active

  1070.             for (i=0; i < aOut.count; i++)

  1071.                 carla_zeroF(outBuffer[i], frames);

  1072. 

  1073.             aOutsPeak[0] = 0.0;

  1074.             aOutsPeak[1] = 0.0;

  1075. 

  1076.         } // End of Post-processing

  1077. 

  1078.         CARLA_PROCESS_CONTINUE_CHECK;

  1079. 

  1080.         // --------------------------------------------------------------------------------------------------------

  1081.         // Control Output

  1082. 

  1083.         if (param.portCout && m_active)

  1084.         {

  1085.             double value;

  1086. 

  1087.             for (k=0; k < param.count; k++)

  1088.             {

  1089.                 if (param.data[k].type == PARAMETER_OUTPUT)

  1090.                 {

  1091.                     fixParameterValue(paramBuffers[k], param.ranges[k]);

  1092. 

  1093.                     if (param.data[k].midiCC > 0)

  1094.                     {

  1095.                         value = (paramBuffers[k] - param.ranges[k].min) / (param.ranges[k].max - param.ranges[k].min);

  1096.                         param.portCout->writeEvent(CarlaEngineParameterChangeEvent, framesOffset, param.data[k].midiChannel, param.data[k].midiCC, value);

  1097.                     }

  1098.                 }

  1099.             }

  1100.         } // End of Control Output

  1101. 

  1102.         CARLA_PROCESS_CONTINUE_CHECK;

  1103. 

  1104.         // --------------------------------------------------------------------------------------------------------

  1105.         // Peak Values

  1106. 

  1107.         x_engine->setInputPeak(m_id, 0, aInsPeak[0]);

  1108.         x_engine->setInputPeak(m_id, 1, aInsPeak[1]);

  1109.         x_engine->setOutputPeak(m_id, 0, aOutsPeak[0]);

  1110.         x_engine->setOutputPeak(m_id, 1, aOutsPeak[1]);

  1111. 

  1112.         m_activeBefore = m_active;

  1113.     }

  1114. 

  1115.     // -------------------------------------------------------------------

  1116.     // Cleanup

  1117. 

  1118.     void deleteBuffers()

  1119.     {

  1120.         qDebug("LadspaPlugin::deleteBuffers() - start");

  1121. 

  1122.         if (param.count > 0)

  1123.             delete[] paramBuffers;

  1124. 

  1125.         paramBuffers = nullptr;

  1126. 

  1127.         CarlaPlugin::deleteBuffers();

  1128. 

  1129.         qDebug("LadspaPlugin::deleteBuffers() - end");

  1130.     }

  1131. 

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

  1133. 

  1134.     bool init(const char* const filename, const char* const name, const char* const label, const LADSPA_RDF_Descriptor* const rdf_descriptor_)

  1135.     {

  1136.         // ---------------------------------------------------------------

  1137.         // open DLL

  1138. 

  1139.         if (! libOpen(filename))

  1140.         {

  1141.             x_engine->setLastError(libError(filename));

  1142.             return false;

  1143.         }

  1144. 

  1145.         // ---------------------------------------------------------------

  1146.         // get DLL main entry

  1147. 

  1148.         const LADSPA_Descriptor_Function descFn = (LADSPA_Descriptor_Function)libSymbol("ladspa_descriptor");

  1149. 

  1150.         if (! descFn)

  1151.         {

  1152.             x_engine->setLastError("Could not find the LASDPA Descriptor in the plugin library");

  1153.             return false;

  1154.         }

  1155. 

  1156.         // ---------------------------------------------------------------

  1157.         // get descriptor that matches label

  1158. 

  1159.         unsigned long i = 0;

  1160.         while ((descriptor = descFn(i++)))

  1161.         {

  1162.             if (strcmp(descriptor->Label, label) == 0)

  1163.                 break;

  1164.         }

  1165. 

  1166.         if (! descriptor)

  1167.         {

  1168.             x_engine->setLastError("Could not find the requested plugin Label in the plugin library");

  1169.             return false;

  1170.         }

  1171. 

  1172.         // ---------------------------------------------------------------

  1173.         // get info

  1174. 

  1175.         m_filename = strdup(filename);

  1176. 

  1177.         if (is_ladspa_rdf_descriptor_valid(rdf_descriptor_, descriptor))

  1178.             rdf_descriptor = ladspa_rdf_dup(rdf_descriptor_);

  1179. 

  1180.         if (name)

  1181.             m_name = x_engine->getUniquePluginName(name);

  1182.         else if (rdf_descriptor && rdf_descriptor->Title)

  1183.             m_name = x_engine->getUniquePluginName(rdf_descriptor->Title);

  1184.         else

  1185.             m_name = x_engine->getUniquePluginName(descriptor->Name);

  1186. 

  1187.         // ---------------------------------------------------------------

  1188.         // register client

  1189. 

  1190.         x_client = x_engine->addClient(this);

  1191. 

  1192.         if (! x_client->isOk())

  1193.         {

  1194.             x_engine->setLastError("Failed to register plugin client");

  1195.             return false;

  1196.         }

  1197. 

  1198.         // ---------------------------------------------------------------

  1199.         // initialize plugin

  1200. 

  1201.         handle = descriptor->instantiate(descriptor, x_engine->getSampleRate());

  1202. 

  1203.         if (! handle)

  1204.         {

  1205.             x_engine->setLastError("Plugin failed to initialize");

  1206.             return false;

  1207.         }

  1208. 

  1209.         return true;

  1210.     }

  1211. 

  1212. private:

  1213.     LADSPA_Handle handle, h2;

  1214.     const LADSPA_Descriptor* descriptor;

  1215.     const LADSPA_RDF_Descriptor* rdf_descriptor;

  1216. 

  1217.     float* paramBuffers;

  1218. };

  1219. 

  1220. /**@}*/

  1221. 

  1222. CARLA_BACKEND_END_NAMESPACE

  1223. 

  1224. #else // WANT_LADSPA

  1225. #  warning Building without LADSPA support

  1226. #endif

  1227. 

  1228. CARLA_BACKEND_START_NAMESPACE

  1229. 

  1230. CarlaPlugin* CarlaPlugin::newLADSPA(const initializer& init, const void* const extra)

  1231. {

  1232.     qDebug("CarlaPlugin::newLADSPA(%p, \"%s\", \"%s\", \"%s\", %p)", init.engine, init.filename, init.name, init.label, extra);

  1233. 

  1234. #ifdef WANT_LADSPA

  1235.     short id = init.engine->getNewPluginId();

  1236. 

  1237.     if (id < 0 || id > init.engine->maxPluginNumber())

  1238.     {

  1239.         init.engine->setLastError("Maximum number of plugins reached");

  1240.         return nullptr;

  1241.     }

  1242. 

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

  1244. 

  1245.     if (! plugin->init(init.filename, init.name, init.label, (const LADSPA_RDF_Descriptor*)extra))

  1246.     {

  1247.         delete plugin;

  1248.         return nullptr;

  1249.     }

  1250. 

  1251.     plugin->reload();

  1252. 

  1253. # ifndef BUILD_BRIDGE

  1254.     if (init.engine->getOptions().processMode == PROCESS_MODE_CONTINUOUS_RACK)

  1255.     {

  1256.         if (! (plugin->hints() & PLUGIN_CAN_FORCE_STEREO))

  1257.         {

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

  1259.             delete plugin;

  1260.             return nullptr;

  1261.         }

  1262.     }

  1263. # endif

  1264. 

  1265.     plugin->registerToOscControl();

  1266. 

  1267.     return plugin;

  1268. #else

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

  1270.     return nullptr;

  1271. #endif

  1272. }

  1273. 

  1274. CARLA_BACKEND_END_NAMESPACE