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

1724 lines
55KB
Raw Blame History 

  1. /*

  2.  * Carla Native Plugin

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

  4.  *

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

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

  7.  * published by the Free Software Foundation; either version 2 of

  8.  * the License, or any later version.

  9.  *

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

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

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

  13.  * GNU General Public License for more details.

  14.  *

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

  16.  */

  17. 

  18. #include "carla_plugin_internal.hpp"

  19. #include "carla_native.h"

  20. 

  21. CARLA_BACKEND_START_NAMESPACE

  22. 

  23. #if 0

  24. struct NativePluginMidiData {

  25.     uint32_t  count;

  26.     uint32_t* indexes;

  27.     CarlaEngineMidiPort** ports;

  28. 

  29.     NativePluginMidiData()

  30.         : count(0),

  31.           indexes(nullptr),

  32.           ports(nullptr) {}

  33. };

  34. #endif

  35. 

  36. class NativePlugin : public CarlaPlugin

  37. {

  38. public:

  39.     NativePlugin(CarlaEngine* const engine, const unsigned int id)

  40.         : CarlaPlugin(engine, id)

  41.     {

  42.         qDebug("NativePlugin::NativePlugin(%p, %i)", engine, id);

  43. 

  44.         fHandle  = nullptr;

  45.         fHandle2 = nullptr;

  46.         fDescriptor = nullptr;

  47. 

  48.         fHost.handle = this;

  49.         fHost.get_buffer_size        = carla_host_get_buffer_size;

  50.         fHost.get_sample_rate        = carla_host_get_sample_rate;

  51.         fHost.get_time_info          = carla_host_get_time_info;

  52.         fHost.write_midi_event       = carla_host_write_midi_event;

  53.         fHost.ui_parameter_changed   = carla_host_ui_parameter_changed;

  54.         fHost.ui_custom_data_changed = carla_host_ui_custom_data_changed;

  55.         fHost.ui_closed              = carla_host_ui_closed;

  56. 

  57.         fIsProcessing = false;

  58. 

  59.         //midiEventCount = 0;

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

  61.     }

  62. 

  63.     ~NativePlugin()

  64.     {

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

  66. 

  67.         if (fDescriptor != nullptr)

  68.         {

  69.             if (fDescriptor->deactivate != nullptr && kData->activeBefore)

  70.             {

  71.                 if (fHandle != nullptr)

  72.                     fDescriptor->deactivate(fHandle);

  73.                 if (fHandle2 != nullptr)

  74.                     fDescriptor->deactivate(fHandle2);

  75.             }

  76. 

  77.             if (fDescriptor->cleanup != nullptr)

  78.             {

  79.                 if (fHandle != nullptr)

  80.                     fDescriptor->cleanup(fHandle);

  81.                 if (fHandle2 != nullptr)

  82.                     fDescriptor->cleanup(fHandle2);

  83.             }

  84. 

  85.             fHandle  = nullptr;

  86.             fHandle2 = nullptr;

  87.             fDescriptor = nullptr;

  88.         }

  89.     }

  90. 

  91.     // -------------------------------------------------------------------

  92.     // Information (base)

  93. 

  94.     virtual PluginType type() const

  95.     {

  96.         return PLUGIN_INTERNAL;

  97.     }

  98. 

  99.     PluginCategory category()

  100.     {

  101.         CARLA_ASSERT(fDescriptor != nullptr);

  102. 

  103.         if (fDescriptor != nullptr)

  104.             return static_cast<PluginCategory>(fDescriptor->category);

  105. 

  106.         return getPluginCategoryFromName(fName);

  107.     }

  108. 

  109.     // -------------------------------------------------------------------

  110.     // Information (count)

  111. 

  112. #if 0

  113.     uint32_t midiInCount()

  114.     {

  115.         return mIn.count;

  116.     }

  117. 

  118.     uint32_t midiOutCount()

  119.     {

  120.         return mOut.count;

  121.     }

  122. #endif

  123. 

  124.     uint32_t parameterScalePointCount(const uint32_t parameterId) const

  125.     {

  126.         CARLA_ASSERT(fDescriptor != nullptr);

  127.         CARLA_ASSERT(fHandle != nullptr);

  128.         CARLA_ASSERT(parameterId < kData->param.count);

  129. 

  130.         if (fDescriptor != nullptr && fHandle != nullptr && parameterId < kData->param.count && fDescriptor->get_parameter_info != nullptr)

  131.         {

  132.             if (const Parameter* const param = fDescriptor->get_parameter_info(fHandle, parameterId))

  133.                 return param->scalePointCount;

  134.         }

  135. 

  136.         return 0;

  137.     }

  138. 

  139.     // -------------------------------------------------------------------

  140.     // Information (per-plugin data)

  141. 

  142.     float getParameterValue(const uint32_t parameterId)

  143.     {

  144.         CARLA_ASSERT(fDescriptor != nullptr);

  145.         CARLA_ASSERT(fHandle != nullptr);

  146.         CARLA_ASSERT(parameterId < kData->param.count);

  147. 

  148.         if (fDescriptor != nullptr && fHandle != nullptr && parameterId < kData->param.count && fDescriptor->get_parameter_value != nullptr)

  149.             return fDescriptor->get_parameter_value(fHandle, parameterId);

  150. 

  151.         return 0.0f;

  152.     }

  153. 

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

  155.     {

  156.         CARLA_ASSERT(fDescriptor != nullptr);

  157.         CARLA_ASSERT(fHandle != nullptr);

  158.         CARLA_ASSERT(parameterId < kData->param.count);

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

  160. 

  161.         if (fDescriptor != nullptr && fHandle != nullptr && parameterId < kData->param.count && fDescriptor->get_parameter_info != nullptr)

  162.         {

  163.             if (const Parameter* const param = fDescriptor->get_parameter_info(fHandle, parameterId))

  164.             {

  165.                 const ParameterScalePoint& scalePoint = param->scalePoints[scalePointId];

  166. 

  167.                 return scalePoint.value;

  168.             }

  169.         }

  170. 

  171.         return 0.0f;

  172.     }

  173. 

  174.     void getLabel(char* const strBuf)

  175.     {

  176.         CARLA_ASSERT(fDescriptor != nullptr);

  177. 

  178.         if (fDescriptor != nullptr && fDescriptor->label != nullptr)

  179.             std::strncpy(strBuf, fDescriptor->label, STR_MAX);

  180.         else

  181.             CarlaPlugin::getLabel(strBuf);

  182.     }

  183. 

  184.     void getMaker(char* const strBuf)

  185.     {

  186.         CARLA_ASSERT(fDescriptor != nullptr);

  187. 

  188.         if (fDescriptor != nullptr && fDescriptor->maker != nullptr)

  189.             std::strncpy(strBuf, fDescriptor->maker, STR_MAX);

  190.         else

  191.             CarlaPlugin::getMaker(strBuf);

  192.     }

  193. 

  194.     void getCopyright(char* const strBuf)

  195.     {

  196.         CARLA_ASSERT(fDescriptor != nullptr);

  197. 

  198.         if (fDescriptor != nullptr && fDescriptor->copyright != nullptr)

  199.             std::strncpy(strBuf, fDescriptor->copyright, STR_MAX);

  200.         else

  201.             CarlaPlugin::getCopyright(strBuf);

  202.     }

  203. 

  204.     void getRealName(char* const strBuf)

  205.     {

  206.         CARLA_ASSERT(fDescriptor != nullptr);

  207. 

  208.         if (fDescriptor != nullptr && fDescriptor->name != nullptr)

  209.             std::strncpy(strBuf, fDescriptor->name, STR_MAX);

  210.         else

  211.             CarlaPlugin::getRealName(strBuf);

  212.     }

  213. 

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

  215.     {

  216.         CARLA_ASSERT(fDescriptor != nullptr);

  217.         CARLA_ASSERT(fHandle != nullptr);

  218.         CARLA_ASSERT(parameterId < kData->param.count);

  219. 

  220.         if (fDescriptor != nullptr && fHandle != nullptr && parameterId < kData->param.count && fDescriptor->get_parameter_info != nullptr)

  221.         {

  222.             const Parameter* const param = fDescriptor->get_parameter_info(fHandle, parameterId);

  223. 

  224.             if (param != nullptr && param->name != nullptr)

  225.             {

  226.                 std::strncpy(strBuf, param->name, STR_MAX);

  227.                 return;

  228.             }

  229.         }

  230. 

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

  232.     }

  233. 

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

  235.     {

  236.         CARLA_ASSERT(fDescriptor != nullptr);

  237.         CARLA_ASSERT(fHandle != nullptr);

  238.         CARLA_ASSERT(parameterId < kData->param.count);

  239. 

  240.         if (fDescriptor != nullptr && fHandle != nullptr && parameterId < kData->param.count && fDescriptor->get_parameter_text != nullptr)

  241.         {

  242.             if (const char* const text = fDescriptor->get_parameter_text(fHandle, parameterId))

  243.             {

  244.                 std::strncpy(strBuf, text, STR_MAX);

  245.                 return;

  246.             }

  247.         }

  248. 

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

  250.     }

  251. 

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

  253.     {

  254.         CARLA_ASSERT(fDescriptor != nullptr);

  255.         CARLA_ASSERT(fHandle != nullptr);

  256.         CARLA_ASSERT(parameterId < kData->param.count);

  257. 

  258.         if (fDescriptor != nullptr && fHandle != nullptr && parameterId < kData->param.count && fDescriptor->get_parameter_info != nullptr)

  259.         {

  260.             const Parameter* const param = fDescriptor->get_parameter_info(fHandle, parameterId);

  261. 

  262.             if (param != nullptr && param->unit != nullptr)

  263.             {

  264.                 std::strncpy(strBuf, param->unit, STR_MAX);

  265.                 return;

  266.             }

  267.         }

  268. 

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

  270.     }

  271. 

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

  273.     {

  274.         CARLA_ASSERT(fDescriptor != nullptr);

  275.         CARLA_ASSERT(fHandle != nullptr);

  276.         CARLA_ASSERT(parameterId < kData->param.count);

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

  278. 

  279.         if (fDescriptor != nullptr && fHandle != nullptr && parameterId < kData->param.count && fDescriptor->get_parameter_info != nullptr)

  280.         {

  281.             if (const Parameter* const param = fDescriptor->get_parameter_info(fHandle, parameterId))

  282.             {

  283.                 const ParameterScalePoint& scalePoint = param->scalePoints[scalePointId];

  284. 

  285.                 if (scalePoint.label != nullptr)

  286.                 {

  287.                     std::strncpy(strBuf, scalePoint.label, STR_MAX);

  288.                     return;

  289.                 }

  290.             }

  291.         }

  292. 

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

  294.     }

  295. 

  296.     // -------------------------------------------------------------------

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

  298. 

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

  300.     {

  301.         CARLA_ASSERT(fDescriptor != nullptr);

  302.         CARLA_ASSERT(fHandle != nullptr);

  303.         CARLA_ASSERT(parameterId < kData->param.count);

  304. 

  305.         const float fixedValue = kData->param.fixValue(parameterId, value);

  306. 

  307.         if (fDescriptor != nullptr && fHandle != nullptr && parameterId < kData->param.count && fDescriptor->set_parameter_value != nullptr)

  308.         {

  309.             fDescriptor->set_parameter_value(fHandle, parameterId, fixedValue);

  310. 

  311.             if (fHandle2 != nullptr)

  312.                 fDescriptor->set_parameter_value(fHandle2, parameterId, fixedValue);

  313.         }

  314. 

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

  316.     }

  317. 

  318. #if 0

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

  320.     {

  321.         CARLA_ASSERT(descriptor);

  322.         CARLA_ASSERT(handle);

  323.         CARLA_ASSERT(type);

  324.         CARLA_ASSERT(key);

  325.         CARLA_ASSERT(value);

  326. 

  327.         if (! type)

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

  329. 

  330.         if (! key)

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

  332. 

  333.         if (! value)

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

  335. 

  336.         if (descriptor && handle)

  337.         {

  338.             if (descriptor->set_custom_data)

  339.             {

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

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

  342.             }

  343. 

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

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

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

  347.         }

  348. 

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

  350.     }

  351. 

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

  353.     {

  354.         CARLA_ASSERT(fDescriptor != nullptr);

  355.         CARLA_ASSERT(fHandle != nullptr);

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

  357. 

  358.         if (index < -1)

  359.             index = -1;

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

  361.             return;

  362. 

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

  364.         {

  365.             if (x_engine->isOffline())

  366.             {

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

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

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

  370.             }

  371.             else

  372.             {

  373.                 const ScopedDisabler m(this, block);

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

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

  376.             }

  377.         }

  378. 

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

  380.     }

  381. #endif

  382. 

  383.     // -------------------------------------------------------------------

  384.     // Set gui stuff

  385. 

  386.     void showGui(const bool yesNo)

  387.     {

  388.         CARLA_ASSERT(fDescriptor != nullptr);

  389.         CARLA_ASSERT(fHandle != nullptr);

  390. 

  391.         if (fDescriptor != nullptr && fHandle != nullptr && fDescriptor->ui_show != nullptr)

  392.             fDescriptor->ui_show(fHandle, yesNo);

  393.     }

  394. 

  395.     void idleGui()

  396.     {

  397.         CARLA_ASSERT(fDescriptor != nullptr);

  398.         CARLA_ASSERT(fHandle != nullptr);

  399. 

  400.         if (fDescriptor != nullptr && fHandle != nullptr && fDescriptor->ui_idle != nullptr)

  401.             fDescriptor->ui_idle(fHandle);

  402.     }

  403. 

  404.     // -------------------------------------------------------------------

  405.     // Plugin state

  406. 

  407.     void reload()

  408.     {

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

  410.         CARLA_ASSERT(fDescriptor != nullptr);

  411. 

  412. #if 0

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

  414. 

  415.         // Safely disable plugin for reload

  416.         const ScopedDisabler m(this);

  417. 

  418.         if (x_client->isActive())

  419.             x_client->deactivate();

  420. 

  421.         // Remove client ports

  422.         removeClientPorts();

  423. 

  424.         // Delete old data

  425.         deleteBuffers();

  426. 

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

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

  429. 

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

  431. 

  432.         aIns   = descriptor->audioIns;

  433.         aOuts  = descriptor->audioOuts;

  434.         mIns   = descriptor->midiIns;

  435.         mOuts  = descriptor->midiOuts;

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

  437. 

  438.         bool forcedStereoIn, forcedStereoOut;

  439.         forcedStereoIn = forcedStereoOut = false;

  440. 

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

  442.         {

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

  444. 

  445.             if (aIns == 1)

  446.             {

  447.                 aIns = 2;

  448.                 forcedStereoIn = true;

  449.             }

  450. 

  451.             if (aOuts == 1)

  452.             {

  453.                 aOuts = 2;

  454.                 forcedStereoOut = true;

  455.             }

  456.         }

  457. 

  458.         if (aIns > 0)

  459.         {

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

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

  462.         }

  463. 

  464.         if (aOuts > 0)

  465.         {

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

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

  468.         }

  469. 

  470.         if (mIns > 0)

  471.         {

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

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

  474.         }

  475. 

  476.         if (mOuts > 0)

  477.         {

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

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

  480.         }

  481. 

  482.         if (params > 0)

  483.         {

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

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

  486.         }

  487. 

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

  489.         char portName[portNameSize];

  490.         bool needsCtrlIn  = false;

  491.         bool needsCtrlOut = false;

  492. 

  493.         // Audio Ins

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

  495.         {

  496.             if (processMode == PROCESS_MODE_SINGLE_CLIENT)

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

  498.             else

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

  500. 

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

  502.             aIn.rindexes[j] = j;

  503. 

  504.             if (forcedStereoIn)

  505.             {

  506.                 strcat(portName, "_");

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

  508.                 aIn.rindexes[1] = j;

  509.             }

  510.         }

  511. 

  512.         // Audio Outs

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

  514.         {

  515.             if (processMode == PROCESS_MODE_SINGLE_CLIENT)

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

  517.             else

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

  519. 

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

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

  522.             aOut.rindexes[j] = j;

  523.             needsCtrlIn = true;

  524. 

  525.             if (forcedStereoOut)

  526.             {

  527.                 strcat(portName, "_");

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

  529.                 aOut.rindexes[1] = j;

  530.             }

  531.         }

  532. 

  533.         // MIDI Input

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

  535.         {

  536.             if (processMode == PROCESS_MODE_SINGLE_CLIENT)

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

  538.             else

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

  540. 

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

  542.             mIn.indexes[j] = j;

  543.         }

  544. 

  545.         // MIDI Output

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

  547.         {

  548.             if (processMode == PROCESS_MODE_SINGLE_CLIENT)

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

  550.             else

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

  552. 

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

  554.             mOut.indexes[j] = j;

  555.         }

  556. 

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

  558.         {

  559.             if (! descriptor->get_parameter_info)

  560.                 break;

  561. 

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

  563. 

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

  565.             //const bool     paramOutput = paramHins;

  566. 

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

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

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

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

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

  572. 

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

  574. 

  575.             // min value

  576.             min = paramInfo->ranges.min;

  577. 

  578.             // max value

  579.             max = paramInfo->ranges.max;

  580. 

  581.             if (min > max)

  582.                 max = min;

  583.             else if (max < min)

  584.                 min = max;

  585. 

  586.             if (max - min == 0.0)

  587.             {

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

  589.                 max = min + 0.1;

  590.             }

  591. 

  592.             // default value

  593.             def = paramInfo->ranges.def;

  594. 

  595.             if (def < min)

  596.                 def = min;

  597.             else if (def > max)

  598.                 def = max;

  599. 

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

  601.             {

  602.                 min *= sampleRate;

  603.                 max *= sampleRate;

  604.                 def *= sampleRate;

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

  606.             }

  607. 

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

  609.             {

  610.                 step = max - min;

  611.                 stepSmall = step;

  612.                 stepLarge = step;

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

  614.             }

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

  616.             {

  617.                 step = 1.0;

  618.                 stepSmall = 1.0;

  619.                 stepLarge = 10.0;

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

  621.             }

  622.             else

  623.             {

  624.                 double range = max - min;

  625.                 step = range/100.0;

  626.                 stepSmall = range/1000.0;

  627.                 stepLarge = range/10.0;

  628.             }

  629. 

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

  631.             {

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

  633.                 needsCtrlOut = true;

  634.             }

  635.             else

  636.             {

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

  638.                 needsCtrlIn = true;

  639.             }

  640. 

  641.             // extra parameter hints

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

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

  644. 

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

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

  647. 

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

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

  650. 

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

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

  653. 

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

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

  656. 

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

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

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

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

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

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

  663.         }

  664. 

  665.         if (needsCtrlIn)

  666.         {

  667.             if (processMode == PROCESS_MODE_SINGLE_CLIENT)

  668.             {

  669.                 strcpy(portName, m_name);

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

  671.             }

  672.             else

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

  674. 

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

  676.         }

  677. 

  678.         if (needsCtrlOut)

  679.         {

  680.             if (processMode == PROCESS_MODE_SINGLE_CLIENT)

  681.             {

  682.                 strcpy(portName, m_name);

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

  684.             }

  685.             else

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

  687. 

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

  689.         }

  690. 

  691.         aIn.count   = aIns;

  692.         aOut.count  = aOuts;

  693.         mIn.count   = mIns;

  694.         mOut.count  = mOuts;

  695.         param.count = params;

  696. 

  697.         // plugin checks

  698.         fHints &= ~(PLUGIN_IS_SYNTH | PLUGIN_USES_CHUNKS | PLUGIN_CAN_DRYWET | PLUGIN_CAN_VOLUME | PLUGIN_CAN_BALANCE | PLUGIN_CAN_FORCE_STEREO);

  699. 

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

  701.             fHints |= PLUGIN_CAN_DRYWET;

  702. 

  703.         if (aOuts > 0)

  704.             fHints |= PLUGIN_CAN_VOLUME;

  705. 

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

  707.             fHints |= PLUGIN_CAN_BALANCE;

  708. 

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

  710.             fHints |= PLUGIN_CAN_FORCE_STEREO;

  711. #endif

  712. 

  713.         // native plugin hints

  714.         if (fDescriptor->hints & ::PLUGIN_IS_RTSAFE)

  715.             fHints |= PLUGIN_IS_RTSAFE;

  716.         if (fDescriptor->hints & ::PLUGIN_IS_SYNTH)

  717.             fHints |= PLUGIN_IS_SYNTH;

  718.         if (fDescriptor->hints & ::PLUGIN_HAS_GUI)

  719.             fHints |= PLUGIN_HAS_GUI;

  720.         if (fDescriptor->hints & ::PLUGIN_USES_SINGLE_THREAD)

  721.             fHints |= PLUGIN_USES_SINGLE_THREAD;

  722. 

  723.         reloadPrograms(true);

  724. 

  725.         kData->client->activate();

  726. 

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

  728.     }

  729. 

  730. #if 0

  731.     void reloadPrograms(const bool init)

  732.     {

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

  734.         uint32_t i, oldCount = midiprog.count;

  735. 

  736.         // Delete old programs

  737.         if (midiprog.count > 0)

  738.         {

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

  740.             {

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

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

  743.             }

  744. 

  745.             delete[] midiprog.data;

  746.         }

  747. 

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

  749.         midiprog.data  = nullptr;

  750. 

  751.         if (midiprog.count > 0)

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

  753. 

  754.         // Update data

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

  756.         {

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

  758.             CARLA_ASSERT(mpDesc);

  759.             CARLA_ASSERT(mpDesc->name);

  760. 

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

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

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

  764.         }

  765. 

  766.         // Update OSC Names

  767.         if (x_engine->isOscControlRegistered())

  768.         {

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

  770. 

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

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

  773.         }

  774. 

  775.         if (init)

  776.         {

  777.             if (midiprog.count > 0)

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

  779.         }

  780.         else

  781.         {

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

  783. 

  784.             // Check if current program is invalid

  785.             bool programChanged = false;

  786. 

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

  788.             {

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

  790.                 midiprog.current = oldCount;

  791.                 programChanged   = true;

  792.             }

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

  794.             {

  795.                 // current midi program > count

  796.                 midiprog.current = 0;

  797.                 programChanged   = true;

  798.             }

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

  800.             {

  801.                 // programs exist now, but not before

  802.                 midiprog.current = 0;

  803.                 programChanged   = true;

  804.             }

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

  806.             {

  807.                 // programs existed before, but not anymore

  808.                 midiprog.current = -1;

  809.                 programChanged   = true;

  810.             }

  811. 

  812.             if (programChanged)

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

  814.         }

  815.     }

  816. 

  817.     // -------------------------------------------------------------------

  818.     // Plugin processing

  819. 

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

  821.     {

  822.         uint32_t i, k;

  823. 

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

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

  826. 

  827.         // reset MIDI

  828.         midiEventCount = 0;

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

  830. 

  831.         CARLA_PROCESS_CONTINUE_CHECK;

  832. 

  833.         // --------------------------------------------------------------------------------------------------------

  834.         // Input VU

  835. 

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

  837.         {

  838.             if (aIn.count == 1)

  839.             {

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

  841.                 {

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

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

  844.                 }

  845.             }

  846.             else if (aIn.count > 1)

  847.             {

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

  849.                 {

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

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

  852. 

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

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

  855.                 }

  856.             }

  857.         }

  858. 

  859.         CARLA_PROCESS_CONTINUE_CHECK;

  860. 

  861.         // --------------------------------------------------------------------------------------------------------

  862.         // Parameters Input [Automation]

  863. 

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

  865.         {

  866.             bool allNotesOffSent = false;

  867. 

  868.             const CarlaEngineControlEvent* cinEvent;

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

  870. 

  871.             uint32_t nextBankId = 0;

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

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

  874. 

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

  876.             {

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

  878. 

  879.                 if (! cinEvent)

  880.                     continue;

  881. 

  882.                 time = cinEvent->time - framesOffset;

  883. 

  884.                 if (time >= frames)

  885.                     continue;

  886. 

  887.                 // Control change

  888.                 switch (cinEvent->type)

  889.                 {

  890.                 case CarlaEngineNullEvent:

  891.                     break;

  892. 

  893.                 case CarlaEngineParameterChangeEvent:

  894.                 {

  895.                     double value;

  896. 

  897.                     // Control backend stuff

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

  899.                     {

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

  901.                         {

  902.                             value = cinEvent->value;

  903.                             setDryWet(value, false, false);

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

  905.                             continue;

  906.                         }

  907. 

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

  909.                         {

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

  911.                             setVolume(value, false, false);

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

  913.                             continue;

  914.                         }

  915. 

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

  917.                         {

  918.                             double left, right;

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

  920. 

  921.                             if (value < 0.0)

  922.                             {

  923.                                 left  = -1.0;

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

  925.                             }

  926.                             else if (value > 0.0)

  927.                             {

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

  929.                                 right = 1.0;

  930.                             }

  931.                             else

  932.                             {

  933.                                 left  = -1.0;

  934.                                 right = 1.0;

  935.                             }

  936. 

  937.                             setBalanceLeft(left, false, false);

  938.                             setBalanceRight(right, false, false);

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

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

  941.                             continue;

  942.                         }

  943.                     }

  944. 

  945.                     // Control plugin parameters

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

  947.                     {

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

  949.                             continue;

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

  951.                             continue;

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

  953.                             continue;

  954. 

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

  956.                         {

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

  958.                             {

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

  960.                             }

  961.                             else

  962.                             {

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

  964. 

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

  966.                                     value = rint(value);

  967.                             }

  968. 

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

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

  971.                         }

  972.                     }

  973. 

  974.                     break;

  975.                 }

  976. 

  977.                 case CarlaEngineMidiBankChangeEvent:

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

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

  980.                     break;

  981. 

  982.                 case CarlaEngineMidiProgramChangeEvent:

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

  984.                     {

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

  986. 

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

  988.                         {

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

  990.                             {

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

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

  993.                                 break;

  994.                             }

  995.                         }

  996.                     }

  997.                     break;

  998. 

  999.                 case CarlaEngineAllSoundOffEvent:

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

  1001.                     {

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

  1003.                             sendMidiAllNotesOff();

  1004. 

  1005.                         if (descriptor->deactivate)

  1006.                         {

  1007.                             descriptor->deactivate(handle);

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

  1009.                         }

  1010. 

  1011.                         if (descriptor->activate)

  1012.                         {

  1013.                             descriptor->activate(handle);

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

  1015.                         }

  1016. 

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

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

  1019. 

  1020.                         allNotesOffSent = true;

  1021.                     }

  1022.                     break;

  1023. 

  1024.                 case CarlaEngineAllNotesOffEvent:

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

  1026.                     {

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

  1028.                             sendMidiAllNotesOff();

  1029. 

  1030.                         allNotesOffSent = true;

  1031.                     }

  1032.                     break;

  1033.                 }

  1034.             }

  1035.         } // End of Parameters Input

  1036. 

  1037.         CARLA_PROCESS_CONTINUE_CHECK;

  1038. 

  1039.         // --------------------------------------------------------------------------------------------------------

  1040.         // MIDI Input

  1041. 

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

  1043.         {

  1044.             // ----------------------------------------------------------------------------------------------------

  1045.             // MIDI Input (External)

  1046. 

  1047.             {

  1048.                 engineMidiLock();

  1049. 

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

  1051.                 {

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

  1053.                         break;

  1054. 

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

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

  1057. 

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

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

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

  1061. 

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

  1063.                     midiEventCount += 1;

  1064.                 }

  1065. 

  1066.                 engineMidiUnlock();

  1067. 

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

  1069. 

  1070.             CARLA_PROCESS_CONTINUE_CHECK;

  1071. 

  1072.             // ----------------------------------------------------------------------------------------------------

  1073.             // MIDI Input (System)

  1074. 

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

  1076.             {

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

  1078.                     continue;

  1079. 

  1080.                 const CarlaEngineMidiEvent* minEvent;

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

  1082. 

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

  1084.                 {

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

  1086. 

  1087.                     if (! minEvent)

  1088.                         continue;

  1089. 

  1090.                     time = minEvent->time - framesOffset;

  1091. 

  1092.                     if (time >= frames)

  1093.                         continue;

  1094. 

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

  1096.                     uint8_t channel = status & 0x0F;

  1097. 

  1098.                     // Fix bad note-off

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

  1100.                         status -= 0x10;

  1101. 

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

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

  1104. 

  1105.                     midiEvent->port = i;

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

  1107. 

  1108.                     if (MIDI_IS_STATUS_NOTE_OFF(status))

  1109.                     {

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

  1111. 

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

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

  1114. 

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

  1116.                     }

  1117.                     else if (MIDI_IS_STATUS_NOTE_ON(status))

  1118.                     {

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

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

  1121. 

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

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

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

  1125. 

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

  1127.                     }

  1128.                     else if (MIDI_IS_STATUS_POLYPHONIC_AFTERTOUCH(status))

  1129.                     {

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

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

  1132. 

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

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

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

  1136.                     }

  1137.                     else if (MIDI_IS_STATUS_AFTERTOUCH(status))

  1138.                     {

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

  1140. 

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

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

  1143.                     }

  1144.                     else if (MIDI_IS_STATUS_PITCH_WHEEL_CONTROL(status))

  1145.                     {

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

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

  1148. 

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

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

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

  1152.                     }

  1153.                     else

  1154.                         continue;

  1155. 

  1156.                     midiEventCount += 1;

  1157.                 }

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

  1159. 

  1160.         } // End of MIDI Input

  1161. 

  1162.         CARLA_PROCESS_CONTINUE_CHECK;

  1163. 

  1164.         // --------------------------------------------------------------------------------------------------------

  1165.         // Plugin processing

  1166. 

  1167.         uint32_t midiEventCountBefore = midiEventCount;

  1168. 

  1169.         if (m_active)

  1170.         {

  1171.             if (! m_activeBefore)

  1172.             {

  1173.                 if (mIn.count > 0)

  1174.                 {

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

  1176.                     {

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

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

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

  1180. 

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

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

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

  1184.                     }

  1185. 

  1186.                     midiEventCount = MAX_MIDI_CHANNELS*2;

  1187.                 }

  1188. 

  1189.                 if (descriptor->activate)

  1190.                 {

  1191.                     descriptor->activate(handle);

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

  1193.                 }

  1194.             }

  1195. 

  1196.             isProcessing = true;

  1197. 

  1198.             if (h2)

  1199.             {

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

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

  1202.             }

  1203.             else

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

  1205. 

  1206.             isProcessing = false;

  1207.         }

  1208.         else

  1209.         {

  1210.             if (m_activeBefore)

  1211.             {

  1212.                 if (descriptor->deactivate)

  1213.                 {

  1214.                     descriptor->deactivate(handle);

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

  1216.                 }

  1217.             }

  1218.         }

  1219. 

  1220.         CARLA_PROCESS_CONTINUE_CHECK;

  1221. 

  1222.         // --------------------------------------------------------------------------------------------------------

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

  1224. 

  1225.         if (m_active)

  1226.         {

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

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

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

  1230. 

  1231.             double bal_rangeL, bal_rangeR;

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

  1233. 

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

  1235.             {

  1236.                 // Dry/Wet

  1237.                 if (do_drywet)

  1238.                 {

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

  1240.                     {

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

  1242. 

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

  1244.                     }

  1245.                 }

  1246. 

  1247.                 // Balance

  1248.                 if (do_balance)

  1249.                 {

  1250.                     if (i%2 == 0)

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

  1252. 

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

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

  1255. 

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

  1257.                     {

  1258.                         if (i%2 == 0)

  1259.                         {

  1260.                             // left output

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

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

  1263.                         }

  1264.                         else

  1265.                         {

  1266.                             // right

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

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

  1269.                         }

  1270.                     }

  1271.                 }

  1272. 

  1273.                 // Volume

  1274.                 if (do_volume)

  1275.                 {

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

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

  1278.                 }

  1279. 

  1280.                 // Output VU

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

  1282.                 {

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

  1284.                     {

  1285.                         if (std::abs(outBuffer[i][k]) > aOutsPeak[i])

  1286.                             aOutsPeak[i] = std::abs(outBuffer[i][k]);

  1287.                     }

  1288.                 }

  1289.             }

  1290.         }

  1291.         else

  1292.         {

  1293.             // disable any output sound if not active

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

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

  1296. 

  1297.             aOutsPeak[0] = 0.0;

  1298.             aOutsPeak[1] = 0.0;

  1299. 

  1300.         } // End of Post-processing

  1301. 

  1302.         CARLA_PROCESS_CONTINUE_CHECK;

  1303. 

  1304.         // --------------------------------------------------------------------------------------------------------

  1305.         // MIDI Output

  1306. 

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

  1308.         {

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

  1310. 

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

  1312.             {

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

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

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

  1316. 

  1317.                 // Fix bad note-off

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

  1319.                     data[0] -= 0x10;

  1320. 

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

  1322. 

  1323.                 if (port < mOut.count)

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

  1325.             }

  1326. 

  1327.         } // End of MIDI Output

  1328. 

  1329.         // --------------------------------------------------------------------------------------------------------

  1330.         // Control Output

  1331. 

  1332.         if (param.portCout && m_active)

  1333.         {

  1334.             double value, valueControl;

  1335. 

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

  1337.             {

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

  1339.                 {

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

  1341. 

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

  1343.                     {

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

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

  1346.                     }

  1347.                 }

  1348.             }

  1349.         } // End of Control Output

  1350. 

  1351.         CARLA_PROCESS_CONTINUE_CHECK;

  1352. 

  1353.         // --------------------------------------------------------------------------------------------------------

  1354.         // Peak Values

  1355. 

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

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

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

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

  1360. 

  1361.         m_activeBefore = m_active;

  1362.     }

  1363. 

  1364.     // -------------------------------------------------------------------

  1365.     // Cleanup

  1366. 

  1367.     void removeClientPorts()

  1368.     {

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

  1370. 

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

  1372.         {

  1373.             delete mIn.ports[i];

  1374.             mIn.ports[i] = nullptr;

  1375.         }

  1376. 

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

  1378.         {

  1379.             delete mOut.ports[i];

  1380.             mOut.ports[i] = nullptr;

  1381.         }

  1382. 

  1383.         CarlaPlugin::removeClientPorts();

  1384. 

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

  1386.     }

  1387. 

  1388.     void initBuffers()

  1389.     {

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

  1391.         {

  1392.             if (mIn.ports[i])

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

  1394.         }

  1395. 

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

  1397.         {

  1398.             if (mOut.ports[i])

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

  1400.         }

  1401. 

  1402.         CarlaPlugin::initBuffers();

  1403.     }

  1404. 

  1405.     void deleteBuffers()

  1406.     {

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

  1408. 

  1409.         if (mIn.count > 0)

  1410.         {

  1411.             delete[] mIn.ports;

  1412.             delete[] mIn.indexes;

  1413.         }

  1414. 

  1415.         if (mOut.count > 0)

  1416.         {

  1417.             delete[] mOut.ports;

  1418.             delete[] mOut.indexes;

  1419.         }

  1420. 

  1421.         mIn.count = 0;

  1422.         mIn.ports = nullptr;

  1423.         mIn.indexes = nullptr;

  1424. 

  1425.         mOut.count = 0;

  1426.         mOut.ports = nullptr;

  1427.         mOut.indexes = nullptr;

  1428. 

  1429.         CarlaPlugin::deleteBuffers();

  1430. 

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

  1432.     }

  1433. 

  1434.     // -------------------------------------------------------------------

  1435. #endif

  1436. 

  1437. protected:

  1438.     uint32_t handleGetBufferSize()

  1439.     {

  1440.         return kData->engine->getBufferSize();

  1441.     }

  1442. 

  1443.     double handleGetSampleRate()

  1444.     {

  1445.         return kData->engine->getSampleRate();

  1446.     }

  1447. 

  1448.     const TimeInfo* handleGetTimeInfo()

  1449.     {

  1450.         // TODO

  1451.         return nullptr;

  1452.     }

  1453. 

  1454.     bool handleWriteMidiEvent(const MidiEvent* const event)

  1455.     {

  1456.         CARLA_ASSERT(fEnabled);

  1457.         //CARLA_ASSERT(mOut.count > 0);

  1458.         CARLA_ASSERT(fIsProcessing);

  1459.         CARLA_ASSERT(event != nullptr);

  1460. 

  1461.         if (! fEnabled)

  1462.             return false;

  1463. 

  1464.         //if (mOut.count == 0)

  1465.         //    return false;

  1466. 

  1467.         if (! fIsProcessing)

  1468.         {

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

  1470.             return false;

  1471.         }

  1472. 

  1473.         //if (midiEventCount >= MAX_MIDI_EVENTS*2)

  1474.         //    return false;

  1475. 

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

  1477.         //midiEventCount += 1;

  1478. 

  1479.         return true;

  1480.     }

  1481. 

  1482.     void handleUiParameterChanged(const uint32_t index, const float value)

  1483.     {

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

  1485.     }

  1486. 

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

  1488.     {

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

  1490.     }

  1491. 

  1492.     void handleUiClosed()

  1493.     {

  1494.         kData->engine->callback(CALLBACK_SHOW_GUI, fId, 0, 0, 0.0f, nullptr);

  1495.     }

  1496. 

  1497. public:

  1498.     static size_t getPluginCount()

  1499.     {

  1500.         maybeFirstInit();

  1501.         return sPluginDescriptors.size();

  1502.     }

  1503. 

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

  1505.     {

  1506.         maybeFirstInit();

  1507.         CARLA_ASSERT(index < sPluginDescriptors.size());

  1508. 

  1509.         if (index < sPluginDescriptors.size())

  1510.             return sPluginDescriptors[index];

  1511. 

  1512.         return nullptr;

  1513.     }

  1514. 

  1515.     static void registerPlugin(const PluginDescriptor* desc)

  1516.     {

  1517.         sPluginDescriptors.push_back(desc);

  1518.     }

  1519. 

  1520.     static void maybeFirstInit()

  1521.     {

  1522.         if (! sFirstInit)

  1523.             return;

  1524. 

  1525.         sFirstInit = false;

  1526. 

  1527. #ifndef BUILD_BRIDGE

  1528.         carla_register_native_plugin_bypass();

  1529.         carla_register_native_plugin_midiSplit();

  1530.         carla_register_native_plugin_midiThrough();

  1531. 

  1532.         carla_register_native_plugin_3BandEQ();

  1533.         carla_register_native_plugin_3BandSplitter();

  1534.         carla_register_native_plugin_PingPongPan();

  1535. 

  1536. # ifdef WANT_ZYNADDSUBFX

  1537.         carla_register_native_plugin_zynaddsubfx();

  1538. # endif

  1539. #endif

  1540.     }

  1541. 

  1542.     // -------------------------------------------------------------------

  1543. 

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

  1545.     {

  1546.         CARLA_ASSERT(kData->engine != nullptr);

  1547.         CARLA_ASSERT(kData->client == nullptr);

  1548.         CARLA_ASSERT(label);

  1549. 

  1550.         // ---------------------------------------------------------------

  1551.         // initialize native-plugins descriptors

  1552. 

  1553.         maybeFirstInit();

  1554. 

  1555.         // ---------------------------------------------------------------

  1556.         // get descriptor that matches label

  1557. 

  1558.         for (size_t i=0; i < sPluginDescriptors.size(); i++)

  1559.         {

  1560.             fDescriptor = sPluginDescriptors[i];

  1561. 

  1562.             if (fDescriptor == nullptr)

  1563.                 break;

  1564.             if (fDescriptor->label != nullptr && std::strcmp(fDescriptor->label, label) == 0)

  1565.                 break;

  1566. 

  1567.             fDescriptor = nullptr;

  1568.         }

  1569. 

  1570.         if (fDescriptor == nullptr)

  1571.         {

  1572.             kData->engine->setLastError("Invalid internal plugin");

  1573.             return false;

  1574.         }

  1575. 

  1576.         // ---------------------------------------------------------------

  1577.         // get info

  1578. 

  1579.         if (name != nullptr)

  1580.             fName = kData->engine->getNewUniquePluginName(name);

  1581.         else if (fDescriptor->name != nullptr)

  1582.             fName = kData->engine->getNewUniquePluginName(fDescriptor->name);

  1583.         else

  1584.             fName = kData->engine->getNewUniquePluginName(fDescriptor->name);

  1585. 

  1586.         // ---------------------------------------------------------------

  1587.         // register client

  1588. 

  1589.         kData->client = kData->engine->addClient(this);

  1590. 

  1591.         if (kData->client == nullptr || ! kData->client->isOk())

  1592.         {

  1593.             kData->engine->setLastError("Failed to register plugin client");

  1594.             return false;

  1595.         }

  1596. 

  1597.         // ---------------------------------------------------------------

  1598.         // initialize plugin

  1599. 

  1600.         fHandle = fDescriptor->instantiate(fDescriptor, &fHost);

  1601. 

  1602.         if (fHandle == nullptr)

  1603.         {

  1604.             kData->engine->setLastError("Plugin failed to initialize");

  1605.             return false;

  1606.         }

  1607. 

  1608.         return true;

  1609.     }

  1610. 

  1611. private:

  1612.     PluginHandle   fHandle;

  1613.     PluginHandle   fHandle2;

  1614.     HostDescriptor fHost;

  1615.     const PluginDescriptor* fDescriptor;

  1616. 

  1617.     bool fIsProcessing;

  1618. 

  1619. #if 0

  1620.     NativePluginMidiData mIn;

  1621.     NativePluginMidiData mOut;

  1622. 

  1623.     uint32_t    midiEventCount;

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

  1625. #endif

  1626. 

  1627.     static bool sFirstInit;

  1628.     static std::vector<const PluginDescriptor*> sPluginDescriptors;

  1629. 

  1630.     // -------------------------------------------------------------------

  1631. 

  1632.     #define handlePtr ((NativePlugin*)handle)

  1633. 

  1634.     static uint32_t carla_host_get_buffer_size(HostHandle handle)

  1635.     {

  1636.         return handlePtr->handleGetBufferSize();

  1637.     }

  1638. 

  1639.     static double carla_host_get_sample_rate(HostHandle handle)

  1640.     {

  1641.         return handlePtr->handleGetSampleRate();

  1642.     }

  1643. 

  1644.     static const TimeInfo* carla_host_get_time_info(HostHandle handle)

  1645.     {

  1646.         return handlePtr->handleGetTimeInfo();

  1647.     }

  1648. 

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

  1650.     {

  1651.         return handlePtr->handleWriteMidiEvent(event);

  1652.     }

  1653. 

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

  1655.     {

  1656.         handlePtr->handleUiParameterChanged(index, value);

  1657.     }

  1658. 

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

  1660.     {

  1661.         handlePtr->handleUiCustomDataChanged(key, value);

  1662.     }

  1663. 

  1664.     static void carla_host_ui_closed(HostHandle handle)

  1665.     {

  1666.         handlePtr->handleUiClosed();

  1667.     }

  1668. 

  1669.     #undef handlePtr

  1670. };

  1671. 

  1672. bool NativePlugin::sFirstInit = true;

  1673. std::vector<const PluginDescriptor*> NativePlugin::sPluginDescriptors;

  1674. 

  1675. // -----------------------------------------------------------------------

  1676. 

  1677. size_t CarlaPlugin::getNativePluginCount()

  1678. {

  1679.     return NativePlugin::getPluginCount();

  1680. }

  1681. 

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

  1683. {

  1684.     return NativePlugin::getPlugin(index);

  1685. }

  1686. 

  1687. CarlaPlugin* CarlaPlugin::newNative(const Initializer& init)

  1688. {

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

  1690. 

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

  1692. 

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

  1694.     {

  1695.         delete plugin;

  1696.         return nullptr;

  1697.     }

  1698. 

  1699.     plugin->reload();

  1700. 

  1701.     if (init.engine->getProccessMode() == PROCESS_MODE_CONTINUOUS_RACK && (plugin->hints() & PLUGIN_CAN_FORCE_STEREO) == 0)

  1702.     {

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

  1704.         delete plugin;

  1705.         return nullptr;

  1706.     }

  1707. 

  1708.     plugin->registerToOscClient();

  1709. 

  1710.     return plugin;

  1711. }

  1712. 

  1713. // -----------------------------------------------------------------------

  1714. 

  1715. CARLA_BACKEND_END_NAMESPACE

  1716. 

  1717. void carla_register_native_plugin(const PluginDescriptor* desc)

  1718. {

  1719.     CARLA_BACKEND_USE_NAMESPACE

  1720.     NativePlugin::registerPlugin(desc);

  1721. }

  1722. 

  1723. // -----------------------------------------------------------------------