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.
778 Commits
16 Branches
260MB
Tree: 8d14a10cae
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '8d14a10cae'
${ noResults }
Carla/source/backend/plugin/NativePlugin.cpp

2564 lines
86KB
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 "CarlaPluginInternal.hpp"

  19. 

  20. #ifdef WANT_NATIVE

  21. 

  22. #include "CarlaNative.h"

  23. 

  24. #include <QtCore/Qt>

  25. 

  26. #if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))

  27. # include <QtWidgets/QFileDialog>

  28. #else

  29. # include <QtGui/QFileDialog>

  30. #endif

  31. 

  32. void carla_register_all_plugins()

  33. {

  34.     // Simple plugins

  35.     carla_register_native_plugin_bypass();

  36.     carla_register_native_plugin_lfo();

  37.     //carla_register_native_plugin_midiSequencer(); // unfinished

  38.     carla_register_native_plugin_midiSplit();

  39.     carla_register_native_plugin_midiThrough();

  40.     carla_register_native_plugin_midiTranspose();

  41.     carla_register_native_plugin_nekofilter();

  42.     //carla_register_native_plugin_sunvoxfile(); // unfinished

  43. 

  44. #ifndef BUILD_BRIDGE

  45.     // Carla

  46.     //carla_register_native_plugin_carla(); // kinda unfinished

  47. #endif

  48. 

  49. #ifdef WANT_AUDIOFILE

  50.     // AudioFile

  51.     carla_register_native_plugin_audiofile();

  52. #endif

  53. 

  54. #ifdef WANT_MIDIFILE

  55.     // MidiFile

  56.     carla_register_native_plugin_midifile();

  57. #endif

  58. 

  59. #ifdef WANT_OPENGL

  60.     // DISTRHO plugins (OpenGL)

  61.     carla_register_native_plugin_3BandEQ();

  62.     carla_register_native_plugin_3BandSplitter();

  63.     carla_register_native_plugin_Nekobi();

  64.     carla_register_native_plugin_PingPongPan();

  65.     //carla_register_native_plugin_StereoEnhancer(); // unfinished

  66. #endif

  67. 

  68.     // DISTRHO plugins (Qt)

  69.     //carla_register_native_plugin_Notes(); // unfinished

  70. 

  71. #ifdef WANT_ZYNADDSUBFX

  72.     // ZynAddSubFX

  73.     carla_register_native_plugin_zynaddsubfx();

  74. #endif

  75. }

  76. 

  77. CARLA_BACKEND_START_NAMESPACE

  78. 

  79. #if 0

  80. }

  81. #endif

  82. 

  83. struct NativePluginMidiData {

  84.     uint32_t  count;

  85.     uint32_t* indexes;

  86.     CarlaEngineEventPort** ports;

  87. 

  88.     NativePluginMidiData()

  89.         : count(0),

  90.           indexes(nullptr),

  91.           ports(nullptr) {}

  92. 

  93.     ~NativePluginMidiData()

  94.     {

  95.         CARLA_ASSERT_INT(count == 0, count);

  96.         CARLA_ASSERT(ports == nullptr);

  97.         CARLA_ASSERT(indexes == nullptr);

  98.     }

  99. 

  100.     void createNew(const uint32_t newCount)

  101.     {

  102.         CARLA_ASSERT_INT(count == 0, count);

  103.         CARLA_ASSERT(ports == nullptr);

  104.         CARLA_ASSERT(indexes == nullptr);

  105.         CARLA_ASSERT_INT(newCount > 0, newCount);

  106. 

  107.         if (ports != nullptr || indexes != nullptr || newCount == 0)

  108.             return;

  109. 

  110.         ports   = new CarlaEngineEventPort*[newCount];

  111.         indexes = new uint32_t[newCount];

  112.         count   = newCount;

  113. 

  114.         for (uint32_t i=0; i < newCount; ++i)

  115.             ports[i] = nullptr;

  116. 

  117.         for (uint32_t i=0; i < newCount; ++i)

  118.             indexes[i] = 0;

  119.     }

  120. 

  121.     void clear()

  122.     {

  123.         if (ports != nullptr)

  124.         {

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

  126.             {

  127.                 if (ports[i] != nullptr)

  128.                 {

  129.                     delete ports[i];

  130.                     ports[i] = nullptr;

  131.                 }

  132.             }

  133. 

  134.             delete[] ports;

  135.             ports = nullptr;

  136.         }

  137. 

  138.         if (indexes != nullptr)

  139.         {

  140.             delete[] indexes;

  141.             indexes = nullptr;

  142.         }

  143. 

  144.         count = 0;

  145.     }

  146. 

  147.     void initBuffers(CarlaEngine* const engine)

  148.     {

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

  150.         {

  151.             if (ports[i] != nullptr)

  152.                 ports[i]->initBuffer(engine);

  153.         }

  154.     }

  155. 

  156.     CARLA_DECLARE_NON_COPY_STRUCT_WITH_LEAK_DETECTOR(NativePluginMidiData)

  157. };

  158. 

  159. class NativePlugin : public CarlaPlugin

  160. {

  161. public:

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

  163.         : CarlaPlugin(engine, id),

  164.           fHandle(nullptr),

  165.           fHandle2(nullptr),

  166.           fDescriptor(nullptr),

  167.           fIsProcessing(false),

  168.           fIsUiVisible(false),

  169.           fAudioInBuffers(nullptr),

  170.           fAudioOutBuffers(nullptr),

  171. #ifdef CARLA_PROPER_CPP11_SUPPORT

  172.           fMidiEventCount(0),

  173.           fCurMidiProgs{0}

  174. #else

  175.           fMidiEventCount(0)

  176. #endif

  177.     {

  178.         carla_debug("NativePlugin::NativePlugin(%p, %i)", engine, id);

  179. 

  180. #ifndef CARLA_PROPER_CPP11_SUPPORT

  181.         carla_fill<int32_t>(fCurMidiProgs, MAX_MIDI_CHANNELS, 0);

  182. #endif

  183. 

  184.         carla_zeroStruct< ::MidiEvent>(fMidiEvents, MAX_MIDI_EVENTS*2);

  185. 

  186.         fHost.handle       = this;

  187.         fHost.resource_dir = carla_strdup((const char*)engine->getOptions().resourceDir);

  188.         fHost.ui_name      = nullptr;

  189. 

  190.         fHost.get_buffer_size        = carla_host_get_buffer_size;

  191.         fHost.get_sample_rate        = carla_host_get_sample_rate;

  192.         fHost.is_offline             = carla_host_is_offline;

  193.         fHost.get_time_info          = carla_host_get_time_info;

  194.         fHost.write_midi_event       = carla_host_write_midi_event;

  195.         fHost.ui_parameter_changed   = carla_host_ui_parameter_changed;

  196.         fHost.ui_custom_data_changed = carla_host_ui_custom_data_changed;

  197.         fHost.ui_closed              = carla_host_ui_closed;

  198.         fHost.ui_open_file           = carla_host_ui_open_file;

  199.         fHost.ui_save_file           = carla_host_ui_save_file;

  200.         fHost.dispatcher             = carla_host_dispatcher;

  201.     }

  202. 

  203.     ~NativePlugin() override

  204.     {

  205.         carla_debug("NativePlugin::~NativePlugin()");

  206. 

  207.         // close UI

  208.         if (fHints & PLUGIN_HAS_GUI)

  209.         {

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

  211.                 fDescriptor->ui_show(fHandle, false);

  212.         }

  213. 

  214.         kData->singleMutex.lock();

  215.         kData->masterMutex.lock();

  216. 

  217.         if (kData->client != nullptr && kData->client->isActive())

  218.             kData->client->deactivate();

  219. 

  220.         CARLA_ASSERT(! fIsProcessing);

  221. 

  222.         if (kData->active)

  223.         {

  224.             deactivate();

  225.             kData->active = false;

  226.         }

  227. 

  228.         if (fDescriptor != nullptr)

  229.         {

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

  231.             {

  232.                 if (fHandle != nullptr)

  233.                     fDescriptor->cleanup(fHandle);

  234.                 if (fHandle2 != nullptr)

  235.                     fDescriptor->cleanup(fHandle2);

  236.             }

  237. 

  238.             fHandle  = nullptr;

  239.             fHandle2 = nullptr;

  240.             fDescriptor = nullptr;

  241.         }

  242. 

  243.         if (fHost.resource_dir != nullptr)

  244.         {

  245.             delete[] fHost.resource_dir;

  246.             fHost.resource_dir = nullptr;

  247.         }

  248. 

  249.         if (fHost.ui_name != nullptr)

  250.         {

  251.             delete[] fHost.ui_name;

  252.             fHost.ui_name = nullptr;

  253.         }

  254. 

  255.         clearBuffers();

  256.     }

  257. 

  258.     // -------------------------------------------------------------------

  259.     // Information (base)

  260. 

  261.     PluginType type() const override

  262.     {

  263.         return PLUGIN_INTERNAL;

  264.     }

  265. 

  266.     PluginCategory category() override

  267.     {

  268.         CARLA_ASSERT(fDescriptor != nullptr);

  269. 

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

  271.     }

  272. 

  273.     // -------------------------------------------------------------------

  274.     // Information (count)

  275. 

  276.     uint32_t midiInCount() const override

  277.     {

  278.         return fMidiIn.count;

  279.     }

  280. 

  281.     uint32_t midiOutCount() const override

  282.     {

  283.         return fMidiOut.count;

  284.     }

  285. 

  286.     uint32_t parameterScalePointCount(const uint32_t parameterId) const override

  287.     {

  288.         CARLA_ASSERT(fDescriptor != nullptr);

  289.         CARLA_ASSERT(fHandle != nullptr);

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

  291. 

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

  293.         {

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

  295.                 return param->scalePointCount;

  296.         }

  297. 

  298.         return 0;

  299.     }

  300. 

  301.     // -------------------------------------------------------------------

  302.     // Information (current data)

  303. 

  304.     // nothing

  305. 

  306.     // -------------------------------------------------------------------

  307.     // Information (per-plugin data)

  308. 

  309.     unsigned int availableOptions() override

  310.     {

  311.         CARLA_ASSERT(fDescriptor != nullptr);

  312. 

  313.         if (fDescriptor == nullptr)

  314.             return 0x0;

  315. 

  316.         const bool hasMidiProgs(fDescriptor->get_midi_program_count != nullptr && fDescriptor->get_midi_program_count(fHandle) > 0);

  317. 

  318.         unsigned int options = 0x0;

  319. 

  320.         if (hasMidiProgs && (fDescriptor->supports & ::PLUGIN_SUPPORTS_PROGRAM_CHANGES) == 0)

  321.             options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  322. 

  323.         if (midiInCount() == 0 && (fDescriptor->hints & ::PLUGIN_USES_STATIC_BUFFERS) == 0)

  324.             options |= PLUGIN_OPTION_FIXED_BUFFER;

  325. 

  326.         if (kData->engine->getProccessMode() != PROCESS_MODE_CONTINUOUS_RACK)

  327.         {

  328.             if (fOptions & PLUGIN_OPTION_FORCE_STEREO)

  329.                 options |= PLUGIN_OPTION_FORCE_STEREO;

  330.             else if (kData->audioIn.count <= 1 && kData->audioOut.count <= 1 && (kData->audioIn.count != 0 || kData->audioOut.count != 0))

  331.                 options |= PLUGIN_OPTION_FORCE_STEREO;

  332.         }

  333. 

  334.         if (fDescriptor->supports & ::PLUGIN_SUPPORTS_CONTROL_CHANGES)

  335.             options |= PLUGIN_OPTION_SEND_CONTROL_CHANGES;

  336.         if (fDescriptor->supports & ::PLUGIN_SUPPORTS_CHANNEL_PRESSURE)

  337.             options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  338.         if (fDescriptor->supports & ::PLUGIN_SUPPORTS_NOTE_AFTERTOUCH)

  339.             options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

  340.         if (fDescriptor->supports & ::PLUGIN_SUPPORTS_PITCHBEND)

  341.             options |= PLUGIN_OPTION_SEND_PITCHBEND;

  342.         if (fDescriptor->supports & ::PLUGIN_SUPPORTS_ALL_SOUND_OFF)

  343.             options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  344. 

  345.         return options;

  346.     }

  347. 

  348.     float getParameterValue(const uint32_t parameterId) override

  349.     {

  350.         CARLA_ASSERT(fDescriptor != nullptr);

  351.         CARLA_ASSERT(fHandle != nullptr);

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

  353. 

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

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

  356. 

  357.         return 0.0f;

  358.     }

  359. 

  360.     float getParameterScalePointValue(const uint32_t parameterId, const uint32_t scalePointId) override

  361.     {

  362.         CARLA_ASSERT(fDescriptor != nullptr);

  363.         CARLA_ASSERT(fHandle != nullptr);

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

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

  366. 

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

  368.         {

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

  370.             {

  371.                 const ParameterScalePoint& scalePoint(param->scalePoints[scalePointId]);

  372.                 return scalePoint.value;

  373.             }

  374.         }

  375. 

  376.         return 0.0f;

  377.     }

  378. 

  379.     void getLabel(char* const strBuf) override

  380.     {

  381.         CARLA_ASSERT(fDescriptor != nullptr);

  382. 

  383.         if (fDescriptor->label != nullptr)

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

  385.         else

  386.             CarlaPlugin::getLabel(strBuf);

  387.     }

  388. 

  389.     void getMaker(char* const strBuf) override

  390.     {

  391.         CARLA_ASSERT(fDescriptor != nullptr);

  392. 

  393.         if (fDescriptor->maker != nullptr)

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

  395.         else

  396.             CarlaPlugin::getMaker(strBuf);

  397.     }

  398. 

  399.     void getCopyright(char* const strBuf) override

  400.     {

  401.         CARLA_ASSERT(fDescriptor != nullptr);

  402. 

  403.         if (fDescriptor->copyright != nullptr)

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

  405.         else

  406.             CarlaPlugin::getCopyright(strBuf);

  407.     }

  408. 

  409.     void getRealName(char* const strBuf) override

  410.     {

  411.         CARLA_ASSERT(fDescriptor != nullptr);

  412. 

  413.         if (fDescriptor->name != nullptr)

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

  415.         else

  416.             CarlaPlugin::getRealName(strBuf);

  417.     }

  418. 

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

  420.     {

  421.         CARLA_ASSERT(fDescriptor != nullptr);

  422.         CARLA_ASSERT(fHandle != nullptr);

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

  424. 

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

  426.         {

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

  428. 

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

  430.             {

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

  432.                 return;

  433.             }

  434.         }

  435. 

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

  437.     }

  438. 

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

  440.     {

  441.         CARLA_ASSERT(fDescriptor != nullptr);

  442.         CARLA_ASSERT(fHandle != nullptr);

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

  444. 

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

  446.         {

  447.             const float value(fDescriptor->get_parameter_value(fHandle, parameterId));

  448. 

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

  450.             {

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

  452.                 return;

  453.             }

  454.         }

  455. 

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

  457.     }

  458. 

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

  460.     {

  461.         CARLA_ASSERT(fDescriptor != nullptr);

  462.         CARLA_ASSERT(fHandle != nullptr);

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

  464. 

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

  466.         {

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

  468. 

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

  470.             {

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

  472.                 return;

  473.             }

  474.         }

  475. 

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

  477.     }

  478. 

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

  480.     {

  481.         CARLA_ASSERT(fDescriptor != nullptr);

  482.         CARLA_ASSERT(fHandle != nullptr);

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

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

  485. 

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

  487.         {

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

  489.             {

  490.                 const ParameterScalePoint& scalePoint(param->scalePoints[scalePointId]);

  491. 

  492.                 if (scalePoint.label != nullptr)

  493.                 {

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

  495.                     return;

  496.                 }

  497.             }

  498.         }

  499. 

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

  501.     }

  502. 

  503.     // -------------------------------------------------------------------

  504.     // Set data (state)

  505. 

  506.     void prepareForSave() override

  507.     {

  508.         CARLA_ASSERT(fDescriptor != nullptr);

  509.         CARLA_ASSERT(fHandle != nullptr);

  510. 

  511.         if (kData->midiprog.count > 0 && (fHints & PLUGIN_IS_SYNTH) != 0)

  512.         {

  513.             char strBuf[STR_MAX+1];

  514.             std::snprintf(strBuf, STR_MAX, "%i:%i:%i:%i:%i:%i:%i:%i:%i:%i:%i:%i:%i:%i:%i:%i",

  515.                           fCurMidiProgs[0],  fCurMidiProgs[1],  fCurMidiProgs[2],  fCurMidiProgs[3],

  516.                           fCurMidiProgs[4],  fCurMidiProgs[5],  fCurMidiProgs[6],  fCurMidiProgs[7],

  517.                           fCurMidiProgs[8],  fCurMidiProgs[9],  fCurMidiProgs[10], fCurMidiProgs[11],

  518.                           fCurMidiProgs[12], fCurMidiProgs[13], fCurMidiProgs[14], fCurMidiProgs[15]);

  519.             strBuf[STR_MAX] = '\0';

  520. 

  521.             CarlaPlugin::setCustomData(CUSTOM_DATA_STRING, "midiPrograms", strBuf, false);

  522.         }

  523. 

  524.         if (fDescriptor == nullptr || fDescriptor->get_state == nullptr || (fDescriptor->hints & ::PLUGIN_USES_STATE) == 0)

  525.             return;

  526. 

  527.         if (char* data = fDescriptor->get_state(fHandle))

  528.         {

  529.             CarlaPlugin::setCustomData(CUSTOM_DATA_CHUNK, "State", data, false);

  530.             std::free(data);

  531.         }

  532.     }

  533. 

  534.     // -------------------------------------------------------------------

  535.     // Set data (internal stuff)

  536. 

  537.     void setName(const char* const newName) override

  538.     {

  539.         CARLA_ASSERT(fDescriptor != nullptr);

  540.         CARLA_ASSERT(fHandle != nullptr);

  541. 

  542.         char uiName[std::strlen(newName)+6+1];

  543.         std::strcpy(uiName, newName);

  544.         std::strcat(uiName, " (GUI)");

  545. 

  546.         if (fHost.ui_name != nullptr)

  547.             delete[] fHost.ui_name;

  548.         fHost.ui_name = carla_strdup(uiName);

  549. 

  550.         if (fDescriptor != nullptr && fDescriptor->dispatcher != nullptr)

  551.             fDescriptor->dispatcher(fHandle, PLUGIN_OPCODE_UI_NAME_CHANGED, 0, 0, uiName, 0.0f);

  552. 

  553.         CarlaPlugin::setName(newName);

  554.     }

  555. 

  556.     void setCtrlChannel(const int8_t channel, const bool sendOsc, const bool sendCallback) override

  557.     {

  558.         if (channel < MAX_MIDI_CHANNELS && kData->midiprog.count > 0)

  559.             kData->midiprog.current = fCurMidiProgs[channel];

  560. 

  561.         CarlaPlugin::setCtrlChannel(channel, sendOsc, sendCallback);

  562.     }

  563. 

  564.     // -------------------------------------------------------------------

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

  566. 

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

  568.     {

  569.         CARLA_ASSERT(fDescriptor != nullptr);

  570.         CARLA_ASSERT(fHandle != nullptr);

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

  572. 

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

  574. 

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

  576.         {

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

  578. 

  579.             if (fHandle2 != nullptr)

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

  581.         }

  582. 

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

  584.     }

  585. 

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

  587.     {

  588.         CARLA_ASSERT(fDescriptor != nullptr);

  589.         CARLA_ASSERT(fHandle != nullptr);

  590.         CARLA_ASSERT(type != nullptr);

  591.         CARLA_ASSERT(key != nullptr);

  592.         CARLA_ASSERT(value != nullptr);

  593.         carla_debug("NativePlugin::setCustomData(%s, %s, %s, %s)", type, key, value, bool2str(sendGui));

  594. 

  595.         if (type == nullptr)

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

  597. 

  598.         if (std::strcmp(type, CUSTOM_DATA_STRING) != 0 && std::strcmp(type, CUSTOM_DATA_CHUNK) != 0)

  599.             return carla_stderr2("NativePlugin::setCustomData(\"%s\", \"%s\", \"%s\", %s) - type is invalid", type, key, value, bool2str(sendGui));

  600. 

  601.         if (key == nullptr)

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

  603. 

  604.         if (value == nullptr)

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

  606. 

  607.         if (std::strcmp(type, CUSTOM_DATA_CHUNK) == 0)

  608.         {

  609.             if (fDescriptor->set_state != nullptr && (fDescriptor->hints & ::PLUGIN_USES_STATE) != 0)

  610.             {

  611.                 const ScopedSingleProcessLocker spl(this, true);

  612. 

  613.                 fDescriptor->set_state(fHandle, value);

  614. 

  615.                 if (fHandle2 != nullptr)

  616.                     fDescriptor->set_state(fHandle2, value);

  617.             }

  618.         }

  619.         else if (std::strcmp(key, "midiPrograms") == 0 && fDescriptor->set_midi_program != nullptr)

  620.         {

  621.             QStringList midiProgramList(QString(value).split(":", QString::SkipEmptyParts));

  622. 

  623.             if (midiProgramList.count() == MAX_MIDI_CHANNELS)

  624.             {

  625.                 uint i = 0;

  626.                 foreach (const QString& midiProg, midiProgramList)

  627.                 {

  628.                     bool ok;

  629.                     const uint index(midiProg.toUInt(&ok));

  630. 

  631.                     if (ok && index < kData->midiprog.count)

  632.                     {

  633.                         const uint32_t bank    = kData->midiprog.data[index].bank;

  634.                         const uint32_t program = kData->midiprog.data[index].program;

  635. 

  636.                         fDescriptor->set_midi_program(fHandle, i, bank, program);

  637. 

  638.                         if (fHandle2 != nullptr)

  639.                             fDescriptor->set_midi_program(fHandle2, i, bank, program);

  640. 

  641.                         fCurMidiProgs[i] = index;

  642. 

  643.                         if (kData->ctrlChannel == static_cast<int32_t>(i))

  644.                         {

  645.                             kData->midiprog.current = index;

  646.                             kData->engine->callback(CALLBACK_MIDI_PROGRAM_CHANGED, fId, index, 0, 0.0f, nullptr);

  647.                         }

  648.                     }

  649. 

  650.                     ++i;

  651.                 }

  652.             }

  653.         }

  654.         else

  655.         {

  656.             if (fDescriptor->set_custom_data != nullptr)

  657.             {

  658.                 fDescriptor->set_custom_data(fHandle, key, value);

  659. 

  660.                 if (fHandle2 != nullptr)

  661.                     fDescriptor->set_custom_data(fHandle2, key, value);

  662.             }

  663. 

  664.             if (sendGui && fIsUiVisible && fDescriptor->ui_set_custom_data != nullptr)

  665.                 fDescriptor->ui_set_custom_data(fHandle, key, value);

  666.         }

  667. 

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

  669.     }

  670. 

  671.     void setMidiProgram(int32_t index, const bool sendGui, const bool sendOsc, const bool sendCallback) override

  672.     {

  673.         CARLA_ASSERT(fDescriptor != nullptr);

  674.         CARLA_ASSERT(fHandle != nullptr);

  675.         CARLA_ASSERT(index >= -1 && index < static_cast<int32_t>(kData->midiprog.count));

  676. 

  677.         if (index < -1)

  678.             index = -1;

  679.         else if (index > static_cast<int32_t>(kData->midiprog.count))

  680.             return;

  681. 

  682.         if ((fHints & PLUGIN_IS_SYNTH) != 0 && (kData->ctrlChannel < 0 || kData->ctrlChannel >= MAX_MIDI_CHANNELS))

  683.             return;

  684. 

  685.         if (index >= 0)

  686.         {

  687.             const uint8_t  channel = (kData->ctrlChannel >= 0 || kData->ctrlChannel < MAX_MIDI_CHANNELS) ? kData->ctrlChannel : 0;

  688.             const uint32_t bank    = kData->midiprog.data[index].bank;

  689.             const uint32_t program = kData->midiprog.data[index].program;

  690. 

  691.             const ScopedSingleProcessLocker spl(this, (sendGui || sendOsc || sendCallback));

  692. 

  693.             fDescriptor->set_midi_program(fHandle, channel, bank, program);

  694. 

  695.             if (fHandle2 != nullptr)

  696.                 fDescriptor->set_midi_program(fHandle2, channel, bank, program);

  697. 

  698.             fCurMidiProgs[channel] = index;

  699.         }

  700. 

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

  702.     }

  703. 

  704.     // -------------------------------------------------------------------

  705.     // Set gui stuff

  706. 

  707.     void showGui(const bool yesNo) override

  708.     {

  709.         CARLA_ASSERT(fDescriptor != nullptr);

  710.         CARLA_ASSERT(fHandle != nullptr);

  711. 

  712.         if (fDescriptor->ui_show == nullptr)

  713.             return;

  714. 

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

  716.         fIsUiVisible = yesNo;

  717. 

  718.         if (! yesNo)

  719.             return;

  720. 

  721.         if (fDescriptor->ui_set_custom_data != nullptr)

  722.         {

  723.             for (NonRtList<CustomData>::Itenerator it = kData->custom.begin(); it.valid(); it.next())

  724.             {

  725.                 const CustomData& cData(*it);

  726. 

  727.                 if (std::strcmp(cData.type, CUSTOM_DATA_STRING) == 0 && std::strcmp(cData.key, "midiPrograms") != 0)

  728.                     fDescriptor->ui_set_custom_data(fHandle, cData.key, cData.value);

  729.             }

  730.         }

  731. 

  732.         if (fDescriptor->ui_set_midi_program != nullptr && kData->midiprog.current >= 0 && kData->midiprog.count > 0)

  733.         {

  734.             const uint32_t index   = kData->midiprog.current;

  735.             const uint8_t  channel = (kData->ctrlChannel >= 0 || kData->ctrlChannel < MAX_MIDI_CHANNELS) ? kData->ctrlChannel : 0;

  736.             const uint32_t bank    = kData->midiprog.data[index].bank;

  737.             const uint32_t program = kData->midiprog.data[index].program;

  738. 

  739.             fDescriptor->ui_set_midi_program(fHandle, channel, bank, program);

  740.         }

  741. 

  742.         if (fDescriptor->ui_set_parameter_value != nullptr)

  743.         {

  744.             for (uint32_t i=0; i < kData->param.count; ++i)

  745.                 fDescriptor->ui_set_parameter_value(fHandle, i, fDescriptor->get_parameter_value(fHandle, i));

  746.         }

  747.     }

  748. 

  749.     void idleGui() override

  750.     {

  751.         CARLA_ASSERT(fDescriptor != nullptr);

  752.         CARLA_ASSERT(fHandle != nullptr);

  753. 

  754.         if (fIsUiVisible && fDescriptor->ui_idle != nullptr)

  755.             fDescriptor->ui_idle(fHandle);

  756.     }

  757. 

  758.     // -------------------------------------------------------------------

  759.     // Plugin state

  760. 

  761.     void reload() override

  762.     {

  763.         carla_debug("NativePlugin::reload() - start");

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

  765.         CARLA_ASSERT(fDescriptor != nullptr);

  766.         CARLA_ASSERT(fHandle != nullptr);

  767. 

  768.         if (kData->engine == nullptr)

  769.             return;

  770.         if (fDescriptor == nullptr)

  771.             return;

  772.         if (fHandle == nullptr)

  773.             return;

  774. 

  775.         const ProcessMode processMode(kData->engine->getProccessMode());

  776. 

  777.         // Safely disable plugin for reload

  778.         const ScopedDisabler sd(this);

  779. 

  780.         if (kData->active)

  781.             deactivate();

  782. 

  783.         clearBuffers();

  784. 

  785.         const float sampleRate((float)kData->engine->getSampleRate());

  786. 

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

  788. 

  789.         bool forcedStereoIn, forcedStereoOut;

  790.         forcedStereoIn = forcedStereoOut = false;

  791. 

  792.         bool needsCtrlIn, needsCtrlOut;

  793.         needsCtrlIn = needsCtrlOut = false;

  794. 

  795.         aIns   = fDescriptor->audioIns;

  796.         aOuts  = fDescriptor->audioOuts;

  797.         mIns   = fDescriptor->midiIns;

  798.         mOuts  = fDescriptor->midiOuts;

  799.         params = (fDescriptor->get_parameter_count != nullptr && fDescriptor->get_parameter_info != nullptr) ? fDescriptor->get_parameter_count(fHandle) : 0;

  800. 

  801.         if ((fOptions & PLUGIN_OPTION_FORCE_STEREO) != 0 && (aIns == 1 || aOuts == 1) && mIns <= 1 && mOuts <= 1)

  802.         {

  803.             if (fHandle2 == nullptr)

  804.                 fHandle2 = fDescriptor->instantiate(fDescriptor, &fHost);

  805. 

  806.             if (fHandle2 != nullptr)

  807.             {

  808.                 if (aIns == 1)

  809.                 {

  810.                     aIns = 2;

  811.                     forcedStereoIn = true;

  812.                 }

  813. 

  814.                 if (aOuts == 1)

  815.                 {

  816.                     aOuts = 2;

  817.                     forcedStereoOut = true;

  818.                 }

  819.             }

  820.         }

  821. 

  822.         if (aIns > 0)

  823.         {

  824.             kData->audioIn.createNew(aIns);

  825.             fAudioInBuffers = new float*[aIns];

  826. 

  827.             for (uint32_t i=0; i < aIns; ++i)

  828.                 fAudioInBuffers[i] = nullptr;

  829.         }

  830. 

  831.         if (aOuts > 0)

  832.         {

  833.             kData->audioOut.createNew(aOuts);

  834.             fAudioOutBuffers = new float*[aOuts];

  835.             needsCtrlIn = true;

  836. 

  837.             for (uint32_t i=0; i < aOuts; ++i)

  838.                 fAudioOutBuffers[i] = nullptr;

  839.         }

  840. 

  841.         if (mIns > 0)

  842.         {

  843.             fMidiIn.createNew(mIns);

  844.             needsCtrlIn = (mIns == 1);

  845.         }

  846. 

  847.         if (mOuts > 0)

  848.         {

  849.             fMidiOut.createNew(mOuts);

  850.             needsCtrlOut = (mOuts == 1);

  851.         }

  852. 

  853.         if (params > 0)

  854.         {

  855.             kData->param.createNew(params);

  856.         }

  857. 

  858.         const uint portNameSize(kData->engine->maxPortNameSize());

  859.         CarlaString portName;

  860. 

  861.         // Audio Ins

  862.         for (j=0; j < aIns; ++j)

  863.         {

  864.             portName.clear();

  865. 

  866.             if (processMode == PROCESS_MODE_SINGLE_CLIENT)

  867.             {

  868.                 portName  = fName;

  869.                 portName += ":";

  870.             }

  871. 

  872.             if (aIns > 1 && ! forcedStereoIn)

  873.             {

  874.                 portName += "input_";

  875.                 portName += CarlaString(j+1);

  876.             }

  877.             else

  878.                 portName += "input";

  879. 

  880.             portName.truncate(portNameSize);

  881. 

  882.             kData->audioIn.ports[j].port   = (CarlaEngineAudioPort*)kData->client->addPort(kEnginePortTypeAudio, portName, true);

  883.             kData->audioIn.ports[j].rindex = j;

  884. 

  885.             if (forcedStereoIn)

  886.             {

  887.                 portName += "_2";

  888.                 kData->audioIn.ports[1].port   = (CarlaEngineAudioPort*)kData->client->addPort(kEnginePortTypeAudio, portName, true);

  889.                 kData->audioIn.ports[1].rindex = j;

  890.                 break;

  891.             }

  892.         }

  893. 

  894.         // Audio Outs

  895.         for (j=0; j < aOuts; ++j)

  896.         {

  897.             portName.clear();

  898. 

  899.             if (processMode == PROCESS_MODE_SINGLE_CLIENT)

  900.             {

  901.                 portName  = fName;

  902.                 portName += ":";

  903.             }

  904. 

  905.             if (aOuts > 1 && ! forcedStereoOut)

  906.             {

  907.                 portName += "output_";

  908.                 portName += CarlaString(j+1);

  909.             }

  910.             else

  911.                 portName += "output";

  912. 

  913.             portName.truncate(portNameSize);

  914. 

  915.             kData->audioOut.ports[j].port   = (CarlaEngineAudioPort*)kData->client->addPort(kEnginePortTypeAudio, portName, false);

  916.             kData->audioOut.ports[j].rindex = j;

  917. 

  918.             if (forcedStereoOut)

  919.             {

  920.                 portName += "_2";

  921.                 kData->audioOut.ports[1].port   = (CarlaEngineAudioPort*)kData->client->addPort(kEnginePortTypeAudio, portName, false);

  922.                 kData->audioOut.ports[1].rindex = j;

  923.                 break;

  924.             }

  925.         }

  926. 

  927.         // MIDI Input (only if multiple)

  928.         if (mIns > 1)

  929.         {

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

  931.             {

  932.                 portName.clear();

  933. 

  934.                 if (processMode == PROCESS_MODE_SINGLE_CLIENT)

  935.                 {

  936.                     portName  = fName;

  937.                     portName += ":";

  938.                 }

  939. 

  940.                 portName += "midi-in_";

  941.                 portName += CarlaString(j+1);

  942.                 portName.truncate(portNameSize);

  943. 

  944.                 fMidiIn.ports[j]   = (CarlaEngineEventPort*)kData->client->addPort(kEnginePortTypeEvent, portName, true);

  945.                 fMidiIn.indexes[j] = j;

  946.             }

  947.         }

  948. 

  949.         // MIDI Output (only if multiple)

  950.         if (mOuts > 1)

  951.         {

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

  953.             {

  954.                 portName.clear();

  955. 

  956.                 if (processMode == PROCESS_MODE_SINGLE_CLIENT)

  957.                 {

  958.                     portName  = fName;

  959.                     portName += ":";

  960.                 }

  961. 

  962.                 portName += "midi-out_";

  963.                 portName += CarlaString(j+1);

  964.                 portName.truncate(portNameSize);

  965. 

  966.                 fMidiOut.ports[j]   = (CarlaEngineEventPort*)kData->client->addPort(kEnginePortTypeEvent, portName, false);

  967.                 fMidiOut.indexes[j] = j;

  968.             }

  969.         }

  970. 

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

  972.         {

  973.             const ::Parameter* const paramInfo(fDescriptor->get_parameter_info(fHandle, j));

  974. 

  975.             CARLA_ASSERT(paramInfo != nullptr);

  976. 

  977.             if (paramInfo == nullptr)

  978.                 continue;

  979. 

  980.             kData->param.data[j].index  = j;

  981.             kData->param.data[j].rindex = j;

  982.             kData->param.data[j].hints  = 0x0;

  983.             kData->param.data[j].midiChannel = 0;

  984.             kData->param.data[j].midiCC = -1;

  985. 

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

  987. 

  988.             // min value

  989.             min = paramInfo->ranges.min;

  990. 

  991.             // max value

  992.             max = paramInfo->ranges.max;

  993. 

  994.             if (min > max)

  995.                 max = min;

  996.             else if (max < min)

  997.                 min = max;

  998. 

  999.             if (max - min == 0.0f)

  1000.             {

  1001.                 carla_stderr2("WARNING - Broken plugin parameter '%s': max - min == 0.0f", paramInfo->name);

  1002.                 max = min + 0.1f;

  1003.             }

  1004. 

  1005.             // default value

  1006.             def = paramInfo->ranges.def;

  1007. 

  1008.             if (def < min)

  1009.                 def = min;

  1010.             else if (def > max)

  1011.                 def = max;

  1012. 

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

  1014.             {

  1015.                 min *= sampleRate;

  1016.                 max *= sampleRate;

  1017.                 def *= sampleRate;

  1018.                 kData->param.data[j].hints |= PARAMETER_USES_SAMPLERATE;

  1019.             }

  1020. 

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

  1022.             {

  1023.                 step = max - min;

  1024.                 stepSmall = step;

  1025.                 stepLarge = step;

  1026.                 kData->param.data[j].hints |= PARAMETER_IS_BOOLEAN;

  1027.             }

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

  1029.             {

  1030.                 step = 1.0f;

  1031.                 stepSmall = 1.0f;

  1032.                 stepLarge = 10.0f;

  1033.                 kData->param.data[j].hints |= PARAMETER_IS_INTEGER;

  1034.             }

  1035.             else

  1036.             {

  1037.                 float range = max - min;

  1038.                 step = range/100.0f;

  1039.                 stepSmall = range/1000.0f;

  1040.                 stepLarge = range/10.0f;

  1041.             }

  1042. 

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

  1044.             {

  1045.                 kData->param.data[j].type = PARAMETER_OUTPUT;

  1046.                 needsCtrlOut = true;

  1047.             }

  1048.             else

  1049.             {

  1050.                 kData->param.data[j].type = PARAMETER_INPUT;

  1051.                 needsCtrlIn = true;

  1052.             }

  1053. 

  1054.             // extra parameter hints

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

  1056.                 kData->param.data[j].hints |= PARAMETER_IS_ENABLED;

  1057. 

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

  1059.                 kData->param.data[j].hints |= PARAMETER_IS_AUTOMABLE;

  1060. 

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

  1062.                 kData->param.data[j].hints |= PARAMETER_IS_LOGARITHMIC;

  1063. 

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

  1065.                 kData->param.data[j].hints |= PARAMETER_USES_SCALEPOINTS;

  1066. 

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

  1068.                 kData->param.data[j].hints |= PARAMETER_USES_CUSTOM_TEXT;

  1069. 

  1070.             kData->param.ranges[j].min = min;

  1071.             kData->param.ranges[j].max = max;

  1072.             kData->param.ranges[j].def = def;

  1073.             kData->param.ranges[j].step = step;

  1074.             kData->param.ranges[j].stepSmall = stepSmall;

  1075.             kData->param.ranges[j].stepLarge = stepLarge;

  1076.         }

  1077. 

  1078.         if (needsCtrlIn)

  1079.         {

  1080.             portName.clear();

  1081. 

  1082.             if (processMode == PROCESS_MODE_SINGLE_CLIENT)

  1083.             {

  1084.                 portName  = fName;

  1085.                 portName += ":";

  1086.             }

  1087. 

  1088.             portName += "events-in";

  1089.             portName.truncate(portNameSize);

  1090. 

  1091.             kData->event.portIn = (CarlaEngineEventPort*)kData->client->addPort(kEnginePortTypeEvent, portName, true);

  1092.         }

  1093. 

  1094.         if (needsCtrlOut)

  1095.         {

  1096.             portName.clear();

  1097. 

  1098.             if (processMode == PROCESS_MODE_SINGLE_CLIENT)

  1099.             {

  1100.                 portName  = fName;

  1101.                 portName += ":";

  1102.             }

  1103. 

  1104.             portName += "events-out";

  1105.             portName.truncate(portNameSize);

  1106. 

  1107.             kData->event.portOut = (CarlaEngineEventPort*)kData->client->addPort(kEnginePortTypeEvent, portName, false);

  1108.         }

  1109. 

  1110.         if (forcedStereoIn || forcedStereoOut)

  1111.             fOptions |= PLUGIN_OPTION_FORCE_STEREO;

  1112.         else

  1113.             fOptions &= ~PLUGIN_OPTION_FORCE_STEREO;

  1114. 

  1115.         // plugin hints

  1116.         fHints = 0x0;

  1117. 

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

  1119.             fHints |= PLUGIN_CAN_DRYWET;

  1120. 

  1121.         if (aOuts > 0)

  1122.             fHints |= PLUGIN_CAN_VOLUME;

  1123. 

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

  1125.             fHints |= PLUGIN_CAN_BALANCE;

  1126. 

  1127.         // native plugin hints

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

  1129.             fHints |= PLUGIN_IS_RTSAFE;

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

  1131.             fHints |= PLUGIN_IS_SYNTH;

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

  1133.             fHints |= PLUGIN_HAS_GUI;

  1134.         if (fDescriptor->hints & ::PLUGIN_USES_GUI_AS_FILE)

  1135.             fHints |= PLUGIN_HAS_GUI_AS_FILE;

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

  1137.             fHints |= PLUGIN_HAS_SINGLE_THREAD;

  1138. 

  1139.         // extra plugin hints

  1140.         kData->extraHints = 0x0;

  1141. 

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

  1143.             kData->extraHints |= PLUGIN_HINT_CAN_RUN_RACK;

  1144. 

  1145.         bufferSizeChanged(kData->engine->getBufferSize());

  1146.         reloadPrograms(true);

  1147. 

  1148.         if (kData->active)

  1149.             activate();

  1150. 

  1151.         carla_debug("NativePlugin::reload() - end");

  1152.     }

  1153. 

  1154.     void reloadPrograms(const bool init) override

  1155.     {

  1156.         carla_debug("NativePlugin::reloadPrograms(%s)", bool2str(init));

  1157.         uint32_t i, oldCount  = kData->midiprog.count;

  1158.         const int32_t current = kData->midiprog.current;

  1159. 

  1160.         // Delete old programs

  1161.         kData->midiprog.clear();

  1162. 

  1163.         // Query new programs

  1164.         uint32_t count = 0;

  1165.         if (fDescriptor->get_midi_program_count != nullptr && fDescriptor->get_midi_program_info != nullptr && fDescriptor->set_midi_program != nullptr)

  1166.             count = fDescriptor->get_midi_program_count(fHandle);

  1167. 

  1168.         if (count > 0)

  1169.         {

  1170.             kData->midiprog.createNew(count);

  1171. 

  1172.             // Update data

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

  1174.             {

  1175.                 const ::MidiProgram* const mpDesc = fDescriptor->get_midi_program_info(fHandle, i);

  1176.                 CARLA_ASSERT(mpDesc != nullptr);

  1177.                 CARLA_ASSERT(mpDesc->name != nullptr);

  1178. 

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

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

  1181.                 kData->midiprog.data[i].name    = carla_strdup(mpDesc->name);

  1182.             }

  1183.         }

  1184. 

  1185. #ifndef BUILD_BRIDGE

  1186.         // Update OSC Names

  1187.         if (kData->engine->isOscControlRegistered())

  1188.         {

  1189.             kData->engine->osc_send_control_set_midi_program_count(fId, count);

  1190. 

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

  1192.                 kData->engine->osc_send_control_set_midi_program_data(fId, i, kData->midiprog.data[i].bank, kData->midiprog.data[i].program, kData->midiprog.data[i].name);

  1193.         }

  1194. #endif

  1195. 

  1196.         if (init)

  1197.         {

  1198.             if (count > 0)

  1199.                 setMidiProgram(0, false, false, false);

  1200.         }

  1201.         else

  1202.         {

  1203.             // Check if current program is invalid

  1204.             bool programChanged = false;

  1205. 

  1206.             if (count == oldCount+1)

  1207.             {

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

  1209.                 kData->midiprog.current = oldCount;

  1210.                 programChanged = true;

  1211.             }

  1212.             else if (current < 0 && count > 0)

  1213.             {

  1214.                 // programs exist now, but not before

  1215.                 kData->midiprog.current = 0;

  1216.                 programChanged = true;

  1217.             }

  1218.             else if (current >= 0 && count == 0)

  1219.             {

  1220.                 // programs existed before, but not anymore

  1221.                 kData->midiprog.current = -1;

  1222.                 programChanged = true;

  1223.             }

  1224.             else if (current >= static_cast<int32_t>(count))

  1225.             {

  1226.                 // current midi program > count

  1227.                 kData->midiprog.current = 0;

  1228.                 programChanged = true;

  1229.             }

  1230.             else

  1231.             {

  1232.                 // no change

  1233.                 kData->midiprog.current = current;

  1234.             }

  1235. 

  1236.             if (programChanged)

  1237.                 setMidiProgram(kData->midiprog.current, true, true, true);

  1238. 

  1239.             kData->engine->callback(CALLBACK_RELOAD_PROGRAMS, fId, 0, 0, 0.0f, nullptr);

  1240.         }

  1241.     }

  1242. 

  1243.     // -------------------------------------------------------------------

  1244.     // Plugin processing

  1245. 

  1246.     void activate() override

  1247.     {

  1248.         CARLA_ASSERT(fDescriptor != nullptr);

  1249.         CARLA_ASSERT(fHandle != nullptr);

  1250. 

  1251.         if (fDescriptor->activate != nullptr)

  1252.         {

  1253.             fDescriptor->activate(fHandle);

  1254. 

  1255.             if (fHandle2 != nullptr)

  1256.                 fDescriptor->activate(fHandle2);

  1257.         }

  1258.     }

  1259. 

  1260.     void deactivate() override

  1261.     {

  1262.         CARLA_ASSERT(fDescriptor != nullptr);

  1263.         CARLA_ASSERT(fHandle != nullptr);

  1264. 

  1265.         if (fDescriptor->deactivate != nullptr)

  1266.         {

  1267.             fDescriptor->deactivate(fHandle);

  1268. 

  1269.             if (fHandle2 != nullptr)

  1270.                 fDescriptor->deactivate(fHandle2);

  1271.         }

  1272.     }

  1273. 

  1274.     void process(float** const inBuffer, float** const outBuffer, const uint32_t frames) override

  1275.     {

  1276.         uint32_t i, k;

  1277. 

  1278.         // --------------------------------------------------------------------------------------------------------

  1279.         // Check if active

  1280. 

  1281.         if (! kData->active)

  1282.         {

  1283.             // disable any output sound

  1284.             for (i=0; i < kData->audioOut.count; ++i)

  1285.                 carla_zeroFloat(outBuffer[i], frames);

  1286. 

  1287.             return;

  1288.         }

  1289. 

  1290.         fMidiEventCount = 0;

  1291.         carla_zeroStruct< ::MidiEvent>(fMidiEvents, MAX_MIDI_EVENTS*2);

  1292. 

  1293.         // --------------------------------------------------------------------------------------------------------

  1294.         // Check if needs reset

  1295. 

  1296.         if (kData->needsReset)

  1297.         {

  1298.             if (fOptions & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  1299.             {

  1300.                 for (k=0, i=MAX_MIDI_CHANNELS; k < MAX_MIDI_CHANNELS; ++k)

  1301.                 {

  1302.                     fMidiEvents[k].data[0] = MIDI_STATUS_CONTROL_CHANGE + k;

  1303.                     fMidiEvents[k].data[1] = MIDI_CONTROL_ALL_NOTES_OFF;

  1304.                     fMidiEvents[k].data[2] = 0;

  1305.                     fMidiEvents[k].size    = 3;

  1306. 

  1307.                     fMidiEvents[k+i].data[0] = MIDI_STATUS_CONTROL_CHANGE + k;

  1308.                     fMidiEvents[k+i].data[1] = MIDI_CONTROL_ALL_SOUND_OFF;

  1309.                     fMidiEvents[k+i].data[2] = 0;

  1310.                     fMidiEvents[k+i].size    = 3;

  1311.                 }

  1312. 

  1313.                 fMidiEventCount = MAX_MIDI_CHANNELS*2;

  1314.             }

  1315.             else if (kData->ctrlChannel >= 0 && kData->ctrlChannel < MAX_MIDI_CHANNELS)

  1316.             {

  1317.                 for (k=0; k < MAX_MIDI_NOTE; ++k)

  1318.                 {

  1319.                     fMidiEvents[k].data[0] = MIDI_STATUS_NOTE_OFF + kData->ctrlChannel;

  1320.                     fMidiEvents[k].data[1] = k;

  1321.                     fMidiEvents[k].data[2] = 0;

  1322.                     fMidiEvents[k].size    = 3;

  1323.                 }

  1324. 

  1325.                 fMidiEventCount = MAX_MIDI_NOTE;

  1326.             }

  1327. 

  1328.             kData->needsReset = false;

  1329.         }

  1330. 

  1331.         CARLA_PROCESS_CONTINUE_CHECK;

  1332. 

  1333.         // --------------------------------------------------------------------------------------------------------

  1334.         // Set TimeInfo

  1335. 

  1336.         const EngineTimeInfo& timeInfo(kData->engine->getTimeInfo());

  1337. 

  1338.         fTimeInfo.playing = timeInfo.playing;

  1339.         fTimeInfo.frame   = timeInfo.frame;

  1340.         fTimeInfo.usecs   = timeInfo.usecs;

  1341. 

  1342.         if (timeInfo.valid & EngineTimeInfo::ValidBBT)

  1343.         {

  1344.             fTimeInfo.bbt.valid = true;

  1345. 

  1346.             fTimeInfo.bbt.bar  = timeInfo.bbt.bar;

  1347.             fTimeInfo.bbt.beat = timeInfo.bbt.beat;

  1348.             fTimeInfo.bbt.tick = timeInfo.bbt.tick;

  1349.             fTimeInfo.bbt.barStartTick = timeInfo.bbt.barStartTick;

  1350. 

  1351.             fTimeInfo.bbt.beatsPerBar = timeInfo.bbt.beatsPerBar;

  1352.             fTimeInfo.bbt.beatType    = timeInfo.bbt.beatType;

  1353. 

  1354.             fTimeInfo.bbt.ticksPerBeat   = timeInfo.bbt.ticksPerBeat;

  1355.             fTimeInfo.bbt.beatsPerMinute = timeInfo.bbt.beatsPerMinute;

  1356.         }

  1357.         else

  1358.             fTimeInfo.bbt.valid = false;

  1359. 

  1360.         CARLA_PROCESS_CONTINUE_CHECK;

  1361. 

  1362.         // --------------------------------------------------------------------------------------------------------

  1363.         // Event Input and Processing

  1364. 

  1365.         if (kData->event.portIn != nullptr)

  1366.         {

  1367.             // ----------------------------------------------------------------------------------------------------

  1368.             // MIDI Input (External)

  1369. 

  1370.             if (kData->extNotes.mutex.tryLock())

  1371.             {

  1372.                 while (fMidiEventCount < MAX_MIDI_EVENTS*2 && ! kData->extNotes.data.isEmpty())

  1373.                 {

  1374.                     const ExternalMidiNote& note(kData->extNotes.data.getFirst(true));

  1375. 

  1376.                     CARLA_ASSERT(note.channel >= 0 && note.channel < MAX_MIDI_CHANNELS);

  1377. 

  1378.                     fMidiEvents[fMidiEventCount].data[0]  = (note.velo > 0) ? MIDI_STATUS_NOTE_ON : MIDI_STATUS_NOTE_OFF;

  1379.                     fMidiEvents[fMidiEventCount].data[0] += note.channel;

  1380.                     fMidiEvents[fMidiEventCount].data[1]  = note.note;

  1381.                     fMidiEvents[fMidiEventCount].data[2]  = note.velo;

  1382.                     fMidiEvents[fMidiEventCount].size     = 3;

  1383. 

  1384.                     fMidiEventCount += 1;

  1385.                 }

  1386. 

  1387.                 kData->extNotes.mutex.unlock();

  1388. 

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

  1390. 

  1391.             // ----------------------------------------------------------------------------------------------------

  1392.             // Event Input (System)

  1393. 

  1394.             bool allNotesOffSent = false;

  1395.             bool sampleAccurate  = (fOptions & PLUGIN_OPTION_FIXED_BUFFER) == 0;

  1396. 

  1397.             uint32_t time, nEvents = kData->event.portIn->getEventCount();

  1398.             uint32_t startTime  = 0;

  1399.             uint32_t timeOffset = 0;

  1400.             uint32_t nextBankId = 0;

  1401. 

  1402.             if (kData->midiprog.current >= 0 && kData->midiprog.count > 0)

  1403.                 nextBankId = kData->midiprog.data[kData->midiprog.current].bank;

  1404. 

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

  1406.             {

  1407.                 const EngineEvent& event(kData->event.portIn->getEvent(i));

  1408. 

  1409.                 time = event.time;

  1410. 

  1411.                 if (time >= frames)

  1412.                     continue;

  1413. 

  1414.                 CARLA_ASSERT_INT2(time >= timeOffset, time, timeOffset);

  1415. 

  1416.                 if (time > timeOffset && sampleAccurate)

  1417.                 {

  1418.                     if (processSingle(inBuffer, outBuffer, time - timeOffset, timeOffset))

  1419.                     {

  1420.                         startTime  = 0;

  1421.                         timeOffset = time;

  1422. 

  1423.                         if (kData->midiprog.current >= 0 && kData->midiprog.count > 0)

  1424.                             nextBankId = kData->midiprog.data[kData->midiprog.current].bank;

  1425.                         else

  1426.                             nextBankId = 0;

  1427. 

  1428.                         if (fMidiEventCount > 0)

  1429.                         {

  1430.                             carla_zeroStruct< ::MidiEvent>(fMidiEvents, fMidiEventCount);

  1431.                             fMidiEventCount = 0;

  1432.                         }

  1433.                     }

  1434.                     else

  1435.                         startTime += timeOffset;

  1436.                 }

  1437. 

  1438.                 // Control change

  1439.                 switch (event.type)

  1440.                 {

  1441.                 case kEngineEventTypeNull:

  1442.                     break;

  1443. 

  1444.                 case kEngineEventTypeControl:

  1445.                 {

  1446.                     const EngineControlEvent& ctrlEvent = event.ctrl;

  1447. 

  1448.                     switch (ctrlEvent.type)

  1449.                     {

  1450.                     case kEngineControlEventTypeNull:

  1451.                         break;

  1452. 

  1453.                     case kEngineControlEventTypeParameter:

  1454.                     {

  1455. #ifndef BUILD_BRIDGE

  1456.                         // Control backend stuff

  1457.                         if (event.channel == kData->ctrlChannel)

  1458.                         {

  1459.                             float value;

  1460. 

  1461.                             if (MIDI_IS_CONTROL_BREATH_CONTROLLER(ctrlEvent.param) && (fHints & PLUGIN_CAN_DRYWET) > 0)

  1462.                             {

  1463.                                 value = ctrlEvent.value;

  1464.                                 setDryWet(value, false, false);

  1465.                                 postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_DRYWET, 0, value);

  1466.                             }

  1467. 

  1468.                             if (MIDI_IS_CONTROL_CHANNEL_VOLUME(ctrlEvent.param) && (fHints & PLUGIN_CAN_VOLUME) > 0)

  1469.                             {

  1470.                                 value = ctrlEvent.value*127.0f/100.0f;

  1471.                                 setVolume(value, false, false);

  1472.                                 postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_VOLUME, 0, value);

  1473.                             }

  1474. 

  1475.                             if (MIDI_IS_CONTROL_BALANCE(ctrlEvent.param) && (fHints & PLUGIN_CAN_BALANCE) > 0)

  1476.                             {

  1477.                                 float left, right;

  1478.                                 value = ctrlEvent.value/0.5f - 1.0f;

  1479. 

  1480.                                 if (value < 0.0f)

  1481.                                 {

  1482.                                     left  = -1.0f;

  1483.                                     right = (value*2.0f)+1.0f;

  1484.                                 }

  1485.                                 else if (value > 0.0f)

  1486.                                 {

  1487.                                     left  = (value*2.0f)-1.0f;

  1488.                                     right = 1.0f;

  1489.                                 }

  1490.                                 else

  1491.                                 {

  1492.                                     left  = -1.0f;

  1493.                                     right = 1.0f;

  1494.                                 }

  1495. 

  1496.                                 setBalanceLeft(left, false, false);

  1497.                                 setBalanceRight(right, false, false);

  1498.                                 postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_BALANCE_LEFT, 0, left);

  1499.                                 postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_BALANCE_RIGHT, 0, right);

  1500.                             }

  1501.                         }

  1502. #endif

  1503. 

  1504.                         // Control plugin parameters

  1505.                         for (k=0; k < kData->param.count; ++k)

  1506.                         {

  1507.                             if (kData->param.data[k].midiChannel != event.channel)

  1508.                                 continue;

  1509.                             if (kData->param.data[k].midiCC != ctrlEvent.param)

  1510.                                 continue;

  1511.                             if (kData->param.data[k].type != PARAMETER_INPUT)

  1512.                                 continue;

  1513.                             if ((kData->param.data[k].hints & PARAMETER_IS_AUTOMABLE) == 0)

  1514.                                 continue;

  1515. 

  1516.                             float value;

  1517. 

  1518.                             if (kData->param.data[k].hints & PARAMETER_IS_BOOLEAN)

  1519.                             {

  1520.                                 value = (ctrlEvent.value < 0.5f) ? kData->param.ranges[k].min : kData->param.ranges[k].max;

  1521.                             }

  1522.                             else

  1523.                             {

  1524.                                 value = kData->param.ranges[k].unnormalizeValue(ctrlEvent.value);

  1525. 

  1526.                                 if (kData->param.data[k].hints & PARAMETER_IS_INTEGER)

  1527.                                     value = std::rint(value);

  1528.                             }

  1529. 

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

  1531.                             postponeRtEvent(kPluginPostRtEventParameterChange, static_cast<int32_t>(k), 0, value);

  1532.                         }

  1533. 

  1534.                         if ((fOptions & PLUGIN_OPTION_SEND_CONTROL_CHANGES) != 0 && ctrlEvent.param <= 0x5F)

  1535.                         {

  1536.                             if (fMidiEventCount >= MAX_MIDI_EVENTS*2)

  1537.                                 continue;

  1538. 

  1539.                             fMidiEvents[fMidiEventCount].port = 0;

  1540.                             fMidiEvents[fMidiEventCount].time = sampleAccurate ? startTime : time;

  1541.                             fMidiEvents[fMidiEventCount].data[0] = MIDI_STATUS_CONTROL_CHANGE + event.channel;

  1542.                             fMidiEvents[fMidiEventCount].data[1] = ctrlEvent.param;

  1543.                             fMidiEvents[fMidiEventCount].data[2] = ctrlEvent.value*127.0f;

  1544.                             fMidiEvents[fMidiEventCount].size    = 3;

  1545. 

  1546.                             fMidiEventCount += 1;

  1547.                         }

  1548. 

  1549.                         break;

  1550.                     }

  1551. 

  1552.                     case kEngineControlEventTypeMidiBank:

  1553.                         if (event.channel == kData->ctrlChannel && (fOptions & PLUGIN_OPTION_MAP_PROGRAM_CHANGES) != 0)

  1554.                             nextBankId = ctrlEvent.param;

  1555.                         break;

  1556. 

  1557.                     case kEngineControlEventTypeMidiProgram:

  1558.                         if (event.channel < MAX_MIDI_CHANNELS && (fOptions & PLUGIN_OPTION_MAP_PROGRAM_CHANGES) != 0)

  1559.                         {

  1560.                             const uint32_t nextProgramId(ctrlEvent.param);

  1561. 

  1562.                             for (k=0; k < kData->midiprog.count; ++k)

  1563.                             {

  1564.                                 if (kData->midiprog.data[k].bank == nextBankId && kData->midiprog.data[k].program == nextProgramId)

  1565.                                 {

  1566.                                     fDescriptor->set_midi_program(fHandle, event.channel, nextBankId, nextProgramId);

  1567. 

  1568.                                     if (fHandle2 != nullptr)

  1569.                                         fDescriptor->set_midi_program(fHandle2, event.channel, nextBankId, nextProgramId);

  1570. 

  1571.                                     fCurMidiProgs[event.channel] = k;

  1572. 

  1573.                                     if (event.channel == kData->ctrlChannel)

  1574.                                         postponeRtEvent(kPluginPostRtEventMidiProgramChange, k, 0, 0.0f);

  1575. 

  1576.                                     break;

  1577.                                 }

  1578.                             }

  1579.                         }

  1580.                         break;

  1581. 

  1582.                     case kEngineControlEventTypeAllSoundOff:

  1583.                         if (fOptions & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  1584.                         {

  1585.                             if (fMidiEventCount >= MAX_MIDI_EVENTS*2)

  1586.                                 continue;

  1587. 

  1588.                             fMidiEvents[fMidiEventCount].port = 0;

  1589.                             fMidiEvents[fMidiEventCount].time = sampleAccurate ? startTime : time;

  1590.                             fMidiEvents[fMidiEventCount].data[0] = MIDI_STATUS_CONTROL_CHANGE + event.channel;

  1591.                             fMidiEvents[fMidiEventCount].data[1] = MIDI_CONTROL_ALL_SOUND_OFF;

  1592.                             fMidiEvents[fMidiEventCount].data[2] = 0;

  1593.                             fMidiEvents[fMidiEventCount].size    = 3;

  1594. 

  1595.                             fMidiEventCount += 1;

  1596.                         }

  1597.                         break;

  1598. 

  1599.                     case kEngineControlEventTypeAllNotesOff:

  1600.                         if (fOptions & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  1601.                         {

  1602.                             if (event.channel == kData->ctrlChannel && ! allNotesOffSent)

  1603.                             {

  1604.                                 allNotesOffSent = true;

  1605.                                 sendMidiAllNotesOffToCallback();

  1606.                             }

  1607. 

  1608.                             if (fMidiEventCount >= MAX_MIDI_EVENTS*2)

  1609.                                 continue;

  1610. 

  1611.                             fMidiEvents[fMidiEventCount].port = 0;

  1612.                             fMidiEvents[fMidiEventCount].time = sampleAccurate ? startTime : time;

  1613.                             fMidiEvents[fMidiEventCount].data[0] = MIDI_STATUS_CONTROL_CHANGE + event.channel;

  1614.                             fMidiEvents[fMidiEventCount].data[1] = MIDI_CONTROL_ALL_NOTES_OFF;

  1615.                             fMidiEvents[fMidiEventCount].data[2] = 0;

  1616.                             fMidiEvents[fMidiEventCount].size    = 3;

  1617. 

  1618.                             fMidiEventCount += 1;

  1619.                         }

  1620.                         break;

  1621.                     }

  1622. 

  1623.                     break;

  1624.                 }

  1625. 

  1626.                 case kEngineEventTypeMidi:

  1627.                 {

  1628.                     if (fMidiEventCount >= MAX_MIDI_EVENTS*2)

  1629.                         continue;

  1630. 

  1631.                     const EngineMidiEvent& midiEvent(event.midi);

  1632. 

  1633.                     uint8_t status  = MIDI_GET_STATUS_FROM_DATA(midiEvent.data);

  1634.                     uint8_t channel = event.channel;

  1635. 

  1636.                     if (MIDI_IS_STATUS_AFTERTOUCH(status) && (fOptions & PLUGIN_OPTION_SEND_CHANNEL_PRESSURE) == 0)

  1637.                         continue;

  1638.                     if (MIDI_IS_STATUS_CONTROL_CHANGE(status) && (fOptions & PLUGIN_OPTION_SEND_CONTROL_CHANGES) == 0)

  1639.                         continue;

  1640.                     if (MIDI_IS_STATUS_POLYPHONIC_AFTERTOUCH(status) && (fOptions & PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH) == 0)

  1641.                         continue;

  1642.                     if (MIDI_IS_STATUS_PITCH_WHEEL_CONTROL(status) && (fOptions & PLUGIN_OPTION_SEND_PITCHBEND) == 0)

  1643.                         continue;

  1644. 

  1645.                     // Fix bad note-off

  1646.                     if (status == MIDI_STATUS_NOTE_ON && midiEvent.data[2] == 0)

  1647.                         status -= 0x10;

  1648. 

  1649.                     fMidiEvents[fMidiEventCount].port = 0;

  1650.                     fMidiEvents[fMidiEventCount].time = sampleAccurate ? startTime : time;

  1651.                     fMidiEvents[fMidiEventCount].size = midiEvent.size;

  1652. 

  1653.                     fMidiEvents[fMidiEventCount].data[0] = status + channel;

  1654.                     fMidiEvents[fMidiEventCount].data[1] = midiEvent.data[1];

  1655.                     fMidiEvents[fMidiEventCount].data[2] = midiEvent.data[2];

  1656.                     fMidiEvents[fMidiEventCount].data[3] = midiEvent.data[3];

  1657. 

  1658.                     fMidiEventCount += 1;

  1659. 

  1660.                     if (status == MIDI_STATUS_NOTE_ON)

  1661.                         postponeRtEvent(kPluginPostRtEventNoteOn, channel, midiEvent.data[1], midiEvent.data[2]);

  1662.                     else if (status == MIDI_STATUS_NOTE_OFF)

  1663.                         postponeRtEvent(kPluginPostRtEventNoteOff, channel, midiEvent.data[1], 0.0f);

  1664. 

  1665.                     break;

  1666.                 }

  1667.                 }

  1668.             }

  1669. 

  1670.             kData->postRtEvents.trySplice();

  1671. 

  1672.             if (frames > timeOffset)

  1673.                 processSingle(inBuffer, outBuffer, frames - timeOffset, timeOffset);

  1674. 

  1675.         } // End of Event Input and Processing

  1676. 

  1677.         // --------------------------------------------------------------------------------------------------------

  1678.         // Plugin processing (no events)

  1679. 

  1680.         else

  1681.         {

  1682.             processSingle(inBuffer, outBuffer, frames, 0);

  1683. 

  1684.         } // End of Plugin processing (no events)

  1685. 

  1686.         CARLA_PROCESS_CONTINUE_CHECK;

  1687. 

  1688.         // --------------------------------------------------------------------------------------------------------

  1689.         // Control and MIDI Output

  1690. 

  1691.         if (fMidiOut.count > 0 || kData->event.portOut != nullptr)

  1692.         {

  1693.             float value, curValue;

  1694. 

  1695.             for (k=0; k < kData->param.count; ++k)

  1696.             {

  1697.                 if (kData->param.data[k].type != PARAMETER_OUTPUT)

  1698.                     continue;

  1699. 

  1700.                 curValue = fDescriptor->get_parameter_value(fHandle, k);

  1701.                 kData->param.ranges[k].fixValue(curValue);

  1702. 

  1703.                 if (kData->param.data[k].midiCC > 0)

  1704.                 {

  1705.                     value = kData->param.ranges[k].normalizeValue(curValue);

  1706.                     kData->event.portOut->writeControlEvent(0, kData->param.data[k].midiChannel, kEngineControlEventTypeParameter, kData->param.data[k].midiCC, value);

  1707.                 }

  1708.             }

  1709. 

  1710.             // reverse lookup MIDI events

  1711.             for (k = (MAX_MIDI_EVENTS*2)-1; k >= fMidiEventCount; --k)

  1712.             {

  1713.                 if (fMidiEvents[k].data[0] == 0)

  1714.                     break;

  1715. 

  1716.                 const uint8_t channel = MIDI_GET_CHANNEL_FROM_DATA(fMidiEvents[k].data);

  1717.                 const uint8_t port    = fMidiEvents[k].port;

  1718. 

  1719.                 if (kData->event.portOut != nullptr)

  1720.                     kData->event.portOut->writeMidiEvent(fMidiEvents[k].time, channel, port, fMidiEvents[k].data, fMidiEvents[k].size);

  1721.                 else if (port < fMidiOut.count)

  1722.                     fMidiOut.ports[port]->writeMidiEvent(fMidiEvents[k].time, channel, port, fMidiEvents[k].data, fMidiEvents[k].size);

  1723.             }

  1724. 

  1725.         } // End of Control and MIDI Output

  1726.     }

  1727. 

  1728.     bool processSingle(float** const inBuffer, float** const outBuffer, const uint32_t frames, const uint32_t timeOffset)

  1729.     {

  1730.         CARLA_ASSERT(frames > 0);

  1731. 

  1732.         if (frames == 0)

  1733.             return false;

  1734. 

  1735.         if (kData->audioIn.count > 0)

  1736.         {

  1737.             CARLA_ASSERT(inBuffer != nullptr);

  1738.             if (inBuffer == nullptr)

  1739.                 return false;

  1740.         }

  1741.         if (kData->audioOut.count > 0)

  1742.         {

  1743.             CARLA_ASSERT(outBuffer != nullptr);

  1744.             if (outBuffer == nullptr)

  1745.                 return false;

  1746.         }

  1747. 

  1748.         uint32_t i, k;

  1749. 

  1750.         // --------------------------------------------------------------------------------------------------------

  1751.         // Try lock, silence otherwise

  1752. 

  1753.         if (kData->engine->isOffline())

  1754.         {

  1755.             kData->singleMutex.lock();

  1756.         }

  1757.         else if (! kData->singleMutex.tryLock())

  1758.         {

  1759.             for (i=0; i < kData->audioOut.count; ++i)

  1760.             {

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

  1762.                     outBuffer[i][k+timeOffset] = 0.0f;

  1763.             }

  1764. 

  1765.             return false;

  1766.         }

  1767. 

  1768.         // --------------------------------------------------------------------------------------------------------

  1769.         // Reset audio buffers

  1770. 

  1771.         for (i=0; i < kData->audioIn.count; ++i)

  1772.             carla_copyFloat(fAudioInBuffers[i], inBuffer[i]+timeOffset, frames);

  1773.         for (i=0; i < kData->audioOut.count; ++i)

  1774.             carla_zeroFloat(fAudioOutBuffers[i], frames);

  1775. 

  1776.         // --------------------------------------------------------------------------------------------------------

  1777.         // Run plugin

  1778. 

  1779.         fIsProcessing = true;

  1780. 

  1781.         if (fHandle2 == nullptr)

  1782.         {

  1783.             fDescriptor->process(fHandle, fAudioInBuffers, fAudioOutBuffers, frames, fMidiEventCount, fMidiEvents);

  1784.         }

  1785.         else

  1786.         {

  1787.             fDescriptor->process(fHandle,

  1788.                                  (kData->audioIn.count > 0) ? &fAudioInBuffers[0] : nullptr,

  1789.                                  (kData->audioOut.count > 0) ? &fAudioOutBuffers[0] : nullptr,

  1790.                                  frames, fMidiEventCount, fMidiEvents);

  1791. 

  1792.             fDescriptor->process(fHandle2,

  1793.                                  (kData->audioIn.count > 0) ? &fAudioInBuffers[1] : nullptr,

  1794.                                  (kData->audioOut.count > 0) ? &fAudioOutBuffers[1] : nullptr,

  1795.                                  frames, fMidiEventCount, fMidiEvents);

  1796.         }

  1797. 

  1798.         fIsProcessing = false;

  1799.         fTimeInfo.frame += frames;

  1800. 

  1801. #ifndef BUILD_BRIDGE

  1802.         // --------------------------------------------------------------------------------------------------------

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

  1804. 

  1805.         {

  1806.             const bool doDryWet  = (fHints & PLUGIN_CAN_DRYWET) != 0 && kData->postProc.dryWet != 1.0f;

  1807.             const bool doBalance = (fHints & PLUGIN_CAN_BALANCE) != 0 && (kData->postProc.balanceLeft != -1.0f || kData->postProc.balanceRight != 1.0f);

  1808. 

  1809.             bool isPair;

  1810.             float bufValue, oldBufLeft[doBalance ? frames : 1];

  1811. 

  1812.             for (i=0; i < kData->audioOut.count; ++i)

  1813.             {

  1814.                 // Dry/Wet

  1815.                 if (doDryWet)

  1816.                 {

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

  1818.                     {

  1819.                         bufValue = fAudioInBuffers[(kData->audioIn.count == 1) ? 0 : i][k];

  1820.                         fAudioOutBuffers[i][k] = (fAudioOutBuffers[i][k] * kData->postProc.dryWet) + (bufValue * (1.0f - kData->postProc.dryWet));

  1821.                     }

  1822.                 }

  1823. 

  1824.                 // Balance

  1825.                 if (doBalance)

  1826.                 {

  1827.                     isPair = (i % 2 == 0);

  1828. 

  1829.                     if (isPair)

  1830.                     {

  1831.                         CARLA_ASSERT(i+1 < kData->audioOut.count);

  1832.                         carla_copyFloat(oldBufLeft, fAudioOutBuffers[i], frames);

  1833.                     }

  1834. 

  1835.                     float balRangeL = (kData->postProc.balanceLeft  + 1.0f)/2.0f;

  1836.                     float balRangeR = (kData->postProc.balanceRight + 1.0f)/2.0f;

  1837. 

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

  1839.                     {

  1840.                         if (isPair)

  1841.                         {

  1842.                             // left

  1843.                             fAudioOutBuffers[i][k]  = oldBufLeft[k]            * (1.0f - balRangeL);

  1844.                             fAudioOutBuffers[i][k] += fAudioOutBuffers[i+1][k] * (1.0f - balRangeR);

  1845.                         }

  1846.                         else

  1847.                         {

  1848.                             // right

  1849.                             fAudioOutBuffers[i][k]  = fAudioOutBuffers[i][k] * balRangeR;

  1850.                             fAudioOutBuffers[i][k] += oldBufLeft[k]          * balRangeL;

  1851.                         }

  1852.                     }

  1853.                 }

  1854. 

  1855.                 // Volume (and buffer copy)

  1856.                 {

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

  1858.                         outBuffer[i][k+timeOffset] = fAudioOutBuffers[i][k] * kData->postProc.volume;

  1859.                 }

  1860.             }

  1861. 

  1862.         } // End of Post-processing

  1863. #else

  1864.         for (i=0; i < kData->audioOut.count; ++i)

  1865.         {

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

  1867.                 outBuffer[i][k+timeOffset] = fAudioOutBuffers[i][k];

  1868.         }

  1869. #endif

  1870. 

  1871.         // --------------------------------------------------------------------------------------------------------

  1872. 

  1873.         kData->singleMutex.unlock();

  1874.         return true;

  1875.     }

  1876. 

  1877.     void bufferSizeChanged(const uint32_t newBufferSize) override

  1878.     {

  1879.         CARLA_ASSERT_INT(newBufferSize > 0, newBufferSize);

  1880.         carla_debug("NativePlugin::bufferSizeChanged(%i)", newBufferSize);

  1881. 

  1882.         for (uint32_t i=0; i < kData->audioIn.count; ++i)

  1883.         {

  1884.             if (fAudioInBuffers[i] != nullptr)

  1885.                 delete[] fAudioInBuffers[i];

  1886.             fAudioInBuffers[i] = new float[newBufferSize];

  1887.         }

  1888. 

  1889.         for (uint32_t i=0; i < kData->audioOut.count; ++i)

  1890.         {

  1891.             if (fAudioOutBuffers[i] != nullptr)

  1892.                 delete[] fAudioOutBuffers[i];

  1893.             fAudioOutBuffers[i] = new float[newBufferSize];

  1894.         }

  1895. 

  1896.         if (fDescriptor != nullptr && fDescriptor->dispatcher != nullptr)

  1897.         {

  1898.             fDescriptor->dispatcher(fHandle, PLUGIN_OPCODE_BUFFER_SIZE_CHANGED, 0, newBufferSize, nullptr, 0.0f);

  1899. 

  1900.             if (fHandle2 != nullptr)

  1901.                 fDescriptor->dispatcher(fHandle2, PLUGIN_OPCODE_BUFFER_SIZE_CHANGED, 0, newBufferSize, nullptr, 0.0f);

  1902.         }

  1903.     }

  1904. 

  1905.     void sampleRateChanged(const double newSampleRate) override

  1906.     {

  1907.         CARLA_ASSERT_INT(newSampleRate > 0.0, newSampleRate);

  1908.         carla_debug("NativePlugin::sampleRateChanged(%g)", newSampleRate);

  1909. 

  1910.         if (fDescriptor != nullptr && fDescriptor->dispatcher != nullptr)

  1911.         {

  1912.             fDescriptor->dispatcher(fHandle, PLUGIN_OPCODE_SAMPLE_RATE_CHANGED, 0, 0, nullptr, newSampleRate);

  1913. 

  1914.             if (fHandle2 != nullptr)

  1915.                 fDescriptor->dispatcher(fHandle2, PLUGIN_OPCODE_SAMPLE_RATE_CHANGED, 0, 0, nullptr, newSampleRate);

  1916.         }

  1917.     }

  1918. 

  1919.     void offlineModeChanged(const bool isOffline) override

  1920.     {

  1921.         if (fDescriptor != nullptr && fDescriptor->dispatcher != nullptr)

  1922.         {

  1923.             fDescriptor->dispatcher(fHandle, PLUGIN_OPCODE_OFFLINE_CHANGED, 0, isOffline ? 1 : 0, nullptr, 0.0f);

  1924. 

  1925.             if (fHandle2 != nullptr)

  1926.                 fDescriptor->dispatcher(fHandle2, PLUGIN_OPCODE_OFFLINE_CHANGED, 0, isOffline ? 1 : 0, nullptr, 0.0f);

  1927.         }

  1928.     }

  1929. 

  1930.     // -------------------------------------------------------------------

  1931.     // Plugin buffers

  1932. 

  1933.     void initBuffers() override

  1934.     {

  1935.         fMidiIn.initBuffers(kData->engine);

  1936.         fMidiOut.initBuffers(kData->engine);

  1937. 

  1938.         CarlaPlugin::initBuffers();

  1939.     }

  1940. 

  1941.     void clearBuffers() override

  1942.     {

  1943.         carla_debug("NativePlugin::clearBuffers() - start");

  1944. 

  1945.         if (fAudioInBuffers != nullptr)

  1946.         {

  1947.             for (uint32_t i=0; i < kData->audioIn.count; ++i)

  1948.             {

  1949.                 if (fAudioInBuffers[i] != nullptr)

  1950.                 {

  1951.                     delete[] fAudioInBuffers[i];

  1952.                     fAudioInBuffers[i] = nullptr;

  1953.                 }

  1954.             }

  1955. 

  1956.             delete[] fAudioInBuffers;

  1957.             fAudioInBuffers = nullptr;

  1958.         }

  1959. 

  1960.         if (fAudioOutBuffers != nullptr)

  1961.         {

  1962.             for (uint32_t i=0; i < kData->audioOut.count; ++i)

  1963.             {

  1964.                 if (fAudioOutBuffers[i] != nullptr)

  1965.                 {

  1966.                     delete[] fAudioOutBuffers[i];

  1967.                     fAudioOutBuffers[i] = nullptr;

  1968.                 }

  1969.             }

  1970. 

  1971.             delete[] fAudioOutBuffers;

  1972.             fAudioOutBuffers = nullptr;

  1973.         }

  1974. 

  1975.         fMidiIn.clear();

  1976.         fMidiOut.clear();

  1977. 

  1978.         CarlaPlugin::clearBuffers();

  1979. 

  1980.         carla_debug("NativePlugin::clearBuffers() - end");

  1981.     }

  1982. 

  1983.     // -------------------------------------------------------------------

  1984.     // Post-poned UI Stuff

  1985. 

  1986.     void uiParameterChange(const uint32_t index, const float value) override

  1987.     {

  1988.         CARLA_ASSERT(fDescriptor != nullptr);

  1989.         CARLA_ASSERT(fHandle != nullptr);

  1990.         CARLA_ASSERT(index < kData->param.count);

  1991. 

  1992.         if (! fIsUiVisible)

  1993.             return;

  1994.         if (fDescriptor == nullptr || fHandle == nullptr)

  1995.             return;

  1996.         if (index >= kData->param.count)

  1997.             return;

  1998. 

  1999.         if (fDescriptor->ui_set_parameter_value != nullptr)

  2000.             fDescriptor->ui_set_parameter_value(fHandle, index, value);

  2001.     }

  2002. 

  2003.     void uiMidiProgramChange(const uint32_t index) override

  2004.     {

  2005.         CARLA_ASSERT(fDescriptor != nullptr);

  2006.         CARLA_ASSERT(fHandle != nullptr);

  2007.         CARLA_ASSERT(index < kData->midiprog.count);

  2008. 

  2009.         if (! fIsUiVisible)

  2010.             return;

  2011.         if (fDescriptor == nullptr || fHandle == nullptr)

  2012.             return;

  2013.         if (index >= kData->midiprog.count)

  2014.             return;

  2015. 

  2016.         if (fDescriptor->ui_set_midi_program != nullptr) // TODO

  2017.             fDescriptor->ui_set_midi_program(fHandle, 0, kData->midiprog.data[index].bank, kData->midiprog.data[index].program);

  2018.     }

  2019. 

  2020.     void uiNoteOn(const uint8_t channel, const uint8_t note, const uint8_t velo) override

  2021.     {

  2022.         CARLA_ASSERT(fDescriptor != nullptr);

  2023.         CARLA_ASSERT(fHandle != nullptr);

  2024.         CARLA_ASSERT(channel < MAX_MIDI_CHANNELS);

  2025.         CARLA_ASSERT(note < MAX_MIDI_NOTE);

  2026.         CARLA_ASSERT(velo > 0 && velo < MAX_MIDI_VALUE);

  2027. 

  2028.         if (! fIsUiVisible)

  2029.             return;

  2030.         if (fDescriptor == nullptr || fHandle == nullptr)

  2031.             return;

  2032.         if (channel >= MAX_MIDI_CHANNELS)

  2033.             return;

  2034.         if (note >= MAX_MIDI_NOTE)

  2035.             return;

  2036.         if (velo >= MAX_MIDI_VALUE)

  2037.             return;

  2038. 

  2039.         // TODO

  2040.     }

  2041. 

  2042.     void uiNoteOff(const uint8_t channel, const uint8_t note) override

  2043.     {

  2044.         CARLA_ASSERT(fDescriptor != nullptr);

  2045.         CARLA_ASSERT(fHandle != nullptr);

  2046.         CARLA_ASSERT(channel < MAX_MIDI_CHANNELS);

  2047.         CARLA_ASSERT(note < MAX_MIDI_NOTE);

  2048. 

  2049.         if (! fIsUiVisible)

  2050.             return;

  2051.         if (fDescriptor == nullptr || fHandle == nullptr)

  2052.             return;

  2053.         if (channel >= MAX_MIDI_CHANNELS)

  2054.             return;

  2055.         if (note >= MAX_MIDI_NOTE)

  2056.             return;

  2057. 

  2058.         // TODO

  2059.     }

  2060. 

  2061.     // -------------------------------------------------------------------

  2062. 

  2063. protected:

  2064.     uint32_t handleGetBufferSize()

  2065.     {

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

  2067.     }

  2068. 

  2069.     double handleGetSampleRate()

  2070.     {

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

  2072.     }

  2073. 

  2074.     bool handleIsOffline()

  2075.     {

  2076.         return kData->engine->isOffline();

  2077.     }

  2078. 

  2079.     const ::TimeInfo* handleGetTimeInfo()

  2080.     {

  2081.         CARLA_ASSERT(fIsProcessing);

  2082. 

  2083.         return &fTimeInfo;

  2084.     }

  2085. 

  2086.     bool handleWriteMidiEvent(const ::MidiEvent* const event)

  2087.     {

  2088.         CARLA_ASSERT(fEnabled);

  2089.         CARLA_ASSERT(fIsProcessing);

  2090.         CARLA_ASSERT(fMidiOut.count > 0 || kData->event.portOut != nullptr);

  2091.         CARLA_ASSERT(event != nullptr);

  2092.         CARLA_ASSERT(event->data[0] != 0);

  2093. 

  2094.         if (! fEnabled)

  2095.             return false;

  2096.         if (fMidiOut.count == 0)

  2097.             return false;

  2098.         if (event == nullptr)

  2099.             return false;

  2100.         if (event->data[0] == 0)

  2101.             return false;

  2102.         if (! fIsProcessing)

  2103.         {

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

  2105.             return false;

  2106.         }

  2107. 

  2108.         if (fMidiEventCount >= MAX_MIDI_EVENTS*2)

  2109.             return false;

  2110. 

  2111.         // reverse-find first free event, and put it there

  2112.         for (uint32_t i=(MAX_MIDI_EVENTS*2)-1; i >= fMidiEventCount; --i)

  2113.         {

  2114.             if (fMidiEvents[i].data[0] == 0)

  2115.             {

  2116.                 std::memcpy(&fMidiEvents[i], event, sizeof(::MidiEvent));

  2117.                 break;

  2118.             }

  2119.         }

  2120. 

  2121.         return true;

  2122.     }

  2123. 

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

  2125.     {

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

  2127.     }

  2128. 

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

  2130.     {

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

  2132.     }

  2133. 

  2134.     void handleUiClosed()

  2135.     {

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

  2137.         fIsUiVisible = false;

  2138.     }

  2139. 

  2140.     const char* handleUiOpenFile(const bool isDir, const char* const title, const char* const filter)

  2141.     {

  2142.         static CarlaString retStr;

  2143.         QFileDialog::Options options(isDir ? QFileDialog::ShowDirsOnly : 0x0);

  2144. 

  2145.         retStr = QFileDialog::getOpenFileName(nullptr, title, "", filter, nullptr, options).toUtf8().constData();

  2146. 

  2147.         return retStr.isNotEmpty() ? (const char*)retStr : nullptr;

  2148.     }

  2149. 

  2150.     const char* handleUiSaveFile(const bool isDir, const char* const title, const char* const filter)

  2151.     {

  2152.         static CarlaString retStr;

  2153.         QFileDialog::Options options(isDir ? QFileDialog::ShowDirsOnly : 0x0);

  2154. 

  2155.         retStr = QFileDialog::getSaveFileName(nullptr, title, "", filter, nullptr, options).toUtf8().constData();

  2156. 

  2157.         return retStr.isNotEmpty() ? (const char*)retStr : nullptr;

  2158.     }

  2159. 

  2160.     intptr_t handleDispatcher(const ::HostDispatcherOpcode opcode, const int32_t index, const intptr_t value, void* const ptr, const float opt)

  2161.     {

  2162.         carla_debug("NativePlugin::handleDispatcher(%i, %i, " P_INTPTR ", %p, %f)", opcode, index, value, ptr, opt);

  2163. 

  2164.         intptr_t ret = 0;

  2165. 

  2166.         switch (opcode)

  2167.         {

  2168.         case ::HOST_OPCODE_NULL:

  2169.             break;

  2170. #ifdef BUILD_BRIDGE

  2171.         case ::HOST_OPCODE_SET_VOLUME:

  2172.         case ::HOST_OPCODE_SET_DRYWET:

  2173.         case ::HOST_OPCODE_SET_BALANCE_LEFT:

  2174.         case ::HOST_OPCODE_SET_BALANCE_RIGHT:

  2175.         case ::HOST_OPCODE_SET_PANNING:

  2176.             break;

  2177. #else

  2178.         case ::HOST_OPCODE_SET_VOLUME:

  2179.             setVolume(opt, true, true);

  2180.             break;

  2181.         case ::HOST_OPCODE_SET_DRYWET:

  2182.             setDryWet(opt, true, true);

  2183.             break;

  2184.         case ::HOST_OPCODE_SET_BALANCE_LEFT:

  2185.             setBalanceLeft(opt, true, true);

  2186.             break;

  2187.         case ::HOST_OPCODE_SET_BALANCE_RIGHT:

  2188.             setBalanceRight(opt, true, true);

  2189.             break;

  2190.         case ::HOST_OPCODE_SET_PANNING:

  2191.             setPanning(opt, true, true);

  2192.             break;

  2193. #endif

  2194.         case ::HOST_OPCODE_SET_PROCESS_PRECISION:

  2195.             // TODO

  2196.             break;

  2197.         case ::HOST_OPCODE_UPDATE_PARAMETER:

  2198.             break;

  2199.         case ::HOST_OPCODE_UPDATE_MIDI_PROGRAM:

  2200.             break;

  2201.         case ::HOST_OPCODE_RELOAD_PARAMETERS:

  2202.             break;

  2203.         case ::HOST_OPCODE_RELOAD_MIDI_PROGRAMS:

  2204.             break;

  2205.         case ::HOST_OPCODE_RELOAD_ALL:

  2206.             break;

  2207.         case HOST_OPCODE_UI_UNAVAILABLE:

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

  2209.             break;

  2210.         }

  2211. 

  2212.         return ret;

  2213. 

  2214.         // unused for now

  2215.         (void)index;

  2216.         (void)value;

  2217.         (void)ptr;

  2218.     }

  2219. 

  2220.     // -------------------------------------------------------------------

  2221. 

  2222. public:

  2223.     static size_t getPluginCount()

  2224.     {

  2225.         return sPluginDescriptors.count();

  2226.     }

  2227. 

  2228.     static const ::PluginDescriptor* getPluginDescriptor(const size_t index)

  2229.     {

  2230.         CARLA_ASSERT(index < sPluginDescriptors.count());

  2231. 

  2232.         if (index < sPluginDescriptors.count())

  2233.             return sPluginDescriptors.getAt(index);

  2234. 

  2235.         return nullptr;

  2236.     }

  2237. 

  2238.     static void registerPlugin(const ::PluginDescriptor* desc)

  2239.     {

  2240.         sPluginDescriptors.append(desc);

  2241.     }

  2242. 

  2243.     // -------------------------------------------------------------------

  2244. 

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

  2246.     {

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

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

  2249.         CARLA_ASSERT(label != nullptr);

  2250. 

  2251.         // ---------------------------------------------------------------

  2252.         // first checks

  2253. 

  2254.         if (kData->engine == nullptr)

  2255.         {

  2256.             return false;

  2257.         }

  2258. 

  2259.         if (kData->client != nullptr)

  2260.         {

  2261.             kData->engine->setLastError("Plugin client is already registered");

  2262.             return false;

  2263.         }

  2264. 

  2265.         if (label == nullptr)

  2266.         {

  2267.             kData->engine->setLastError("null label");

  2268.             return false;

  2269.         }

  2270. 

  2271.         // ---------------------------------------------------------------

  2272.         // get descriptor that matches label

  2273. 

  2274.         for (NonRtList<const ::PluginDescriptor*>::Itenerator it = sPluginDescriptors.begin(); it.valid(); it.next())

  2275.         {

  2276.             fDescriptor = *it;

  2277. 

  2278.             CARLA_ASSERT(fDescriptor != nullptr);

  2279. 

  2280.             if (fDescriptor == nullptr)

  2281.                 break;

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

  2283.                 break;

  2284. 

  2285.             fDescriptor = nullptr;

  2286.         }

  2287. 

  2288.         if (fDescriptor == nullptr)

  2289.         {

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

  2291.             return false;

  2292.         }

  2293. 

  2294.         // ---------------------------------------------------------------

  2295.         // set icon

  2296. 

  2297.         if (std::strcmp(fDescriptor->label, "audiofile") == 0)

  2298.             fIconName = "file";

  2299.         else if (std::strcmp(fDescriptor->label, "midifile") == 0)

  2300.             fIconName = "file";

  2301.         else if (std::strcmp(fDescriptor->label, "sunvoxfile") == 0)

  2302.             fIconName = "file";

  2303. 

  2304.         else if (std::strcmp(fDescriptor->label, "3BandEQ") == 0)

  2305.             fIconName = "distrho";

  2306.         else if (std::strcmp(fDescriptor->label, "3BandSplitter") == 0)

  2307.             fIconName = "distrho";

  2308.         else if (std::strcmp(fDescriptor->label, "Nekobi") == 0)

  2309.             fIconName = "distrho";

  2310.         else if (std::strcmp(fDescriptor->label, "Notes") == 0)

  2311.             fIconName = "distrho";

  2312.         else if (std::strcmp(fDescriptor->label, "PingPongPan") == 0)

  2313.             fIconName = "distrho";

  2314.         else if (std::strcmp(fDescriptor->label, "StereoEnhancer") == 0)

  2315.             fIconName = "distrho";

  2316. 

  2317.         // ---------------------------------------------------------------

  2318.         // get info

  2319. 

  2320.         if (name != nullptr)

  2321.             fName = kData->engine->getUniquePluginName(name);

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

  2323.             fName = kData->engine->getUniquePluginName(fDescriptor->name);

  2324.         else

  2325.             fName = kData->engine->getUniquePluginName(label);

  2326. 

  2327.         {

  2328.             CARLA_ASSERT(fHost.ui_name == nullptr);

  2329. 

  2330.             char uiName[fName.length()+6+1];

  2331.             std::strcpy(uiName, (const char*)fName);

  2332.             std::strcat(uiName, " (GUI)");

  2333. 

  2334.             fHost.ui_name = carla_strdup(uiName);

  2335.         }

  2336. 

  2337.         // ---------------------------------------------------------------

  2338.         // register client

  2339. 

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

  2341. 

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

  2343.         {

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

  2345.             return false;

  2346.         }

  2347. 

  2348.         // ---------------------------------------------------------------

  2349.         // initialize plugin

  2350. 

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

  2352. 

  2353.         if (fHandle == nullptr)

  2354.         {

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

  2356.             return false;

  2357.         }

  2358. 

  2359.         // ---------------------------------------------------------------

  2360.         // load plugin settings

  2361. 

  2362.         {

  2363.             const bool hasMidiProgs(fDescriptor->get_midi_program_count != nullptr && fDescriptor->get_midi_program_count(fHandle) > 0);

  2364. 

  2365.             // set default options

  2366.             fOptions = 0x0;

  2367. 

  2368.             if (hasMidiProgs && (fDescriptor->supports & ::PLUGIN_SUPPORTS_PROGRAM_CHANGES) == 0)

  2369.                 fOptions |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  2370. 

  2371.             if (midiInCount() > 0 || (fDescriptor->hints & ::PLUGIN_USES_STATIC_BUFFERS) != 0)

  2372.                 fOptions |= PLUGIN_OPTION_FIXED_BUFFER;

  2373. 

  2374.             if (kData->engine->getOptions().forceStereo)

  2375.                 fOptions |= PLUGIN_OPTION_FORCE_STEREO;

  2376. 

  2377.             if (fDescriptor->supports & ::PLUGIN_SUPPORTS_CHANNEL_PRESSURE)

  2378.                 fOptions |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  2379.             if (fDescriptor->supports & ::PLUGIN_SUPPORTS_NOTE_AFTERTOUCH)

  2380.                 fOptions |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

  2381.             if (fDescriptor->supports & ::PLUGIN_SUPPORTS_PITCHBEND)

  2382.                 fOptions |= PLUGIN_OPTION_SEND_PITCHBEND;

  2383.             if (fDescriptor->supports & ::PLUGIN_SUPPORTS_ALL_SOUND_OFF)

  2384.                 fOptions |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  2385. 

  2386.             // load settings

  2387.             kData->idStr  = "Native/";

  2388.             kData->idStr += label;

  2389.             fOptions = kData->loadSettings(fOptions, availableOptions());

  2390. 

  2391.             // ignore settings, we need this anyway

  2392.             if (midiInCount() > 0 || (fDescriptor->hints & ::PLUGIN_USES_STATIC_BUFFERS) != 0)

  2393.                 fOptions |= PLUGIN_OPTION_FIXED_BUFFER;

  2394.         }

  2395. 

  2396.         return true;

  2397.     }

  2398. 

  2399.     class ScopedInitializer

  2400.     {

  2401.     public:

  2402.         ScopedInitializer()

  2403.         {

  2404.             carla_register_all_plugins();

  2405.         }

  2406. 

  2407.         ~ScopedInitializer()

  2408.         {

  2409.             sPluginDescriptors.clear();

  2410.         }

  2411.     };

  2412. 

  2413. private:

  2414.     ::PluginHandle   fHandle;

  2415.     ::PluginHandle   fHandle2;

  2416.     ::HostDescriptor fHost;

  2417.     const ::PluginDescriptor* fDescriptor;

  2418. 

  2419.     bool fIsProcessing;

  2420.     bool fIsUiVisible;

  2421. 

  2422.     float**     fAudioInBuffers;

  2423.     float**     fAudioOutBuffers;

  2424.     uint32_t    fMidiEventCount;

  2425.     ::MidiEvent fMidiEvents[MAX_MIDI_EVENTS*2];

  2426. 

  2427.     int32_t fCurMidiProgs[MAX_MIDI_CHANNELS];

  2428. 

  2429.     NativePluginMidiData fMidiIn;

  2430.     NativePluginMidiData fMidiOut;

  2431. 

  2432.     ::TimeInfo fTimeInfo;

  2433. 

  2434.     static NonRtList<const ::PluginDescriptor*> sPluginDescriptors;

  2435. 

  2436.     // -------------------------------------------------------------------

  2437. 

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

  2439. 

  2440.     static uint32_t carla_host_get_buffer_size(::HostHandle handle)

  2441.     {

  2442.         return handlePtr->handleGetBufferSize();

  2443.     }

  2444. 

  2445.     static double carla_host_get_sample_rate(::HostHandle handle)

  2446.     {

  2447.         return handlePtr->handleGetSampleRate();

  2448.     }

  2449. 

  2450.     static bool carla_host_is_offline(::HostHandle handle)

  2451.     {

  2452.         return handlePtr->handleIsOffline();

  2453.     }

  2454. 

  2455.     static const ::TimeInfo* carla_host_get_time_info(::HostHandle handle)

  2456.     {

  2457.         return handlePtr->handleGetTimeInfo();

  2458.     }

  2459. 

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

  2461.     {

  2462.         return handlePtr->handleWriteMidiEvent(event);

  2463.     }

  2464. 

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

  2466.     {

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

  2468.     }

  2469. 

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

  2471.     {

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

  2473.     }

  2474. 

  2475.     static void carla_host_ui_closed(::HostHandle handle)

  2476.     {

  2477.         handlePtr->handleUiClosed();

  2478.     }

  2479. 

  2480.     static const char* carla_host_ui_open_file(::HostHandle handle, bool isDir, const char* title, const char* filter)

  2481.     {

  2482.         return handlePtr->handleUiOpenFile(isDir, title, filter);

  2483.     }

  2484. 

  2485.     static const char* carla_host_ui_save_file(::HostHandle handle, bool isDir, const char* title, const char* filter)

  2486.     {

  2487.         return handlePtr->handleUiSaveFile(isDir, title, filter);

  2488.     }

  2489. 

  2490.     static intptr_t carla_host_dispatcher(::HostHandle handle, ::HostDispatcherOpcode opcode, int32_t index, intptr_t value, void* ptr, float opt)

  2491.     {

  2492.         return handlePtr->handleDispatcher(opcode, index, value, ptr, opt);

  2493.     }

  2494. 

  2495.     #undef handlePtr

  2496. 

  2497.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(NativePlugin)

  2498. };

  2499. 

  2500. NonRtList<const ::PluginDescriptor*> NativePlugin::sPluginDescriptors;

  2501. 

  2502. static const NativePlugin::ScopedInitializer _si;

  2503. 

  2504. CARLA_BACKEND_END_NAMESPACE

  2505. 

  2506. void carla_register_native_plugin(const PluginDescriptor* desc)

  2507. {

  2508.     CARLA_BACKEND_USE_NAMESPACE

  2509.     NativePlugin::registerPlugin(desc);

  2510. }

  2511. 

  2512. #else // WANT_NATIVE

  2513. # warning Building without Internal plugin support

  2514. #endif

  2515. 

  2516. CARLA_BACKEND_START_NAMESPACE

  2517. 

  2518. // -----------------------------------------------------------------------

  2519. 

  2520. #ifdef WANT_NATIVE

  2521. size_t CarlaPlugin::getNativePluginCount()

  2522. {

  2523.     return NativePlugin::getPluginCount();

  2524. }

  2525. 

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

  2527. {

  2528.     return NativePlugin::getPluginDescriptor(index);

  2529. }

  2530. #endif

  2531. 

  2532. // -----------------------------------------------------------------------

  2533. 

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

  2535. {

  2536.     carla_debug("CarlaPlugin::newNative({%p, \"%s\", \"%s\", \"%s\"})", init.engine, init.filename, init.name, init.label);

  2537. 

  2538. #ifdef WANT_NATIVE

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

  2540. 

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

  2542.     {

  2543.         delete plugin;

  2544.         return nullptr;

  2545.     }

  2546. 

  2547.     plugin->reload();

  2548. 

  2549.     if (init.engine->getProccessMode() == PROCESS_MODE_CONTINUOUS_RACK && ! CarlaPluginProtectedData::canRunInRack(plugin))

  2550.     {

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

  2552.         delete plugin;

  2553.         return nullptr;

  2554.     }

  2555. 

  2556.     return plugin;

  2557. #else

  2558.     init.engine->setLastError("Internal plugins support not available");

  2559.     return nullptr;

  2560. #endif

  2561. }

  2562. 

  2563. CARLA_BACKEND_END_NAMESPACE