falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
49 Commits
16 Branches
310MB
Tree: 211d7e244c
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '211d7e244c'
${ noResults }
Carla/source/backend/plugin/ladspa.cpp

1260 lines
42KB
Raw Blame History 

  1. /*

  2.  * Carla LADSPA Plugin

  3.  * Copyright (C) 2011-2013 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 GPL.txt file

  16.  */

  17. 

  18. #include "carla_plugin_internal.hpp"

  19. 

  20. #ifdef WANT_LADSPA

  21. 

  22. #include "carla_ladspa_utils.hpp"

  23. 

  24. CARLA_BACKEND_START_NAMESPACE

  25. 

  26. class LadspaPlugin : public CarlaPlugin

  27. {

  28. public:

  29.     LadspaPlugin(CarlaEngine* const engine, const unsigned int id)

  30.         : CarlaPlugin(engine, id)

  31.     {

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

  33. 

  34.         fHandle  = nullptr;

  35.         fHandle2 = nullptr;

  36.         fDescriptor  = nullptr;

  37.         fRdfDescriptor = nullptr;

  38. 

  39.         fParamBuffers = nullptr;

  40.     }

  41. 

  42.     ~LadspaPlugin()

  43.     {

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

  45. 

  46.         if (fDescriptor)

  47.         {

  48.             if (fDescriptor->deactivate && fData->activeBefore)

  49.             {

  50.                 if (fHandle)

  51.                     fDescriptor->deactivate(fHandle);

  52.                 if (fHandle2)

  53.                     fDescriptor->deactivate(fHandle2);

  54.             }

  55. 

  56.             if (fDescriptor->cleanup)

  57.             {

  58.                 if (fHandle)

  59.                     fDescriptor->cleanup(fHandle);

  60.                 if (fHandle2)

  61.                     fDescriptor->cleanup(fHandle2);

  62.             }

  63.         }

  64. 

  65.         delete fRdfDescriptor;

  66.     }

  67. 

  68.     // -------------------------------------------------------------------

  69.     // Information (base)

  70. 

  71.     PluginCategory category()

  72.     {

  73.         if (fRdfDescriptor)

  74.         {

  75.             const LADSPA_Properties category = fRdfDescriptor->Type;

  76. 

  77.             // Specific Types

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

  79.                 return PLUGIN_CATEGORY_DELAY;

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

  81.                 return PLUGIN_CATEGORY_MODULATOR;

  82.             if (category & (LADSPA_PLUGIN_AMPLIFIER))

  83.                 return PLUGIN_CATEGORY_DYNAMICS;

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

  85.                 return PLUGIN_CATEGORY_UTILITY;

  86. 

  87.             // Pre-set LADSPA Types

  88.             if (LADSPA_IS_PLUGIN_DYNAMICS(category))

  89.                 return PLUGIN_CATEGORY_DYNAMICS;

  90.             if (LADSPA_IS_PLUGIN_AMPLITUDE(category))

  91.                 return PLUGIN_CATEGORY_MODULATOR;

  92.             if (LADSPA_IS_PLUGIN_EQ(category))

  93.                 return PLUGIN_CATEGORY_EQ;

  94.             if (LADSPA_IS_PLUGIN_FILTER(category))

  95.                 return PLUGIN_CATEGORY_FILTER;

  96.             if (LADSPA_IS_PLUGIN_FREQUENCY(category))

  97.                 return PLUGIN_CATEGORY_UTILITY;

  98.             if (LADSPA_IS_PLUGIN_SIMULATOR(category))

  99.                 return PLUGIN_CATEGORY_OTHER;

  100.             if (LADSPA_IS_PLUGIN_TIME(category))

  101.                 return PLUGIN_CATEGORY_DELAY;

  102.             if (LADSPA_IS_PLUGIN_GENERATOR(category))

  103.                 return PLUGIN_CATEGORY_SYNTH;

  104.         }

  105. 

  106.         return getPluginCategoryFromName(fData->name);

  107.     }

  108. 

  109.     long uniqueId()

  110.     {

  111.         CARLA_ASSERT(fDescriptor);

  112. 

  113.         return fDescriptor ? fDescriptor->UniqueID : 0;

  114.     }

  115. 

  116.     // -------------------------------------------------------------------

  117.     // Information (count)

  118. 

  119.     uint32_t parameterScalePointCount(const uint32_t parameterId)

  120.     {

  121.         CARLA_ASSERT(parameterId < fData->param.count);

  122. 

  123.         int32_t rindex = fData->param.data[parameterId].rindex;

  124. 

  125.         if (fRdfDescriptor && rindex < (int32_t)fRdfDescriptor->PortCount)

  126.         {

  127.             const LADSPA_RDF_Port* const port = &fRdfDescriptor->Ports[rindex];

  128. 

  129.             if (port)

  130.                 return port->ScalePointCount;

  131.         }

  132. 

  133.         return 0;

  134.     }

  135. 

  136.     // -------------------------------------------------------------------

  137.     // Information (per-plugin data)

  138. 

  139.     float getParameterValue(const uint32_t parameterId)

  140.     {

  141.         CARLA_ASSERT(parameterId < fData->param.count);

  142. 

  143.         return fParamBuffers[parameterId];

  144.     }

  145. 

  146.     float getParameterScalePointValue(const uint32_t parameterId, const uint32_t scalePointId)

  147.     {

  148.         CARLA_ASSERT(parameterId < fData->param.count);

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

  150. 

  151.         int32_t rindex = fData->param.data[parameterId].rindex;

  152. 

  153.         if (fRdfDescriptor && rindex < (int32_t)fRdfDescriptor->PortCount)

  154.         {

  155.             const LADSPA_RDF_Port* const port = &fRdfDescriptor->Ports[rindex];

  156. 

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

  158.             {

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

  160. 

  161.                 if (scalePoint)

  162.                     return scalePoint->Value;

  163.             }

  164.         }

  165. 

  166.         return 0.0;

  167.     }

  168. 

  169.     void getLabel(char* const strBuf)

  170.     {

  171.         CARLA_ASSERT(fDescriptor);

  172. 

  173.         if (fDescriptor && fDescriptor->Label)

  174.             strncpy(strBuf, fDescriptor->Label, STR_MAX);

  175.         else

  176.             CarlaPlugin::getLabel(strBuf);

  177.     }

  178. 

  179.     void getMaker(char* const strBuf)

  180.     {

  181.         CARLA_ASSERT(fDescriptor);

  182. 

  183.         if (fRdfDescriptor && fRdfDescriptor->Creator)

  184.             strncpy(strBuf, fRdfDescriptor->Creator, STR_MAX);

  185.         else if (fDescriptor && fDescriptor->Maker)

  186.             strncpy(strBuf, fDescriptor->Maker, STR_MAX);

  187.         else

  188.             CarlaPlugin::getMaker(strBuf);

  189.     }

  190. 

  191.     void getCopyright(char* const strBuf)

  192.     {

  193.         CARLA_ASSERT(fDescriptor);

  194. 

  195.         if (fDescriptor && fDescriptor->Copyright)

  196.             strncpy(strBuf, fDescriptor->Copyright, STR_MAX);

  197.         else

  198.             CarlaPlugin::getCopyright(strBuf);

  199.     }

  200. 

  201.     void getRealName(char* const strBuf)

  202.     {

  203.         CARLA_ASSERT(fDescriptor);

  204. 

  205.         if (fRdfDescriptor && fRdfDescriptor->Title)

  206.             strncpy(strBuf, fRdfDescriptor->Title, STR_MAX);

  207.         else if (fDescriptor && fDescriptor->Name)

  208.             strncpy(strBuf, fDescriptor->Name, STR_MAX);

  209.         else

  210.             CarlaPlugin::getRealName(strBuf);

  211.     }

  212. 

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

  214.     {

  215.         CARLA_ASSERT(fDescriptor);

  216.         CARLA_ASSERT(parameterId < fData->param.count);

  217. 

  218.         int32_t rindex = fData->param.data[parameterId].rindex;

  219. 

  220.         if (fDescriptor && rindex < (int32_t)fDescriptor->PortCount)

  221.             strncpy(strBuf, fDescriptor->PortNames[rindex], STR_MAX);

  222.         else

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

  224.     }

  225. 

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

  227.     {

  228.         CARLA_ASSERT(parameterId < fData->param.count);

  229. 

  230.         int32_t rindex = fData->param.data[parameterId].rindex;

  231. 

  232.         if (fRdfDescriptor && rindex < (int32_t)fRdfDescriptor->PortCount)

  233.         {

  234.             const LADSPA_RDF_Port* const port = &fRdfDescriptor->Ports[rindex];

  235. 

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

  237.             {

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

  239.                 return;

  240.             }

  241.         }

  242. 

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

  244.     }

  245. 

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

  247.     {

  248.         CARLA_ASSERT(parameterId < fData->param.count);

  249. 

  250.         int32_t rindex = fData->param.data[parameterId].rindex;

  251. 

  252.         if (fRdfDescriptor && rindex < (int32_t)fRdfDescriptor->PortCount)

  253.         {

  254.             const LADSPA_RDF_Port* const port = &fRdfDescriptor->Ports[rindex];

  255. 

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

  257.             {

  258.                 switch (port->Unit)

  259.                 {

  260.                 case LADSPA_UNIT_DB:

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

  262.                     return;

  263.                 case LADSPA_UNIT_COEF:

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

  265.                     return;

  266.                 case LADSPA_UNIT_HZ:

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

  268.                     return;

  269.                 case LADSPA_UNIT_S:

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

  271.                     return;

  272.                 case LADSPA_UNIT_MS:

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

  274.                     return;

  275.                 case LADSPA_UNIT_MIN:

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

  277.                     return;

  278.                 }

  279.             }

  280.         }

  281. 

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

  283.     }

  284. 

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

  286.     {

  287.         CARLA_ASSERT(parameterId < fData->param.count);

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

  289. 

  290.         int32_t rindex = fData->param.data[parameterId].rindex;

  291. 

  292.         if (fRdfDescriptor && rindex < (int32_t)fRdfDescriptor->PortCount)

  293.         {

  294.             const LADSPA_RDF_Port* const port = &fRdfDescriptor->Ports[rindex];

  295. 

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

  297.             {

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

  299. 

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

  301.                 {

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

  303.                     return;

  304.                 }

  305.             }

  306.         }

  307. 

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

  309.     }

  310. 

  311.     // -------------------------------------------------------------------

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

  313. 

  314.     void setParameterValue(const uint32_t parameterId, const float value, const bool sendGui, const bool sendOsc, const bool sendCallback)

  315.     {

  316.         CARLA_ASSERT(parameterId < fData->param.count);

  317. 

  318.         const float fixedValue = fData->param.ranges[parameterId].fixValue(value);

  319.         fParamBuffers[parameterId] = fixedValue;

  320. 

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

  322.     }

  323. 

  324.     // -------------------------------------------------------------------

  325.     // Plugin state

  326. 

  327.     void reload()

  328.     {

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

  330.         CARLA_ASSERT(fDescriptor);

  331. 

  332.         const ProcessMode processMode(fData->engine->getOptions().processMode);

  333. 

  334.         // Safely disable plugin for reload

  335.         //const ScopedDisabler m(this);

  336. 

  337.         if (fData->client->isActive())

  338.             fData->client->deactivate();

  339. 

  340.         // Remove client ports

  341.         removeClientPorts();

  342. 

  343.         // Delete old data

  344.         deleteBuffers();

  345. 

  346.         uint32_t aIns, aOuts, params, j;

  347.         aIns = aOuts = params = 0;

  348. 

  349.         const double sampleRate = fData->engine->getSampleRate();

  350.         const unsigned long portCount = fDescriptor->PortCount;

  351. 

  352.         bool forcedStereoIn, forcedStereoOut;

  353.         forcedStereoIn = forcedStereoOut = false;

  354. 

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

  356.         {

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

  358. 

  359.             if (LADSPA_IS_PORT_AUDIO(portType))

  360.             {

  361.                 if (LADSPA_IS_PORT_INPUT(portType))

  362.                     aIns += 1;

  363.                 else if (LADSPA_IS_PORT_OUTPUT(portType))

  364.                     aOuts += 1;

  365.             }

  366.             else if (LADSPA_IS_PORT_CONTROL(portType))

  367.                 params += 1;

  368.         }

  369. 

  370.         if (fData->engine->getOptions().forceStereo && (aIns == 1 || aOuts == 1) && ! fHandle2)

  371.         {

  372.             fHandle2 = fDescriptor->instantiate(fDescriptor, sampleRate);

  373. 

  374.             if (aIns == 1)

  375.             {

  376.                 aIns = 2;

  377.                 forcedStereoIn = true;

  378.             }

  379. 

  380.             if (aOuts == 1)

  381.             {

  382.                 aOuts = 2;

  383.                 forcedStereoOut = true;

  384.             }

  385.         }

  386. 

  387.         if (aIns > 0)

  388.         {

  389.             //fData->audioIn.ports    = new CarlaEngineAudioPort*[aIns];

  390.             //fData->audioIn.rindexes = new uint32_t[aIns];

  391.         }

  392. 

  393.         if (aOuts > 0)

  394.         {

  395.             //fData->audioOut.ports    = new CarlaEngineAudioPort*[aOuts];

  396.             //fData->audioOut.rindexes = new uint32_t[aOuts];

  397.         }

  398. 

  399.         if (params > 0)

  400.         {

  401.             fData->param.data   = new ParameterData[params];

  402.             fData->param.ranges = new ParameterRanges[params];

  403.             fParamBuffers       = new float[params];

  404.         }

  405. 

  406.         bool needsCtrlIn  = false;

  407.         bool needsCtrlOut = false;

  408. 

  409.         const int   portNameSize = fData->engine->maxPortNameSize();

  410.         CarlaString portName;

  411. 

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

  413.         {

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

  415.             const LADSPA_PortRangeHint portHints = fDescriptor->PortRangeHints[i];

  416.             const bool hasPortRDF = (fRdfDescriptor && i < fRdfDescriptor->PortCount);

  417. 

  418.             if (LADSPA_IS_PORT_AUDIO(portType))

  419.             {

  420.                 portName.clear();

  421. 

  422.                 if (processMode == PROCESS_MODE_SINGLE_CLIENT)

  423.                 {

  424.                     portName  = fData->name;

  425.                     portName += ":";

  426.                 }

  427. 

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

  429.                 portName.truncate(portNameSize);

  430. 

  431.                 if (LADSPA_IS_PORT_INPUT(portType))

  432.                 {

  433.                     //j = fData->audioIn.count++;

  434.                     //aIn.ports[j]    = (CarlaEngineAudioPort*)fData->client->addPort(kEnginePortTypeAudio, portName, true);

  435.                     //aIn.rindexes[j] = i;

  436. 

  437.                     if (forcedStereoIn)

  438.                     {

  439.                         portName += "_2";

  440.                         //aIn.ports[1]    = (CarlaEngineAudioPort*)fData->client->addPort(kEnginePortTypeAudio, portName, true);

  441.                         //aIn.rindexes[1] = i;

  442.                     }

  443.                 }

  444.                 else if (LADSPA_IS_PORT_OUTPUT(portType))

  445.                 {

  446.                     //j = aOut.count++;

  447.                     //aOut.ports[j]    = (CarlaEngineAudioPort*)fData->client->addPort(kEnginePortTypeAudio, portName, false);

  448.                     //aOut.rindexes[j] = i;

  449.                     needsCtrlIn = true;

  450. 

  451.                     if (forcedStereoOut)

  452.                     {

  453.                         portName += "_2";

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

  455.                         //aOut.rindexes[1] = i;

  456.                     }

  457.                 }

  458.                 else

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

  460.             }

  461.             else if (LADSPA_IS_PORT_CONTROL(portType))

  462.             {

  463.                 j = fData->param.count++;

  464.                 fData->param.data[j].index  = j;

  465.                 fData->param.data[j].rindex = i;

  466.                 fData->param.data[j].hints  = 0;

  467.                 fData->param.data[j].midiChannel = 0;

  468.                 fData->param.data[j].midiCC = -1;

  469. 

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

  471. 

  472.                 // min value

  473.                 if (LADSPA_IS_HINT_BOUNDED_BELOW(portHints.HintDescriptor))

  474.                     min = portHints.LowerBound;

  475.                 else

  476.                     min = 0.0;

  477. 

  478.                 // max value

  479.                 if (LADSPA_IS_HINT_BOUNDED_ABOVE(portHints.HintDescriptor))

  480.                     max = portHints.UpperBound;

  481.                 else

  482.                     max = 1.0;

  483. 

  484.                 if (min > max)

  485.                     max = min;

  486.                 else if (max < min)

  487.                     min = max;

  488. 

  489.                 if (max - min == 0.0)

  490.                 {

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

  492.                     max = min + 0.1;

  493.                 }

  494. 

  495.                 // default value

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

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

  498.                 else

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

  500. 

  501.                 if (def < min)

  502.                     def = min;

  503.                 else if (def > max)

  504.                     def = max;

  505. 

  506.                 if (LADSPA_IS_HINT_SAMPLE_RATE(portHints.HintDescriptor))

  507.                 {

  508.                     min *= sampleRate;

  509.                     max *= sampleRate;

  510.                     def *= sampleRate;

  511.                     fData->param.data[j].hints |= PARAMETER_USES_SAMPLERATE;

  512.                 }

  513. 

  514.                 if (LADSPA_IS_HINT_TOGGLED(portHints.HintDescriptor))

  515.                 {

  516.                     step = max - min;

  517.                     stepSmall = step;

  518.                     stepLarge = step;

  519.                     fData->param.data[j].hints |= PARAMETER_IS_BOOLEAN;

  520.                 }

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

  522.                 {

  523.                     step = 1.0;

  524.                     stepSmall = 1.0;

  525.                     stepLarge = 10.0;

  526.                     fData->param.data[j].hints |= PARAMETER_IS_INTEGER;

  527.                 }

  528.                 else

  529.                 {

  530.                     double range = max - min;

  531.                     step = range/100.0;

  532.                     stepSmall = range/1000.0;

  533.                     stepLarge = range/10.0;

  534.                 }

  535. 

  536.                 if (LADSPA_IS_PORT_INPUT(portType))

  537.                 {

  538.                     fData->param.data[j].type   = PARAMETER_INPUT;

  539.                     fData->param.data[j].hints |= PARAMETER_IS_ENABLED;

  540.                     fData->param.data[j].hints |= PARAMETER_IS_AUTOMABLE;

  541.                     needsCtrlIn = true;

  542.                 }

  543.                 else if (LADSPA_IS_PORT_OUTPUT(portType))

  544.                 {

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

  546.                     {

  547.                         min = 0.0;

  548.                         max = sampleRate;

  549.                         def = 0.0;

  550.                         step = 1.0;

  551.                         stepSmall = 1.0;

  552.                         stepLarge = 1.0;

  553. 

  554.                         fData->param.data[j].type  = PARAMETER_LATENCY;

  555.                         fData->param.data[j].hints = 0;

  556.                     }

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

  558.                     {

  559.                         def = sampleRate;

  560.                         step = 1.0;

  561.                         stepSmall = 1.0;

  562.                         stepLarge = 1.0;

  563. 

  564.                         fData->param.data[j].type  = PARAMETER_SAMPLE_RATE;

  565.                         fData->param.data[j].hints = 0;

  566.                     }

  567.                     else

  568.                     {

  569.                         fData->param.data[j].type   = PARAMETER_OUTPUT;

  570.                         fData->param.data[j].hints |= PARAMETER_IS_ENABLED;

  571.                         fData->param.data[j].hints |= PARAMETER_IS_AUTOMABLE;

  572.                         needsCtrlOut = true;

  573.                     }

  574.                 }

  575.                 else

  576.                 {

  577.                     fData->param.data[j].type = PARAMETER_UNKNOWN;

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

  579.                 }

  580. 

  581.                 // extra parameter hints

  582.                 if (LADSPA_IS_HINT_LOGARITHMIC(portHints.HintDescriptor))

  583.                     fData->param.data[j].hints |= PARAMETER_IS_LOGARITHMIC;

  584. 

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

  586.                 if (hasPortRDF && fRdfDescriptor->Ports[i].ScalePointCount > 1)

  587.                     fData->param.data[j].hints |= PARAMETER_USES_SCALEPOINTS;

  588. 

  589.                 fData->param.ranges[j].min = min;

  590.                 fData->param.ranges[j].max = max;

  591.                 fData->param.ranges[j].def = def;

  592.                 fData->param.ranges[j].step = step;

  593.                 fData->param.ranges[j].stepSmall = stepSmall;

  594.                 fData->param.ranges[j].stepLarge = stepLarge;

  595. 

  596.                 // Start parameters in their default values

  597.                 fParamBuffers[j] = def;

  598. 

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

  600. 

  601.                 if (fHandle2)

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

  603.             }

  604.             else

  605.             {

  606.                 // Not Audio or Control

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

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

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

  610.             }

  611.         }

  612. 

  613.         if (needsCtrlIn)

  614.         {

  615.             portName.clear();

  616. 

  617.             if (processMode == PROCESS_MODE_SINGLE_CLIENT)

  618.             {

  619.                 portName  = fData->name;

  620.                 portName += ":";

  621.             }

  622. 

  623.             portName += "control-in";

  624.             portName.truncate(portNameSize);

  625. 

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

  627.         }

  628. 

  629.         if (needsCtrlOut)

  630.         {

  631.             portName.clear();

  632. 

  633.             if (processMode == PROCESS_MODE_SINGLE_CLIENT)

  634.             {

  635.                 portName  = fData->name;

  636.                 portName += ":";

  637.             }

  638. 

  639.             portName += "control-out";

  640.             portName.truncate(portNameSize);

  641. 

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

  643.         }

  644. 

  645.         //aIn.count   = aIns;

  646.         //aOut.count  = aOuts;

  647.         //param.count = params;

  648. 

  649.         // plugin checks

  650.         fData->hints &= ~(PLUGIN_IS_SYNTH | PLUGIN_USES_CHUNKS | PLUGIN_CAN_DRYWET | PLUGIN_CAN_VOLUME | PLUGIN_CAN_BALANCE | PLUGIN_CAN_FORCE_STEREO);

  651. 

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

  653.             fData->hints |= PLUGIN_CAN_DRYWET;

  654. 

  655.         if (aOuts > 0)

  656.             fData->hints |= PLUGIN_CAN_VOLUME;

  657. 

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

  659.             fData->hints |= PLUGIN_CAN_BALANCE;

  660. 

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

  662.             fData->hints |= PLUGIN_CAN_FORCE_STEREO;

  663. 

  664. #if 0

  665.         // check latency

  666.         if (fData->hints & PLUGIN_CAN_DRYWET)

  667.         {

  668.             bool hasLatency = false;

  669.             fData->latency = 0;

  670. 

  671.             for (uint32_t i=0; i < fData->param.count; i++)

  672.             {

  673.                 if (fData->param.data[i].type == PARAMETER_LATENCY)

  674.                 {

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

  676.                     float tmpIn[2][aIns];

  677.                     float tmpOut[2][aOuts];

  678. 

  679.                     for (j=0; j < fData->audioIn.count; j++)

  680.                     {

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

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

  683. 

  684.                         //if (j == 0 || ! fHandle2)

  685.                         //    fDescriptor->connect_port(fHandle, fData->audioIn.rindexes[j], tmpIn[j]);

  686.                     }

  687. 

  688.                     for (j=0; j < fData->audioOut.count; j++)

  689.                     {

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

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

  692. 

  693.                         //if (j == 0 || ! fHandle2)

  694.                         //    fDescriptor->connect_port(fHandle, fData->audioOut.rindexes[j], tmpOut[j]);

  695.                     }

  696. 

  697.                     if (fDescriptor->activate)

  698.                         fDescriptor->activate(fHandle);

  699. 

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

  701. 

  702.                     if (fDescriptor->deactivate)

  703.                         fDescriptor->deactivate(fHandle);

  704. 

  705.                     fData->latency = rint(fParamBuffers[i]);

  706.                     hasLatency = true;

  707.                     break;

  708.                 }

  709.             }

  710. 

  711.             if (hasLatency)

  712.             {

  713.                 fData->client->setLatency(fData->latency);

  714.                 recreateLatencyBuffers();

  715.             }

  716.         }

  717. #endif

  718. 

  719.         fData->client->activate();

  720. 

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

  722.     }

  723. 

  724.     // -------------------------------------------------------------------

  725.     // Plugin processing

  726. 

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

  728.     {

  729.         uint32_t i, k;

  730. 

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

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

  733. 

  734.         CARLA_PROCESS_CONTINUE_CHECK;

  735. 

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

  737.         // Input VU

  738. 

  739.         if (fData->audioIn.count > 0 && fData->engine->getOptions().processMode != PROCESS_MODE_CONTINUOUS_RACK)

  740.         {

  741.             if (fData->audioIn.count == 1)

  742.             {

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

  744.                 {

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

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

  747.                 }

  748.             }

  749.             else if (fData->audioIn.count > 1)

  750.             {

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

  752.                 {

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

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

  755. 

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

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

  758.                 }

  759.             }

  760.         }

  761. 

  762.         CARLA_PROCESS_CONTINUE_CHECK;

  763. 

  764.         // --------------------------------------------------------------------------------------------------------

  765.         // Parameters Input [Automation]

  766. 

  767. #if 0

  768.         //if (param.portCin && m_active && m_activeBefore)

  769.         {

  770.             const EngineEvent* cinEvent = nullptr;

  771.             uint32_t time, nEvents = 0; //param.portCin->getEventCount();

  772. 

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

  774.             {

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

  776. 

  777.                 if (! cinEvent)

  778.                     continue;

  779. 

  780.                 time = cinEvent->time - framesOffset;

  781. 

  782.                 if (time >= frames)

  783.                     continue;

  784. 

  785.                 // Control change

  786.                 switch (cinEvent->type)

  787.                 {

  788.                 case kEngineControlEventTypeNull:

  789.                     break;

  790. 

  791.                 case CarlaEngineParameterChangeEvent:

  792.                 {

  793.                     double value;

  794. 

  795.                     // Control backend stuff

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

  797.                     {

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

  799.                         {

  800.                             value = cinEvent->value;

  801.                             setDryWet(value, false, false);

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

  803.                             continue;

  804.                         }

  805. 

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

  807.                         {

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

  809.                             setVolume(value, false, false);

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

  811.                             continue;

  812.                         }

  813. 

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

  815.                         {

  816.                             double left, right;

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

  818. 

  819.                             if (value < 0.0)

  820.                             {

  821.                                 left  = -1.0;

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

  823.                             }

  824.                             else if (value > 0.0)

  825.                             {

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

  827.                                 right = 1.0;

  828.                             }

  829.                             else

  830.                             {

  831.                                 left  = -1.0;

  832.                                 right = 1.0;

  833.                             }

  834. 

  835.                             setBalanceLeft(left, false, false);

  836.                             setBalanceRight(right, false, false);

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

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

  839.                             continue;

  840.                         }

  841.                     }

  842. 

  843.                     // Control plugin parameters

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

  845.                     {

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

  847.                             continue;

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

  849.                             continue;

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

  851.                             continue;

  852. 

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

  854.                         {

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

  856.                             {

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

  858.                             }

  859.                             else

  860.                             {

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

  862. 

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

  864.                                     value = rint(value);

  865.                             }

  866. 

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

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

  869.                         }

  870.                     }

  871. 

  872.                     break;

  873.                 }

  874. 

  875.                 case CarlaEngineMidiBankChangeEvent:

  876.                 case CarlaEngineMidiProgramChangeEvent:

  877.                     break;

  878. 

  879.                 case CarlaEngineAllSoundOffEvent:

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

  881.                     {

  882.                         if (fDescriptor->deactivate)

  883.                         {

  884.                             descriptor->deactivate(fHandle);

  885.                             if (fHandle2) descriptor->deactivate(fHandle2);

  886.                         }

  887. 

  888.                         if (fDescriptor->activate)

  889.                         {

  890.                             descriptor->activate(fHandle);

  891.                             if (fHandle2) descriptor->activate(fHandle2);

  892.                         }

  893. 

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

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

  896.                     }

  897.                     break;

  898. 

  899.                 case CarlaEngineAllNotesOffEvent:

  900.                     break;

  901.                 }

  902.             }

  903.         } // End of Parameters Input

  904. 

  905.         CARLA_PROCESS_CONTINUE_CHECK;

  906. #endif

  907. 

  908.         // --------------------------------------------------------------------------------------------------------

  909.         // Special Parameters

  910. 

  911. #if 0

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

  913.         {

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

  915.             {

  916.                 // TODO: ladspa special params

  917.             }

  918.         }

  919. 

  920.         CARLA_PROCESS_CONTINUE_CHECK;

  921. #endif

  922. 

  923.         // --------------------------------------------------------------------------------------------------------

  924.         // Plugin processing

  925. 

  926.         if (fData->active)

  927.         {

  928.             if (! fData->activeBefore)

  929.             {

  930. #if 0

  931.                 if (fData->latency > 0)

  932.                 {

  933.                     for (i=0; i < fData->audioIn.count; i++)

  934.                         memset(fData->latencyBuffers[i], 0, sizeof(float)*fData->latency);

  935.                 }

  936. #endif

  937. 

  938.                 if (fDescriptor->activate)

  939.                 {

  940.                     fDescriptor->activate(fHandle);

  941.                     if (fHandle2) fDescriptor->activate(fHandle2);

  942.                 }

  943.             }

  944. 

  945. #if 0

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

  947.             {

  948.                 if (i == 0 || ! fHandle2)

  949.                     fDescriptor->connect_port(fHandle, aIn.rindexes[i], inBuffer[i]);

  950.                 else if (i == 1)

  951.                     fDescriptor->connect_port(fHandle2, aIn.rindexes[i], inBuffer[i]);

  952.             }

  953. 

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

  955.             {

  956.                 if (i == 0 || ! fHandle2)

  957.                     fDescriptor->connect_port(handle, aOut.rindexes[i], outBuffer[i]);

  958.                 else if (i == 1)

  959.                     fDescriptor->connect_port(fHandle2, aOut.rindexes[i], outBuffer[i]);

  960.             }

  961. #endif

  962. 

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

  964.             if (fHandle2) fDescriptor->run(fHandle2, frames);

  965.         }

  966.         else

  967.         {

  968.             if (fData->activeBefore)

  969.             {

  970.                 if (fDescriptor->deactivate)

  971.                 {

  972.                     fDescriptor->deactivate(fHandle);

  973.                     if (fHandle2) fDescriptor->deactivate(fHandle2);

  974.                 }

  975.             }

  976.         }

  977. 

  978.         CARLA_PROCESS_CONTINUE_CHECK;

  979. 

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

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

  982. 

  983. #if 0

  984.         if (fData->active)

  985.         {

  986.             bool do_drywet  = (fData->hints & PLUGIN_CAN_DRYWET) > 0 && x_dryWet != 1.0;

  987.             bool do_volume  = (fData->hints & PLUGIN_CAN_VOLUME) > 0 && x_volume != 1.0;

  988.             bool do_balance = (fData->hints & PLUGIN_CAN_BALANCE) > 0 && (x_balanceLeft != -1.0 || x_balanceRight != 1.0);

  989. 

  990.             double bal_rangeL, bal_rangeR;

  991.             float bufValue, oldBufLeft[do_balance ? frames : 1];

  992. 

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

  994.             {

  995.                 // Dry/Wet

  996.                 if (do_drywet)

  997.                 {

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

  999.                     {

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

  1001.                             bufValue = (aIn.count == 1) ? fData->latencyBuffers[0][k] : fData->latencyBuffers[i][k];

  1002.                         else

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

  1004. 

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

  1006.                     }

  1007.                 }

  1008. 

  1009.                 // Balance

  1010.                 if (do_balance)

  1011.                 {

  1012.                     if (i%2 == 0)

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

  1014. 

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

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

  1017. 

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

  1019.                     {

  1020.                         if (i%2 == 0)

  1021.                         {

  1022.                             // left output

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

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

  1025.                         }

  1026.                         else

  1027.                         {

  1028.                             // right

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

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

  1031.                         }

  1032.                     }

  1033.                 }

  1034. 

  1035.                 // Volume

  1036.                 if (do_volume)

  1037.                 {

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

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

  1040.                 }

  1041. 

  1042.                 // Output VU

  1043.                 if (fData->engine->getOptions().processMode != PROCESS_MODE_CONTINUOUS_RACK)

  1044.                 {

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

  1046.                     {

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

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

  1049.                     }

  1050.                 }

  1051.             }

  1052. 

  1053.             // Latency, save values for next callback

  1054.             if (fData->latency > 0 && fData->latency < frames)

  1055.             {

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

  1057.                     memcpy(fData->latencyBuffers[i], inBuffer[i] + (frames - fData->latency), sizeof(float)*fData->latency);

  1058.             }

  1059.         }

  1060.         else

  1061.         {

  1062.             // disable any output sound if not active

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

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

  1065. 

  1066.             aOutsPeak[0] = 0.0;

  1067.             aOutsPeak[1] = 0.0;

  1068. 

  1069.         } // End of Post-processing

  1070. #endif

  1071. 

  1072.         CARLA_PROCESS_CONTINUE_CHECK;

  1073. 

  1074.         // --------------------------------------------------------------------------------------------------------

  1075.         // Control Output

  1076. 

  1077. #if 0

  1078.         if (param.portCout && m_active)

  1079.         {

  1080.             double value;

  1081. 

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

  1083.             {

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

  1085.                 {

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

  1087. 

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

  1089.                     {

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

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

  1092.                     }

  1093.                 }

  1094.             }

  1095.         } // End of Control Output

  1096. #endif

  1097. 

  1098.         CARLA_PROCESS_CONTINUE_CHECK;

  1099. 

  1100.         // --------------------------------------------------------------------------------------------------------

  1101.         // Peak Values

  1102. 

  1103.         //fData->engine->setInputPeak(fData->id, 0, aInsPeak[0]);

  1104.         //fData->engine->setInputPeak(fData->id, 1, aInsPeak[1]);

  1105.         //fData->engine->setOutputPeak(fData->id, 0, aOutsPeak[0]);

  1106.         //fData->engine->setOutputPeak(fData->id, 1, aOutsPeak[1]);

  1107. 

  1108.         fData->activeBefore = fData->active;

  1109.     }

  1110. 

  1111.     // -------------------------------------------------------------------

  1112.     // Cleanup

  1113. 

  1114.     void deleteBuffers()

  1115.     {

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

  1117. 

  1118.         if (fData->param.count > 0)

  1119.             delete[] fParamBuffers;

  1120. 

  1121.         fParamBuffers = nullptr;

  1122. 

  1123.         CarlaPlugin::deleteBuffers();

  1124. 

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

  1126.     }

  1127. 

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

  1129. 

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

  1131.     {

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

  1133.         // open DLL

  1134. 

  1135.         if (! libOpen(filename))

  1136.         {

  1137.             fData->engine->setLastError(libError(filename));

  1138.             return false;

  1139.         }

  1140. 

  1141.         // ---------------------------------------------------------------

  1142.         // get DLL main entry

  1143. 

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

  1145. 

  1146.         if (! descFn)

  1147.         {

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

  1149.             return false;

  1150.         }

  1151. 

  1152.         // ---------------------------------------------------------------

  1153.         // get descriptor that matches label

  1154. 

  1155.         unsigned long i = 0;

  1156.         while ((fDescriptor = descFn(i++)))

  1157.         {

  1158.             if (strcmp(fDescriptor->Label, label) == 0)

  1159.                 break;

  1160.         }

  1161. 

  1162.         if (! fDescriptor)

  1163.         {

  1164.             fData->engine->setLastError("Could not find the requested plugin Label in the plugin library");

  1165.             return false;

  1166.         }

  1167. 

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

  1169.         // get info

  1170. 

  1171.         fData->filename = strdup(filename);

  1172. 

  1173.         if (is_ladspa_rdf_descriptor_valid(rdfDescriptor, fDescriptor))

  1174.             fRdfDescriptor = ladspa_rdf_dup(rdfDescriptor);

  1175. 

  1176.         if (name)

  1177.             fData->name = fData->engine->getNewUniquePluginName(name);

  1178.         else if (fRdfDescriptor && fRdfDescriptor->Title)

  1179.             fData->name = fData->engine->getNewUniquePluginName(fRdfDescriptor->Title);

  1180.         else

  1181.             fData->name = fData->engine->getNewUniquePluginName(fDescriptor->Name);

  1182. 

  1183.         // ---------------------------------------------------------------

  1184.         // register client

  1185. 

  1186.         fData->client = fData->engine->addClient(this);

  1187. 

  1188.         if (! fData->client->isOk())

  1189.         {

  1190.             fData->engine->setLastError("Failed to register plugin client");

  1191.             return false;

  1192.         }

  1193. 

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

  1195.         // initialize plugin

  1196. 

  1197.         fHandle = fDescriptor->instantiate(fDescriptor, fData->engine->getSampleRate());

  1198. 

  1199.         if (! fHandle)

  1200.         {

  1201.             fData->engine->setLastError("Plugin failed to initialize");

  1202.             return false;

  1203.         }

  1204. 

  1205.         return true;

  1206.     }

  1207. 

  1208. private:

  1209.     LADSPA_Handle fHandle;

  1210.     LADSPA_Handle fHandle2;

  1211.     const LADSPA_Descriptor* fDescriptor;

  1212.     const LADSPA_RDF_Descriptor* fRdfDescriptor;

  1213. 

  1214.     float* fParamBuffers;

  1215. };

  1216. 

  1217. CARLA_BACKEND_END_NAMESPACE

  1218. 

  1219. #else // WANT_LADSPA

  1220. #  warning Building without LADSPA support

  1221. #endif

  1222. 

  1223. CARLA_BACKEND_START_NAMESPACE

  1224. 

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

  1226. {

  1227.     qDebug("CarlaPlugin::newLADSPA({%p, \"%s\", \"%s\", \"%s\"}, %p)", init.engine, init.filename, init.name, init.label, rdfDescriptor);

  1228. 

  1229. #ifdef WANT_LADSPA

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

  1231. 

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

  1233.     {

  1234.         delete plugin;

  1235.         return nullptr;

  1236.     }

  1237. 

  1238.     plugin->reload();

  1239. 

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

  1241.     {

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

  1243.         {

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

  1245.             delete plugin;

  1246.             return nullptr;

  1247.         }

  1248.     }

  1249. 

  1250.     plugin->registerToOscClient();

  1251. 

  1252.     return plugin;

  1253. #else

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

  1255.     return nullptr;

  1256. #endif

  1257. }

  1258. 

  1259. CARLA_BACKEND_END_NAMESPACE