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.
226 Commits
2 Branches
29MB
Tree: e2b1d8adea
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'e2b1d8adea'
${ noResults }
Cadence/src/carla-backend/ladspa.cpp

1060 lines
36KB
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. 

  20. #include "ladspa/ladspa.h"

  21. #include "ladspa_rdf.h"

  22. 

  23. CARLA_BACKEND_START_NAMESPACE

  24. 

  25. #if 0

  26. } /* adjust editor indent */

  27. #endif

  28. 

  29. bool is_rdf_port_good(int Type1, int Type2)

  30. {

  31.     if (LADSPA_IS_PORT_INPUT(Type1) && ! LADSPA_IS_PORT_INPUT(Type2))

  32.         return false;

  33.     else if (LADSPA_IS_PORT_OUTPUT(Type1) && ! LADSPA_IS_PORT_OUTPUT(Type2))

  34.         return false;

  35.     else if (LADSPA_IS_PORT_CONTROL(Type1) && ! LADSPA_IS_PORT_CONTROL(Type2))

  36.         return false;

  37.     else if (LADSPA_IS_PORT_AUDIO(Type1) && ! LADSPA_IS_PORT_AUDIO(Type2))

  38.         return false;

  39.     else

  40.         return true;

  41. }

  42. 

  43. bool is_ladspa_rdf_descriptor_valid(const LADSPA_RDF_Descriptor* rdf_descriptor, const LADSPA_Descriptor* descriptor)

  44. {

  45.     if (rdf_descriptor)

  46.     {

  47.         if (rdf_descriptor->PortCount <= descriptor->PortCount)

  48.         {

  49.             for (unsigned long i=0; i < rdf_descriptor->PortCount; i++)

  50.             {

  51.                 if (is_rdf_port_good(rdf_descriptor->Ports[i].Type, descriptor->PortDescriptors[i]) == false)

  52.                 {

  53.                     qWarning("WARNING - Plugin has RDF data, but invalid PortTypes: %i != %i", rdf_descriptor->Ports[i].Type, descriptor->PortDescriptors[i]);

  54.                     return false;

  55.                 }

  56.             }

  57.             return true;

  58.         }

  59.         else

  60.         {

  61.             qWarning("WARNING - Plugin has RDF data, but invalid PortCount: %li > %li", rdf_descriptor->PortCount, descriptor->PortCount);

  62.             return false;

  63.         }

  64.     }

  65.     else

  66.         // No RDF Descriptor

  67.         return false;

  68. }

  69. 

  70. class LadspaPlugin : public CarlaPlugin

  71. {

  72. public:

  73.     LadspaPlugin(unsigned short id) : CarlaPlugin(id)

  74.     {

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

  76.         m_type = PLUGIN_LADSPA;

  77. 

  78.         handle = nullptr;

  79.         descriptor = nullptr;

  80.         rdf_descriptor = nullptr;

  81. 

  82.         param_buffers = nullptr;

  83.     }

  84. 

  85.     ~LadspaPlugin()

  86.     {

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

  88. 

  89.         if (handle && descriptor && descriptor->deactivate && m_active_before)

  90.             descriptor->deactivate(handle);

  91. 

  92.         if (handle && descriptor && descriptor->cleanup)

  93.             descriptor->cleanup(handle);

  94. 

  95.         if (rdf_descriptor)

  96.             ladspa_rdf_free(rdf_descriptor);

  97.     }

  98. 

  99.     // -------------------------------------------------------------------

  100.     // Information (base)

  101. 

  102.     PluginCategory category()

  103.     {

  104.         if (rdf_descriptor)

  105.         {

  106.             LADSPA_Properties Category = rdf_descriptor->Type;

  107. 

  108.             // Specific Types

  109.             if (Category & (LADSPA_CLASS_DELAY|LADSPA_CLASS_REVERB))

  110.                 return PLUGIN_CATEGORY_DELAY;

  111.             if (Category & (LADSPA_CLASS_PHASER|LADSPA_CLASS_FLANGER|LADSPA_CLASS_CHORUS))

  112.                 return PLUGIN_CATEGORY_MODULATOR;

  113.             if (Category & (LADSPA_CLASS_AMPLIFIER))

  114.                 return PLUGIN_CATEGORY_DYNAMICS;

  115.             if (Category & (LADSPA_CLASS_UTILITY|LADSPA_CLASS_SPECTRAL|LADSPA_CLASS_FREQUENCY_METER))

  116.                 return PLUGIN_CATEGORY_UTILITY;

  117. 

  118.             // Pre-set LADSPA Types

  119.             if (LADSPA_IS_PLUGIN_DYNAMICS(Category))

  120.                 return PLUGIN_CATEGORY_DYNAMICS;

  121.             if (LADSPA_IS_PLUGIN_AMPLITUDE(Category))

  122.                 return PLUGIN_CATEGORY_MODULATOR;

  123.             if (LADSPA_IS_PLUGIN_EQ(Category))

  124.                 return PLUGIN_CATEGORY_EQ;

  125.             if (LADSPA_IS_PLUGIN_FILTER(Category))

  126.                 return PLUGIN_CATEGORY_FILTER;

  127.             if (LADSPA_IS_PLUGIN_FREQUENCY(Category))

  128.                 return PLUGIN_CATEGORY_UTILITY;

  129.             if (LADSPA_IS_PLUGIN_SIMULATOR(Category))

  130.                 return PLUGIN_CATEGORY_OTHER;

  131.             if (LADSPA_IS_PLUGIN_TIME(Category))

  132.                 return PLUGIN_CATEGORY_DELAY;

  133.             if (LADSPA_IS_PLUGIN_GENERATOR(Category))

  134.                 return PLUGIN_CATEGORY_SYNTH;

  135.         }

  136. 

  137.         return get_category_from_name(m_name);

  138.     }

  139. 

  140.     long unique_id()

  141.     {

  142.         return descriptor->UniqueID;

  143.     }

  144. 

  145.     // -------------------------------------------------------------------

  146.     // Information (count)

  147. 

  148.     uint32_t param_scalepoint_count(uint32_t param_id)

  149.     {

  150.         int32_t rindex = param.data[param_id].rindex;

  151. 

  152.         bool HasPortRDF = (rdf_descriptor && rindex < (int32_t)rdf_descriptor->PortCount);

  153.         if (HasPortRDF)

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

  155.         return 0;

  156.     }

  157. 

  158.     // -------------------------------------------------------------------

  159.     // Information (per-plugin data)

  160. 

  161.     double get_parameter_value(uint32_t param_id)

  162.     {

  163.         return param_buffers[param_id];

  164.     }

  165. 

  166.     double get_parameter_scalepoint_value(uint32_t param_id, uint32_t scalepoint_id)

  167.     {

  168.         int32_t param_rindex = param.data[param_id].rindex;

  169. 

  170.         bool HasPortRDF = (rdf_descriptor && param_rindex < (int32_t)rdf_descriptor->PortCount);

  171.         if (HasPortRDF)

  172.             return rdf_descriptor->Ports[param_rindex].ScalePoints[scalepoint_id].Value;

  173.         return 0.0;

  174.     }

  175. 

  176.     void get_label(char* buf_str)

  177.     {

  178.         strncpy(buf_str, descriptor->Label, STR_MAX);

  179.     }

  180. 

  181.     void get_maker(char* buf_str)

  182.     {

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

  184.             strncpy(buf_str, rdf_descriptor->Creator, STR_MAX);

  185.         else

  186.             strncpy(buf_str, descriptor->Maker, STR_MAX);

  187.     }

  188. 

  189.     void get_copyright(char* buf_str)

  190.     {

  191.         strncpy(buf_str, descriptor->Copyright, STR_MAX);

  192.     }

  193. 

  194.     void get_real_name(char* buf_str)

  195.     {

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

  197.             strncpy(buf_str, rdf_descriptor->Title, STR_MAX);

  198.         else

  199.             strncpy(buf_str, descriptor->Name, STR_MAX);

  200.     }

  201. 

  202.     void get_parameter_name(uint32_t param_id, char* buf_str)

  203.     {

  204.         int32_t rindex = param.data[param_id].rindex;

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

  206.     }

  207. 

  208.     void get_parameter_symbol(uint32_t param_id, char* buf_str)

  209.     {

  210.         int32_t rindex = param.data[param_id].rindex;

  211. 

  212.         bool HasPortRDF = (rdf_descriptor && rindex < (int32_t)rdf_descriptor->PortCount);

  213.         if (HasPortRDF)

  214.         {

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

  216.             if (LADSPA_PORT_HAS_LABEL(Port.Hints))

  217.             {

  218.                 strncpy(buf_str, Port.Label, STR_MAX);

  219.                 return;

  220.             }

  221.         }

  222.         *buf_str = 0;

  223.     }

  224. 

  225.     void get_parameter_unit(uint32_t param_id, char* buf_str)

  226.     {

  227.         int32_t rindex = param.data[param_id].rindex;

  228. 

  229.         bool HasPortRDF = (rdf_descriptor && rindex < (int32_t)rdf_descriptor->PortCount);

  230.         if (HasPortRDF)

  231.         {

  232.             LADSPA_RDF_Port Port = rdf_descriptor->Ports[rindex];

  233.             if (LADSPA_PORT_HAS_UNIT(Port.Hints))

  234.             {

  235.                 switch (Port.Unit)

  236.                 {

  237.                 case LADSPA_UNIT_DB:

  238.                     strncpy(buf_str, "dB", STR_MAX);

  239.                     return;

  240.                 case LADSPA_UNIT_COEF:

  241.                     strncpy(buf_str, "(coef)", STR_MAX);

  242.                     return;

  243.                 case LADSPA_UNIT_HZ:

  244.                     strncpy(buf_str, "Hz", STR_MAX);

  245.                     return;

  246.                 case LADSPA_UNIT_S:

  247.                     strncpy(buf_str, "s", STR_MAX);

  248.                     return;

  249.                 case LADSPA_UNIT_MS:

  250.                     strncpy(buf_str, "ms", STR_MAX);

  251.                     return;

  252.                 case LADSPA_UNIT_MIN:

  253.                     strncpy(buf_str, "min", STR_MAX);

  254.                     return;

  255.                 }

  256.             }

  257.         }

  258.         *buf_str = 0;

  259.     }

  260. 

  261.     void get_parameter_scalepoint_label(uint32_t param_id, uint32_t scalepoint_id, char* buf_str)

  262.     {

  263.         int32_t param_rindex = param.data[param_id].rindex;

  264. 

  265.         bool HasPortRDF = (rdf_descriptor && param_rindex < (int32_t)rdf_descriptor->PortCount);

  266.         if (HasPortRDF)

  267.             strncpy(buf_str, rdf_descriptor->Ports[param_rindex].ScalePoints[scalepoint_id].Label, STR_MAX);

  268.         else

  269.             *buf_str = 0;

  270.     }

  271. 

  272.     // -------------------------------------------------------------------

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

  274. 

  275.     void set_parameter_value(uint32_t param_id, double value, bool gui_send, bool osc_send, bool callback_send)

  276.     {

  277.         param_buffers[param_id] = fix_parameter_value(value, param.ranges[param_id]);

  278. 

  279.         CarlaPlugin::set_parameter_value(param_id, value, gui_send, osc_send, callback_send);

  280.     }

  281. 

  282.     // -------------------------------------------------------------------

  283.     // Plugin state

  284. 

  285.     void reload()

  286.     {

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

  288. 

  289.         // Safely disable plugin for reload

  290.         const CarlaPluginScopedDisabler m(this);

  291. 

  292.         if (x_client->isActive())

  293.             x_client->deactivate();

  294. 

  295.         // Remove client ports

  296.         remove_client_ports();

  297. 

  298.         // Delete old data

  299.         delete_buffers();

  300. 

  301.         uint32_t ains, aouts, params, j;

  302.         ains = aouts = params = 0;

  303. 

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

  305. 

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

  307.         {

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

  309.             if (LADSPA_IS_PORT_AUDIO(PortType))

  310.             {

  311.                 if (LADSPA_IS_PORT_INPUT(PortType))

  312.                     ains += 1;

  313.                 else if (LADSPA_IS_PORT_OUTPUT(PortType))

  314.                     aouts += 1;

  315.             }

  316.             else if (LADSPA_IS_PORT_CONTROL(PortType))

  317.                 params += 1;

  318.         }

  319. 

  320.         if (ains > 0)

  321.         {

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

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

  324.         }

  325. 

  326.         if (aouts > 0)

  327.         {

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

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

  330.         }

  331. 

  332.         if (params > 0)

  333.         {

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

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

  336.             param_buffers = new float[params];

  337.         }

  338. 

  339.         const int port_name_size = CarlaEngine::maxPortNameSize() - 1;

  340.         char port_name[port_name_size];

  341.         bool needs_cin  = false;

  342.         bool needs_cout = false;

  343. 

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

  345.         {

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

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

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

  349. 

  350.             if (LADSPA_IS_PORT_AUDIO(PortType))

  351.             {

  352. #ifndef BUILD_BRIDGE

  353.                 if (carla_options.global_jack_client)

  354.                 {

  355.                     strcpy(port_name, m_name);

  356.                     strcat(port_name, ":");

  357.                     strncat(port_name, descriptor->PortNames[i], port_name_size/2);

  358.                 }

  359.                 else

  360. #endif

  361.                     strncpy(port_name, descriptor->PortNames[i], port_name_size);

  362. 

  363.                 if (LADSPA_IS_PORT_INPUT(PortType))

  364.                 {

  365.                     j = ain.count++;

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

  367.                     ain.rindexes[j] = i;

  368.                 }

  369.                 else if (LADSPA_IS_PORT_OUTPUT(PortType))

  370.                 {

  371.                     j = aout.count++;

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

  373.                     aout.rindexes[j] = i;

  374.                     needs_cin = true;

  375.                 }

  376.                 else

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

  378.             }

  379.             else if (LADSPA_IS_PORT_CONTROL(PortType))

  380.             {

  381.                 j = param.count++;

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

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

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

  385.                 param.data[j].midi_channel = 0;

  386.                 param.data[j].midi_cc = -1;

  387. 

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

  389. 

  390.                 // min value

  391.                 if (LADSPA_IS_HINT_BOUNDED_BELOW(PortHint.HintDescriptor))

  392.                     min = PortHint.LowerBound;

  393.                 else

  394.                     min = 0.0;

  395. 

  396.                 // max value

  397.                 if (LADSPA_IS_HINT_BOUNDED_ABOVE(PortHint.HintDescriptor))

  398.                     max = PortHint.UpperBound;

  399.                 else

  400.                     max = 1.0;

  401. 

  402.                 if (min > max)

  403.                     max = min;

  404.                 else if (max < min)

  405.                     min = max;

  406. 

  407.                 if (max - min == 0.0)

  408.                 {

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

  410.                     max = min + 0.1;

  411.                 }

  412. 

  413.                 // default value

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

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

  416. 

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

  418.                 {

  419.                     switch (PortHint.HintDescriptor & LADSPA_HINT_DEFAULT_MASK)

  420.                     {

  421.                     case LADSPA_HINT_DEFAULT_MINIMUM:

  422.                         def = min;

  423.                         break;

  424.                     case LADSPA_HINT_DEFAULT_MAXIMUM:

  425.                         def = max;

  426.                         break;

  427.                     case LADSPA_HINT_DEFAULT_0:

  428.                         def = 0.0;

  429.                         break;

  430.                     case LADSPA_HINT_DEFAULT_1:

  431.                         def = 1.0;

  432.                         break;

  433.                     case LADSPA_HINT_DEFAULT_100:

  434.                         def = 100.0;

  435.                         break;

  436.                     case LADSPA_HINT_DEFAULT_440:

  437.                         def = 440.0;

  438.                         break;

  439.                     case LADSPA_HINT_DEFAULT_LOW:

  440.                         if (LADSPA_IS_HINT_LOGARITHMIC(PortHint.HintDescriptor))

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

  442.                         else

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

  444.                         break;

  445.                     case LADSPA_HINT_DEFAULT_MIDDLE:

  446.                         if (LADSPA_IS_HINT_LOGARITHMIC(PortHint.HintDescriptor))

  447.                             def = sqrt(min*max);

  448.                         else

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

  450.                         break;

  451.                     case LADSPA_HINT_DEFAULT_HIGH:

  452.                         if (LADSPA_IS_HINT_LOGARITHMIC(PortHint.HintDescriptor))

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

  454.                         else

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

  456.                         break;

  457.                     default:

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

  459.                             def = 0.0;

  460.                         else

  461.                             def = min;

  462.                         break;

  463.                     }

  464.                 }

  465.                 else

  466.                 {

  467.                     // no default value

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

  469.                         def = 0.0;

  470.                     else

  471.                         def = min;

  472.                 }

  473. 

  474.                 if (def < min)

  475.                     def = min;

  476.                 else if (def > max)

  477.                     def = max;

  478. 

  479.                 if (LADSPA_IS_HINT_SAMPLE_RATE(PortHint.HintDescriptor))

  480.                 {

  481.                     double sample_rate = get_sample_rate();

  482.                     min *= sample_rate;

  483.                     max *= sample_rate;

  484.                     def *= sample_rate;

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

  486.                 }

  487. 

  488.                 if (LADSPA_IS_HINT_TOGGLED(PortHint.HintDescriptor))

  489.                 {

  490.                     step = max - min;

  491.                     step_small = step;

  492.                     step_large = step;

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

  494.                 }

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

  496.                 {

  497.                     step = 1.0;

  498.                     step_small = 1.0;

  499.                     step_large = 10.0;

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

  501.                 }

  502.                 else

  503.                 {

  504.                     double range = max - min;

  505.                     step = range/100.0;

  506.                     step_small = range/1000.0;

  507.                     step_large = range/10.0;

  508.                 }

  509. 

  510.                 if (LADSPA_IS_PORT_INPUT(PortType))

  511.                 {

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

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

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

  515.                     needs_cin = true;

  516.                 }

  517.                 else if (LADSPA_IS_PORT_OUTPUT(PortType))

  518.                 {

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

  520.                     {

  521.                         min = 0.0;

  522.                         max = get_sample_rate();

  523.                         def = 0.0;

  524.                         step = 1.0;

  525.                         step_small = 1.0;

  526.                         step_large = 1.0;

  527. 

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

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

  530.                     }

  531.                     else

  532.                     {

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

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

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

  536.                         needs_cout = true;

  537.                     }

  538.                 }

  539.                 else

  540.                 {

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

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

  543.                 }

  544. 

  545.                 // extra parameter hints

  546.                 if (LADSPA_IS_HINT_LOGARITHMIC(PortHint.HintDescriptor))

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

  548. 

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

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

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

  552. 

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

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

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

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

  557.                 param.ranges[j].step_small = step_small;

  558.                 param.ranges[j].step_large = step_large;

  559. 

  560.                 // Start parameters in their default values

  561.                 param_buffers[j] = def;

  562. 

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

  564.             }

  565.             else

  566.             {

  567.                 // Not Audio or Control

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

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

  570.             }

  571.         }

  572. 

  573.         if (needs_cin)

  574.         {

  575. #ifndef BUILD_BRIDGE

  576.             if (carla_options.global_jack_client)

  577.             {

  578.                 strcpy(port_name, m_name);

  579.                 strcat(port_name, ":control-in");

  580.             }

  581.             else

  582. #endif

  583.                 strcpy(port_name, "control-in");

  584. 

  585.             param.port_cin = (CarlaEngineControlPort*)x_client->addPort(port_name, CarlaEnginePortTypeControl, true);

  586.         }

  587. 

  588.         if (needs_cout)

  589.         {

  590. #ifndef BUILD_BRIDGE

  591.             if (carla_options.global_jack_client)

  592.             {

  593.                 strcpy(port_name, m_name);

  594.                 strcat(port_name, ":control-out");

  595.             }

  596.             else

  597. #endif

  598.                 strcpy(port_name, "control-out");

  599. 

  600.             param.port_cout = (CarlaEngineControlPort*)x_client->addPort(port_name, CarlaEnginePortTypeControl, false);

  601.         }

  602. 

  603.         ain.count   = ains;

  604.         aout.count  = aouts;

  605.         param.count = params;

  606. 

  607.         // plugin checks

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

  609. 

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

  611.             m_hints |= PLUGIN_CAN_DRYWET;

  612. 

  613.         if (aouts > 0)

  614.             m_hints |= PLUGIN_CAN_VOLUME;

  615. 

  616.         if (aouts >= 2 && aouts%2 == 0)

  617.             m_hints |= PLUGIN_CAN_BALANCE;

  618. 

  619.         x_client->activate();

  620. 

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

  622.     }

  623. 

  624.     // -------------------------------------------------------------------

  625.     // Plugin processing

  626. 

  627.     void process(float** ains_buffer, float** aouts_buffer, uint32_t nframes, uint32_t nframesOffset)

  628.     {

  629.         uint32_t i, k;

  630. 

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

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

  633. 

  634.         CARLA_PROCESS_CONTINUE_CHECK;

  635. 

  636.         // --------------------------------------------------------------------------------------------------------

  637.         // Input VU

  638. 

  639.         if (ain.count > 0)

  640.         {

  641.             if (ain.count == 1)

  642.             {

  643.                 for (k=0; k < nframes; k++)

  644.                 {

  645.                     if (abs_d(ains_buffer[0][k]) > ains_peak_tmp[0])

  646.                         ains_peak_tmp[0] = abs_d(ains_buffer[0][k]);

  647.                 }

  648.             }

  649.             else if (ain.count >= 1)

  650.             {

  651.                 for (k=0; k < nframes; k++)

  652.                 {

  653.                     if (abs_d(ains_buffer[0][k]) > ains_peak_tmp[0])

  654.                         ains_peak_tmp[0] = abs_d(ains_buffer[0][k]);

  655. 

  656.                     if (abs_d(ains_buffer[1][k]) > ains_peak_tmp[1])

  657.                         ains_peak_tmp[1] = abs_d(ains_buffer[1][k]);

  658.                 }

  659.             }

  660.         }

  661. 

  662.         CARLA_PROCESS_CONTINUE_CHECK;

  663. 

  664.         // --------------------------------------------------------------------------------------------------------

  665.         // Parameters Input [Automation]

  666. 

  667.         if (param.port_cin && m_active && m_active_before)

  668.         {

  669.             void* cin_buffer = param.port_cin->getBuffer();

  670. 

  671.             const CarlaEngineControlEvent* cin_event;

  672.             uint32_t time, n_cin_events = param.port_cin->getEventCount(cin_buffer);

  673. 

  674.             for (i=0; i < n_cin_events; i++)

  675.             {

  676.                 cin_event = param.port_cin->getEvent(cin_buffer, i);

  677. 

  678.                 if (! cin_event)

  679.                     continue;

  680. 

  681.                 time = cin_event->time - nframesOffset;

  682. 

  683.                 if (time >= nframes)

  684.                     continue;

  685. 

  686.                 // Control change

  687.                 switch (cin_event->type)

  688.                 {

  689.                 case CarlaEngineEventControlChange:

  690.                 {

  691.                     double value;

  692. 

  693.                     // Control backend stuff

  694.                     if (cin_event->channel == cin_channel)

  695.                     {

  696.                         if (MIDI_IS_CONTROL_BREATH_CONTROLLER(cin_event->controller) && (m_hints & PLUGIN_CAN_DRYWET) > 0)

  697.                         {

  698.                             value = cin_event->value;

  699.                             set_drywet(value, false, false);

  700.                             postpone_event(PluginPostEventParameterChange, PARAMETER_DRYWET, value);

  701.                             continue;

  702.                         }

  703.                         else if (MIDI_IS_CONTROL_CHANNEL_VOLUME(cin_event->controller) && (m_hints & PLUGIN_CAN_VOLUME) > 0)

  704.                         {

  705.                             value = cin_event->value*127/100;

  706.                             set_volume(value, false, false);

  707.                             postpone_event(PluginPostEventParameterChange, PARAMETER_VOLUME, value);

  708.                             continue;

  709.                         }

  710.                         else if (MIDI_IS_CONTROL_BALANCE(cin_event->controller) && (m_hints & PLUGIN_CAN_BALANCE) > 0)

  711.                         {

  712.                             double left, right;

  713.                             value = cin_event->value/0.5 - 1.0;

  714. 

  715.                             if (value < 0)

  716.                             {

  717.                                 left  = -1.0;

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

  719.                             }

  720.                             else if (value > 0)

  721.                             {

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

  723.                                 right = 1.0;

  724.                             }

  725.                             else

  726.                             {

  727.                                 left  = -1.0;

  728.                                 right = 1.0;

  729.                             }

  730. 

  731.                             set_balance_left(left, false, false);

  732.                             set_balance_right(right, false, false);

  733.                             postpone_event(PluginPostEventParameterChange, PARAMETER_BALANCE_LEFT, left);

  734.                             postpone_event(PluginPostEventParameterChange, PARAMETER_BALANCE_RIGHT, right);

  735.                             continue;

  736.                         }

  737.                     }

  738. 

  739.                     // Control plugin parameters

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

  741.                     {

  742.                         if (param.data[k].midi_channel == cin_event->channel && param.data[k].midi_cc == cin_event->controller && param.data[k].type == PARAMETER_INPUT && (param.data[k].hints & PARAMETER_IS_AUTOMABLE) > 0)

  743.                         {

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

  745.                             {

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

  747.                             }

  748.                             else

  749.                             {

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

  751. 

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

  753.                                     value = rint(value);

  754.                             }

  755. 

  756.                             set_parameter_value(k, value, false, false, false);

  757.                             postpone_event(PluginPostEventParameterChange, k, value);

  758.                         }

  759.                     }

  760. 

  761.                     break;

  762.                 }

  763. 

  764.                 case CarlaEngineEventAllSoundOff:

  765.                     if (cin_event->channel == cin_channel)

  766.                     {

  767.                         if (descriptor->deactivate)

  768.                             descriptor->deactivate(handle);

  769. 

  770.                         if (descriptor->activate)

  771.                             descriptor->activate(handle);

  772.                     }

  773.                     break;

  774. 

  775.                 default:

  776.                     break;

  777.                 }

  778.             }

  779.         } // End of Parameters Input

  780. 

  781.         CARLA_PROCESS_CONTINUE_CHECK;

  782. 

  783.         // --------------------------------------------------------------------------------------------------------

  784.         // Special Parameters

  785. 

  786. #if 0

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

  788.         {

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

  790.             {

  791.                 // TODO

  792.             }

  793.         }

  794. 

  795.         CARLA_PROCESS_CONTINUE_CHECK;

  796. #endif

  797. 

  798.         // --------------------------------------------------------------------------------------------------------

  799.         // Plugin processing

  800. 

  801.         if (m_active)

  802.         {

  803.             if (! m_active_before)

  804.             {

  805.                 if (descriptor->activate)

  806.                     descriptor->activate(handle);

  807.             }

  808. 

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

  810.                 descriptor->connect_port(handle, ain.rindexes[i], ains_buffer[i]);

  811. 

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

  813.                 descriptor->connect_port(handle, aout.rindexes[i], aouts_buffer[i]);

  814. 

  815.             if (descriptor->run)

  816.                 descriptor->run(handle, nframes);

  817.         }

  818.         else

  819.         {

  820.             if (m_active_before)

  821.             {

  822.                 if (descriptor->deactivate)

  823.                     descriptor->deactivate(handle);

  824.             }

  825.         }

  826. 

  827.         CARLA_PROCESS_CONTINUE_CHECK;

  828. 

  829.         // --------------------------------------------------------------------------------------------------------

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

  831. 

  832.         if (m_active)

  833.         {

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

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

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

  837. 

  838.             double bal_rangeL, bal_rangeR;

  839.             float old_bal_left[do_balance ? nframes : 0];

  840. 

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

  842.             {

  843.                 // Dry/Wet and Volume

  844.                 if (do_drywet || do_volume)

  845.                 {

  846.                     for (k=0; k<nframes; k++)

  847.                     {

  848.                         if (do_drywet)

  849.                         {

  850.                             if (aout.count == 1)

  851.                                 aouts_buffer[i][k] = (aouts_buffer[i][k]*x_drywet)+(ains_buffer[0][k]*(1.0-x_drywet));

  852.                             else

  853.                                 aouts_buffer[i][k] = (aouts_buffer[i][k]*x_drywet)+(ains_buffer[i][k]*(1.0-x_drywet));

  854.                         }

  855. 

  856.                         if (do_volume)

  857.                             aouts_buffer[i][k] *= x_vol;

  858.                     }

  859.                 }

  860. 

  861.                 // Balance

  862.                 if (do_balance)

  863.                 {

  864.                     if (i%2 == 0)

  865.                         memcpy(&old_bal_left, aouts_buffer[i], sizeof(float)*nframes);

  866. 

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

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

  869. 

  870.                     for (k=0; k<nframes; k++)

  871.                     {

  872.                         if (i%2 == 0)

  873.                         {

  874.                             // left output

  875.                             aouts_buffer[i][k]  = old_bal_left[k]*(1.0-bal_rangeL);

  876.                             aouts_buffer[i][k] += aouts_buffer[i+1][k]*(1.0-bal_rangeR);

  877.                         }

  878.                         else

  879.                         {

  880.                             // right

  881.                             aouts_buffer[i][k]  = aouts_buffer[i][k]*bal_rangeR;

  882.                             aouts_buffer[i][k] += old_bal_left[k]*bal_rangeL;

  883.                         }

  884.                     }

  885.                 }

  886. 

  887.                 // Output VU

  888.                 for (k=0; k < nframes && i < 2; k++)

  889.                 {

  890.                     if (abs_d(aouts_buffer[i][k]) > aouts_peak_tmp[i])

  891.                         aouts_peak_tmp[i] = abs_d(aouts_buffer[i][k]);

  892.                 }

  893.             }

  894.         }

  895.         else

  896.         {

  897.             // disable any output sound if not active

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

  899.                 memset(aouts_buffer[i], 0.0f, sizeof(float)*nframes);

  900. 

  901.             aouts_peak_tmp[0] = 0.0;

  902.             aouts_peak_tmp[1] = 0.0;

  903. 

  904.         } // End of Post-processing

  905. 

  906.         CARLA_PROCESS_CONTINUE_CHECK;

  907. 

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

  909.         // Control Output

  910. 

  911.         if (param.port_cout && m_active)

  912.         {

  913.             void* cout_buffer = param.port_cout->getBuffer();

  914. 

  915.             if (nframesOffset == 0 || ! m_active_before)

  916.                 param.port_cout->initBuffer(cout_buffer);

  917. 

  918.             double value;

  919. 

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

  921.             {

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

  923.                 {

  924.                     fix_parameter_value(param_buffers[k], param.ranges[k]);

  925. 

  926.                     if (param.data[k].midi_cc > 0)

  927.                     {

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

  929.                         param.port_cout->writeEvent(cout_buffer, CarlaEngineEventControlChange, nframesOffset, param.data[k].midi_channel, param.data[k].midi_cc, value);

  930.                     }

  931.                 }

  932.             }

  933.         } // End of Control Output

  934. 

  935.         CARLA_PROCESS_CONTINUE_CHECK;

  936. 

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

  938.         // Peak Values

  939. 

  940.         ains_peak[(m_id*2)+0]  = ains_peak_tmp[0];

  941.         ains_peak[(m_id*2)+1]  = ains_peak_tmp[1];

  942.         aouts_peak[(m_id*2)+0] = aouts_peak_tmp[0];

  943.         aouts_peak[(m_id*2)+1] = aouts_peak_tmp[1];

  944. 

  945.         m_active_before = m_active;

  946.     }

  947. 

  948.     // -------------------------------------------------------------------

  949.     // Cleanup

  950. 

  951.     void delete_buffers()

  952.     {

  953.         qDebug("LadspaPlugin::delete_buffers() - start");

  954. 

  955.         if (param.count > 0)

  956.             delete[] param_buffers;

  957. 

  958.         param_buffers = nullptr;

  959. 

  960.         qDebug("LadspaPlugin::delete_buffers() - end");

  961.     }

  962. 

  963.     // -------------------------------------------------------------------

  964. 

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

  966.     {

  967.         if (lib_open(filename))

  968.         {

  969.             LADSPA_Descriptor_Function descfn = (LADSPA_Descriptor_Function)lib_symbol("ladspa_descriptor");

  970. 

  971.             if (descfn)

  972.             {

  973.                 unsigned long i = 0;

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

  975.                 {

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

  977.                         break;

  978.                 }

  979. 

  980.                 if (descriptor)

  981.                 {

  982.                     handle = descriptor->instantiate(descriptor, get_sample_rate());

  983. 

  984.                     if (handle)

  985.                     {

  986.                         m_filename = strdup(filename);

  987. 

  988.                         if (is_ladspa_rdf_descriptor_valid(rdf_descriptor_, descriptor))

  989.                             rdf_descriptor = ladspa_rdf_dup(rdf_descriptor_);

  990. 

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

  992.                             m_name = get_unique_name(rdf_descriptor->Title);

  993.                         else

  994.                             m_name = get_unique_name(descriptor->Name);

  995. 

  996.                         x_client = new CarlaEngineClient(this);

  997. 

  998.                         if (x_client->isOk())

  999.                         {

  1000.                             return true;

  1001.                         }

  1002.                         else

  1003.                             set_last_error("Failed to register plugin client");

  1004.                     }

  1005.                     else

  1006.                         set_last_error("Plugin failed to initialize");

  1007.                 }

  1008.                 else

  1009.                     set_last_error("Could not find the requested plugin Label in the plugin library");

  1010.             }

  1011.             else

  1012.                 set_last_error("Could not find the LASDPA Descriptor in the plugin library");

  1013.         }

  1014.         else

  1015.             set_last_error(lib_error());

  1016. 

  1017.         return false;

  1018.     }

  1019. 

  1020. private:

  1021.     LADSPA_Handle handle;

  1022.     const LADSPA_Descriptor* descriptor;

  1023.     const LADSPA_RDF_Descriptor* rdf_descriptor;

  1024. 

  1025.     float* param_buffers;

  1026. };

  1027. 

  1028. short add_plugin_ladspa(const char* filename, const char* label, const void* extra_stuff)

  1029. {

  1030.     qDebug("add_plugin_ladspa(%s, %s, %p)", filename, label, extra_stuff);

  1031. 

  1032.     short id = get_new_plugin_id();

  1033. 

  1034.     if (id >= 0)

  1035.     {

  1036.         LadspaPlugin* plugin = new LadspaPlugin(id);

  1037. 

  1038.         if (plugin->init(filename, label, (LADSPA_RDF_Descriptor*)extra_stuff))

  1039.         {

  1040.             plugin->reload();

  1041. 

  1042.             unique_names[id] = plugin->name();

  1043.             CarlaPlugins[id] = plugin;

  1044. 

  1045.             plugin->osc_register_new();

  1046.         }

  1047.         else

  1048.         {

  1049.             delete plugin;

  1050.             id = -1;

  1051.         }

  1052.     }

  1053.     else

  1054.         set_last_error("Maximum number of plugins reached");

  1055. 

  1056.     return id;

  1057. }

  1058. 

  1059. CARLA_BACKEND_END_NAMESPACE