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

2492 lines
88KB
Raw Blame History 

  1. /*

  2.  * Carla Native Plugin

  3.  * Copyright (C) 2012-2014 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 doc/GPL.txt file.

  16.  */

  17. 

  18. #include "CarlaPluginInternal.hpp"

  19. #include "CarlaEngine.hpp"

  20. 

  21. #ifdef WANT_NATIVE

  22. 

  23. #include "CarlaMathUtils.hpp"

  24. 

  25. #include "CarlaNative.h"

  26. 

  27. #include <QtCore/QStringList>

  28. 

  29. // -----------------------------------------------------

  30. 

  31. static LinkedList<const NativePluginDescriptor*> gPluginDescriptors;

  32. 

  33. void carla_register_native_plugin(const NativePluginDescriptor* desc)

  34. {

  35.     gPluginDescriptors.append(desc);

  36. }

  37. 

  38. // -----------------------------------------------------

  39. 

  40. CARLA_BACKEND_START_NAMESPACE

  41. 

  42. #if 0

  43. }

  44. #endif

  45. 

  46. struct NativePluginMidiData {

  47.     uint32_t  count;

  48.     uint32_t* indexes;

  49.     CarlaEngineEventPort** ports;

  50. 

  51.     NativePluginMidiData()

  52.         : count(0),

  53.           indexes(nullptr),

  54.           ports(nullptr) {}

  55. 

  56.     ~NativePluginMidiData()

  57.     {

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

  59.         CARLA_ASSERT(indexes == nullptr);

  60.         CARLA_ASSERT(ports == nullptr);

  61.     }

  62. 

  63.     void createNew(const uint32_t newCount)

  64.     {

  65.         CARLA_SAFE_ASSERT_INT(count == 0, count);

  66.         CARLA_SAFE_ASSERT_RETURN(indexes == nullptr,);

  67.         CARLA_SAFE_ASSERT_RETURN(ports == nullptr,);

  68.         CARLA_SAFE_ASSERT_RETURN(newCount > 0,);

  69. 

  70.         ports   = new CarlaEngineEventPort*[newCount];

  71.         indexes = new uint32_t[newCount];

  72.         count   = newCount;

  73. 

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

  75.             ports[i] = nullptr;

  76. 

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

  78.             indexes[i] = 0;

  79.     }

  80. 

  81.     void clear()

  82.     {

  83.         if (ports != nullptr)

  84.         {

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

  86.             {

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

  88.                 {

  89.                     delete ports[i];

  90.                     ports[i] = nullptr;

  91.                 }

  92.             }

  93. 

  94.             delete[] ports;

  95.             ports = nullptr;

  96.         }

  97. 

  98.         if (indexes != nullptr)

  99.         {

  100.             delete[] indexes;

  101.             indexes = nullptr;

  102.         }

  103. 

  104.         count = 0;

  105.     }

  106. 

  107.     void initBuffers()

  108.     {

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

  110.         {

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

  112.                 ports[i]->initBuffer();

  113.         }

  114.     }

  115. 

  116.     CARLA_DECLARE_NON_COPY_STRUCT(NativePluginMidiData)

  117. };

  118. 

  119. // -----------------------------------------------------

  120. 

  121. static const

  122. struct ScopedInitializer {

  123.     ScopedInitializer()

  124.     {

  125.         carla_register_all_plugins();

  126.     }

  127. 

  128.     ~ScopedInitializer()

  129.     {

  130.         gPluginDescriptors.clear();

  131.     }

  132. } _si;

  133. 

  134. // -----------------------------------------------------

  135. 

  136. class NativePlugin : public CarlaPlugin

  137. {

  138. public:

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

  140.         : CarlaPlugin(engine, id),

  141.           fHandle(nullptr),

  142.           fHandle2(nullptr),

  143.           fDescriptor(nullptr),

  144.           fIsProcessing(false),

  145.           fIsUiVisible(false),

  146.           fAudioInBuffers(nullptr),

  147.           fAudioOutBuffers(nullptr),

  148.           fMidiEventCount(0)

  149.     {

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

  151. 

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

  153.         carla_zeroStruct<NativeMidiEvent>(fMidiEvents, kPluginMaxMidiEvents*2);

  154.         carla_zeroStruct<NativeTimeInfo>(fTimeInfo);

  155. 

  156.         fHost.handle      = this;

  157.         fHost.resourceDir = carla_strdup(engine->getOptions().resourceDir);

  158.         fHost.uiName      = nullptr;

  159.         fHost.uiParentId  = engine->getOptions().frontendWinId;

  160. 

  161.         fHost.get_buffer_size        = carla_host_get_buffer_size;

  162.         fHost.get_sample_rate        = carla_host_get_sample_rate;

  163.         fHost.is_offline             = carla_host_is_offline;

  164.         fHost.get_time_info          = carla_host_get_time_info;

  165.         fHost.write_midi_event       = carla_host_write_midi_event;

  166.         fHost.ui_parameter_changed   = carla_host_ui_parameter_changed;

  167.         fHost.ui_custom_data_changed = carla_host_ui_custom_data_changed;

  168.         fHost.ui_closed              = carla_host_ui_closed;

  169.         fHost.ui_open_file           = carla_host_ui_open_file;

  170.         fHost.ui_save_file           = carla_host_ui_save_file;

  171.         fHost.dispatcher             = carla_host_dispatcher;

  172.     }

  173. 

  174.     ~NativePlugin() override

  175.     {

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

  177. 

  178.         // close UI

  179.         if (pData->hints & PLUGIN_HAS_UI)

  180.         {

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

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

  183.         }

  184. 

  185.         pData->singleMutex.lock();

  186.         pData->masterMutex.lock();

  187. 

  188.         if (pData->client != nullptr && pData->client->isActive())

  189.             pData->client->deactivate();

  190. 

  191.         CARLA_ASSERT(! fIsProcessing);

  192. 

  193.         if (pData->active)

  194.         {

  195.             deactivate();

  196.             pData->active = false;

  197.         }

  198. 

  199.         if (fDescriptor != nullptr)

  200.         {

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

  202.             {

  203.                 if (fHandle != nullptr)

  204.                     fDescriptor->cleanup(fHandle);

  205.                 if (fHandle2 != nullptr)

  206.                     fDescriptor->cleanup(fHandle2);

  207.             }

  208. 

  209.             fHandle  = nullptr;

  210.             fHandle2 = nullptr;

  211.             fDescriptor = nullptr;

  212.         }

  213. 

  214.         if (fHost.resourceDir != nullptr)

  215.         {

  216.             delete[] fHost.resourceDir;

  217.             fHost.resourceDir = nullptr;

  218.         }

  219. 

  220.         if (fHost.uiName != nullptr)

  221.         {

  222.             delete[] fHost.uiName;

  223.             fHost.uiName = nullptr;

  224.         }

  225. 

  226.         clearBuffers();

  227.     }

  228. 

  229.     // -------------------------------------------------------------------

  230.     // Information (base)

  231. 

  232.     PluginType getType() const noexcept override

  233.     {

  234.         return PLUGIN_INTERNAL;

  235.     }

  236. 

  237.     PluginCategory getCategory() const noexcept override

  238.     {

  239.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr, PLUGIN_CATEGORY_NONE);

  240. 

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

  242.     }

  243. 

  244.     // -------------------------------------------------------------------

  245.     // Information (count)

  246. 

  247.     uint32_t getMidiInCount() const noexcept override

  248.     {

  249.         return fMidiIn.count;

  250.     }

  251. 

  252.     uint32_t getMidiOutCount() const noexcept override

  253.     {

  254.         return fMidiOut.count;

  255.     }

  256. 

  257.     uint32_t getParameterScalePointCount(const uint32_t parameterId) const noexcept override

  258.     {

  259.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr, 0);

  260.         CARLA_SAFE_ASSERT_RETURN(fDescriptor->get_parameter_info != nullptr, 0);

  261.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr, 0);

  262.         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, 0);

  263. 

  264.         // FIXME - try

  265.         if (const NativeParameter* const param = fDescriptor->get_parameter_info(fHandle, parameterId))

  266.             return param->scalePointCount;

  267. 

  268.         carla_safe_assert("const Parameter* const param = fDescriptor->get_parameter_info(fHandle, parameterId)", __FILE__, __LINE__);

  269.         return 0;

  270.     }

  271. 

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

  273.     // Information (current data)

  274. 

  275.     // nothing

  276. 

  277.     // -------------------------------------------------------------------

  278.     // Information (per-plugin data)

  279. 

  280.     unsigned int getOptionsAvailable() const noexcept override

  281.     {

  282.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr, 0x0);

  283.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr, 0);

  284. 

  285.         // FIXME - try

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

  287. 

  288.         unsigned int options = 0x0;

  289. 

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

  291.             options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  292. 

  293.         if (getMidiInCount() == 0 && (fDescriptor->hints & ::PLUGIN_NEEDS_FIXED_BUFFERS) == 0)

  294.             options |= PLUGIN_OPTION_FIXED_BUFFERS;

  295. 

  296.         if (pData->engine->getProccessMode() != ENGINE_PROCESS_MODE_CONTINUOUS_RACK)

  297.         {

  298.             if (pData->options & PLUGIN_OPTION_FORCE_STEREO)

  299.                 options |= PLUGIN_OPTION_FORCE_STEREO;

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

  301.                 options |= PLUGIN_OPTION_FORCE_STEREO;

  302.         }

  303. 

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

  305.             options |= PLUGIN_OPTION_SEND_CONTROL_CHANGES;

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

  307.             options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

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

  309.             options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

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

  311.             options |= PLUGIN_OPTION_SEND_PITCHBEND;

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

  313.             options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  314. 

  315.         return options;

  316.     }

  317. 

  318.     float getParameterValue(const uint32_t parameterId) const noexcept override

  319.     {

  320.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr, 0.0f);

  321.         CARLA_SAFE_ASSERT_RETURN(fDescriptor->get_parameter_value != nullptr, 0.0f);

  322.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr, 0.0f);

  323.         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, 0.0f);

  324. 

  325.         // FIXME - try

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

  327.     }

  328. 

  329.     float getParameterScalePointValue(const uint32_t parameterId, const uint32_t scalePointId) const noexcept override

  330.     {

  331.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr, 0.0f);

  332.         CARLA_SAFE_ASSERT_RETURN(fDescriptor->get_parameter_info != nullptr, 0.0f);

  333.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr, 0.0f);

  334.         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, 0.0f);

  335.         CARLA_SAFE_ASSERT_RETURN(scalePointId < getParameterScalePointCount(parameterId), 0.0f);

  336. 

  337.         // FIXME - try

  338.         if (const NativeParameter* const param = fDescriptor->get_parameter_info(fHandle, parameterId))

  339.         {

  340.             const NativeParameterScalePoint* scalePoint(&param->scalePoints[scalePointId]);

  341.             return scalePoint->value;

  342.         }

  343. 

  344.         carla_safe_assert("const Parameter* const param = fDescriptor->get_parameter_info(fHandle, parameterId)", __FILE__, __LINE__);

  345.         return 0.0f;

  346.     }

  347. 

  348.     void getLabel(char* const strBuf) const noexcept override

  349.     {

  350.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  351. 

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

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

  354.         else

  355.             CarlaPlugin::getLabel(strBuf);

  356.     }

  357. 

  358.     void getMaker(char* const strBuf) const noexcept override

  359.     {

  360.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  361. 

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

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

  364.         else

  365.             CarlaPlugin::getMaker(strBuf);

  366.     }

  367. 

  368.     void getCopyright(char* const strBuf) const noexcept override

  369.     {

  370.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  371. 

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

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

  374.         else

  375.             CarlaPlugin::getCopyright(strBuf);

  376.     }

  377. 

  378.     void getRealName(char* const strBuf) const noexcept override

  379.     {

  380.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  381. 

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

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

  384.         else

  385.             CarlaPlugin::getRealName(strBuf);

  386.     }

  387. 

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

  389.     {

  390.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  391.         CARLA_SAFE_ASSERT_RETURN(fDescriptor->get_parameter_info != nullptr,);

  392.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  393.         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count,);

  394. 

  395.         // FIXME - try

  396.         if (const NativeParameter* const param = fDescriptor->get_parameter_info(fHandle, parameterId))

  397.         {

  398.             if (param->name != nullptr)

  399.             {

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

  401.                 return;

  402.             }

  403.             carla_safe_assert("param->name != nullptr", __FILE__, __LINE__);

  404.             return CarlaPlugin::getParameterName(parameterId, strBuf);

  405.         }

  406. 

  407.         carla_safe_assert("const Parameter* const param = fDescriptor->get_parameter_info(fHandle, parameterId)", __FILE__, __LINE__);

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

  409.     }

  410. 

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

  412.     {

  413.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  414.         CARLA_SAFE_ASSERT_RETURN(fDescriptor->get_parameter_text != nullptr,);

  415.         CARLA_SAFE_ASSERT_RETURN(fDescriptor->get_parameter_value != nullptr,);

  416.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  417.         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count,);

  418. 

  419.         // FIXME - try

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

  421.         {

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

  423.             return;

  424.         }

  425. 

  426.         carla_safe_assert("const char* const text = fDescriptor->get_parameter_text(fHandle, parameterId, value)", __FILE__, __LINE__);

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

  428.     }

  429. 

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

  431.     {

  432.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  433.         CARLA_SAFE_ASSERT_RETURN(fDescriptor->get_parameter_info != nullptr,);

  434.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  435.         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count,);

  436. 

  437.         // FIXME - try

  438.         if (const NativeParameter* const param = fDescriptor->get_parameter_info(fHandle, parameterId))

  439.         {

  440.             if (param->unit != nullptr)

  441.             {

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

  443.                 return;

  444.             }

  445.             return CarlaPlugin::getParameterUnit(parameterId, strBuf);

  446.         }

  447. 

  448.         carla_safe_assert("const Parameter* const param = fDescriptor->get_parameter_info(fHandle, parameterId)", __FILE__, __LINE__);

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

  450.     }

  451. 

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

  453.     {

  454.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  455.         CARLA_SAFE_ASSERT_RETURN(fDescriptor->get_parameter_info != nullptr,);

  456.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  457.         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count,);

  458.         CARLA_SAFE_ASSERT_RETURN(scalePointId < getParameterScalePointCount(parameterId),);

  459. 

  460.         // FIXME - try

  461.         if (const NativeParameter* const param = fDescriptor->get_parameter_info(fHandle, parameterId))

  462.         {

  463.             const NativeParameterScalePoint* scalePoint(&param->scalePoints[scalePointId]);

  464. 

  465.             if (scalePoint->label != nullptr)

  466.             {

  467.                 std::strncpy(strBuf, scalePoint->label, STR_MAX);

  468.                 return;

  469.             }

  470.             carla_safe_assert("scalePoint->label != nullptr", __FILE__, __LINE__);

  471.             return CarlaPlugin::getParameterScalePointLabel(parameterId, scalePointId, strBuf);

  472.         }

  473. 

  474.         carla_safe_assert("const Parameter* const param = fDescriptor->get_parameter_info(fHandle, parameterId)", __FILE__, __LINE__);

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

  476.     }

  477. 

  478.     // -------------------------------------------------------------------

  479.     // Set data (state)

  480. 

  481.     void prepareForSave() override

  482.     {

  483.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  484.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  485. 

  486.         if (pData->midiprog.count > 0 && fDescriptor->category == ::PLUGIN_CATEGORY_SYNTH)

  487.         {

  488.             char strBuf[STR_MAX+1];

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

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

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

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

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

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

  495. 

  496.             CarlaPlugin::setCustomData(CUSTOM_DATA_TYPE_STRING, "midiPrograms", strBuf, false);

  497.         }

  498. 

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

  500.             return;

  501. 

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

  503.         {

  504.             CarlaPlugin::setCustomData(CUSTOM_DATA_TYPE_CHUNK, "State", data, false);

  505.             std::free(data);

  506.         }

  507.     }

  508. 

  509.     // -------------------------------------------------------------------

  510.     // Set data (internal stuff)

  511. 

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

  513.     {

  514.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  515.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  516.         CARLA_SAFE_ASSERT_RETURN(newName != nullptr && newName[0] != '\0',);

  517. 

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

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

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

  521. 

  522.         if (fHost.uiName != nullptr)

  523.             delete[] fHost.uiName;

  524.         fHost.uiName = carla_strdup(uiName);

  525. 

  526.         if (fDescriptor->dispatcher != nullptr)

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

  528. 

  529.         CarlaPlugin::setName(newName);

  530.     }

  531. 

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

  533.     {

  534.         if (channel < MAX_MIDI_CHANNELS && pData->midiprog.count > 0)

  535.             pData->midiprog.current = fCurMidiProgs[channel];

  536. 

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

  538.     }

  539. 

  540.     // -------------------------------------------------------------------

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

  542. 

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

  544.     {

  545.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  546.         CARLA_SAFE_ASSERT_RETURN(fDescriptor->set_parameter_value != nullptr,);

  547.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  548.         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count,);

  549. 

  550.         const float fixedValue(pData->param.getFixedValue(parameterId, value));

  551. 

  552.         // FIXME - try

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

  554. 

  555.         if (fHandle2 != nullptr)

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

  557. 

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

  559.     }

  560. 

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

  562.     {

  563.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  564.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  565.         CARLA_SAFE_ASSERT_RETURN(type != nullptr && type[0] != '\0',);

  566.         CARLA_SAFE_ASSERT_RETURN(key != nullptr && key[0] != '\0',);

  567.         CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

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

  569. 

  570.         if (std::strcmp(type, CUSTOM_DATA_TYPE_STRING) != 0 && std::strcmp(type, CUSTOM_DATA_TYPE_CHUNK) != 0)

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

  572. 

  573.         if (std::strcmp(type, CUSTOM_DATA_TYPE_CHUNK) == 0)

  574.         {

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

  576.             {

  577.                 const ScopedSingleProcessLocker spl(this, true);

  578. 

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

  580. 

  581.                 if (fHandle2 != nullptr)

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

  583.             }

  584.         }

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

  586.         {

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

  588. 

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

  590.             {

  591.                 uint8_t channel = 0;

  592.                 foreach (const QString& midiProg, midiProgramList)

  593.                 {

  594.                     bool ok;

  595.                     const int index(midiProg.toInt(&ok));

  596. 

  597.                     if (ok && index >= 0 && index < static_cast<int>(pData->midiprog.count))

  598.                     {

  599.                         const uint32_t bank    = pData->midiprog.data[index].bank;

  600.                         const uint32_t program = pData->midiprog.data[index].program;

  601. 

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

  603. 

  604.                         if (fHandle2 != nullptr)

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

  606. 

  607.                         fCurMidiProgs[channel] = index;

  608. 

  609.                         if (pData->ctrlChannel == static_cast<int32_t>(channel))

  610.                         {

  611.                             pData->midiprog.current = index;

  612.                             pData->engine->callback(ENGINE_CALLBACK_MIDI_PROGRAM_CHANGED, pData->id, index, 0, 0.0f, nullptr);

  613.                         }

  614.                     }

  615. 

  616.                     ++channel;

  617.                 }

  618.             }

  619.         }

  620.         else

  621.         {

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

  623.             {

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

  625. 

  626.                 if (fHandle2 != nullptr)

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

  628.             }

  629. 

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

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

  632.         }

  633. 

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

  635.     }

  636. 

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

  638.     {

  639.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  640.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  641.         CARLA_SAFE_ASSERT_RETURN(index >= -1 && index < static_cast<int32_t>(pData->midiprog.count),);

  642. 

  643.         // TODO, put into check below

  644.         if ((pData->hints & PLUGIN_IS_SYNTH) != 0 && (pData->ctrlChannel < 0 || pData->ctrlChannel >= MAX_MIDI_CHANNELS))

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

  646. 

  647.         if (index >= 0)

  648.         {

  649.             const uint8_t  channel = uint8_t((pData->ctrlChannel >= 0 && pData->ctrlChannel < MAX_MIDI_CHANNELS) ? pData->ctrlChannel : 0);

  650.             const uint32_t bank    = pData->midiprog.data[index].bank;

  651.             const uint32_t program = pData->midiprog.data[index].program;

  652. 

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

  654. 

  655.             try {

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

  657.             } catch(...) {}

  658. 

  659.             if (fHandle2 != nullptr)

  660.             {

  661.                 try {

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

  663.                 } catch(...) {}

  664.             }

  665. 

  666.             fCurMidiProgs[channel] = index;

  667.         }

  668. 

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

  670.     }

  671. 

  672.     // -------------------------------------------------------------------

  673.     // Set ui stuff

  674. 

  675.     void showCustomUI(const bool yesNo) override

  676.     {

  677.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  678.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  679. 

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

  681.             return;

  682. 

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

  684. 

  685.         if (fIsUiVisible == yesNo)

  686.             return;

  687. 

  688.         fIsUiVisible = yesNo;

  689. 

  690.         if (! yesNo)

  691.             return;

  692. 

  693.         if ((fDescriptor->hints & ::PLUGIN_USES_PARENT_ID) == 0)

  694.             pData->tryTransient();

  695. 

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

  697.         {

  698.             for (LinkedList<CustomData>::Itenerator it = pData->custom.begin(); it.valid(); it.next())

  699.             {

  700.                 const CustomData& cData(it.getValue());

  701. 

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

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

  704.             }

  705.         }

  706. 

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

  708.         {

  709.             const int32_t  index   = pData->midiprog.current;

  710.             const uint8_t  channel = uint8_t((pData->ctrlChannel >= 0 && pData->ctrlChannel < MAX_MIDI_CHANNELS) ? pData->ctrlChannel : 0);

  711.             const uint32_t bank    = pData->midiprog.data[index].bank;

  712.             const uint32_t program = pData->midiprog.data[index].program;

  713. 

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

  715.         }

  716. 

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

  718.         {

  719.             for (uint32_t i=0; i < pData->param.count; ++i)

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

  721.         }

  722.     }

  723. 

  724.     void idle() override

  725.     {

  726.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  727.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  728. 

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

  730.             fDescriptor->ui_idle(fHandle);

  731. 

  732.         CarlaPlugin::idle();

  733.     }

  734. 

  735.     // -------------------------------------------------------------------

  736.     // Plugin state

  737. 

  738.     void reload() override

  739.     {

  740.         CARLA_SAFE_ASSERT_RETURN(pData->engine != nullptr,);

  741.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  742.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

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

  744. 

  745.         const EngineProcessMode processMode(pData->engine->getProccessMode());

  746. 

  747.         // Safely disable plugin for reload

  748.         const ScopedDisabler sd(this);

  749. 

  750.         if (pData->active)

  751.             deactivate();

  752. 

  753.         clearBuffers();

  754. 

  755.         const float sampleRate((float)pData->engine->getSampleRate());

  756. 

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

  758. 

  759.         bool forcedStereoIn, forcedStereoOut;

  760.         forcedStereoIn = forcedStereoOut = false;

  761. 

  762.         bool needsCtrlIn, needsCtrlOut;

  763.         needsCtrlIn = needsCtrlOut = false;

  764. 

  765.         aIns   = fDescriptor->audioIns;

  766.         aOuts  = fDescriptor->audioOuts;

  767.         mIns   = fDescriptor->midiIns;

  768.         mOuts  = fDescriptor->midiOuts;

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

  770. 

  771.         if ((pData->options & PLUGIN_OPTION_FORCE_STEREO) != 0 && (aIns == 1 || aOuts == 1) && mIns <= 1 && mOuts <= 1)

  772.         {

  773.             if (fHandle2 == nullptr)

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

  775. 

  776.             if (fHandle2 != nullptr)

  777.             {

  778.                 if (aIns == 1)

  779.                 {

  780.                     aIns = 2;

  781.                     forcedStereoIn = true;

  782.                 }

  783. 

  784.                 if (aOuts == 1)

  785.                 {

  786.                     aOuts = 2;

  787.                     forcedStereoOut = true;

  788.                 }

  789.             }

  790.         }

  791. 

  792.         if (aIns > 0)

  793.         {

  794.             pData->audioIn.createNew(aIns);

  795.             fAudioInBuffers = new float*[aIns];

  796. 

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

  798.                 fAudioInBuffers[i] = nullptr;

  799.         }

  800. 

  801.         if (aOuts > 0)

  802.         {

  803.             pData->audioOut.createNew(aOuts);

  804.             fAudioOutBuffers = new float*[aOuts];

  805.             needsCtrlIn = true;

  806. 

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

  808.                 fAudioOutBuffers[i] = nullptr;

  809.         }

  810. 

  811.         if (mIns > 0)

  812.         {

  813.             fMidiIn.createNew(mIns);

  814.             needsCtrlIn = (mIns == 1);

  815.         }

  816. 

  817.         if (mOuts > 0)

  818.         {

  819.             fMidiOut.createNew(mOuts);

  820.             needsCtrlOut = (mOuts == 1);

  821.         }

  822. 

  823.         if (params > 0)

  824.         {

  825.             pData->param.createNew(params, true);

  826.         }

  827. 

  828.         const uint portNameSize(pData->engine->getMaxPortNameSize());

  829.         CarlaString portName;

  830. 

  831.         // Audio Ins

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

  833.         {

  834.             portName.clear();

  835. 

  836.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  837.             {

  838.                 portName  = pData->name;

  839.                 portName += ":";

  840.             }

  841. 

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

  843.             {

  844.                 portName += "input_";

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

  846.             }

  847.             else

  848.                 portName += "input";

  849. 

  850.             portName.truncate(portNameSize);

  851. 

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

  853.             pData->audioIn.ports[j].rindex = j;

  854. 

  855.             if (forcedStereoIn)

  856.             {

  857.                 portName += "_2";

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

  859.                 pData->audioIn.ports[1].rindex = j;

  860.                 break;

  861.             }

  862.         }

  863. 

  864.         // Audio Outs

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

  866.         {

  867.             portName.clear();

  868. 

  869.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  870.             {

  871.                 portName  = pData->name;

  872.                 portName += ":";

  873.             }

  874. 

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

  876.             {

  877.                 portName += "output_";

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

  879.             }

  880.             else

  881.                 portName += "output";

  882. 

  883.             portName.truncate(portNameSize);

  884. 

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

  886.             pData->audioOut.ports[j].rindex = j;

  887. 

  888.             if (forcedStereoOut)

  889.             {

  890.                 portName += "_2";

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

  892.                 pData->audioOut.ports[1].rindex = j;

  893.                 break;

  894.             }

  895.         }

  896. 

  897.         // MIDI Input (only if multiple)

  898.         if (mIns > 1)

  899.         {

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

  901.             {

  902.                 portName.clear();

  903. 

  904.                 if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  905.                 {

  906.                     portName  = pData->name;

  907.                     portName += ":";

  908.                 }

  909. 

  910.                 portName += "midi-in_";

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

  912.                 portName.truncate(portNameSize);

  913. 

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

  915.                 fMidiIn.indexes[j] = j;

  916.             }

  917.         }

  918. 

  919.         // MIDI Output (only if multiple)

  920.         if (mOuts > 1)

  921.         {

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

  923.             {

  924.                 portName.clear();

  925. 

  926.                 if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  927.                 {

  928.                     portName  = pData->name;

  929.                     portName += ":";

  930.                 }

  931. 

  932.                 portName += "midi-out_";

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

  934.                 portName.truncate(portNameSize);

  935. 

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

  937.                 fMidiOut.indexes[j] = j;

  938.             }

  939.         }

  940. 

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

  942.         {

  943.             const NativeParameter* const paramInfo(fDescriptor->get_parameter_info(fHandle, j));

  944. 

  945.             CARLA_SAFE_ASSERT_CONTINUE(paramInfo != nullptr);

  946. 

  947.             pData->param.data[j].type   = PARAMETER_UNKNOWN;

  948.             pData->param.data[j].hints  = 0x0;

  949.             pData->param.data[j].index  = static_cast<int32_t>(j);

  950.             pData->param.data[j].rindex = static_cast<int32_t>(j);

  951.             pData->param.data[j].midiCC = -1;

  952.             pData->param.data[j].midiChannel = 0;

  953.             pData->param.special[j] = PARAMETER_SPECIAL_NULL;

  954. 

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

  956. 

  957.             // min value

  958.             min = paramInfo->ranges.min;

  959. 

  960.             // max value

  961.             max = paramInfo->ranges.max;

  962. 

  963.             if (min > max)

  964.                 max = min;

  965.             else if (max < min)

  966.                 min = max;

  967. 

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

  969.             {

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

  971.                 max = min + 0.1f;

  972.             }

  973. 

  974.             // default value

  975.             def = paramInfo->ranges.def;

  976. 

  977.             if (def < min)

  978.                 def = min;

  979.             else if (def > max)

  980.                 def = max;

  981. 

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

  983.             {

  984.                 min *= sampleRate;

  985.                 max *= sampleRate;

  986.                 def *= sampleRate;

  987.                 pData->param.data[j].hints |= PARAMETER_USES_SAMPLERATE;

  988.             }

  989. 

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

  991.             {

  992.                 step = max - min;

  993.                 stepSmall = step;

  994.                 stepLarge = step;

  995.                 pData->param.data[j].hints |= PARAMETER_IS_BOOLEAN;

  996.             }

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

  998.             {

  999.                 step = 1.0f;

  1000.                 stepSmall = 1.0f;

  1001.                 stepLarge = 10.0f;

  1002.                 pData->param.data[j].hints |= PARAMETER_IS_INTEGER;

  1003.             }

  1004.             else

  1005.             {

  1006.                 float range = max - min;

  1007.                 step = range/100.0f;

  1008.                 stepSmall = range/1000.0f;

  1009.                 stepLarge = range/10.0f;

  1010.             }

  1011. 

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

  1013.             {

  1014.                 pData->param.data[j].type = PARAMETER_OUTPUT;

  1015.                 needsCtrlOut = true;

  1016.             }

  1017.             else

  1018.             {

  1019.                 pData->param.data[j].type = PARAMETER_INPUT;

  1020.                 needsCtrlIn = true;

  1021.             }

  1022. 

  1023.             // extra parameter hints

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

  1025.                 pData->param.data[j].hints |= PARAMETER_IS_ENABLED;

  1026. 

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

  1028.                 pData->param.data[j].hints |= PARAMETER_IS_AUTOMABLE;

  1029. 

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

  1031.                 pData->param.data[j].hints |= PARAMETER_IS_LOGARITHMIC;

  1032. 

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

  1034.                 pData->param.data[j].hints |= PARAMETER_USES_SCALEPOINTS;

  1035. 

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

  1037.                 pData->param.data[j].hints |= PARAMETER_USES_CUSTOM_TEXT;

  1038. 

  1039.             pData->param.ranges[j].min = min;

  1040.             pData->param.ranges[j].max = max;

  1041.             pData->param.ranges[j].def = def;

  1042.             pData->param.ranges[j].step = step;

  1043.             pData->param.ranges[j].stepSmall = stepSmall;

  1044.             pData->param.ranges[j].stepLarge = stepLarge;

  1045.         }

  1046. 

  1047.         if (needsCtrlIn)

  1048.         {

  1049.             portName.clear();

  1050. 

  1051.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  1052.             {

  1053.                 portName  = pData->name;

  1054.                 portName += ":";

  1055.             }

  1056. 

  1057.             portName += "events-in";

  1058.             portName.truncate(portNameSize);

  1059. 

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

  1061.         }

  1062. 

  1063.         if (needsCtrlOut)

  1064.         {

  1065.             portName.clear();

  1066. 

  1067.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  1068.             {

  1069.                 portName  = pData->name;

  1070.                 portName += ":";

  1071.             }

  1072. 

  1073.             portName += "events-out";

  1074.             portName.truncate(portNameSize);

  1075. 

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

  1077.         }

  1078. 

  1079.         if (forcedStereoIn || forcedStereoOut)

  1080.             pData->options |= PLUGIN_OPTION_FORCE_STEREO;

  1081.         else

  1082.             pData->options &= ~PLUGIN_OPTION_FORCE_STEREO;

  1083. 

  1084.         // plugin hints

  1085.         pData->hints = 0x0;

  1086. 

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

  1088.             pData->hints |= PLUGIN_CAN_DRYWET;

  1089. 

  1090.         if (aOuts > 0)

  1091.             pData->hints |= PLUGIN_CAN_VOLUME;

  1092. 

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

  1094.             pData->hints |= PLUGIN_CAN_BALANCE;

  1095. 

  1096.         // native plugin hints

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

  1098.             pData->hints |= PLUGIN_IS_RTSAFE;

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

  1100.             pData->hints |= PLUGIN_IS_SYNTH;

  1101.         if (fDescriptor->hints & ::PLUGIN_HAS_UI)

  1102.             pData->hints |= PLUGIN_HAS_CUSTOM_UI;

  1103.         if (fDescriptor->hints & ::PLUGIN_NEEDS_SINGLE_THREAD)

  1104.             pData->hints |= PLUGIN_NEEDS_SINGLE_THREAD;

  1105.         if (fDescriptor->hints & ::PLUGIN_NEEDS_FIXED_BUFFERS)

  1106.             pData->hints |= PLUGIN_NEEDS_FIXED_BUFFERS;

  1107. 

  1108.         // extra plugin hints

  1109.         pData->extraHints = 0x0;

  1110. 

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

  1112.             pData->extraHints |= PLUGIN_EXTRA_HINT_CAN_RUN_RACK;

  1113. 

  1114.         if (fDescriptor->hints & ::PLUGIN_USES_MULTI_PROGS)

  1115.             pData->extraHints |= PLUGIN_EXTRA_HINT_USES_MULTI_PROGS;

  1116. 

  1117.         bufferSizeChanged(pData->engine->getBufferSize());

  1118.         reloadPrograms(true);

  1119. 

  1120.         if (pData->active)

  1121.             activate();

  1122. 

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

  1124.     }

  1125. 

  1126.     void reloadPrograms(const bool doInit) override

  1127.     {

  1128.         carla_debug("NativePlugin::reloadPrograms(%s)", bool2str(doInit));

  1129.         uint32_t i, oldCount  = pData->midiprog.count;

  1130.         const int32_t current = pData->midiprog.current;

  1131. 

  1132.         // Delete old programs

  1133.         pData->midiprog.clear();

  1134. 

  1135.         // Query new programs

  1136.         uint32_t count = 0;

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

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

  1139. 

  1140.         if (count > 0)

  1141.         {

  1142.             pData->midiprog.createNew(count);

  1143. 

  1144.             // Update data

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

  1146.             {

  1147.                 const NativeMidiProgram* const mpDesc(fDescriptor->get_midi_program_info(fHandle, i));

  1148.                 CARLA_ASSERT(mpDesc != nullptr);

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

  1150. 

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

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

  1153.                 pData->midiprog.data[i].name    = carla_strdup(mpDesc->name);

  1154.             }

  1155.         }

  1156. 

  1157. #ifndef BUILD_BRIDGE

  1158.         // Update OSC Names

  1159.         if (pData->engine->isOscControlRegistered())

  1160.         {

  1161.             pData->engine->oscSend_control_set_midi_program_count(pData->id, count);

  1162. 

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

  1164.                 pData->engine->oscSend_control_set_midi_program_data(pData->id, i, pData->midiprog.data[i].bank, pData->midiprog.data[i].program, pData->midiprog.data[i].name);

  1165.         }

  1166. #endif

  1167. 

  1168.         if (doInit)

  1169.         {

  1170.             if (count > 0)

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

  1172.         }

  1173.         else

  1174.         {

  1175.             // Check if current program is invalid

  1176.             bool programChanged = false;

  1177. 

  1178.             if (count == oldCount+1)

  1179.             {

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

  1181.                 pData->midiprog.current = static_cast<int32_t>(oldCount);

  1182.                 programChanged = true;

  1183.             }

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

  1185.             {

  1186.                 // programs exist now, but not before

  1187.                 pData->midiprog.current = 0;

  1188.                 programChanged = true;

  1189.             }

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

  1191.             {

  1192.                 // programs existed before, but not anymore

  1193.                 pData->midiprog.current = -1;

  1194.                 programChanged = true;

  1195.             }

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

  1197.             {

  1198.                 // current midi program > count

  1199.                 pData->midiprog.current = 0;

  1200.                 programChanged = true;

  1201.             }

  1202.             else

  1203.             {

  1204.                 // no change

  1205.                 pData->midiprog.current = current;

  1206.             }

  1207. 

  1208.             if (programChanged)

  1209.                 setMidiProgram(pData->midiprog.current, true, true, true);

  1210. 

  1211.             pData->engine->callback(ENGINE_CALLBACK_RELOAD_PROGRAMS, pData->id, 0, 0, 0.0f, nullptr);

  1212.         }

  1213.     }

  1214. 

  1215.     // -------------------------------------------------------------------

  1216.     // Plugin processing

  1217. 

  1218.     void activate() noexcept override

  1219.     {

  1220.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  1221.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  1222. 

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

  1224.         {

  1225.             try {

  1226.                 fDescriptor->activate(fHandle);

  1227.             } catch(...) {}

  1228. 

  1229.             if (fHandle2 != nullptr)

  1230.             {

  1231.                 try {

  1232.                     fDescriptor->activate(fHandle2);

  1233.                 } catch(...) {}

  1234.             }

  1235.         }

  1236.     }

  1237. 

  1238.     void deactivate() noexcept override

  1239.     {

  1240.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  1241.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  1242. 

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

  1244.         {

  1245.             try {

  1246.                 fDescriptor->deactivate(fHandle);

  1247.             } catch(...) {}

  1248. 

  1249.             if (fHandle2 != nullptr)

  1250.             {

  1251.                 try {

  1252.                     fDescriptor->deactivate(fHandle2);

  1253.                 } catch(...) {}

  1254.             }

  1255.         }

  1256.     }

  1257. 

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

  1259.     {

  1260.         // --------------------------------------------------------------------------------------------------------

  1261.         // Check if active

  1262. 

  1263.         if (! pData->active)

  1264.         {

  1265.             // disable any output sound

  1266.             for (uint32_t i=0; i < pData->audioOut.count; ++i)

  1267.                 FLOAT_CLEAR(outBuffer[i], frames);

  1268. 

  1269.             return;

  1270.         }

  1271. 

  1272.         fMidiEventCount = 0;

  1273.         carla_zeroStruct<NativeMidiEvent>(fMidiEvents, kPluginMaxMidiEvents*2);

  1274. 

  1275.         // --------------------------------------------------------------------------------------------------------

  1276.         // Check if needs reset

  1277. 

  1278.         if (pData->needsReset)

  1279.         {

  1280.             if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  1281.             {

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

  1283.                 {

  1284.                     fMidiEvents[k].data[0] = static_cast<uint8_t>(MIDI_STATUS_CONTROL_CHANGE + k);

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

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

  1287.                     fMidiEvents[k].size    = 3;

  1288. 

  1289.                     fMidiEvents[k+i].data[0] = static_cast<uint8_t>(MIDI_STATUS_CONTROL_CHANGE + k);

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

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

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

  1293.                 }

  1294. 

  1295.                 fMidiEventCount = MAX_MIDI_CHANNELS*2;

  1296.             }

  1297.             else if (pData->ctrlChannel >= 0 && pData->ctrlChannel < MAX_MIDI_CHANNELS)

  1298.             {

  1299.                 for (uint8_t k=0; k < MAX_MIDI_NOTE; ++k)

  1300.                 {

  1301.                     fMidiEvents[k].data[0] = static_cast<uint8_t>(MIDI_STATUS_NOTE_OFF + pData->ctrlChannel);

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

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

  1304.                     fMidiEvents[k].size    = 3;

  1305.                 }

  1306. 

  1307.                 fMidiEventCount = MAX_MIDI_NOTE;

  1308.             }

  1309. 

  1310.             pData->needsReset = false;

  1311.         }

  1312. 

  1313.         CARLA_PROCESS_CONTINUE_CHECK;

  1314. 

  1315.         // --------------------------------------------------------------------------------------------------------

  1316.         // Set TimeInfo

  1317. 

  1318.         const EngineTimeInfo& timeInfo(pData->engine->getTimeInfo());

  1319. 

  1320.         fTimeInfo.playing = timeInfo.playing;

  1321.         fTimeInfo.frame   = timeInfo.frame;

  1322.         fTimeInfo.usecs   = timeInfo.usecs;

  1323. 

  1324.         if (timeInfo.valid & EngineTimeInfo::kValidBBT)

  1325.         {

  1326.             fTimeInfo.bbt.valid = true;

  1327. 

  1328.             fTimeInfo.bbt.bar  = timeInfo.bbt.bar;

  1329.             fTimeInfo.bbt.beat = timeInfo.bbt.beat;

  1330.             fTimeInfo.bbt.tick = timeInfo.bbt.tick;

  1331.             fTimeInfo.bbt.barStartTick = timeInfo.bbt.barStartTick;

  1332. 

  1333.             fTimeInfo.bbt.beatsPerBar = timeInfo.bbt.beatsPerBar;

  1334.             fTimeInfo.bbt.beatType    = timeInfo.bbt.beatType;

  1335. 

  1336.             fTimeInfo.bbt.ticksPerBeat   = timeInfo.bbt.ticksPerBeat;

  1337.             fTimeInfo.bbt.beatsPerMinute = timeInfo.bbt.beatsPerMinute;

  1338.         }

  1339.         else

  1340.             fTimeInfo.bbt.valid = false;

  1341. 

  1342.         CARLA_PROCESS_CONTINUE_CHECK;

  1343. 

  1344.         // --------------------------------------------------------------------------------------------------------

  1345.         // Event Input and Processing

  1346. 

  1347.         if (pData->event.portIn != nullptr)

  1348.         {

  1349.             // ----------------------------------------------------------------------------------------------------

  1350.             // MIDI Input (External)

  1351. 

  1352.             if (pData->extNotes.mutex.tryLock())

  1353.             {

  1354.                 while (fMidiEventCount < kPluginMaxMidiEvents*2 && ! pData->extNotes.data.isEmpty())

  1355.                 {

  1356.                     const ExternalMidiNote& note(pData->extNotes.data.getFirst(true));

  1357. 

  1358.                     CARLA_SAFE_ASSERT_CONTINUE(note.channel >= 0 && note.channel < MAX_MIDI_CHANNELS);

  1359. 

  1360.                     fMidiEvents[fMidiEventCount].data[0] = static_cast<uint8_t>((note.velo > 0 ? MIDI_STATUS_NOTE_ON : MIDI_STATUS_NOTE_OFF) | (note.channel & MIDI_CHANNEL_BIT));

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

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

  1363.                     fMidiEvents[fMidiEventCount].size    = 3;

  1364. 

  1365.                     fMidiEventCount += 1;

  1366.                 }

  1367. 

  1368.                 pData->extNotes.mutex.unlock();

  1369. 

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

  1371. 

  1372.             // ----------------------------------------------------------------------------------------------------

  1373.             // Event Input (System)

  1374. 

  1375.             bool allNotesOffSent = false;

  1376.             bool sampleAccurate  = (pData->options & PLUGIN_OPTION_FIXED_BUFFERS) == 0;

  1377. 

  1378.             uint32_t time, nEvents = pData->event.portIn->getEventCount();

  1379.             uint32_t startTime  = 0;

  1380.             uint32_t timeOffset = 0;

  1381.             uint32_t nextBankId = 0;

  1382. 

  1383.             if (pData->midiprog.current >= 0 && pData->midiprog.count > 0)

  1384.                 nextBankId = pData->midiprog.data[pData->midiprog.current].bank;

  1385. 

  1386.             for (uint32_t i=0; i < nEvents; ++i)

  1387.             {

  1388.                 const EngineEvent& event(pData->event.portIn->getEvent(i));

  1389. 

  1390.                 time = event.time;

  1391. 

  1392.                 if (time >= frames)

  1393.                     continue;

  1394. 

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

  1396. 

  1397.                 if (time > timeOffset && sampleAccurate)

  1398.                 {

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

  1400.                     {

  1401.                         startTime  = 0;

  1402.                         timeOffset = time;

  1403. 

  1404.                         if (pData->midiprog.current >= 0 && pData->midiprog.count > 0)

  1405.                             nextBankId = pData->midiprog.data[pData->midiprog.current].bank;

  1406.                         else

  1407.                             nextBankId = 0;

  1408. 

  1409.                         if (fMidiEventCount > 0)

  1410.                         {

  1411.                             carla_zeroStruct<NativeMidiEvent>(fMidiEvents, fMidiEventCount);

  1412.                             fMidiEventCount = 0;

  1413.                         }

  1414.                     }

  1415.                     else

  1416.                         startTime += timeOffset;

  1417.                 }

  1418. 

  1419.                 // Control change

  1420.                 switch (event.type)

  1421.                 {

  1422.                 case kEngineEventTypeNull:

  1423.                     break;

  1424. 

  1425.                 case kEngineEventTypeControl:

  1426.                 {

  1427.                     const EngineControlEvent& ctrlEvent = event.ctrl;

  1428. 

  1429.                     switch (ctrlEvent.type)

  1430.                     {

  1431.                     case kEngineControlEventTypeNull:

  1432.                         break;

  1433. 

  1434.                     case kEngineControlEventTypeParameter:

  1435.                     {

  1436. #ifndef BUILD_BRIDGE

  1437.                         // Control backend stuff

  1438.                         if (event.channel == pData->ctrlChannel)

  1439.                         {

  1440.                             float value;

  1441. 

  1442.                             if (MIDI_IS_CONTROL_BREATH_CONTROLLER(ctrlEvent.param) && (pData->hints & PLUGIN_CAN_DRYWET) > 0)

  1443.                             {

  1444.                                 value = ctrlEvent.value;

  1445.                                 setDryWet(value, false, false);

  1446.                                 pData->postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_DRYWET, 0, value);

  1447.                             }

  1448. 

  1449.                             if (MIDI_IS_CONTROL_CHANNEL_VOLUME(ctrlEvent.param) && (pData->hints & PLUGIN_CAN_VOLUME) > 0)

  1450.                             {

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

  1452.                                 setVolume(value, false, false);

  1453.                                 pData->postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_VOLUME, 0, value);

  1454.                             }

  1455. 

  1456.                             if (MIDI_IS_CONTROL_BALANCE(ctrlEvent.param) && (pData->hints & PLUGIN_CAN_BALANCE) > 0)

  1457.                             {

  1458.                                 float left, right;

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

  1460. 

  1461.                                 if (value < 0.0f)

  1462.                                 {

  1463.                                     left  = -1.0f;

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

  1465.                                 }

  1466.                                 else if (value > 0.0f)

  1467.                                 {

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

  1469.                                     right = 1.0f;

  1470.                                 }

  1471.                                 else

  1472.                                 {

  1473.                                     left  = -1.0f;

  1474.                                     right = 1.0f;

  1475.                                 }

  1476. 

  1477.                                 setBalanceLeft(left, false, false);

  1478.                                 setBalanceRight(right, false, false);

  1479.                                 pData->postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_BALANCE_LEFT, 0, left);

  1480.                                 pData->postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_BALANCE_RIGHT, 0, right);

  1481.                             }

  1482.                         }

  1483. #endif

  1484. 

  1485.                         // Control plugin parameters

  1486.                         for (uint32_t k=0; k < pData->param.count; ++k)

  1487.                         {

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

  1489.                                 continue;

  1490.                             if (pData->param.data[k].midiCC != ctrlEvent.param)

  1491.                                 continue;

  1492.                             if (pData->param.data[k].type != PARAMETER_INPUT)

  1493.                                 continue;

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

  1495.                                 continue;

  1496. 

  1497.                             float value;

  1498. 

  1499.                             if (pData->param.data[k].hints & PARAMETER_IS_BOOLEAN)

  1500.                             {

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

  1502.                             }

  1503.                             else

  1504.                             {

  1505.                                 value = pData->param.ranges[k].getUnnormalizedValue(ctrlEvent.value);

  1506. 

  1507.                                 if (pData->param.data[k].hints & PARAMETER_IS_INTEGER)

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

  1509.                             }

  1510. 

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

  1512.                             pData->postponeRtEvent(kPluginPostRtEventParameterChange, static_cast<int32_t>(k), 0, value);

  1513.                         }

  1514. 

  1515.                         if ((pData->options & PLUGIN_OPTION_SEND_CONTROL_CHANGES) != 0 && ctrlEvent.param <= 0x5F)

  1516.                         {

  1517.                             if (fMidiEventCount >= kPluginMaxMidiEvents*2)

  1518.                                 continue;

  1519. 

  1520.                             fMidiEvents[fMidiEventCount].port    = 0;

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

  1522.                             fMidiEvents[fMidiEventCount].data[0] = static_cast<uint8_t>(MIDI_STATUS_CONTROL_CHANGE + event.channel);

  1523.                             fMidiEvents[fMidiEventCount].data[1] = static_cast<uint8_t>(ctrlEvent.param);

  1524.                             fMidiEvents[fMidiEventCount].data[2] = uint8_t(ctrlEvent.value*127.0f);

  1525.                             fMidiEvents[fMidiEventCount].size    = 3;

  1526. 

  1527.                             fMidiEventCount += 1;

  1528.                         }

  1529. 

  1530.                         break;

  1531.                     }

  1532. 

  1533.                     case kEngineControlEventTypeMidiBank:

  1534.                         if (event.channel == pData->ctrlChannel && (pData->options & PLUGIN_OPTION_MAP_PROGRAM_CHANGES) != 0)

  1535.                             nextBankId = ctrlEvent.param;

  1536.                         break;

  1537. 

  1538.                     case kEngineControlEventTypeMidiProgram:

  1539.                         if (event.channel < MAX_MIDI_CHANNELS && (pData->options & PLUGIN_OPTION_MAP_PROGRAM_CHANGES) != 0)

  1540.                         {

  1541.                             const uint32_t nextProgramId(ctrlEvent.param);

  1542. 

  1543.                             for (uint32_t k=0; k < pData->midiprog.count; ++k)

  1544.                             {

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

  1546.                                 {

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

  1548. 

  1549.                                     if (fHandle2 != nullptr)

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

  1551. 

  1552.                                     fCurMidiProgs[event.channel] = static_cast<int32_t>(k);

  1553. 

  1554.                                     if (event.channel == pData->ctrlChannel)

  1555.                                         pData->postponeRtEvent(kPluginPostRtEventMidiProgramChange, static_cast<int32_t>(k), 0, 0.0f);

  1556. 

  1557.                                     break;

  1558.                                 }

  1559.                             }

  1560.                         }

  1561.                         break;

  1562. 

  1563.                     case kEngineControlEventTypeAllSoundOff:

  1564.                         if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  1565.                         {

  1566.                             if (fMidiEventCount >= kPluginMaxMidiEvents*2)

  1567.                                 continue;

  1568. 

  1569.                             fMidiEvents[fMidiEventCount].port    = 0;

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

  1571.                             fMidiEvents[fMidiEventCount].data[0] = static_cast<uint8_t>(MIDI_STATUS_CONTROL_CHANGE + event.channel);

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

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

  1574.                             fMidiEvents[fMidiEventCount].size    = 3;

  1575. 

  1576.                             fMidiEventCount += 1;

  1577.                         }

  1578.                         break;

  1579. 

  1580.                     case kEngineControlEventTypeAllNotesOff:

  1581.                         if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  1582.                         {

  1583.                             if (event.channel == pData->ctrlChannel && ! allNotesOffSent)

  1584.                             {

  1585.                                 allNotesOffSent = true;

  1586.                                 sendMidiAllNotesOffToCallback();

  1587.                             }

  1588. 

  1589.                             if (fMidiEventCount >= kPluginMaxMidiEvents*2)

  1590.                                 continue;

  1591. 

  1592.                             fMidiEvents[fMidiEventCount].port    = 0;

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

  1594.                             fMidiEvents[fMidiEventCount].data[0] = static_cast<uint8_t>(MIDI_STATUS_CONTROL_CHANGE + event.channel);

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

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

  1597.                             fMidiEvents[fMidiEventCount].size    = 3;

  1598. 

  1599.                             fMidiEventCount += 1;

  1600.                         }

  1601.                         break;

  1602.                     }

  1603. 

  1604.                     break;

  1605.                 }

  1606. 

  1607.                 case kEngineEventTypeMidi:

  1608.                 {

  1609.                     if (fMidiEventCount >= kPluginMaxMidiEvents*2)

  1610.                         continue;

  1611. 

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

  1613. 

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

  1615.                     uint8_t channel = event.channel;

  1616. 

  1617.                     if (MIDI_IS_STATUS_CHANNEL_PRESSURE(status) && (pData->options & PLUGIN_OPTION_SEND_CHANNEL_PRESSURE) == 0)

  1618.                         continue;

  1619.                     if (MIDI_IS_STATUS_CONTROL_CHANGE(status) && (pData->options & PLUGIN_OPTION_SEND_CONTROL_CHANGES) == 0)

  1620.                         continue;

  1621.                     if (MIDI_IS_STATUS_POLYPHONIC_AFTERTOUCH(status) && (pData->options & PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH) == 0)

  1622.                         continue;

  1623.                     if (MIDI_IS_STATUS_PITCH_WHEEL_CONTROL(status) && (pData->options & PLUGIN_OPTION_SEND_PITCHBEND) == 0)

  1624.                         continue;

  1625. 

  1626.                     // Fix bad note-off

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

  1628.                         status = MIDI_STATUS_NOTE_OFF;

  1629. 

  1630.                     fMidiEvents[fMidiEventCount].port = 0;

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

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

  1633. 

  1634.                     fMidiEvents[fMidiEventCount].data[0] = static_cast<uint8_t>(status + channel);

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

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

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

  1638. 

  1639.                     fMidiEventCount += 1;

  1640. 

  1641.                     if (status == MIDI_STATUS_NOTE_ON)

  1642.                         pData->postponeRtEvent(kPluginPostRtEventNoteOn, channel, midiEvent.data[1], midiEvent.data[2]);

  1643.                     else if (status == MIDI_STATUS_NOTE_OFF)

  1644.                         pData->postponeRtEvent(kPluginPostRtEventNoteOff, channel, midiEvent.data[1], 0.0f);

  1645. 

  1646.                     break;

  1647.                 }

  1648.                 }

  1649.             }

  1650. 

  1651.             pData->postRtEvents.trySplice();

  1652. 

  1653.             if (frames > timeOffset)

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

  1655. 

  1656.         } // End of Event Input and Processing

  1657. 

  1658.         // --------------------------------------------------------------------------------------------------------

  1659.         // Plugin processing (no events)

  1660. 

  1661.         else

  1662.         {

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

  1664. 

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

  1666. 

  1667.         CARLA_PROCESS_CONTINUE_CHECK;

  1668. 

  1669.         // --------------------------------------------------------------------------------------------------------

  1670.         // Control and MIDI Output

  1671. 

  1672.         if (fMidiOut.count > 0 || pData->event.portOut != nullptr)

  1673.         {

  1674.             float value, curValue;

  1675. 

  1676.             for (uint32_t k=0; k < pData->param.count; ++k)

  1677.             {

  1678.                 if (pData->param.data[k].type != PARAMETER_OUTPUT)

  1679.                     continue;

  1680. 

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

  1682.                 pData->param.ranges[k].fixValue(curValue);

  1683. 

  1684.                 if (pData->param.data[k].midiCC > 0)

  1685.                 {

  1686.                     value = pData->param.ranges[k].getNormalizedValue(curValue);

  1687.                     pData->event.portOut->writeControlEvent(0, pData->param.data[k].midiChannel, kEngineControlEventTypeParameter, static_cast<uint16_t>(pData->param.data[k].midiCC), value);

  1688.                 }

  1689.             }

  1690. 

  1691.             // reverse lookup MIDI events

  1692.             for (uint32_t k = (kPluginMaxMidiEvents*2)-1; k >= fMidiEventCount; --k)

  1693.             {

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

  1695.                     break;

  1696. 

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

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

  1699. 

  1700.                 if (pData->event.portOut != nullptr)

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

  1702.                 else if (port < fMidiOut.count)

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

  1704.             }

  1705. 

  1706.         } // End of Control and MIDI Output

  1707.     }

  1708. 

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

  1710.     {

  1711.         CARLA_ASSERT(frames > 0);

  1712. 

  1713.         if (frames == 0)

  1714.             return false;

  1715. 

  1716.         if (pData->audioIn.count > 0)

  1717.         {

  1718.             CARLA_ASSERT(inBuffer != nullptr);

  1719.             if (inBuffer == nullptr)

  1720.                 return false;

  1721.         }

  1722.         if (pData->audioOut.count > 0)

  1723.         {

  1724.             CARLA_ASSERT(outBuffer != nullptr);

  1725.             if (outBuffer == nullptr)

  1726.                 return false;

  1727.         }

  1728. 

  1729.         uint32_t i, k;

  1730. 

  1731.         // --------------------------------------------------------------------------------------------------------

  1732.         // Try lock, silence otherwise

  1733. 

  1734.         if (pData->engine->isOffline())

  1735.         {

  1736.             pData->singleMutex.lock();

  1737.         }

  1738.         else if (! pData->singleMutex.tryLock())

  1739.         {

  1740.             for (i=0; i < pData->audioOut.count; ++i)

  1741.             {

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

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

  1744.             }

  1745. 

  1746.             return false;

  1747.         }

  1748. 

  1749.         // --------------------------------------------------------------------------------------------------------

  1750.         // Reset audio buffers

  1751. 

  1752.         for (i=0; i < pData->audioIn.count; ++i)

  1753.             FLOAT_COPY(fAudioInBuffers[i], inBuffer[i]+timeOffset, frames);

  1754. 

  1755.         for (i=0; i < pData->audioOut.count; ++i)

  1756.             FLOAT_CLEAR(fAudioOutBuffers[i], frames);

  1757. 

  1758.         // --------------------------------------------------------------------------------------------------------

  1759.         // Run plugin

  1760. 

  1761.         fIsProcessing = true;

  1762. 

  1763.         if (fHandle2 == nullptr)

  1764.         {

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

  1766.         }

  1767.         else

  1768.         {

  1769.             fDescriptor->process(fHandle,

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

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

  1772.                                  frames, fMidiEvents, fMidiEventCount);

  1773. 

  1774.             fDescriptor->process(fHandle2,

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

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

  1777.                                  frames, fMidiEvents, fMidiEventCount);

  1778.         }

  1779. 

  1780.         fIsProcessing = false;

  1781.         fTimeInfo.frame += frames;

  1782. 

  1783. #ifndef BUILD_BRIDGE

  1784.         // --------------------------------------------------------------------------------------------------------

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

  1786. 

  1787.         {

  1788.             const bool doDryWet  = (pData->hints & PLUGIN_CAN_DRYWET) != 0 && pData->postProc.dryWet != 1.0f;

  1789.             const bool doBalance = (pData->hints & PLUGIN_CAN_BALANCE) != 0 && (pData->postProc.balanceLeft != -1.0f || pData->postProc.balanceRight != 1.0f);

  1790. 

  1791.             bool isPair;

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

  1793. 

  1794.             for (i=0; i < pData->audioOut.count; ++i)

  1795.             {

  1796.                 // Dry/Wet

  1797.                 if (doDryWet)

  1798.                 {

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

  1800.                     {

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

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

  1803.                     }

  1804.                 }

  1805. 

  1806.                 // Balance

  1807.                 if (doBalance)

  1808.                 {

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

  1810. 

  1811.                     if (isPair)

  1812.                     {

  1813.                         CARLA_ASSERT(i+1 < pData->audioOut.count);

  1814.                         FLOAT_COPY(oldBufLeft, fAudioOutBuffers[i], frames);

  1815.                     }

  1816. 

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

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

  1819. 

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

  1821.                     {

  1822.                         if (isPair)

  1823.                         {

  1824.                             // left

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

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

  1827.                         }

  1828.                         else

  1829.                         {

  1830.                             // right

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

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

  1833.                         }

  1834.                     }

  1835.                 }

  1836. 

  1837.                 // Volume (and buffer copy)

  1838.                 {

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

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

  1841.                 }

  1842.             }

  1843. 

  1844.         } // End of Post-processing

  1845. #else

  1846.         for (i=0; i < pData->audioOut.count; ++i)

  1847.         {

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

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

  1850.         }

  1851. #endif

  1852. 

  1853.         // --------------------------------------------------------------------------------------------------------

  1854. 

  1855.         pData->singleMutex.unlock();

  1856.         return true;

  1857.     }

  1858. 

  1859.     void bufferSizeChanged(const uint32_t newBufferSize) override

  1860.     {

  1861.         CARLA_ASSERT_INT(newBufferSize > 0, newBufferSize);

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

  1863. 

  1864.         for (uint32_t i=0; i < pData->audioIn.count; ++i)

  1865.         {

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

  1867.                 delete[] fAudioInBuffers[i];

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

  1869.         }

  1870. 

  1871.         for (uint32_t i=0; i < pData->audioOut.count; ++i)

  1872.         {

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

  1874.                 delete[] fAudioOutBuffers[i];

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

  1876.         }

  1877. 

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

  1879.         {

  1880.             fDescriptor->dispatcher(fHandle, PLUGIN_OPCODE_BUFFER_SIZE_CHANGED, 0, static_cast<intptr_t>(newBufferSize), nullptr, 0.0f);

  1881. 

  1882.             if (fHandle2 != nullptr)

  1883.                 fDescriptor->dispatcher(fHandle2, PLUGIN_OPCODE_BUFFER_SIZE_CHANGED, 0, static_cast<intptr_t>(newBufferSize), nullptr, 0.0f);

  1884.         }

  1885.     }

  1886. 

  1887.     void sampleRateChanged(const double newSampleRate) override

  1888.     {

  1889.         CARLA_ASSERT_INT(newSampleRate > 0.0, newSampleRate);

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

  1891. 

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

  1893.         {

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

  1895. 

  1896.             if (fHandle2 != nullptr)

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

  1898.         }

  1899.     }

  1900. 

  1901.     void offlineModeChanged(const bool isOffline) override

  1902.     {

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

  1904.         {

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

  1906. 

  1907.             if (fHandle2 != nullptr)

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

  1909.         }

  1910.     }

  1911. 

  1912.     // -------------------------------------------------------------------

  1913.     // Plugin buffers

  1914. 

  1915.     void initBuffers() override

  1916.     {

  1917.         fMidiIn.initBuffers();

  1918.         fMidiOut.initBuffers();

  1919. 

  1920.         CarlaPlugin::initBuffers();

  1921.     }

  1922. 

  1923.     void clearBuffers() override

  1924.     {

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

  1926. 

  1927.         if (fAudioInBuffers != nullptr)

  1928.         {

  1929.             for (uint32_t i=0; i < pData->audioIn.count; ++i)

  1930.             {

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

  1932.                 {

  1933.                     delete[] fAudioInBuffers[i];

  1934.                     fAudioInBuffers[i] = nullptr;

  1935.                 }

  1936.             }

  1937. 

  1938.             delete[] fAudioInBuffers;

  1939.             fAudioInBuffers = nullptr;

  1940.         }

  1941. 

  1942.         if (fAudioOutBuffers != nullptr)

  1943.         {

  1944.             for (uint32_t i=0; i < pData->audioOut.count; ++i)

  1945.             {

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

  1947.                 {

  1948.                     delete[] fAudioOutBuffers[i];

  1949.                     fAudioOutBuffers[i] = nullptr;

  1950.                 }

  1951.             }

  1952. 

  1953.             delete[] fAudioOutBuffers;

  1954.             fAudioOutBuffers = nullptr;

  1955.         }

  1956. 

  1957.         fMidiIn.clear();

  1958.         fMidiOut.clear();

  1959. 

  1960.         CarlaPlugin::clearBuffers();

  1961. 

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

  1963.     }

  1964. 

  1965.     // -------------------------------------------------------------------

  1966.     // Post-poned UI Stuff

  1967. 

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

  1969.     {

  1970.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  1971.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  1972.         CARLA_SAFE_ASSERT_RETURN(index < pData->param.count,);

  1973. 

  1974.         if (! fIsUiVisible)

  1975.             return;

  1976. 

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

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

  1979.     }

  1980. 

  1981.     void uiMidiProgramChange(const uint32_t index) noexcept override

  1982.     {

  1983.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  1984.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  1985.         CARLA_SAFE_ASSERT_RETURN(index < pData->midiprog.count,);

  1986. 

  1987.         if (! fIsUiVisible)

  1988.             return;

  1989.         if (index >= pData->midiprog.count)

  1990.             return;

  1991. 

  1992.         if (fDescriptor->ui_set_midi_program != nullptr)

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

  1994.     }

  1995. 

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

  1997.     {

  1998.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  1999.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  2000.         CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2001.         CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

  2002.         CARLA_SAFE_ASSERT_RETURN(velo > 0 && velo < MAX_MIDI_VALUE,);

  2003. 

  2004.         if (! fIsUiVisible)

  2005.             return;

  2006. 

  2007.         // TODO

  2008.     }

  2009. 

  2010.     void uiNoteOff(const uint8_t channel, const uint8_t note) noexcept override

  2011.     {

  2012.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  2013.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  2014.         CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2015.         CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

  2016. 

  2017.         if (! fIsUiVisible)

  2018.             return;

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

  2020.             return;

  2021. 

  2022.         // TODO

  2023.     }

  2024. 

  2025.     // -------------------------------------------------------------------

  2026. 

  2027. protected:

  2028.     uint32_t handleGetBufferSize() const noexcept

  2029.     {

  2030.         return pData->engine->getBufferSize();

  2031.     }

  2032. 

  2033.     double handleGetSampleRate() const noexcept

  2034.     {

  2035.         return pData->engine->getSampleRate();

  2036.     }

  2037. 

  2038.     bool handleIsOffline() const noexcept

  2039.     {

  2040.         return pData->engine->isOffline();

  2041.     }

  2042. 

  2043.     const NativeTimeInfo* handleGetTimeInfo() const noexcept

  2044.     {

  2045.         CARLA_SAFE_ASSERT_RETURN(fIsProcessing, nullptr);

  2046. 

  2047.         return &fTimeInfo;

  2048.     }

  2049. 

  2050.     bool handleWriteMidiEvent(const NativeMidiEvent* const event)

  2051.     {

  2052.         CARLA_ASSERT(pData->enabled);

  2053.         CARLA_ASSERT(fIsProcessing);

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

  2055.         CARLA_ASSERT(event != nullptr);

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

  2057. 

  2058.         if (! pData->enabled)

  2059.             return false;

  2060.         if (fMidiOut.count == 0)

  2061.             return false;

  2062.         if (event == nullptr)

  2063.             return false;

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

  2065.             return false;

  2066.         if (! fIsProcessing)

  2067.         {

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

  2069.             return false;

  2070.         }

  2071. 

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

  2073.         for (uint32_t i=(kPluginMaxMidiEvents*2)-1; i > fMidiEventCount; --i)

  2074.         {

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

  2076.             {

  2077.                 std::memcpy(&fMidiEvents[i], event, sizeof(NativeMidiEvent));

  2078.                 return true;

  2079.             }

  2080.         }

  2081. 

  2082.         return false;

  2083.     }

  2084. 

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

  2086.     {

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

  2088.     }

  2089. 

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

  2091.     {

  2092.         setCustomData(CUSTOM_DATA_TYPE_STRING, key, value, false);

  2093.     }

  2094. 

  2095.     void handleUiClosed()

  2096.     {

  2097.         pData->engine->callback(ENGINE_CALLBACK_UI_STATE_CHANGED, pData->id, 0, 0, 0.0f, nullptr);

  2098.         fIsUiVisible = false;

  2099.     }

  2100. 

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

  2102.     {

  2103.         return pData->engine->runFileCallback(FILE_CALLBACK_OPEN, isDir, title, filter);

  2104.     }

  2105. 

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

  2107.     {

  2108.         return pData->engine->runFileCallback(FILE_CALLBACK_SAVE, isDir, title, filter);

  2109.     }

  2110. 

  2111.     intptr_t handleDispatcher(const NativeHostDispatcherOpcode opcode, const int32_t index, const intptr_t value, void* const ptr, const float opt)

  2112.     {

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

  2114. 

  2115.         intptr_t ret = 0;

  2116. 

  2117.         switch (opcode)

  2118.         {

  2119.         case ::HOST_OPCODE_NULL:

  2120.             break;

  2121. #ifdef BUILD_BRIDGE

  2122.         case ::HOST_OPCODE_SET_VOLUME:

  2123.         case ::HOST_OPCODE_SET_DRYWET:

  2124.         case ::HOST_OPCODE_SET_BALANCE_LEFT:

  2125.         case ::HOST_OPCODE_SET_BALANCE_RIGHT:

  2126.         case ::HOST_OPCODE_SET_PANNING:

  2127.             break;

  2128. #else

  2129.         case ::HOST_OPCODE_SET_VOLUME:

  2130.             setVolume(opt, true, true);

  2131.             break;

  2132.         case ::HOST_OPCODE_SET_DRYWET:

  2133.             setDryWet(opt, true, true);

  2134.             break;

  2135.         case ::HOST_OPCODE_SET_BALANCE_LEFT:

  2136.             setBalanceLeft(opt, true, true);

  2137.             break;

  2138.         case ::HOST_OPCODE_SET_BALANCE_RIGHT:

  2139.             setBalanceRight(opt, true, true);

  2140.             break;

  2141.         case ::HOST_OPCODE_SET_PANNING:

  2142.             setPanning(opt, true, true);

  2143.             break;

  2144. #endif

  2145.         case HOST_OPCODE_GET_PARAMETER_MIDI_CC:

  2146.         case HOST_OPCODE_SET_PARAMETER_MIDI_CC:

  2147.             // TODO

  2148.             break;

  2149.         case ::HOST_OPCODE_SET_PROCESS_PRECISION:

  2150.             // TODO

  2151.             break;

  2152.         case ::HOST_OPCODE_UPDATE_PARAMETER:

  2153.             // TODO

  2154.             pData->engine->callback(ENGINE_CALLBACK_UPDATE, pData->id, -1, 0, 0.0f, nullptr);

  2155.             break;

  2156.         case ::HOST_OPCODE_UPDATE_MIDI_PROGRAM:

  2157.             // TODO

  2158.             pData->engine->callback(ENGINE_CALLBACK_UPDATE, pData->id, -1, 0, 0.0f, nullptr);

  2159.             break;

  2160.         case ::HOST_OPCODE_RELOAD_PARAMETERS:

  2161.             reload(); // FIXME

  2162.             pData->engine->callback(ENGINE_CALLBACK_RELOAD_PARAMETERS, pData->id, -1, 0, 0.0f, nullptr);

  2163.             break;

  2164.         case ::HOST_OPCODE_RELOAD_MIDI_PROGRAMS:

  2165.             reloadPrograms(false);

  2166.             pData->engine->callback(ENGINE_CALLBACK_RELOAD_PROGRAMS, pData->id, -1, 0, 0.0f, nullptr);

  2167.             break;

  2168.         case ::HOST_OPCODE_RELOAD_ALL:

  2169.             reload();

  2170.             pData->engine->callback(ENGINE_CALLBACK_RELOAD_ALL, pData->id, -1, 0, 0.0f, nullptr);

  2171.             break;

  2172.         case HOST_OPCODE_UI_UNAVAILABLE:

  2173.             pData->engine->callback(ENGINE_CALLBACK_UI_STATE_CHANGED, pData->id, -1, 0, 0.0f, nullptr);

  2174.             break;

  2175.         }

  2176. 

  2177.         return ret;

  2178. 

  2179.         // unused for now

  2180.         (void)index;

  2181.         (void)value;

  2182.         (void)ptr;

  2183.     }

  2184. 

  2185.     // -------------------------------------------------------------------

  2186. 

  2187. public:

  2188.     static size_t getPluginCount() noexcept

  2189.     {

  2190.         return gPluginDescriptors.count();

  2191.     }

  2192. 

  2193.     static const NativePluginDescriptor* getPluginDescriptor(const size_t index) noexcept

  2194.     {

  2195.         CARLA_SAFE_ASSERT_RETURN(index < gPluginDescriptors.count(), nullptr);

  2196. 

  2197.         return gPluginDescriptors.getAt(index);

  2198.     }

  2199. 

  2200.     // -------------------------------------------------------------------

  2201. 

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

  2203.     {

  2204.         CARLA_SAFE_ASSERT_RETURN(pData->engine != nullptr, false);

  2205. 

  2206.         // ---------------------------------------------------------------

  2207.         // first checks

  2208. 

  2209.         if (pData->client != nullptr)

  2210.         {

  2211.             pData->engine->setLastError("Plugin client is already registered");

  2212.             return false;

  2213.         }

  2214. 

  2215.         if (label == nullptr && label[0] != '\0')

  2216.         {

  2217.             pData->engine->setLastError("null label");

  2218.             return false;

  2219.         }

  2220. 

  2221.         // ---------------------------------------------------------------

  2222.         // get descriptor that matches label

  2223. 

  2224.         for (LinkedList<const NativePluginDescriptor*>::Itenerator it = gPluginDescriptors.begin(); it.valid(); it.next())

  2225.         {

  2226.             fDescriptor = it.getValue();

  2227. 

  2228.             CARLA_SAFE_ASSERT_BREAK(fDescriptor != nullptr);

  2229. 

  2230.             carla_debug("Check vs \"%s\"", fDescriptor->label);

  2231. 

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

  2233.                 break;

  2234. 

  2235.             fDescriptor = nullptr;

  2236.         }

  2237. 

  2238.         if (fDescriptor == nullptr)

  2239.         {

  2240.             pData->engine->setLastError("Invalid internal plugin");

  2241.             return false;

  2242.         }

  2243. 

  2244.         // ---------------------------------------------------------------

  2245.         // set icon

  2246. 

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

  2248.             pData->iconName = carla_strdup("file");

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

  2250.             pData->iconName = carla_strdup("file");

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

  2252.             pData->iconName = carla_strdup("file");

  2253. 

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

  2255.             pData->iconName = carla_strdup("distrho");

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

  2257.             pData->iconName = carla_strdup("distrho");

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

  2259.             pData->iconName = carla_strdup("distrho");

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

  2261.             pData->iconName = carla_strdup("distrho");

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

  2263.             pData->iconName = carla_strdup("distrho");

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

  2265.             pData->iconName = carla_strdup("distrho");

  2266. 

  2267.         // ---------------------------------------------------------------

  2268.         // get info

  2269. 

  2270.         if (name != nullptr && name[0] != '\0')

  2271.             pData->name = pData->engine->getUniquePluginName(name);

  2272.         else if (fDescriptor->name != nullptr && fDescriptor->name[0] != '\0')

  2273.             pData->name = pData->engine->getUniquePluginName(fDescriptor->name);

  2274.         else

  2275.             pData->name = pData->engine->getUniquePluginName(label);

  2276. 

  2277.         {

  2278.             CARLA_ASSERT(fHost.uiName == nullptr);

  2279. 

  2280.             char uiName[std::strlen(pData->name)+6+1];

  2281.             std::strcpy(uiName, pData->name);

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

  2283. 

  2284.             fHost.uiName = carla_strdup(uiName);

  2285.         }

  2286. 

  2287.         // ---------------------------------------------------------------

  2288.         // register client

  2289. 

  2290.         pData->client = pData->engine->addClient(this);

  2291. 

  2292.         if (pData->client == nullptr || ! pData->client->isOk())

  2293.         {

  2294.             pData->engine->setLastError("Failed to register plugin client");

  2295.             return false;

  2296.         }

  2297. 

  2298.         // ---------------------------------------------------------------

  2299.         // initialize plugin

  2300. 

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

  2302. 

  2303.         if (fHandle == nullptr)

  2304.         {

  2305.             pData->engine->setLastError("Plugin failed to initialize");

  2306.             return false;

  2307.         }

  2308. 

  2309.         // ---------------------------------------------------------------

  2310.         // load plugin settings

  2311. 

  2312.         {

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

  2314. 

  2315.             // set default options

  2316.             pData->options = 0x0;

  2317. 

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

  2319.                 pData->options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  2320. 

  2321.             if (getMidiInCount() > 0 || (fDescriptor->hints & ::PLUGIN_NEEDS_FIXED_BUFFERS) != 0)

  2322.                 pData->options |= PLUGIN_OPTION_FIXED_BUFFERS;

  2323. 

  2324.             if (pData->engine->getOptions().forceStereo)

  2325.                 pData->options |= PLUGIN_OPTION_FORCE_STEREO;

  2326. 

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

  2328.                 pData->options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

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

  2330.                 pData->options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

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

  2332.                 pData->options |= PLUGIN_OPTION_SEND_PITCHBEND;

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

  2334.                 pData->options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  2335. 

  2336.             // set identifier string

  2337.             CarlaString identifier("Native/");

  2338.             identifier += label;

  2339.             pData->identifier = identifier.dup();

  2340. 

  2341.             // load settings

  2342.             pData->options = pData->loadSettings(pData->options, getOptionsAvailable());

  2343. 

  2344.             // ignore settings, we need this anyway

  2345.             if (getMidiInCount() > 0 || (fDescriptor->hints & ::PLUGIN_NEEDS_FIXED_BUFFERS) != 0)

  2346.                 pData->options |= PLUGIN_OPTION_FIXED_BUFFERS;

  2347.         }

  2348. 

  2349.         return true;

  2350.     }

  2351. 

  2352. 

  2353. private:

  2354.     NativePluginHandle   fHandle;

  2355.     NativePluginHandle   fHandle2;

  2356.     NativeHostDescriptor fHost;

  2357.     const NativePluginDescriptor* fDescriptor;

  2358. 

  2359.     bool fIsProcessing;

  2360.     bool fIsUiVisible;

  2361. 

  2362.     float**         fAudioInBuffers;

  2363.     float**         fAudioOutBuffers;

  2364.     uint32_t        fMidiEventCount;

  2365.     NativeMidiEvent fMidiEvents[kPluginMaxMidiEvents*2];

  2366. 

  2367.     int32_t fCurMidiProgs[MAX_MIDI_CHANNELS];

  2368. 

  2369.     NativePluginMidiData fMidiIn;

  2370.     NativePluginMidiData fMidiOut;

  2371. 

  2372.     NativeTimeInfo fTimeInfo;

  2373. 

  2374.     // -------------------------------------------------------------------

  2375. 

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

  2377. 

  2378.     static uint32_t carla_host_get_buffer_size(NativeHostHandle handle) noexcept

  2379.     {

  2380.         return handlePtr->handleGetBufferSize();

  2381.     }

  2382. 

  2383.     static double carla_host_get_sample_rate(NativeHostHandle handle) noexcept

  2384.     {

  2385.         return handlePtr->handleGetSampleRate();

  2386.     }

  2387. 

  2388.     static bool carla_host_is_offline(NativeHostHandle handle) noexcept

  2389.     {

  2390.         return handlePtr->handleIsOffline();

  2391.     }

  2392. 

  2393.     static const NativeTimeInfo* carla_host_get_time_info(NativeHostHandle handle) noexcept

  2394.     {

  2395.         return handlePtr->handleGetTimeInfo();

  2396.     }

  2397. 

  2398.     static bool carla_host_write_midi_event(NativeHostHandle handle, const NativeMidiEvent* event)

  2399.     {

  2400.         return handlePtr->handleWriteMidiEvent(event);

  2401.     }

  2402. 

  2403.     static void carla_host_ui_parameter_changed(NativeHostHandle handle, uint32_t index, float value)

  2404.     {

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

  2406.     }

  2407. 

  2408.     static void carla_host_ui_custom_data_changed(NativeHostHandle handle, const char* key, const char* value)

  2409.     {

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

  2411.     }

  2412. 

  2413.     static void carla_host_ui_closed(NativeHostHandle handle)

  2414.     {

  2415.         handlePtr->handleUiClosed();

  2416.     }

  2417. 

  2418.     static const char* carla_host_ui_open_file(NativeHostHandle handle, bool isDir, const char* title, const char* filter)

  2419.     {

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

  2421.     }

  2422. 

  2423.     static const char* carla_host_ui_save_file(NativeHostHandle handle, bool isDir, const char* title, const char* filter)

  2424.     {

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

  2426.     }

  2427. 

  2428.     static intptr_t carla_host_dispatcher(NativeHostHandle handle, NativeHostDispatcherOpcode opcode, int32_t index, intptr_t value, void* ptr, float opt)

  2429.     {

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

  2431.     }

  2432. 

  2433.     #undef handlePtr

  2434. 

  2435.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(NativePlugin)

  2436. };

  2437. 

  2438. CARLA_BACKEND_END_NAMESPACE

  2439. 

  2440. #endif // WANT_NATIVE

  2441. 

  2442. // -----------------------------------------------------------------------

  2443. 

  2444. CARLA_BACKEND_START_NAMESPACE

  2445. 

  2446. #ifdef WANT_NATIVE

  2447. size_t CarlaPlugin::getNativePluginCount() noexcept

  2448. {

  2449.     return NativePlugin::getPluginCount();

  2450. }

  2451. 

  2452. const NativePluginDescriptor* CarlaPlugin::getNativePluginDescriptor(const size_t index) noexcept

  2453. {

  2454.     return NativePlugin::getPluginDescriptor(index);

  2455. }

  2456. #endif

  2457. 

  2458. // -----------------------------------------------------------------------

  2459. 

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

  2461. {

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

  2463. 

  2464. #ifdef WANT_NATIVE

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

  2466. 

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

  2468.     {

  2469.         delete plugin;

  2470.         return nullptr;

  2471.     }

  2472. 

  2473.     plugin->reload();

  2474. 

  2475.     if (init.engine->getProccessMode() == ENGINE_PROCESS_MODE_CONTINUOUS_RACK && ! plugin->canRunInRack())

  2476.     {

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

  2478.         delete plugin;

  2479.         return nullptr;

  2480.     }

  2481. 

  2482.     return plugin;

  2483. #else

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

  2485.     return nullptr;

  2486. #endif

  2487. }

  2488. 

  2489. CARLA_BACKEND_END_NAMESPACE

  2490. 

  2491. // -----------------------------------------------------------------------