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.
764 Commits
2 Branches
16MB
Tree: 3b5630a889
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '3b5630a889'
${ noResults }
Cadence/c++/carla-plugin/native.cpp

1701 lines
54KB
Raw Blame History 

  1. /*

  2.  * Carla Native Plugin

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

  4.  *

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

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

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

  8.  * any later version.

  9.  *

  10.  * This program is distributed in the hope that it will be useful,

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  13.  * GNU General Public License for more details.

  14.  *

  15.  * For a full copy of the GNU General Public License see the COPYING file

  16.  */

  17. 

  18. #include "carla_plugin.hpp"

  19. #include "carla_native.h"

  20. 

  21. CARLA_BACKEND_START_NAMESPACE

  22. 

  23. struct NativePluginMidiData {

  24.     uint32_t  count;

  25.     uint32_t* indexes;

  26.     CarlaEngineMidiPort** ports;

  27. 

  28.     NativePluginMidiData()

  29.         : count(0),

  30.           indexes(nullptr),

  31.           ports(nullptr) {}

  32. };

  33. 

  34. class NativePlugin : public CarlaPlugin

  35. {

  36. public:

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

  38.         : CarlaPlugin(engine, id)

  39.     {

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

  41. 

  42.         m_type = PLUGIN_INTERNAL;

  43. 

  44.         descriptor  = nullptr;

  45.         handle = h2 = nullptr;

  46. 

  47.         host.handle = this;

  48.         host.get_buffer_size  = carla_host_get_buffer_size;

  49.         host.get_sample_rate  = carla_host_get_sample_rate;

  50.         host.get_time_info    = carla_host_get_time_info;

  51.         host.write_midi_event = carla_host_write_midi_event;

  52.         host.ui_parameter_changed   = carla_host_ui_parameter_changed;

  53.         host.ui_custom_data_changed = carla_host_ui_custom_data_changed;

  54. 

  55.         isProcessing = false;

  56. 

  57.         midiEventCount = 0;

  58.         memset(midiEvents, 0, sizeof(::MidiEvent) * MAX_MIDI_EVENTS * 2);

  59.     }

  60. 

  61.     ~NativePlugin()

  62.     {

  63.         qDebug("NativePlugin::~NativePlugin()");

  64. 

  65.         if (descriptor)

  66.         {

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

  68.             {

  69.                 if (handle)

  70.                     descriptor->deactivate(handle);

  71.                 if (h2)

  72.                     descriptor->deactivate(h2);

  73.             }

  74. 

  75.             if (descriptor->cleanup)

  76.             {

  77.                 if (handle)

  78.                     descriptor->cleanup(handle);

  79.                 if (h2)

  80.                     descriptor->cleanup(h2);

  81.             }

  82.         }

  83.     }

  84. 

  85.     // -------------------------------------------------------------------

  86.     // Information (base)

  87. 

  88.     PluginCategory category()

  89.     {

  90.         CARLA_ASSERT(descriptor);

  91. 

  92.         if (descriptor)

  93.             return static_cast<PluginCategory>(descriptor->category);

  94. 

  95.         return getPluginCategoryFromName(m_name);

  96.     }

  97. 

  98.     // -------------------------------------------------------------------

  99.     // Information (count)

  100. 

  101.     uint32_t midiInCount()

  102.     {

  103.         return mIn.count;

  104.     }

  105. 

  106.     uint32_t midiOutCount()

  107.     {

  108.         return mOut.count;

  109.     }

  110. 

  111.     uint32_t parameterScalePointCount(const uint32_t parameterId)

  112.     {

  113.         CARLA_ASSERT(descriptor);

  114.         CARLA_ASSERT(handle);

  115.         CARLA_ASSERT(parameterId < param.count);

  116. 

  117.         if (descriptor && handle && parameterId < param.count && descriptor->get_parameter_info)

  118.         {

  119.             const ::Parameter* const param = descriptor->get_parameter_info(handle, parameterId);

  120. 

  121.             if (param)

  122.                 return param->scalePointCount;

  123.         }

  124. 

  125.         return 0;

  126.     }

  127. 

  128.     // -------------------------------------------------------------------

  129.     // Information (per-plugin data)

  130. 

  131.     double getParameterValue(const uint32_t parameterId)

  132.     {

  133.         CARLA_ASSERT(descriptor);

  134.         CARLA_ASSERT(handle);

  135.         CARLA_ASSERT(parameterId < param.count);

  136. 

  137.         if (descriptor && handle && parameterId < param.count && descriptor->get_parameter_value)

  138.             return descriptor->get_parameter_value(handle, parameterId);

  139. 

  140.         return 0.0;

  141.     }

  142. 

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

  144.     {

  145.         CARLA_ASSERT(descriptor);

  146.         CARLA_ASSERT(handle);

  147.         CARLA_ASSERT(parameterId < param.count);

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

  149. 

  150.         if (descriptor && handle && parameterId < param.count && descriptor->get_parameter_info)

  151.         {

  152.             const ::Parameter* const param = descriptor->get_parameter_info(handle, parameterId);

  153. 

  154.             if (param && scalePointId < param->scalePointCount && param->scalePoints)

  155.             {

  156.                 const ::ParameterScalePoint* const scalePoint = &param->scalePoints[scalePointId];

  157. 

  158.                 if (scalePoint)

  159.                     return scalePoint->value;

  160.             }

  161.         }

  162. 

  163.         return 0.0;

  164.     }

  165. 

  166.     void getLabel(char* const strBuf)

  167.     {

  168.         CARLA_ASSERT(descriptor);

  169. 

  170.         if (descriptor && descriptor->label)

  171.             strncpy(strBuf, descriptor->label, STR_MAX);

  172.         else

  173.             CarlaPlugin::getLabel(strBuf);

  174.     }

  175. 

  176.     void getMaker(char* const strBuf)

  177.     {

  178.         CARLA_ASSERT(descriptor);

  179. 

  180.         if (descriptor && descriptor->maker)

  181.             strncpy(strBuf, descriptor->maker, STR_MAX);

  182.         else

  183.             CarlaPlugin::getMaker(strBuf);

  184.     }

  185. 

  186.     void getCopyright(char* const strBuf)

  187.     {

  188.         CARLA_ASSERT(descriptor);

  189. 

  190.         if (descriptor && descriptor->copyright)

  191.             strncpy(strBuf, descriptor->copyright, STR_MAX);

  192.         else

  193.             CarlaPlugin::getCopyright(strBuf);

  194.     }

  195. 

  196.     void getRealName(char* const strBuf)

  197.     {

  198.         CARLA_ASSERT(descriptor);

  199. 

  200.         if (descriptor && descriptor->name)

  201.             strncpy(strBuf, descriptor->name, STR_MAX);

  202.         else

  203.             CarlaPlugin::getRealName(strBuf);

  204.     }

  205. 

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

  207.     {

  208.         CARLA_ASSERT(descriptor);

  209.         CARLA_ASSERT(handle);

  210.         CARLA_ASSERT(parameterId < param.count);

  211. 

  212.         if (descriptor && handle && parameterId < param.count && descriptor->get_parameter_info)

  213.         {

  214.             const ::Parameter* const param = descriptor->get_parameter_info(handle, parameterId);

  215. 

  216.             if (param && param->name)

  217.             {

  218.                 strncpy(strBuf, param->name, STR_MAX);

  219.                 return;

  220.             }

  221.         }

  222. 

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

  224.     }

  225. 

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

  227.     {

  228.         CARLA_ASSERT(descriptor);

  229.         CARLA_ASSERT(handle);

  230.         CARLA_ASSERT(parameterId < param.count);

  231. 

  232.         if (descriptor && handle && parameterId < param.count && descriptor->get_parameter_text)

  233.         {

  234.             const char* const text = descriptor->get_parameter_text(handle, parameterId);

  235. 

  236.             if (text)

  237.             {

  238.                 strncpy(strBuf, text, STR_MAX);

  239.                 return;

  240.             }

  241.         }

  242. 

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

  244.     }

  245. 

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

  247.     {

  248.         CARLA_ASSERT(descriptor);

  249.         CARLA_ASSERT(handle);

  250.         CARLA_ASSERT(parameterId < param.count);

  251. 

  252.         if (descriptor && handle && parameterId < param.count && descriptor->get_parameter_info)

  253.         {

  254.             const ::Parameter* const param = descriptor->get_parameter_info(handle, parameterId);

  255. 

  256.             if (param && param->unit)

  257.             {

  258.                 strncpy(strBuf, param->unit, STR_MAX);

  259.                 return;

  260.             }

  261.         }

  262. 

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

  264.     }

  265. 

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

  267.     {

  268.         CARLA_ASSERT(descriptor);

  269.         CARLA_ASSERT(handle);

  270.         CARLA_ASSERT(parameterId < param.count);

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

  272. 

  273.         if (descriptor && handle && parameterId < param.count && descriptor->get_parameter_info)

  274.         {

  275.             const ::Parameter* const param = descriptor->get_parameter_info(handle, parameterId);

  276. 

  277.             if (param && scalePointId < param->scalePointCount && param->scalePoints)

  278.             {

  279.                 const ::ParameterScalePoint* const scalePoint = &param->scalePoints[scalePointId];

  280. 

  281.                 if (scalePoint && scalePoint->label)

  282.                 {

  283.                     strncpy(strBuf, scalePoint->label, STR_MAX);

  284.                     return;

  285.                 }

  286.             }

  287.         }

  288. 

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

  290.     }

  291. 

  292.     void getGuiInfo(GuiType* const type, bool* const resizable)

  293.     {

  294.         *type = GUI_EXTERNAL_LV2; // FIXME, should be as _PLUGIN

  295.         *resizable = false;

  296.     }

  297. 

  298.     // -------------------------------------------------------------------

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

  300. 

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

  302.     {

  303.         CARLA_ASSERT(descriptor);

  304.         CARLA_ASSERT(handle);

  305.         CARLA_ASSERT(parameterId < param.count);

  306. 

  307.         if (descriptor && handle && parameterId < param.count)

  308.         {

  309.             fixParameterValue(value, param.ranges[parameterId]);

  310. 

  311.             descriptor->set_parameter_value(handle, param.data[parameterId].rindex, value);

  312.             if (h2) descriptor->set_parameter_value(h2, param.data[parameterId].rindex, value);

  313.         }

  314. 

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

  316.     }

  317. 

  318.     void setCustomData(const CustomDataType type, const char* const key, const char* const value, const bool sendGui)

  319.     {

  320.         CARLA_ASSERT(descriptor);

  321.         CARLA_ASSERT(handle);

  322.         CARLA_ASSERT(type == CUSTOM_DATA_STRING);

  323.         CARLA_ASSERT(key);

  324.         CARLA_ASSERT(value);

  325. 

  326.         if (type != CUSTOM_DATA_STRING)

  327.             return qCritical("NativePlugin::setCustomData(%s, \"%s\", \"%s\", %s) - type is not string", CustomDataType2Str(type), key, value, bool2str(sendGui));

  328. 

  329.         if (! key)

  330.             return qCritical("NativePlugin::setCustomData(%s, \"%s\", \"%s\", %s) - key is null", CustomDataType2Str(type), key, value, bool2str(sendGui));

  331. 

  332.         if (! value)

  333.             return qCritical("Nativelugin::setCustomData(%s, \"%s\", \"%s\", %s) - value is null", CustomDataType2Str(type), key, value, bool2str(sendGui));

  334. 

  335.         if (descriptor && handle)

  336.         {

  337.             if (descriptor->set_custom_data)

  338.             {

  339.                 descriptor->set_custom_data(handle, key, value);

  340.                 if (h2) descriptor->set_custom_data(h2, key, value);

  341.             }

  342. 

  343.             // FIXME - only if gui was started before

  344.             if (sendGui && descriptor->ui_set_custom_data)

  345.                 descriptor->ui_set_custom_data(handle, key, value);

  346.         }

  347. 

  348.         CarlaPlugin::setCustomData(type, key, value, sendGui);

  349.     }

  350. 

  351.     void setMidiProgram(int32_t index, const bool sendGui, const bool sendOsc, const bool sendCallback, const bool block)

  352.     {

  353.         CARLA_ASSERT(descriptor);

  354.         CARLA_ASSERT(handle);

  355.         CARLA_ASSERT(index >= -1 && index < (int32_t)midiprog.count);

  356. 

  357.         if (index < -1)

  358.             index = -1;

  359.         else if (index > (int32_t)midiprog.count)

  360.             return;

  361. 

  362.         if (descriptor && handle && index >= 0)

  363.         {

  364.             if (x_engine->isOffline())

  365.             {

  366.                 const CarlaEngine::ScopedLocker m(x_engine, block);

  367.                 descriptor->set_midi_program(handle, midiprog.data[index].bank, midiprog.data[index].program);

  368.                 if (h2) descriptor->set_midi_program(h2, midiprog.data[index].bank, midiprog.data[index].program);

  369.             }

  370.             else

  371.             {

  372.                 const ScopedDisabler m(this, block);

  373.                 descriptor->set_midi_program(handle, midiprog.data[index].bank, midiprog.data[index].program);

  374.                 if (h2) descriptor->set_midi_program(h2, midiprog.data[index].bank, midiprog.data[index].program);

  375.             }

  376.         }

  377. 

  378.         CarlaPlugin::setMidiProgram(index, sendGui, sendOsc, sendCallback, block);

  379.     }

  380. 

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

  382.     // Set gui stuff

  383. 

  384.     void showGui(const bool yesNo)

  385.     {

  386.         CARLA_ASSERT(descriptor);

  387.         CARLA_ASSERT(handle);

  388. 

  389.         if (descriptor && handle && descriptor->ui_show)

  390.             descriptor->ui_show(handle, yesNo);

  391.     }

  392. 

  393.     void idleGui()

  394.     {

  395.         // FIXME - this should not be called if there's no GUI!

  396.         CARLA_ASSERT(descriptor);

  397.         CARLA_ASSERT(handle);

  398. 

  399.         if (descriptor && handle && descriptor->ui_idle)

  400.             descriptor->ui_idle(handle);

  401.     }

  402. 

  403.     // -------------------------------------------------------------------

  404.     // Plugin state

  405. 

  406.     void reload()

  407.     {

  408.         qDebug("NativePlugin::reload() - start");

  409.         CARLA_ASSERT(descriptor);

  410. 

  411.         // Safely disable plugin for reload

  412.         const ScopedDisabler m(this);

  413. 

  414.         if (x_client->isActive())

  415.             x_client->deactivate();

  416. 

  417.         // Remove client ports

  418.         removeClientPorts();

  419. 

  420.         // Delete old data

  421.         deleteBuffers();

  422. 

  423.         uint32_t aIns, aOuts, mIns, mOuts, params, j;

  424.         aIns = aOuts = mIns = mOuts = params = 0;

  425. 

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

  427. 

  428.         aIns   = descriptor->audioIns;

  429.         aOuts  = descriptor->audioOuts;

  430.         mIns   = descriptor->midiIns;

  431.         mOuts  = descriptor->midiOuts;

  432.         params = descriptor->get_parameter_count ? descriptor->get_parameter_count(handle) : 0;

  433. 

  434.         bool forcedStereoIn, forcedStereoOut;

  435.         forcedStereoIn = forcedStereoOut = false;

  436. 

  437.         if (x_engine->forceStereo() && (aIns == 1 || aOuts == 1) && mIns <= 1 && mOuts <= 1 && ! h2)

  438.         {

  439.             h2 = descriptor->instantiate(descriptor, &host);

  440. 

  441.             if (aIns == 1)

  442.             {

  443.                 aIns = 2;

  444.                 forcedStereoIn = true;

  445.             }

  446. 

  447.             if (aOuts == 1)

  448.             {

  449.                 aOuts = 2;

  450.                 forcedStereoOut = true;

  451.             }

  452.         }

  453. 

  454.         if (aIns > 0)

  455.         {

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

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

  458.         }

  459. 

  460.         if (aOuts > 0)

  461.         {

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

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

  464.         }

  465. 

  466.         if (mIns > 0)

  467.         {

  468.             mIn.ports   = new CarlaEngineMidiPort*[mIns];

  469.             mIn.indexes = new uint32_t[mIns];

  470.         }

  471. 

  472.         if (mOuts > 0)

  473.         {

  474.             mOut.ports   = new CarlaEngineMidiPort*[mOuts];

  475.             mOut.indexes = new uint32_t[mOuts];

  476.         }

  477. 

  478.         if (params > 0)

  479.         {

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

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

  482.         }

  483. 

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

  485.         char portName[portNameSize];

  486.         bool needsCtrlIn  = false;

  487.         bool needsCtrlOut = false;

  488. 

  489.         // Audio Ins

  490.         for (j=0; j < descriptor->audioIns; j++)

  491.         {

  492.             if (x_engine->processMode() == PROCESS_MODE_SINGLE_CLIENT)

  493.                 sprintf(portName, "%s:input_%02i", m_name, j+1);

  494.             else

  495.                 sprintf(portName, "input_%02i", j+1);

  496. 

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

  498.             aIn.rindexes[j] = j;

  499. 

  500.             if (forcedStereoIn)

  501.             {

  502.                 strcat(portName, "_");

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

  504.                 aIn.rindexes[1] = j;

  505.             }

  506.         }

  507. 

  508.         // Audio Outs

  509.         for (j=0; j < descriptor->audioOuts; j++)

  510.         {

  511.             if (x_engine->processMode() == PROCESS_MODE_SINGLE_CLIENT)

  512.                 sprintf(portName, "%s:output_%02i", m_name, j+1);

  513.             else

  514.                 sprintf(portName, "output_%02i", j+1);

  515. 

  516.             qDebug("Audio Out #%i", j);

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

  518.             aOut.rindexes[j] = j;

  519.             needsCtrlIn = true;

  520. 

  521.             if (forcedStereoOut)

  522.             {

  523.                 strcat(portName, "_");

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

  525.                 aOut.rindexes[1] = j;

  526.             }

  527.         }

  528. 

  529.         // MIDI Input

  530.         for (j=0; j < mIns; j++)

  531.         {

  532.             if (x_engine->processMode() == PROCESS_MODE_SINGLE_CLIENT)

  533.                 sprintf(portName, "%s:midi-in_%02i", m_name, j+1);

  534.             else

  535.                 sprintf(portName, "midi-in_%02i", j+1);

  536. 

  537.             mIn.ports[j]   = (CarlaEngineMidiPort*)x_client->addPort(CarlaEnginePortTypeMIDI, portName, true);

  538.             mIn.indexes[j] = j;

  539.         }

  540. 

  541.         // MIDI Output

  542.         for (j=0; j < mOuts; j++)

  543.         {

  544.             if (x_engine->processMode() == PROCESS_MODE_SINGLE_CLIENT)

  545.                 sprintf(portName, "%s:midi-out_%02i", m_name, j+1);

  546.             else

  547.                 sprintf(portName, "midi-out_%02i", j+1);

  548. 

  549.             mOut.ports[j]   = (CarlaEngineMidiPort*)x_client->addPort(CarlaEnginePortTypeMIDI, portName, false);

  550.             mOut.indexes[j] = j;

  551.         }

  552. 

  553.         for (j=0; j < params; j++)

  554.         {

  555.             if (! descriptor->get_parameter_info)

  556.                 break;

  557. 

  558.             const ::Parameter* const paramInfo = descriptor->get_parameter_info(handle, j);

  559. 

  560.             //const uint32_t paramHints  = param->hints;

  561.             //const bool     paramOutput = paramHins;

  562. 

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

  564.             param.data[j].rindex = j;

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

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

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

  568. 

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

  570. 

  571.             // min value

  572.             min = paramInfo->ranges.min;

  573. 

  574.             // max value

  575.             max = paramInfo->ranges.max;

  576. 

  577.             if (min > max)

  578.                 max = min;

  579.             else if (max < min)

  580.                 min = max;

  581. 

  582.             if (max - min == 0.0)

  583.             {

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

  585.                 max = min + 0.1;

  586.             }

  587. 

  588.             // default value

  589.             def = paramInfo->ranges.def;

  590. 

  591.             if (def < min)

  592.                 def = min;

  593.             else if (def > max)

  594.                 def = max;

  595. 

  596.             if (paramInfo->hints & ::PARAMETER_USES_SAMPLE_RATE)

  597.             {

  598.                 min *= sampleRate;

  599.                 max *= sampleRate;

  600.                 def *= sampleRate;

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

  602.             }

  603. 

  604.             if (paramInfo->hints & ::PARAMETER_IS_BOOLEAN)

  605.             {

  606.                 step = max - min;

  607.                 stepSmall = step;

  608.                 stepLarge = step;

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

  610.             }

  611.             else if (paramInfo->hints & ::PARAMETER_IS_INTEGER)

  612.             {

  613.                 step = 1.0;

  614.                 stepSmall = 1.0;

  615.                 stepLarge = 10.0;

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

  617.             }

  618.             else

  619.             {

  620.                 double range = max - min;

  621.                 step = range/100.0;

  622.                 stepSmall = range/1000.0;

  623.                 stepLarge = range/10.0;

  624.             }

  625. 

  626.             if (paramInfo->hints & ::PARAMETER_IS_OUTPUT)

  627.             {

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

  629.                 needsCtrlOut = true;

  630.             }

  631.             else

  632.             {

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

  634.                 needsCtrlIn = true;

  635.             }

  636. 

  637.             // extra parameter hints

  638.             if (paramInfo->hints & ::PARAMETER_IS_ENABLED)

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

  640. 

  641.             if (paramInfo->hints & ::PARAMETER_IS_AUTOMABLE)

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

  643. 

  644.             if (paramInfo->hints & ::PARAMETER_IS_LOGARITHMIC)

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

  646. 

  647.             if (paramInfo->hints & ::PARAMETER_USES_SCALEPOINTS)

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

  649. 

  650.             if (paramInfo->hints & ::PARAMETER_USES_CUSTOM_TEXT)

  651.                 param.data[j].hints |= PARAMETER_USES_CUSTOM_TEXT;

  652. 

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

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

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

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

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

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

  659.         }

  660. 

  661.         if (needsCtrlIn)

  662.         {

  663.             if (x_engine->processMode() == PROCESS_MODE_SINGLE_CLIENT)

  664.             {

  665.                 strcpy(portName, m_name);

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

  667.             }

  668.             else

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

  670. 

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

  672.         }

  673. 

  674.         if (needsCtrlOut)

  675.         {

  676.             if (x_engine->processMode() == PROCESS_MODE_SINGLE_CLIENT)

  677.             {

  678.                 strcpy(portName, m_name);

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

  680.             }

  681.             else

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

  683. 

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

  685.         }

  686. 

  687.         aIn.count   = aIns;

  688.         aOut.count  = aOuts;

  689.         mIn.count   = mIns;

  690.         mOut.count  = mOuts;

  691.         param.count = params;

  692. 

  693.         // plugin checks

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

  695. 

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

  697.             m_hints |= PLUGIN_CAN_DRYWET;

  698. 

  699.         if (aOuts > 0)

  700.             m_hints |= PLUGIN_CAN_VOLUME;

  701. 

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

  703.             m_hints |= PLUGIN_CAN_BALANCE;

  704. 

  705.         if (aIns <= 2 && aOuts <= 2 && (aIns == aOuts || aIns == 0 || aOuts == 0) && mIns <= 1 && mOuts <= 1)

  706.             m_hints |= PLUGIN_CAN_FORCE_STEREO;

  707. 

  708.         // native plugin hints

  709.         if (descriptor->hints & ::PLUGIN_IS_SYNTH)

  710.             m_hints |= PLUGIN_IS_SYNTH;

  711.         if (descriptor->hints & ::PLUGIN_HAS_GUI)

  712.             m_hints |= PLUGIN_HAS_GUI;

  713.         if (descriptor->hints & ::PLUGIN_USES_SINGLE_THREAD)

  714.             m_hints |= PLUGIN_USES_SINGLE_THREAD;

  715. 

  716.         reloadPrograms(true);

  717. 

  718.         x_client->activate();

  719. 

  720.         qDebug("NativePlugin::reload() - end");

  721.     }

  722. 

  723.     void reloadPrograms(const bool init)

  724.     {

  725.         qDebug("NativePlugin::reloadPrograms(%s)", bool2str(init));

  726.         uint32_t i, oldCount = midiprog.count;

  727. 

  728.         // Delete old programs

  729.         if (midiprog.count > 0)

  730.         {

  731.             for (i=0; i < midiprog.count; i++)

  732.             {

  733.                 if (midiprog.data[i].name)

  734.                     free((void*)midiprog.data[i].name);

  735.             }

  736. 

  737.             delete[] midiprog.data;

  738.         }

  739. 

  740.         midiprog.count = (descriptor->get_midi_program_count && descriptor->get_midi_program_info) ? descriptor->get_midi_program_count(handle) : 0;

  741.         midiprog.data  = nullptr;

  742. 

  743.         if (midiprog.count > 0)

  744.             midiprog.data = new MidiProgramData[midiprog.count];

  745. 

  746.         // Update data

  747.         for (i=0; i < midiprog.count; i++)

  748.         {

  749.             const ::MidiProgram* const mpDesc = descriptor->get_midi_program_info(handle, i);

  750.             CARLA_ASSERT(mpDesc);

  751.             CARLA_ASSERT(mpDesc->name);

  752. 

  753.             midiprog.data[i].bank    = mpDesc->bank;

  754.             midiprog.data[i].program = mpDesc->program;

  755.             midiprog.data[i].name    = strdup(mpDesc->name);

  756.         }

  757. 

  758.         // Update OSC Names

  759.         if (x_engine->isOscControlRegisted())

  760.         {

  761.             x_engine->osc_send_control_set_midi_program_count(m_id, midiprog.count);

  762. 

  763.             for (i=0; i < midiprog.count; i++)

  764.                 x_engine->osc_send_control_set_midi_program_data(m_id, i, midiprog.data[i].bank, midiprog.data[i].program, midiprog.data[i].name);

  765.         }

  766. 

  767.         if (init)

  768.         {

  769.             if (midiprog.count > 0)

  770.                 setMidiProgram(0, false, false, false, true);

  771.         }

  772.         else

  773.         {

  774.             x_engine->callback(CALLBACK_RELOAD_PROGRAMS, m_id, 0, 0, 0.0);

  775. 

  776.             // Check if current program is invalid

  777.             bool programChanged = false;

  778. 

  779.             if (midiprog.count == oldCount+1)

  780.             {

  781.                 // one midi program added, probably created by user

  782.                 midiprog.current = oldCount;

  783.                 programChanged   = true;

  784.             }

  785.             else if (midiprog.current >= (int32_t)midiprog.count)

  786.             {

  787.                 // current midi program > count

  788.                 midiprog.current = 0;

  789.                 programChanged   = true;

  790.             }

  791.             else if (midiprog.current < 0 && midiprog.count > 0)

  792.             {

  793.                 // programs exist now, but not before

  794.                 midiprog.current = 0;

  795.                 programChanged   = true;

  796.             }

  797.             else if (midiprog.current >= 0 && midiprog.count == 0)

  798.             {

  799.                 // programs existed before, but not anymore

  800.                 midiprog.current = -1;

  801.                 programChanged   = true;

  802.             }

  803. 

  804.             if (programChanged)

  805.                 setMidiProgram(midiprog.current, true, true, true, true);

  806.         }

  807.     }

  808. 

  809.     // -------------------------------------------------------------------

  810.     // Plugin processing

  811. 

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

  813.     {

  814.         uint32_t i, k;

  815. 

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

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

  818. 

  819.         // reset MIDI

  820.         midiEventCount = 0;

  821.         memset(midiEvents, 0, sizeof(::MidiEvent) * MAX_MIDI_EVENTS * 2);

  822. 

  823.         CARLA_PROCESS_CONTINUE_CHECK;

  824. 

  825.         // --------------------------------------------------------------------------------------------------------

  826.         // Input VU

  827. 

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

  829.         {

  830.             if (aIn.count == 1)

  831.             {

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

  833.                 {

  834.                     if (abs(inBuffer[0][k]) > aInsPeak[0])

  835.                         aInsPeak[0] = abs(inBuffer[0][k]);

  836.                 }

  837.             }

  838.             else if (aIn.count > 1)

  839.             {

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

  841.                 {

  842.                     if (abs(inBuffer[0][k]) > aInsPeak[0])

  843.                         aInsPeak[0] = abs(inBuffer[0][k]);

  844. 

  845.                     if (abs(inBuffer[1][k]) > aInsPeak[1])

  846.                         aInsPeak[1] = abs(inBuffer[1][k]);

  847.                 }

  848.             }

  849.         }

  850. 

  851.         CARLA_PROCESS_CONTINUE_CHECK;

  852. 

  853.         // --------------------------------------------------------------------------------------------------------

  854.         // Parameters Input [Automation]

  855. 

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

  857.         {

  858.             bool allNotesOffSent = false;

  859. 

  860.             const CarlaEngineControlEvent* cinEvent;

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

  862. 

  863.             uint32_t nextBankId = 0;

  864.             if (midiprog.current >= 0 && midiprog.count > 0)

  865.                 nextBankId = midiprog.data[midiprog.current].bank;

  866. 

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

  868.             {

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

  870. 

  871.                 if (! cinEvent)

  872.                     continue;

  873. 

  874.                 time = cinEvent->time - framesOffset;

  875. 

  876.                 if (time >= frames)

  877.                     continue;

  878. 

  879.                 // Control change

  880.                 switch (cinEvent->type)

  881.                 {

  882.                 case CarlaEngineNullEvent:

  883.                     break;

  884. 

  885.                 case CarlaEngineParameterChangeEvent:

  886.                 {

  887.                     double value;

  888. 

  889.                     // Control backend stuff

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

  891.                     {

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

  893.                         {

  894.                             value = cinEvent->value;

  895.                             setDryWet(value, false, false);

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

  897.                             continue;

  898.                         }

  899. 

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

  901.                         {

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

  903.                             setVolume(value, false, false);

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

  905.                             continue;

  906.                         }

  907. 

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

  909.                         {

  910.                             double left, right;

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

  912. 

  913.                             if (value < 0.0)

  914.                             {

  915.                                 left  = -1.0;

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

  917.                             }

  918.                             else if (value > 0.0)

  919.                             {

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

  921.                                 right = 1.0;

  922.                             }

  923.                             else

  924.                             {

  925.                                 left  = -1.0;

  926.                                 right = 1.0;

  927.                             }

  928. 

  929.                             setBalanceLeft(left, false, false);

  930.                             setBalanceRight(right, false, false);

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

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

  933.                             continue;

  934.                         }

  935.                     }

  936. 

  937.                     // Control plugin parameters

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

  939.                     {

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

  941.                             continue;

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

  943.                             continue;

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

  945.                             continue;

  946. 

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

  948.                         {

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

  950.                             {

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

  952.                             }

  953.                             else

  954.                             {

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

  956. 

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

  958.                                     value = rint(value);

  959.                             }

  960. 

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

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

  963.                         }

  964.                     }

  965. 

  966.                     break;

  967.                 }

  968. 

  969.                 case CarlaEngineMidiBankChangeEvent:

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

  971.                         nextBankId = rint(cinEvent->value);

  972.                     break;

  973. 

  974.                 case CarlaEngineMidiProgramChangeEvent:

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

  976.                     {

  977.                         uint32_t nextProgramId = rint(cinEvent->value);

  978. 

  979.                         for (k=0; k < midiprog.count; k++)

  980.                         {

  981.                             if (midiprog.data[k].bank == nextBankId && midiprog.data[k].program == nextProgramId)

  982.                             {

  983.                                 setMidiProgram(k, false, false, false, false);

  984.                                 postponeEvent(PluginPostEventMidiProgramChange, k, 0, 0.0);

  985.                                 break;

  986.                             }

  987.                         }

  988.                     }

  989.                     break;

  990. 

  991.                 case CarlaEngineAllSoundOffEvent:

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

  993.                     {

  994.                         if (mIn.count > 0 && ! allNotesOffSent)

  995.                             sendMidiAllNotesOff();

  996. 

  997.                         if (descriptor->deactivate)

  998.                         {

  999.                             descriptor->deactivate(handle);

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

  1001.                         }

  1002. 

  1003.                         if (descriptor->activate)

  1004.                         {

  1005.                             descriptor->activate(handle);

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

  1007.                         }

  1008. 

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

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

  1011. 

  1012.                         allNotesOffSent = true;

  1013.                     }

  1014.                     break;

  1015. 

  1016.                 case CarlaEngineAllNotesOffEvent:

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

  1018.                     {

  1019.                         if (mIn.count > 0 && ! allNotesOffSent)

  1020.                             sendMidiAllNotesOff();

  1021. 

  1022.                         allNotesOffSent = true;

  1023.                     }

  1024.                     break;

  1025.                 }

  1026.             }

  1027.         } // End of Parameters Input

  1028. 

  1029.         CARLA_PROCESS_CONTINUE_CHECK;

  1030. 

  1031.         // --------------------------------------------------------------------------------------------------------

  1032.         // MIDI Input

  1033. 

  1034.         if (mIn.count > 0 && m_active && m_activeBefore)

  1035.         {

  1036.             // ----------------------------------------------------------------------------------------------------

  1037.             // MIDI Input (External)

  1038. 

  1039.             {

  1040.                 engineMidiLock();

  1041. 

  1042.                 for (i=0; i < MAX_MIDI_EVENTS && midiEventCount < MAX_MIDI_EVENTS; i++)

  1043.                 {

  1044.                     if (extMidiNotes[i].channel < 0)

  1045.                         break;

  1046. 

  1047.                     ::MidiEvent* const midiEvent = &midiEvents[midiEventCount];

  1048.                     memset(midiEvent, 0, sizeof(::MidiEvent));

  1049. 

  1050.                     midiEvent->data[0] = uint8_t(extMidiNotes[i].velo ? MIDI_STATUS_NOTE_ON : MIDI_STATUS_NOTE_OFF) + extMidiNotes[i].channel;

  1051.                     midiEvent->data[1] = extMidiNotes[i].note;

  1052.                     midiEvent->data[2] = extMidiNotes[i].velo;

  1053. 

  1054.                     extMidiNotes[i].channel = -1; // mark as invalid

  1055.                     midiEventCount += 1;

  1056.                 }

  1057. 

  1058.                 engineMidiUnlock();

  1059. 

  1060.             } // End of MIDI Input (External)

  1061. 

  1062.             CARLA_PROCESS_CONTINUE_CHECK;

  1063. 

  1064.             // ----------------------------------------------------------------------------------------------------

  1065.             // MIDI Input (System)

  1066. 

  1067.             for (i=0; i < mIn.count; i++)

  1068.             {

  1069.                 if (! mIn.ports[i])

  1070.                     continue;

  1071. 

  1072.                 const CarlaEngineMidiEvent* minEvent;

  1073.                 uint32_t time, nEvents = mIn.ports[i]->getEventCount();

  1074. 

  1075.                 for (k=0; k < nEvents && midiEventCount < MAX_MIDI_EVENTS; k++)

  1076.                 {

  1077.                     minEvent = mIn.ports[i]->getEvent(k);

  1078. 

  1079.                     if (! minEvent)

  1080.                         continue;

  1081. 

  1082.                     time = minEvent->time - framesOffset;

  1083. 

  1084.                     if (time >= frames)

  1085.                         continue;

  1086. 

  1087.                     uint8_t status  = minEvent->data[0];

  1088.                     uint8_t channel = status & 0x0F;

  1089. 

  1090.                     // Fix bad note-off

  1091.                     if (MIDI_IS_STATUS_NOTE_ON(status) && minEvent->data[2] == 0)

  1092.                         status -= 0x10;

  1093. 

  1094.                     ::MidiEvent* const midiEvent = &midiEvents[midiEventCount];

  1095.                     memset(midiEvent, 0, sizeof(::MidiEvent));

  1096. 

  1097.                     midiEvent->port = i;

  1098.                     midiEvent->time = minEvent->time;

  1099. 

  1100.                     if (MIDI_IS_STATUS_NOTE_OFF(status))

  1101.                     {

  1102.                         uint8_t note = minEvent->data[1];

  1103. 

  1104.                         midiEvent->data[0] = status;

  1105.                         midiEvent->data[1] = note;

  1106. 

  1107.                         postponeEvent(PluginPostEventNoteOff, channel, note, 0.0);

  1108.                     }

  1109.                     else if (MIDI_IS_STATUS_NOTE_ON(status))

  1110.                     {

  1111.                         uint8_t note = minEvent->data[1];

  1112.                         uint8_t velo = minEvent->data[2];

  1113. 

  1114.                         midiEvent->data[0] = status;

  1115.                         midiEvent->data[1] = note;

  1116.                         midiEvent->data[2] = velo;

  1117. 

  1118.                         postponeEvent(PluginPostEventNoteOn, channel, note, velo);

  1119.                     }

  1120.                     else if (MIDI_IS_STATUS_POLYPHONIC_AFTERTOUCH(status))

  1121.                     {

  1122.                         uint8_t note     = minEvent->data[1];

  1123.                         uint8_t pressure = minEvent->data[2];

  1124. 

  1125.                         midiEvent->data[0] = status;

  1126.                         midiEvent->data[1] = note;

  1127.                         midiEvent->data[2] = pressure;

  1128.                     }

  1129.                     else if (MIDI_IS_STATUS_AFTERTOUCH(status))

  1130.                     {

  1131.                         uint8_t pressure = minEvent->data[1];

  1132. 

  1133.                         midiEvent->data[0] = status;

  1134.                         midiEvent->data[1] = pressure;

  1135.                     }

  1136.                     else if (MIDI_IS_STATUS_PITCH_WHEEL_CONTROL(status))

  1137.                     {

  1138.                         uint8_t lsb = minEvent->data[1];

  1139.                         uint8_t msb = minEvent->data[2];

  1140. 

  1141.                         midiEvent->data[0] = status;

  1142.                         midiEvent->data[1] = lsb;

  1143.                         midiEvent->data[2] = msb;

  1144.                     }

  1145.                     else

  1146.                         continue;

  1147. 

  1148.                     midiEventCount += 1;

  1149.                 }

  1150.             } // End of MIDI Input (System)

  1151. 

  1152.         } // End of MIDI Input

  1153. 

  1154.         CARLA_PROCESS_CONTINUE_CHECK;

  1155. 

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

  1157.         // Plugin processing

  1158. 

  1159.         uint32_t midiEventCountBefore = midiEventCount;

  1160. 

  1161.         if (m_active)

  1162.         {

  1163.             if (! m_activeBefore)

  1164.             {

  1165.                 if (mIn.count > 0)

  1166.                 {

  1167.                     for (k=0; k < MAX_MIDI_CHANNELS; k++)

  1168.                     {

  1169.                         memset(&midiEvents[k], 0, sizeof(::MidiEvent));

  1170.                         midiEvents[k].data[0] = MIDI_STATUS_CONTROL_CHANGE + k;

  1171.                         midiEvents[k].data[1] = MIDI_CONTROL_ALL_SOUND_OFF;

  1172. 

  1173.                         memset(&midiEvents[k*2], 0, sizeof(::MidiEvent));

  1174.                         midiEvents[k*2].data[0] = MIDI_STATUS_CONTROL_CHANGE + k;

  1175.                         midiEvents[k*2].data[1] = MIDI_CONTROL_ALL_NOTES_OFF;

  1176.                     }

  1177. 

  1178.                     midiEventCount = MAX_MIDI_CHANNELS*2;

  1179.                 }

  1180. 

  1181.                 if (descriptor->activate)

  1182.                 {

  1183.                     descriptor->activate(handle);

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

  1185.                 }

  1186.             }

  1187. 

  1188.             isProcessing = true;

  1189. 

  1190.             if (h2)

  1191.             {

  1192.                 descriptor->process(handle, inBuffer? &inBuffer[0] : nullptr, outBuffer? &outBuffer[0] : nullptr, frames, midiEventCountBefore, midiEvents);

  1193.                 descriptor->process(h2,     inBuffer? &inBuffer[1] : nullptr, outBuffer? &outBuffer[1] : nullptr, frames, midiEventCountBefore, midiEvents);

  1194.             }

  1195.             else

  1196.                 descriptor->process(handle, inBuffer, outBuffer, frames, midiEventCountBefore, midiEvents);

  1197. 

  1198.             isProcessing = false;

  1199.         }

  1200.         else

  1201.         {

  1202.             if (m_activeBefore)

  1203.             {

  1204.                 if (descriptor->deactivate)

  1205.                 {

  1206.                     descriptor->deactivate(handle);

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

  1208.                 }

  1209.             }

  1210.         }

  1211. 

  1212.         CARLA_PROCESS_CONTINUE_CHECK;

  1213. 

  1214.         // --------------------------------------------------------------------------------------------------------

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

  1216. 

  1217.         if (m_active)

  1218.         {

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

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

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

  1222. 

  1223.             double bal_rangeL, bal_rangeR;

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

  1225. 

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

  1227.             {

  1228.                 // Dry/Wet

  1229.                 if (do_drywet)

  1230.                 {

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

  1232.                     {

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

  1234. 

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

  1236.                     }

  1237.                 }

  1238. 

  1239.                 // Balance

  1240.                 if (do_balance)

  1241.                 {

  1242.                     if (i%2 == 0)

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

  1244. 

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

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

  1247. 

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

  1249.                     {

  1250.                         if (i%2 == 0)

  1251.                         {

  1252.                             // left output

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

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

  1255.                         }

  1256.                         else

  1257.                         {

  1258.                             // right

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

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

  1261.                         }

  1262.                     }

  1263.                 }

  1264. 

  1265.                 // Volume

  1266.                 if (do_volume)

  1267.                 {

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

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

  1270.                 }

  1271. 

  1272.                 // Output VU

  1273.                 if (x_engine->processMode() != PROCESS_MODE_CONTINUOUS_RACK)

  1274.                 {

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

  1276.                     {

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

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

  1279.                     }

  1280.                 }

  1281.             }

  1282.         }

  1283.         else

  1284.         {

  1285.             // disable any output sound if not active

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

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

  1288. 

  1289.             aOutsPeak[0] = 0.0;

  1290.             aOutsPeak[1] = 0.0;

  1291. 

  1292.         } // End of Post-processing

  1293. 

  1294.         CARLA_PROCESS_CONTINUE_CHECK;

  1295. 

  1296.         // --------------------------------------------------------------------------------------------------------

  1297.         // MIDI Output

  1298. 

  1299.         if (mOut.count > 0 && m_active)

  1300.         {

  1301.             uint8_t data[3] = { 0 };

  1302. 

  1303.             for (uint32_t i = midiEventCountBefore; i < midiEventCount; i++)

  1304.             {

  1305.                 data[0] = midiEvents[i].data[0];

  1306.                 data[1] = midiEvents[i].data[1];

  1307.                 data[2] = midiEvents[i].data[2];

  1308. 

  1309.                 // Fix bad note-off

  1310.                 if (MIDI_IS_STATUS_NOTE_ON(data[0]) && data[2] == 0)

  1311.                     data[0] -= 0x10;

  1312. 

  1313.                 const uint32_t port = midiEvents[i].port;

  1314. 

  1315.                 if (port < mOut.count)

  1316.                     mOut.ports[port]->writeEvent(midiEvents[i].time, data, 3);

  1317.             }

  1318. 

  1319.         } // End of MIDI Output

  1320. 

  1321.         // --------------------------------------------------------------------------------------------------------

  1322.         // Control Output

  1323. 

  1324.         if (param.portCout && m_active)

  1325.         {

  1326.             double value, valueControl;

  1327. 

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

  1329.             {

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

  1331.                 {

  1332.                     value = descriptor->get_parameter_value(handle, param.data[k].rindex);

  1333. 

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

  1335.                     {

  1336.                         valueControl = (value - param.ranges[k].min) / (param.ranges[k].max - param.ranges[k].min);

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

  1338.                     }

  1339.                 }

  1340.             }

  1341.         } // End of Control Output

  1342. 

  1343.         CARLA_PROCESS_CONTINUE_CHECK;

  1344. 

  1345.         // --------------------------------------------------------------------------------------------------------

  1346.         // Peak Values

  1347. 

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

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

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

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

  1352. 

  1353.         m_activeBefore = m_active;

  1354.     }

  1355. 

  1356.     // -------------------------------------------------------------------

  1357.     // Cleanup

  1358. 

  1359.     void removeClientPorts()

  1360.     {

  1361.         qDebug("NativePlugin::removeClientPorts() - start");

  1362. 

  1363.         for (uint32_t i=0; i < mIn.count; i++)

  1364.         {

  1365.             delete mIn.ports[i];

  1366.             mIn.ports[i] = nullptr;

  1367.         }

  1368. 

  1369.         for (uint32_t i=0; i < mOut.count; i++)

  1370.         {

  1371.             delete mOut.ports[i];

  1372.             mOut.ports[i] = nullptr;

  1373.         }

  1374. 

  1375.         CarlaPlugin::removeClientPorts();

  1376. 

  1377.         qDebug("NativePlugin::removeClientPorts() - end");

  1378.     }

  1379. 

  1380.     void initBuffers()

  1381.     {

  1382.         for (uint32_t i=0; i < mIn.count; i++)

  1383.         {

  1384.             if (mIn.ports[i])

  1385.                 mIn.ports[i]->initBuffer(x_engine);

  1386.         }

  1387. 

  1388.         for (uint32_t i=0; i < mOut.count; i++)

  1389.         {

  1390.             if (mOut.ports[i])

  1391.                 mOut.ports[i]->initBuffer(x_engine);

  1392.         }

  1393. 

  1394.         CarlaPlugin::initBuffers();

  1395.     }

  1396. 

  1397.     void deleteBuffers()

  1398.     {

  1399.         qDebug("NativePlugin::deleteBuffers() - start");

  1400. 

  1401.         if (mIn.count > 0)

  1402.         {

  1403.             delete[] mIn.ports;

  1404.             delete[] mIn.indexes;

  1405.         }

  1406. 

  1407.         if (mOut.count > 0)

  1408.         {

  1409.             delete[] mOut.ports;

  1410.             delete[] mOut.indexes;

  1411.         }

  1412. 

  1413.         mIn.count = 0;

  1414.         mIn.ports = nullptr;

  1415.         mIn.indexes = nullptr;

  1416. 

  1417.         mOut.count = 0;

  1418.         mOut.ports = nullptr;

  1419.         mOut.indexes = nullptr;

  1420. 

  1421.         CarlaPlugin::deleteBuffers();

  1422. 

  1423.         qDebug("NativePlugin::deleteBuffers() - end");

  1424.     }

  1425. 

  1426.     // -------------------------------------------------------------------

  1427. 

  1428.     uint32_t handleGetBufferSize()

  1429.     {

  1430.         return x_engine->getBufferSize();

  1431.     }

  1432. 

  1433.     double handleGetSampleRate()

  1434.     {

  1435.         return x_engine->getSampleRate();

  1436.     }

  1437. 

  1438.     const TimeInfo* handleGetTimeInfo()

  1439.     {

  1440.         // TODO

  1441.         return nullptr;

  1442.     }

  1443. 

  1444.     bool handleWriteMidiEvent(MidiEvent* event)

  1445.     {

  1446.         CARLA_ASSERT(m_enabled);

  1447.         CARLA_ASSERT(mOut.count > 0);

  1448.         CARLA_ASSERT(isProcessing);

  1449.         CARLA_ASSERT(event);

  1450. 

  1451.         if (! m_enabled)

  1452.             return false;

  1453. 

  1454.         if (mOut.count == 0)

  1455.             return false;

  1456. 

  1457.         if (! isProcessing)

  1458.         {

  1459.             qCritical("NativePlugin::handleWriteMidiEvent(%p) - received MIDI out events outside audio thread, ignoring", event);

  1460.             return false;

  1461.         }

  1462. 

  1463.         if (midiEventCount >= MAX_MIDI_EVENTS*2)

  1464.             return false;

  1465. 

  1466.         memcpy(&midiEvents[midiEventCount], event, sizeof(::MidiEvent));

  1467.         midiEventCount += 1;

  1468. 

  1469.         return true;

  1470.     }

  1471. 

  1472.     void handleUiParameterChanged(uint32_t index, float value)

  1473.     {

  1474.         setParameterValue(index, value, false, true, true);

  1475.     }

  1476. 

  1477.     void handleUiCustomDataChanged(const char* key, const char* value)

  1478.     {

  1479.         setCustomData(CUSTOM_DATA_STRING, key, value, false);

  1480.     }

  1481. 

  1482.     static uint32_t carla_host_get_buffer_size(HostHandle handle)

  1483.     {

  1484.         CARLA_ASSERT(handle);

  1485.         return ((NativePlugin*)handle)->handleGetBufferSize();

  1486.     }

  1487. 

  1488.     static double carla_host_get_sample_rate(HostHandle handle)

  1489.     {

  1490.         CARLA_ASSERT(handle);

  1491.         return ((NativePlugin*)handle)->handleGetSampleRate();

  1492.     }

  1493. 

  1494.     static const TimeInfo* carla_host_get_time_info(HostHandle handle)

  1495.     {

  1496.         CARLA_ASSERT(handle);

  1497.         return ((NativePlugin*)handle)->handleGetTimeInfo();

  1498.     }

  1499. 

  1500.     static bool carla_host_write_midi_event(HostHandle handle, MidiEvent* event)

  1501.     {

  1502.         CARLA_ASSERT(handle);

  1503.         return ((NativePlugin*)handle)->handleWriteMidiEvent(event);

  1504.     }

  1505. 

  1506.     static void carla_host_ui_parameter_changed(HostHandle handle, uint32_t index, float value)

  1507.     {

  1508.         CARLA_ASSERT(handle);

  1509.         ((NativePlugin*)handle)->handleUiParameterChanged(index, value);

  1510.     }

  1511. 

  1512.     static void carla_host_ui_custom_data_changed(HostHandle handle, const char* key, const char* value)

  1513.     {

  1514.         CARLA_ASSERT(handle);

  1515.         ((NativePlugin*)handle)->handleUiCustomDataChanged(key, value);

  1516.     }

  1517. 

  1518.     // -------------------------------------------------------------------

  1519. 

  1520.     static size_t getPluginCount()

  1521.     {

  1522.         maybeFirstInit();

  1523.         return pluginDescriptors.size();

  1524.     }

  1525. 

  1526.     static const PluginDescriptor* getPlugin(const size_t index)

  1527.     {

  1528.         CARLA_ASSERT(index < pluginDescriptors.size());

  1529. 

  1530.         if (index < pluginDescriptors.size())

  1531.             return pluginDescriptors[index];

  1532. 

  1533.         return nullptr;

  1534.     }

  1535. 

  1536.     static void registerPlugin(const PluginDescriptor* desc)

  1537.     {

  1538.         pluginDescriptors.push_back(desc);

  1539.     }

  1540. 

  1541.     static void maybeFirstInit()

  1542.     {

  1543.         if (! firstInit)

  1544.             return;

  1545. 

  1546.         firstInit = false;

  1547. 

  1548.         carla_register_native_plugin_bypass();

  1549.         carla_register_native_plugin_midiSplit();

  1550. #ifdef WANT_ZYNADDSUBFX

  1551.         carla_register_native_plugin_zynaddsubfx();

  1552. #endif

  1553. 

  1554.         //carla_register_native_plugin_3BandEQ();

  1555.         //carla_register_native_plugin_3BandSplitter();

  1556.     }

  1557. 

  1558.     // -------------------------------------------------------------------

  1559. 

  1560.     bool init(const char* const name, const char* const label)

  1561.     {

  1562.         // ---------------------------------------------------------------

  1563.         // initialize native-plugins descriptors

  1564. 

  1565.         maybeFirstInit();

  1566. 

  1567.         // ---------------------------------------------------------------

  1568.         // get descriptor that matches label

  1569. 

  1570.         for (size_t i=0; i < pluginDescriptors.size(); i++)

  1571.         {

  1572.             descriptor = pluginDescriptors[i];

  1573. 

  1574.             if (! descriptor)

  1575.                 break;

  1576.             if (descriptor->label && strcmp(descriptor->label, label) == 0)

  1577.                 break;

  1578. 

  1579.             descriptor = nullptr;

  1580.         }

  1581. 

  1582.         if (! descriptor)

  1583.         {

  1584.             x_engine->setLastError("Invalid internal plugin");

  1585.             return false;

  1586.         }

  1587. 

  1588.         // ---------------------------------------------------------------

  1589.         // get info

  1590. 

  1591.         if (name)

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

  1593.         else

  1594.             m_name = x_engine->getUniquePluginName(descriptor->name);

  1595. 

  1596.         // ---------------------------------------------------------------

  1597.         // register client

  1598. 

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

  1600. 

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

  1602.         {

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

  1604.             return false;

  1605.         }

  1606. 

  1607.         // ---------------------------------------------------------------

  1608.         // initialize plugin

  1609. 

  1610.         handle = descriptor->instantiate(descriptor, &host);

  1611. 

  1612.         if (! handle)

  1613.         {

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

  1615.             return false;

  1616.         }

  1617. 

  1618.         return true;

  1619.     }

  1620. 

  1621. private:

  1622.     const PluginDescriptor* descriptor;

  1623.     PluginHandle handle, h2;

  1624.     HostDescriptor host;

  1625. 

  1626.     bool isProcessing;

  1627. 

  1628.     NativePluginMidiData mIn;

  1629.     NativePluginMidiData mOut;

  1630. 

  1631.     uint32_t    midiEventCount;

  1632.     ::MidiEvent midiEvents[MAX_MIDI_EVENTS*2];

  1633. 

  1634.     static bool firstInit;

  1635.     static std::vector<const PluginDescriptor*> pluginDescriptors;

  1636. };

  1637. 

  1638. bool NativePlugin::firstInit = true;

  1639. std::vector<const PluginDescriptor*> NativePlugin::pluginDescriptors;

  1640. 

  1641. // -----------------------------------------------------------------------

  1642. 

  1643. CarlaPlugin* CarlaPlugin::newNative(const initializer& init)

  1644. {

  1645.     qDebug("CarlaPlugin::newNative(%p, \"%s\", \"%s\", \"%s\")", init.engine, init.filename, init.name, init.label);

  1646. 

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

  1648. 

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

  1650.     {

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

  1652.         return nullptr;

  1653.     }

  1654. 

  1655.     NativePlugin* const plugin = new NativePlugin(init.engine, id);

  1656. 

  1657.     if (! plugin->init(init.name, init.label))

  1658.     {

  1659.         delete plugin;

  1660.         return nullptr;

  1661.     }

  1662. 

  1663.     plugin->reload();

  1664. 

  1665.     if (init.engine->processMode() == PROCESS_MODE_CONTINUOUS_RACK)

  1666.     {

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

  1668.         {

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

  1670.             delete plugin;

  1671.             return nullptr;

  1672.         }

  1673.     }

  1674. 

  1675.     plugin->registerToOscControl();

  1676. 

  1677.     return plugin;

  1678. }

  1679. 

  1680. // -----------------------------------------------------------------------

  1681. 

  1682. size_t CarlaPlugin::getNativePluginCount()

  1683. {

  1684.     return NativePlugin::getPluginCount();

  1685. }

  1686. 

  1687. const PluginDescriptor* CarlaPlugin::getNativePluginDescriptor(const size_t index)

  1688. {

  1689.     return NativePlugin::getPlugin(index);

  1690. }

  1691. 

  1692. // -----------------------------------------------------------------------

  1693. 

  1694. CARLA_BACKEND_END_NAMESPACE

  1695. 

  1696. void carla_register_native_plugin(const PluginDescriptor* desc)

  1697. {

  1698.     CARLA_BACKEND_USE_NAMESPACE

  1699.     NativePlugin::registerPlugin(desc);

  1700. }