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.
371 Commits
2 Branches
47MB
Tree: d1698206a6
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'd1698206a6'
${ noResults }
Cadence/c++/carla-backend/ladspa.cpp

1138 lines
38KB
Raw Blame History 

  1. /*

  2.  * Carla Backend

  3.  * Copyright (C) 2011-2012 Filipe Coelho <falktx@gmail.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.h"

  19. #include "carla_ladspa.h"

  20. 

  21. CARLA_BACKEND_START_NAMESPACE

  22. 

  23. #if 0

  24. } /* adjust editor indent */

  25. #endif

  26. 

  27. /*!

  28.  * @defgroup CarlaBackendLadspaPlugin Carla Backend LADSPA Plugin

  29.  *

  30.  * The Carla Backend LADSPA Plugin.\n

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

  32.  * @{

  33.  */

  34. 

  35. class LadspaPlugin : public CarlaPlugin

  36. {

  37. public:

  38.     LadspaPlugin(CarlaEngine* const engine, unsigned short id) : 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.         param_buffers = 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.             ladspa_rdf_free(rdf_descriptor);

  76.     }

  77. 

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

  79.     // Information (base)

  80. 

  81.     PluginCategory category()

  82.     {

  83.         if (rdf_descriptor)

  84.         {

  85.             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.         return descriptor->UniqueID;

  122.     }

  123. 

  124.     // -------------------------------------------------------------------

  125.     // Information (count)

  126. 

  127.     uint32_t parameterScalePointCount(uint32_t parameterId)

  128.     {

  129.         Q_ASSERT(parameterId < param.count);

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

  131. 

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

  133.             return rdf_descriptor->Ports[rindex].ScalePointCount;

  134. 

  135.         return 0;

  136.     }

  137. 

  138.     // -------------------------------------------------------------------

  139.     // Information (per-plugin data)

  140. 

  141.     double getParameterValue(uint32_t parameterId)

  142.     {

  143.         Q_ASSERT(parameterId < param.count);

  144.         return param_buffers[parameterId];

  145.     }

  146. 

  147.     double getParameterScalePointValue(uint32_t parameterId, uint32_t scalePointId)

  148.     {

  149.         Q_ASSERT(parameterId < param.count);

  150.         Q_ASSERT(scalePointId < parameterScalePointCount(parameterId));

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

  152. 

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

  154.         {

  155.             const LADSPA_RDF_ScalePoint* const scalePoint = &rdf_descriptor->Ports[rindex].ScalePoints[scalePointId];

  156. 

  157.             if (scalePoint)

  158.                 return rdf_descriptor->Ports[rindex].ScalePoints[scalePointId].Value;

  159.         }

  160. 

  161.         return 0.0;

  162.     }

  163. 

  164.     void getLabel(char* const strBuf)

  165.     {

  166.         if (descriptor->Label)

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

  168.         else

  169.             CarlaPlugin::getLabel(strBuf);

  170.     }

  171. 

  172.     void getMaker(char* const strBuf)

  173.     {

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

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

  176.         else if (descriptor->Maker)

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

  178.         else

  179.             CarlaPlugin::getMaker(strBuf);

  180.     }

  181. 

  182.     void getCopyright(char* const strBuf)

  183.     {

  184.         if (descriptor->Copyright)

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

  186.         else

  187.             CarlaPlugin::getCopyright(strBuf);

  188.     }

  189. 

  190.     void getRealName(char* const strBuf)

  191.     {

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

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

  194.         else if (descriptor->Name)

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

  196.         else

  197.             CarlaPlugin::getRealName(strBuf);

  198.     }

  199. 

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

  201.     {

  202.         Q_ASSERT(parameterId < param.count);

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

  204. 

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

  206.     }

  207. 

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

  209.     {

  210.         Q_ASSERT(parameterId < param.count);

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

  212. 

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

  214.         {

  215.             const LADSPA_RDF_Port* const Port = &rdf_descriptor->Ports[rindex];

  216. 

  217.             if (LADSPA_PORT_HAS_LABEL(Port->Hints) && Port->Label)

  218.             {

  219.                 strncpy(strBuf, Port->Label, STR_MAX);

  220.                 return;

  221.             }

  222.         }

  223. 

  224.         *strBuf = 0;

  225.     }

  226. 

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

  228.     {

  229.         Q_ASSERT(parameterId < param.count);

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

  231. 

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

  233.         {

  234.             const LADSPA_RDF_Port* const Port = &rdf_descriptor->Ports[rindex];

  235. 

  236.             if (LADSPA_PORT_HAS_UNIT(Port->Hints))

  237.             {

  238.                 switch (Port->Unit)

  239.                 {

  240.                 case LADSPA_UNIT_DB:

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

  242.                     return;

  243.                 case LADSPA_UNIT_COEF:

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

  245.                     return;

  246.                 case LADSPA_UNIT_HZ:

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

  248.                     return;

  249.                 case LADSPA_UNIT_S:

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

  251.                     return;

  252.                 case LADSPA_UNIT_MS:

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

  254.                     return;

  255.                 case LADSPA_UNIT_MIN:

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

  257.                     return;

  258.                 }

  259.             }

  260.         }

  261. 

  262.         *strBuf = 0;

  263.     }

  264. 

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

  266.     {

  267.         Q_ASSERT(parameterId < param.count);

  268.         Q_ASSERT(scalePointId < parameterScalePointCount(parameterId));

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

  270. 

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

  272.         {

  273.             const LADSPA_RDF_ScalePoint* const scalePoint = &rdf_descriptor->Ports[rindex].ScalePoints[scalePointId];

  274. 

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

  276.             {

  277.                 strncpy(strBuf, rdf_descriptor->Ports[rindex].ScalePoints[scalePointId].Label, STR_MAX);

  278.                 return;

  279.             }

  280.         }

  281. 

  282.         *strBuf = 0;

  283.     }

  284. 

  285.     // -------------------------------------------------------------------

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

  287. 

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

  289.     {

  290.         Q_ASSERT(parameterId < param.count);

  291.         param_buffers[parameterId] = fixParameterValue(value, param.ranges[parameterId]);

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

  293.     }

  294. 

  295.     // -------------------------------------------------------------------

  296.     // Plugin state

  297. 

  298.     void reload()

  299.     {

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

  301. 

  302.         // Safely disable plugin for reload

  303.         const CarlaPluginScopedDisabler m(this);

  304. 

  305.         if (x_client->isActive())

  306.             x_client->deactivate();

  307. 

  308.         // Remove client ports

  309.         removeClientPorts();

  310. 

  311.         // Delete old data

  312.         deleteBuffers();

  313. 

  314.         uint32_t ains, aouts, params, j;

  315.         ains = aouts = params = 0;

  316. 

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

  318.         const unsigned long PortCount = descriptor->PortCount;

  319. 

  320.         for (unsigned long i=0; i < PortCount; i++)

  321.         {

  322.             const LADSPA_PortDescriptor PortType = descriptor->PortDescriptors[i];

  323.             if (LADSPA_IS_PORT_AUDIO(PortType))

  324.             {

  325.                 if (LADSPA_IS_PORT_INPUT(PortType))

  326.                     ains += 1;

  327.                 else if (LADSPA_IS_PORT_OUTPUT(PortType))

  328.                     aouts += 1;

  329.             }

  330.             else if (LADSPA_IS_PORT_CONTROL(PortType))

  331.                 params += 1;

  332.         }

  333. 

  334.         if (carlaOptions.force_stereo && (ains == 1 || aouts == 1) && ! h2)

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

  336. 

  337.         if (ains > 0)

  338.         {

  339.             ain.ports    = new CarlaEngineAudioPort*[ains];

  340.             ain.rindexes = new uint32_t[ains];

  341.         }

  342. 

  343.         if (aouts > 0)

  344.         {

  345.             aout.ports    = new CarlaEngineAudioPort*[aouts];

  346.             aout.rindexes = new uint32_t[aouts];

  347.         }

  348. 

  349.         if (params > 0)

  350.         {

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

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

  353.             param_buffers = new float[params];

  354.         }

  355. 

  356.         const int portNameSize = CarlaEngine::maxPortNameSize() - 1;

  357.         char portName[portNameSize];

  358.         bool needsCin  = false;

  359.         bool needsCout = false;

  360. 

  361.         for (unsigned long i=0; i<PortCount; i++)

  362.         {

  363.             const LADSPA_PortDescriptor PortType = descriptor->PortDescriptors[i];

  364.             const LADSPA_PortRangeHint PortHint  = descriptor->PortRangeHints[i];

  365.             const bool HasPortRDF = (rdf_descriptor && i < rdf_descriptor->PortCount);

  366. 

  367.             if (LADSPA_IS_PORT_AUDIO(PortType))

  368.             {

  369. #ifndef BUILD_BRIDGE

  370.                 if (carlaOptions.process_mode != PROCESS_MODE_MULTIPLE_CLIENTS)

  371.                 {

  372.                     strcpy(portName, m_name);

  373.                     strcat(portName, ":");

  374.                     strncat(portName, descriptor->PortNames[i], portNameSize/2);

  375.                 }

  376.                 else

  377. #endif

  378.                     strncpy(portName, descriptor->PortNames[i], portNameSize);

  379. 

  380.                 if (LADSPA_IS_PORT_INPUT(PortType))

  381.                 {

  382.                     j = ain.count++;

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

  384.                     ain.rindexes[j] = i;

  385.                 }

  386.                 else if (LADSPA_IS_PORT_OUTPUT(PortType))

  387.                 {

  388.                     j = aout.count++;

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

  390.                     aout.rindexes[j] = i;

  391.                     needsCin = true;

  392.                 }

  393.                 else

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

  395.             }

  396.             else if (LADSPA_IS_PORT_CONTROL(PortType))

  397.             {

  398.                 j = param.count++;

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

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

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

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

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

  404. 

  405.                 double min, max, def, step, step_small, step_large;

  406. 

  407.                 // min value

  408.                 if (LADSPA_IS_HINT_BOUNDED_BELOW(PortHint.HintDescriptor))

  409.                     min = PortHint.LowerBound;

  410.                 else

  411.                     min = 0.0;

  412. 

  413.                 // max value

  414.                 if (LADSPA_IS_HINT_BOUNDED_ABOVE(PortHint.HintDescriptor))

  415.                     max = PortHint.UpperBound;

  416.                 else

  417.                     max = 1.0;

  418. 

  419.                 if (min > max)

  420.                     max = min;

  421.                 else if (max < min)

  422.                     min = max;

  423. 

  424.                 if (max - min == 0.0)

  425.                 {

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

  427.                     max = min + 0.1;

  428.                 }

  429. 

  430.                 // default value

  431.                 if (HasPortRDF && LADSPA_PORT_HAS_DEFAULT(rdf_descriptor->Ports[i].Hints))

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

  433. 

  434.                 else if (LADSPA_IS_HINT_HAS_DEFAULT(PortHint.HintDescriptor))

  435.                 {

  436.                     switch (PortHint.HintDescriptor & LADSPA_HINT_DEFAULT_MASK)

  437.                     {

  438.                     case LADSPA_HINT_DEFAULT_MINIMUM:

  439.                         def = min;

  440.                         break;

  441.                     case LADSPA_HINT_DEFAULT_MAXIMUM:

  442.                         def = max;

  443.                         break;

  444.                     case LADSPA_HINT_DEFAULT_0:

  445.                         def = 0.0;

  446.                         break;

  447.                     case LADSPA_HINT_DEFAULT_1:

  448.                         def = 1.0;

  449.                         break;

  450.                     case LADSPA_HINT_DEFAULT_100:

  451.                         def = 100.0;

  452.                         break;

  453.                     case LADSPA_HINT_DEFAULT_440:

  454.                         def = 440.0;

  455.                         break;

  456.                     case LADSPA_HINT_DEFAULT_LOW:

  457.                         if (LADSPA_IS_HINT_LOGARITHMIC(PortHint.HintDescriptor))

  458.                             def = exp((log(min)*0.75) + (log(max)*0.25));

  459.                         else

  460.                             def = (min*0.75) + (max*0.25);

  461.                         break;

  462.                     case LADSPA_HINT_DEFAULT_MIDDLE:

  463.                         if (LADSPA_IS_HINT_LOGARITHMIC(PortHint.HintDescriptor))

  464.                             def = sqrt(min*max);

  465.                         else

  466.                             def = (min+max)/2;

  467.                         break;

  468.                     case LADSPA_HINT_DEFAULT_HIGH:

  469.                         if (LADSPA_IS_HINT_LOGARITHMIC(PortHint.HintDescriptor))

  470.                             def = exp((log(min)*0.25) + (log(max)*0.75));

  471.                         else

  472.                             def = (min*0.25) + (max*0.75);

  473.                         break;

  474.                     default:

  475.                         if (min < 0.0 && max > 0.0)

  476.                             def = 0.0;

  477.                         else

  478.                             def = min;

  479.                         break;

  480.                     }

  481.                 }

  482.                 else

  483.                 {

  484.                     // no default value

  485.                     if (min < 0.0 && max > 0.0)

  486.                         def = 0.0;

  487.                     else

  488.                         def = min;

  489.                 }

  490. 

  491.                 if (def < min)

  492.                     def = min;

  493.                 else if (def > max)

  494.                     def = max;

  495. 

  496.                 if (LADSPA_IS_HINT_SAMPLE_RATE(PortHint.HintDescriptor))

  497.                 {

  498.                     min *= sampleRate;

  499.                     max *= sampleRate;

  500.                     def *= sampleRate;

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

  502.                 }

  503. 

  504.                 if (LADSPA_IS_HINT_TOGGLED(PortHint.HintDescriptor))

  505.                 {

  506.                     step = max - min;

  507.                     step_small = step;

  508.                     step_large = step;

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

  510.                 }

  511.                 else if (LADSPA_IS_HINT_INTEGER(PortHint.HintDescriptor))

  512.                 {

  513.                     step = 1.0;

  514.                     step_small = 1.0;

  515.                     step_large = 10.0;

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

  517.                 }

  518.                 else

  519.                 {

  520.                     double range = max - min;

  521.                     step = range/100.0;

  522.                     step_small = range/1000.0;

  523.                     step_large = range/10.0;

  524.                 }

  525. 

  526.                 if (LADSPA_IS_PORT_INPUT(PortType))

  527.                 {

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

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

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

  531.                     needsCin = true;

  532.                 }

  533.                 else if (LADSPA_IS_PORT_OUTPUT(PortType))

  534.                 {

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

  536.                     {

  537.                         min = 0.0;

  538.                         max = sampleRate;

  539.                         def = 0.0;

  540.                         step = 1.0;

  541.                         step_small = 1.0;

  542.                         step_large = 1.0;

  543. 

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

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

  546.                     }

  547.                     else

  548.                     {

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

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

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

  552.                         needsCout = true;

  553.                     }

  554.                 }

  555.                 else

  556.                 {

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

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

  559.                 }

  560. 

  561.                 // extra parameter hints

  562.                 if (LADSPA_IS_HINT_LOGARITHMIC(PortHint.HintDescriptor))

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

  564. 

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

  566.                 if (HasPortRDF && rdf_descriptor->Ports[i].ScalePointCount > 1)

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

  568. 

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

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

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

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

  573.                 param.ranges[j].stepSmall = step_small;

  574.                 param.ranges[j].stepLarge = step_large;

  575. 

  576.                 // Start parameters in their default values

  577.                 param_buffers[j] = def;

  578. 

  579.                 descriptor->connect_port(handle, i, &param_buffers[j]);

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

  581.             }

  582.             else

  583.             {

  584.                 // Not Audio or Control

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

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

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

  588.             }

  589.         }

  590. 

  591.         if (needsCin)

  592.         {

  593. #ifndef BUILD_BRIDGE

  594.             if (carlaOptions.process_mode != PROCESS_MODE_MULTIPLE_CLIENTS)

  595.             {

  596.                 strcpy(portName, m_name);

  597.                 strcat(portName, ":control-in");

  598.             }

  599.             else

  600. #endif

  601.                 strcpy(portName, "control-in");

  602. 

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

  604.         }

  605. 

  606.         if (needsCout)

  607.         {

  608. #ifndef BUILD_BRIDGE

  609.             if (carlaOptions.process_mode != PROCESS_MODE_MULTIPLE_CLIENTS)

  610.             {

  611.                 strcpy(portName, m_name);

  612.                 strcat(portName, ":control-out");

  613.             }

  614.             else

  615. #endif

  616.                 strcpy(portName, "control-out");

  617. 

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

  619.         }

  620. 

  621.         ain.count   = ains;

  622.         aout.count  = aouts;

  623.         param.count = params;

  624. 

  625.         // plugin checks

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

  627. 

  628.         if (aouts > 0 && (ains == aouts || ains == 1))

  629.             m_hints |= PLUGIN_CAN_DRYWET;

  630. 

  631.         if (aouts > 0)

  632.             m_hints |= PLUGIN_CAN_VOLUME;

  633. 

  634.         if ((aouts >= 2 && aouts%2 == 0) || h2)

  635.             m_hints |= PLUGIN_CAN_BALANCE;

  636. 

  637.         x_client->activate();

  638. 

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

  640.     }

  641. 

  642.     // -------------------------------------------------------------------

  643.     // Plugin processing

  644. 

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

  646.     {

  647.         uint32_t i, k;

  648. 

  649.         double ains_peak_tmp[2]  = { 0.0 };

  650.         double aouts_peak_tmp[2] = { 0.0 };

  651. 

  652.         CARLA_PROCESS_CONTINUE_CHECK;

  653. 

  654.         // --------------------------------------------------------------------------------------------------------

  655.         // Input VU

  656. 

  657.         if (ain.count > 0)

  658.         {

  659.             uint32_t count = h2 ? 2 : ain.count;

  660. 

  661.             if (count == 1)

  662.             {

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

  664.                 {

  665.                     if (abs(inBuffer[0][k]) > ains_peak_tmp[0])

  666.                         ains_peak_tmp[0] = abs(inBuffer[0][k]);

  667.                 }

  668.             }

  669.             else if (count > 1)

  670.             {

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

  672.                 {

  673.                     if (abs(inBuffer[0][k]) > ains_peak_tmp[0])

  674.                         ains_peak_tmp[0] = abs(inBuffer[0][k]);

  675. 

  676.                     if (abs(inBuffer[1][k]) > ains_peak_tmp[1])

  677.                         ains_peak_tmp[1] = abs(inBuffer[1][k]);

  678.                 }

  679.             }

  680.         }

  681. 

  682.         CARLA_PROCESS_CONTINUE_CHECK;

  683. 

  684.         // --------------------------------------------------------------------------------------------------------

  685.         // Parameters Input [Automation]

  686. 

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

  688.         {

  689.             const CarlaEngineControlEvent* cinEvent;

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

  691. 

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

  693.             {

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

  695. 

  696.                 if (! cinEvent)

  697.                     continue;

  698. 

  699.                 time = cinEvent->time - framesOffset;

  700. 

  701.                 if (time >= frames)

  702.                     continue;

  703. 

  704.                 // Control change

  705.                 switch (cinEvent->type)

  706.                 {

  707.                 case CarlaEngineEventControlChange:

  708.                 {

  709.                     double value;

  710. 

  711.                     // Control backend stuff

  712.                     if (cinEvent->channel == cin_channel)

  713.                     {

  714.                         if (MIDI_IS_CONTROL_BREATH_CONTROLLER(cinEvent->controller) && (m_hints & PLUGIN_CAN_DRYWET) > 0)

  715.                         {

  716.                             value = cinEvent->value;

  717.                             setDryWet(value, false, false);

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

  719.                             continue;

  720.                         }

  721. 

  722.                         if (MIDI_IS_CONTROL_CHANNEL_VOLUME(cinEvent->controller) && (m_hints & PLUGIN_CAN_VOLUME) > 0)

  723.                         {

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

  725.                             setVolume(value, false, false);

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

  727.                             continue;

  728.                         }

  729. 

  730.                         if (MIDI_IS_CONTROL_BALANCE(cinEvent->controller) && (m_hints & PLUGIN_CAN_BALANCE) > 0)

  731.                         {

  732.                             double left, right;

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

  734. 

  735.                             if (value < 0)

  736.                             {

  737.                                 left  = -1.0;

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

  739.                             }

  740.                             else if (value > 0)

  741.                             {

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

  743.                                 right = 1.0;

  744.                             }

  745.                             else

  746.                             {

  747.                                 left  = -1.0;

  748.                                 right = 1.0;

  749.                             }

  750. 

  751.                             setBalanceLeft(left, false, false);

  752.                             setBalanceRight(right, false, false);

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

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

  755.                             continue;

  756.                         }

  757.                     }

  758. 

  759.                     // Control plugin parameters

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

  761.                     {

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

  763.                             continue;

  764.                         if (param.data[k].midiCC != cinEvent->controller)

  765.                             continue;

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

  767.                             continue;

  768. 

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

  770.                         {

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

  772.                             {

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

  774.                             }

  775.                             else

  776.                             {

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

  778. 

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

  780.                                     value = rint(value);

  781.                             }

  782. 

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

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

  785.                         }

  786.                     }

  787. 

  788.                     break;

  789.                 }

  790. 

  791.                 case CarlaEngineEventAllSoundOff:

  792.                     if (cinEvent->channel == cin_channel)

  793.                     {

  794.                         if (descriptor->deactivate)

  795.                         {

  796.                             descriptor->deactivate(handle);

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

  798.                         }

  799. 

  800.                         if (descriptor->activate)

  801.                         {

  802.                             descriptor->activate(handle);

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

  804.                         }

  805.                     }

  806.                     break;

  807. 

  808.                 default:

  809.                     break;

  810.                 }

  811.             }

  812.         } // End of Parameters Input

  813. 

  814.         CARLA_PROCESS_CONTINUE_CHECK;

  815. 

  816.         // --------------------------------------------------------------------------------------------------------

  817.         // Special Parameters

  818. 

  819. #if 0

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

  821.         {

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

  823.             {

  824.                 // TODO: ladspa special params

  825.             }

  826.         }

  827. 

  828.         CARLA_PROCESS_CONTINUE_CHECK;

  829. #endif

  830. 

  831.         // --------------------------------------------------------------------------------------------------------

  832.         // Plugin processing

  833. 

  834.         if (m_active)

  835.         {

  836.             if (! m_activeBefore)

  837.             {

  838.                 if (descriptor->activate)

  839.                 {

  840.                     descriptor->activate(handle);

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

  842.                 }

  843.             }

  844. 

  845.             for (i=0; i < ain.count; i++)

  846.             {

  847.                 descriptor->connect_port(handle, ain.rindexes[i], inBuffer[i]);

  848.                 if (h2 && i == 0) descriptor->connect_port(h2, ain.rindexes[i], inBuffer[1]);

  849.             }

  850. 

  851.             for (i=0; i < aout.count; i++)

  852.             {

  853.                 descriptor->connect_port(handle, aout.rindexes[i], outBuffer[i]);

  854.                 if (h2 && i == 0) descriptor->connect_port(h2, aout.rindexes[i], outBuffer[1]);

  855.             }

  856. 

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

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

  859.         }

  860.         else

  861.         {

  862.             if (m_activeBefore)

  863.             {

  864.                 if (descriptor->deactivate)

  865.                 {

  866.                     descriptor->deactivate(handle);

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

  868.                 }

  869.             }

  870.         }

  871. 

  872.         CARLA_PROCESS_CONTINUE_CHECK;

  873. 

  874.         // --------------------------------------------------------------------------------------------------------

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

  876. 

  877.         if (m_active)

  878.         {

  879.             bool do_drywet  = (m_hints & PLUGIN_CAN_DRYWET) > 0 && x_drywet != 1.0;

  880.             bool do_volume  = (m_hints & PLUGIN_CAN_VOLUME) > 0 && x_vol != 1.0;

  881.             bool do_balance = (m_hints & PLUGIN_CAN_BALANCE) > 0 && (x_bal_left != -1.0 || x_bal_right != 1.0);

  882. 

  883.             double bal_rangeL, bal_rangeR;

  884.             float oldBufLeft[do_balance ? frames : 0];

  885. 

  886.             uint32_t count = h2 ? 2 : aout.count;

  887. 

  888.             for (i=0; i < count; i++)

  889.             {

  890.                 // Dry/Wet and Volume

  891.                 if (do_drywet || do_volume)

  892.                 {

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

  894.                     {

  895.                         if (do_drywet)

  896.                         {

  897.                             if (aout.count == 1 && ! h2)

  898.                                 outBuffer[i][k] = (outBuffer[i][k]*x_drywet)+(inBuffer[0][k]*(1.0-x_drywet));

  899.                             else

  900.                                 outBuffer[i][k] = (outBuffer[i][k]*x_drywet)+(inBuffer[i][k]*(1.0-x_drywet));

  901.                         }

  902. 

  903.                         if (do_volume)

  904.                             outBuffer[i][k] *= x_vol;

  905.                     }

  906.                 }

  907. 

  908.                 // Balance

  909.                 if (do_balance)

  910.                 {

  911.                     if (i%2 == 0)

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

  913. 

  914.                     bal_rangeL = (x_bal_left+1.0)/2;

  915.                     bal_rangeR = (x_bal_right+1.0)/2;

  916. 

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

  918.                     {

  919.                         if (i%2 == 0)

  920.                         {

  921.                             // left output

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

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

  924.                         }

  925.                         else

  926.                         {

  927.                             // right

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

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

  930.                         }

  931.                     }

  932.                 }

  933. 

  934.                 // Output VU

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

  936.                 {

  937.                     if (abs(outBuffer[i][k]) > aouts_peak_tmp[i])

  938.                         aouts_peak_tmp[i] = abs(outBuffer[i][k]);

  939.                 }

  940.             }

  941.         }

  942.         else

  943.         {

  944.             // disable any output sound if not active

  945.             for (i=0; i < aout.count; i++)

  946.                 memset(outBuffer[i], 0.0f, sizeof(float)*frames);

  947. 

  948.             aouts_peak_tmp[0] = 0.0;

  949.             aouts_peak_tmp[1] = 0.0;

  950. 

  951.         } // End of Post-processing

  952. 

  953.         CARLA_PROCESS_CONTINUE_CHECK;

  954. 

  955.         // --------------------------------------------------------------------------------------------------------

  956.         // Control Output

  957. 

  958.         if (param.portCout && m_active)

  959.         {

  960.             double value;

  961. 

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

  963.             {

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

  965.                 {

  966.                     fixParameterValue(param_buffers[k], param.ranges[k]);

  967. 

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

  969.                     {

  970.                         value = (param_buffers[k] - param.ranges[k].min) / (param.ranges[k].max - param.ranges[k].min);

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

  972.                     }

  973.                 }

  974.             }

  975.         } // End of Control Output

  976. 

  977.         CARLA_PROCESS_CONTINUE_CHECK;

  978. 

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

  980.         // Peak Values

  981. 

  982.         x_engine->setInputPeak(m_id, 0, ains_peak_tmp[0]);

  983.         x_engine->setInputPeak(m_id, 1, ains_peak_tmp[1]);

  984.         x_engine->setOutputPeak(m_id, 0, aouts_peak_tmp[0]);

  985.         x_engine->setOutputPeak(m_id, 1, aouts_peak_tmp[1]);

  986. 

  987.         m_activeBefore = m_active;

  988.     }

  989. 

  990.     // -------------------------------------------------------------------

  991.     // Cleanup

  992. 

  993.     void deleteBuffers()

  994.     {

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

  996. 

  997.         if (param.count > 0)

  998.             delete[] param_buffers;

  999. 

  1000.         param_buffers = nullptr;

  1001. 

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

  1003.     }

  1004. 

  1005.     // -------------------------------------------------------------------

  1006. 

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

  1008.     {

  1009.         // ---------------------------------------------------------------

  1010.         // open DLL

  1011. 

  1012.         if (! libOpen(filename))

  1013.         {

  1014.             setLastError(libError(filename));

  1015.             return false;

  1016.         }

  1017. 

  1018.         // ---------------------------------------------------------------

  1019.         // get DLL main entry

  1020. 

  1021.         LADSPA_Descriptor_Function descfn = (LADSPA_Descriptor_Function)libSymbol("ladspa_descriptor");

  1022. 

  1023.         if (! descfn)

  1024.         {

  1025.             setLastError("Could not find the LASDPA Descriptor in the plugin library");

  1026.             return false;

  1027.         }

  1028. 

  1029.         // ---------------------------------------------------------------

  1030.         // get descriptor that matches label

  1031. 

  1032.         unsigned long i = 0;

  1033.         while ((descriptor = descfn(i++)))

  1034.         {

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

  1036.                 break;

  1037.         }

  1038. 

  1039.         if (! descriptor)

  1040.         {

  1041.             setLastError("Could not find the requested plugin Label in the plugin library");

  1042.             return false;

  1043.         }

  1044. 

  1045.         // ---------------------------------------------------------------

  1046.         // initialize plugin

  1047. 

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

  1049. 

  1050.         if (! handle)

  1051.         {

  1052.             setLastError("Plugin failed to initialize");

  1053.             return false;

  1054.         }

  1055. 

  1056.         // ---------------------------------------------------------------

  1057.         // get info

  1058. 

  1059.         m_filename = strdup(filename);

  1060. 

  1061.         if (is_ladspa_rdf_descriptor_valid(rdf_descriptor_, descriptor))

  1062.             rdf_descriptor = ladspa_rdf_dup(rdf_descriptor_);

  1063. 

  1064.         if (name)

  1065.             m_name = x_engine->getUniqueName(name);

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

  1067.             m_name = x_engine->getUniqueName(rdf_descriptor->Title);

  1068.         else

  1069.             m_name = x_engine->getUniqueName(descriptor->Name);

  1070. 

  1071.         // ---------------------------------------------------------------

  1072.         // register client

  1073. 

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

  1075. 

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

  1077.         {

  1078.             setLastError("Failed to register plugin client");

  1079.             return false;

  1080.         }

  1081. 

  1082.         return true;

  1083.     }

  1084. 

  1085. private:

  1086.     LADSPA_Handle handle, h2;

  1087.     const LADSPA_Descriptor* descriptor;

  1088.     const LADSPA_RDF_Descriptor* rdf_descriptor;

  1089. 

  1090.     float* param_buffers;

  1091. };

  1092. 

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

  1094. {

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

  1096. 

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

  1098. 

  1099.     if (id < 0)

  1100.     {

  1101.         setLastError("Maximum number of plugins reached");

  1102.         return nullptr;

  1103.     }

  1104. 

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

  1106. 

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

  1108.     {

  1109.         delete plugin;

  1110.         return nullptr;

  1111.     }

  1112. 

  1113.     plugin->reload();

  1114. 

  1115. #ifndef BUILD_BRIDGE

  1116.     if (carlaOptions.process_mode == PROCESS_MODE_CONTINUOUS_RACK)

  1117.     {

  1118.         const uint32_t ins  = plugin->audioInCount();

  1119.         const uint32_t outs = plugin->audioOutCount();

  1120. 

  1121.         if (ins > 2 || outs > 2 || (ins != outs && ins != 0 && outs != 0))

  1122.         {

  1123.             setLastError("Carla's rack mode can only work with Mono or Stereo LADSPA plugins, sorry!");

  1124.             delete plugin;

  1125.             return nullptr;

  1126.         }

  1127.     }

  1128. #endif

  1129. 

  1130.     plugin->registerToOsc();

  1131. 

  1132.     return plugin;

  1133. }

  1134. 

  1135. /**@}*/

  1136. 

  1137. CARLA_BACKEND_END_NAMESPACE