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.
2960 Commits
16 Branches
220MB
Tree: 11b0015713
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '11b0015713'
${ noResults }
Carla/source/backend/plugin/CarlaPluginNative.cpp

2537 lines
91KB
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. #include "CarlaMathUtils.hpp"

  22. #include "CarlaNative.h"

  23. 

  24. #include "juce_core.h"

  25. 

  26. using juce::jmax;

  27. using juce::String;

  28. using juce::StringArray;

  29. 

  30. CARLA_EXTERN_C

  31. std::size_t carla_getNativePluginCount() noexcept;

  32. 

  33. CARLA_EXTERN_C

  34. const NativePluginDescriptor* carla_getNativePluginDescriptor(const std::size_t index) noexcept;

  35. 

  36. // -----------------------------------------------------------------------

  37. 

  38. static LinkedList<const NativePluginDescriptor*> gPluginDescriptors;

  39. 

  40. void carla_register_native_plugin(const NativePluginDescriptor* desc)

  41. {

  42.     gPluginDescriptors.append(desc);

  43. }

  44. 

  45. // -----------------------------------------------------------------------

  46. 

  47. static

  48. class NativePluginInitializer

  49. {

  50. public:

  51.     NativePluginInitializer() noexcept

  52.         : fNeedsInit(true) {}

  53. 

  54.     ~NativePluginInitializer() noexcept

  55.     {

  56.         gPluginDescriptors.clear();

  57.     }

  58. 

  59.     void initIfNeeded() noexcept

  60.     {

  61.         if (! fNeedsInit)

  62.             return;

  63. 

  64.         fNeedsInit = false;

  65. 

  66.         try {

  67.             carla_register_all_native_plugins();

  68.         } CARLA_SAFE_EXCEPTION("carla_register_all_native_plugins")

  69.     }

  70. 

  71. private:

  72.     bool fNeedsInit;

  73. 

  74. } sPluginInitializer;

  75. 

  76. // -----------------------------------------------------------------------

  77. 

  78. std::size_t carla_getNativePluginCount() noexcept

  79. {

  80.     sPluginInitializer.initIfNeeded();

  81.     return gPluginDescriptors.count();

  82. }

  83. 

  84. const NativePluginDescriptor* carla_getNativePluginDescriptor(const std::size_t index) noexcept

  85. {

  86.     sPluginInitializer.initIfNeeded();

  87.     return gPluginDescriptors.getAt(index, nullptr);

  88. }

  89. 

  90. // -----------------------------------------------------------------------

  91. 

  92. CARLA_BACKEND_START_NAMESPACE

  93. 

  94. // -----------------------------------------------------------------------

  95. 

  96. struct NativePluginMidiData {

  97.     uint32_t  count;

  98.     uint32_t* indexes;

  99.     CarlaEngineEventPort** ports;

  100. 

  101.     NativePluginMidiData() noexcept

  102.         : count(0),

  103.           indexes(nullptr),

  104.           ports(nullptr) {}

  105. 

  106.     ~NativePluginMidiData() noexcept

  107.     {

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

  109.         CARLA_SAFE_ASSERT(indexes == nullptr);

  110.         CARLA_SAFE_ASSERT(ports == nullptr);

  111.     }

  112. 

  113.     void createNew(const uint32_t newCount)

  114.     {

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

  116.         CARLA_SAFE_ASSERT_RETURN(indexes == nullptr,);

  117.         CARLA_SAFE_ASSERT_RETURN(ports == nullptr,);

  118.         CARLA_SAFE_ASSERT_RETURN(newCount > 0,);

  119. 

  120.         indexes = new uint32_t[newCount];

  121.         ports   = new CarlaEngineEventPort*[newCount];

  122.         count   = newCount;

  123. 

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

  125.             indexes[i] = 0;

  126. 

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

  128.             ports[i] = nullptr;

  129.     }

  130. 

  131.     void clear() noexcept

  132.     {

  133.         if (ports != nullptr)

  134.         {

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

  136.             {

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

  138.                 {

  139.                     delete ports[i];

  140.                     ports[i] = nullptr;

  141.                 }

  142.             }

  143. 

  144.             delete[] ports;

  145.             ports = nullptr;

  146.         }

  147. 

  148.         if (indexes != nullptr)

  149.         {

  150.             delete[] indexes;

  151.             indexes = nullptr;

  152.         }

  153. 

  154.         count = 0;

  155.     }

  156. 

  157.     void initBuffers() const noexcept

  158.     {

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

  160.         {

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

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

  163.         }

  164.     }

  165. 

  166.     CARLA_DECLARE_NON_COPY_STRUCT(NativePluginMidiData)

  167. };

  168. 

  169. // -----------------------------------------------------

  170. 

  171. class CarlaPluginNative : public CarlaPlugin

  172. {

  173. public:

  174.     CarlaPluginNative(CarlaEngine* const engine, const uint id)

  175.         : CarlaPlugin(engine, id),

  176.           fHandle(nullptr),

  177.           fHandle2(nullptr),

  178.           fHost(),

  179.           fDescriptor(nullptr),

  180.           fIsProcessing(false),

  181.           fIsUiAvailable(false),

  182.           fIsUiVisible(false),

  183.           fAudioInBuffers(nullptr),

  184.           fAudioOutBuffers(nullptr),

  185.           fMidiEventCount(0),

  186.           fMidiIn(),

  187.           fMidiOut(),

  188.           fTimeInfo(),

  189.           leakDetector_CarlaPluginNative()

  190.     {

  191.         carla_debug("CarlaPluginNative::CarlaPluginNative(%p, %i)", engine, id);

  192. 

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

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

  195.         carla_zeroStruct<NativeTimeInfo>(fTimeInfo);

  196. 

  197.         fHost.handle      = this;

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

  199.         fHost.uiName      = nullptr;

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

  201. 

  202.         fHost.get_buffer_size        = carla_host_get_buffer_size;

  203.         fHost.get_sample_rate        = carla_host_get_sample_rate;

  204.         fHost.is_offline             = carla_host_is_offline;

  205.         fHost.get_time_info          = carla_host_get_time_info;

  206.         fHost.write_midi_event       = carla_host_write_midi_event;

  207.         fHost.ui_parameter_changed   = carla_host_ui_parameter_changed;

  208.         fHost.ui_custom_data_changed = carla_host_ui_custom_data_changed;

  209.         fHost.ui_closed              = carla_host_ui_closed;

  210.         fHost.ui_open_file           = carla_host_ui_open_file;

  211.         fHost.ui_save_file           = carla_host_ui_save_file;

  212.         fHost.dispatcher             = carla_host_dispatcher;

  213.     }

  214. 

  215.     ~CarlaPluginNative() override

  216.     {

  217.         carla_debug("CarlaPluginNative::~CarlaPluginNative()");

  218. 

  219.         // close UI

  220.         if (pData->hints & PLUGIN_HAS_CUSTOM_UI)

  221.         {

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

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

  224. 

  225.             pData->transientTryCounter = 0;

  226.         }

  227. 

  228.         pData->singleMutex.lock();

  229.         pData->masterMutex.lock();

  230. 

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

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

  233. 

  234.         CARLA_ASSERT(! fIsProcessing);

  235. 

  236.         if (pData->active)

  237.         {

  238.             deactivate();

  239.             pData->active = false;

  240.         }

  241. 

  242.         if (fDescriptor != nullptr)

  243.         {

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

  245.             {

  246.                 if (fHandle != nullptr)

  247.                     fDescriptor->cleanup(fHandle);

  248.                 if (fHandle2 != nullptr)

  249.                     fDescriptor->cleanup(fHandle2);

  250.             }

  251. 

  252.             fHandle  = nullptr;

  253.             fHandle2 = nullptr;

  254.             fDescriptor = nullptr;

  255.         }

  256. 

  257.         if (fHost.resourceDir != nullptr)

  258.         {

  259.             delete[] fHost.resourceDir;

  260.             fHost.resourceDir = nullptr;

  261.         }

  262. 

  263.         if (fHost.uiName != nullptr)

  264.         {

  265.             delete[] fHost.uiName;

  266.             fHost.uiName = nullptr;

  267.         }

  268. 

  269.         clearBuffers();

  270.     }

  271. 

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

  273.     // Information (base)

  274. 

  275.     PluginType getType() const noexcept override

  276.     {

  277.         return PLUGIN_INTERNAL;

  278.     }

  279. 

  280.     PluginCategory getCategory() const noexcept override

  281.     {

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

  283. 

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

  285.     }

  286. 

  287.     // -------------------------------------------------------------------

  288.     // Information (count)

  289. 

  290.     uint32_t getMidiInCount() const noexcept override

  291.     {

  292.         return fMidiIn.count;

  293.     }

  294. 

  295.     uint32_t getMidiOutCount() const noexcept override

  296.     {

  297.         return fMidiOut.count;

  298.     }

  299. 

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

  301.     {

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

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

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

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

  306. 

  307.         // FIXME - try

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

  309.             return param->scalePointCount;

  310. 

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

  312.         return 0;

  313.     }

  314. 

  315.     // -------------------------------------------------------------------

  316.     // Information (current data)

  317. 

  318.     // nothing

  319. 

  320.     // -------------------------------------------------------------------

  321.     // Information (per-plugin data)

  322. 

  323.     uint getOptionsAvailable() const noexcept override

  324.     {

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

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

  327. 

  328.         // FIXME - try

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

  330. 

  331.         uint options = 0x0;

  332. 

  333.         if (getMidiInCount() == 0 && (fDescriptor->hints & NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS) == 0)

  334.             options |= PLUGIN_OPTION_FIXED_BUFFERS;

  335. 

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

  337.         {

  338.             if (pData->options & PLUGIN_OPTION_FORCE_STEREO)

  339.                 options |= PLUGIN_OPTION_FORCE_STEREO;

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

  341.                 options |= PLUGIN_OPTION_FORCE_STEREO;

  342.         }

  343. 

  344.         if (fDescriptor->supports & NATIVE_PLUGIN_SUPPORTS_CONTROL_CHANGES)

  345.             options |= PLUGIN_OPTION_SEND_CONTROL_CHANGES;

  346.         if (fDescriptor->supports & NATIVE_PLUGIN_SUPPORTS_CHANNEL_PRESSURE)

  347.             options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  348.         if (fDescriptor->supports & NATIVE_PLUGIN_SUPPORTS_NOTE_AFTERTOUCH)

  349.             options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

  350.         if (fDescriptor->supports & NATIVE_PLUGIN_SUPPORTS_PITCHBEND)

  351.             options |= PLUGIN_OPTION_SEND_PITCHBEND;

  352.         if (fDescriptor->supports & NATIVE_PLUGIN_SUPPORTS_ALL_SOUND_OFF)

  353.             options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  354. 

  355.         if (fDescriptor->supports & NATIVE_PLUGIN_SUPPORTS_PROGRAM_CHANGES)

  356.             options |= PLUGIN_OPTION_SEND_PROGRAM_CHANGES;

  357.         else if (hasMidiProgs)

  358.             options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  359. 

  360.         return options;

  361.     }

  362. 

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

  364.     {

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

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

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

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

  369. 

  370.         // FIXME - try

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

  372.     }

  373. 

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

  375.     {

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

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

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

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

  380. 

  381.         // FIXME - try

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

  383.         {

  384.             CARLA_SAFE_ASSERT_RETURN(scalePointId < param->scalePointCount, 0.0f);

  385. 

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

  387.             return scalePoint->value;

  388.         }

  389. 

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

  391.         return 0.0f;

  392.     }

  393. 

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

  395.     {

  396.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  397. 

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

  399.         {

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

  401.             return;

  402.         }

  403. 

  404.         CarlaPlugin::getLabel(strBuf);

  405.     }

  406. 

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

  408.     {

  409.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  410. 

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

  412.         {

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

  414.             return;

  415.         }

  416. 

  417.         CarlaPlugin::getMaker(strBuf);

  418.     }

  419. 

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

  421.     {

  422.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  423. 

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

  425.         {

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

  427.             return;

  428.         }

  429. 

  430.         CarlaPlugin::getCopyright(strBuf);

  431.     }

  432. 

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

  434.     {

  435.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  436. 

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

  438.         {

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

  440.             return;

  441.         }

  442. 

  443.         CarlaPlugin::getRealName(strBuf);

  444.     }

  445. 

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

  447.     {

  448.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

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

  450.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

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

  452. 

  453.         // FIXME - try

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

  455.         {

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

  457.             {

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

  459.                 return;

  460.             }

  461. 

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

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

  464.         }

  465. 

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

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

  468.     }

  469. 

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

  471.     {

  472.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

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

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

  475.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

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

  477. 

  478.         // FIXME - try

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

  480.         {

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

  482.             return;

  483.         }

  484. 

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

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

  487.     }

  488. 

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

  490.     {

  491.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

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

  493.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

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

  495. 

  496.         // FIXME - try

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

  498.         {

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

  500.             {

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

  502.                 return;

  503.             }

  504. 

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

  506.         }

  507. 

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

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

  510.     }

  511. 

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

  513.     {

  514.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

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

  516.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

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

  518. 

  519.         // FIXME - try

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

  521.         {

  522.             CARLA_SAFE_ASSERT_RETURN(scalePointId < param->scalePointCount,);

  523. 

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

  525. 

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

  527.             {

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

  529.                 return;

  530.             }

  531. 

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

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

  534.         }

  535. 

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

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

  538.     }

  539. 

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

  541.     // Set data (state)

  542. 

  543.     void prepareForSave() override

  544.     {

  545.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  546.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  547. 

  548.         if (pData->midiprog.count > 0 && fDescriptor->category == NATIVE_PLUGIN_CATEGORY_SYNTH)

  549.         {

  550.             char strBuf[STR_MAX+1];

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

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

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

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

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

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

  557. 

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

  559.         }

  560. 

  561.         if (fDescriptor == nullptr || fDescriptor->get_state == nullptr || (fDescriptor->hints & NATIVE_PLUGIN_USES_STATE) == 0)

  562.             return;

  563. 

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

  565.         {

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

  567.             std::free(data);

  568.         }

  569.     }

  570. 

  571.     // -------------------------------------------------------------------

  572.     // Set data (internal stuff)

  573. 

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

  575.     {

  576.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  577.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

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

  579. 

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

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

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

  583. 

  584.         if (fHost.uiName != nullptr)

  585.             delete[] fHost.uiName;

  586.         fHost.uiName = carla_strdup(uiName);

  587. 

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

  589.             fDescriptor->dispatcher(fHandle, NATIVE_PLUGIN_OPCODE_UI_NAME_CHANGED, 0, 0, uiName, 0.0f);

  590. 

  591.         CarlaPlugin::setName(newName);

  592.     }

  593. 

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

  595.     {

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

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

  598. 

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

  600.     }

  601. 

  602.     // -------------------------------------------------------------------

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

  604. 

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

  606.     {

  607.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

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

  609.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

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

  611. 

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

  613. 

  614.         // FIXME - try

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

  616. 

  617.         if (fHandle2 != nullptr)

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

  619. 

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

  621.     }

  622. 

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

  624.     {

  625.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  626.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

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

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

  629.         CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

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

  631. 

  632.         if (std::strcmp(type, CUSTOM_DATA_TYPE_PROPERTY) == 0)

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

  634. 

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

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

  637. 

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

  639.         {

  640.             if (fDescriptor->set_state != nullptr && (fDescriptor->hints & NATIVE_PLUGIN_USES_STATE) != 0)

  641.             {

  642.                 const ScopedSingleProcessLocker spl(this, true);

  643. 

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

  645. 

  646.                 if (fHandle2 != nullptr)

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

  648.             }

  649.         }

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

  651.         {

  652.             StringArray midiProgramList(StringArray::fromTokens(value, ":", ""));

  653. 

  654.             if (midiProgramList.size() == MAX_MIDI_CHANNELS)

  655.             {

  656.                 uint8_t channel = 0;

  657.                 for (String *it=midiProgramList.begin(), *end=midiProgramList.end(); it != end; ++it)

  658.                 {

  659.                     const int index(it->getIntValue());

  660. 

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

  662.                     {

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

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

  665. 

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

  667. 

  668.                         if (fHandle2 != nullptr)

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

  670. 

  671.                         fCurMidiProgs[channel] = index;

  672. 

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

  674.                         {

  675.                             pData->midiprog.current = index;

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

  677.                         }

  678.                     }

  679. 

  680.                     ++channel;

  681.                 }

  682.                 CARLA_SAFE_ASSERT(channel == MAX_MIDI_CHANNELS);

  683.             }

  684.         }

  685.         else

  686.         {

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

  688.             {

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

  690. 

  691.                 if (fHandle2 != nullptr)

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

  693.             }

  694. 

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

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

  697.         }

  698. 

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

  700.     }

  701. 

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

  703.     {

  704.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  705.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

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

  707. 

  708.         // TODO, put into check below

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

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

  711. 

  712.         if (index >= 0)

  713.         {

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

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

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

  717. 

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

  719. 

  720.             try {

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

  722.             } catch(...) {}

  723. 

  724.             if (fHandle2 != nullptr)

  725.             {

  726.                 try {

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

  728.                 } catch(...) {}

  729.             }

  730. 

  731.             fCurMidiProgs[channel] = index;

  732.         }

  733. 

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

  735.     }

  736. 

  737.     // -------------------------------------------------------------------

  738.     // Set ui stuff

  739. 

  740.     void showCustomUI(const bool yesNo) override

  741.     {

  742.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  743.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  744. 

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

  746.             return;

  747. 

  748.         fIsUiAvailable = true;

  749. 

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

  751. 

  752.         // UI might not be available, see NATIVE_HOST_OPCODE_UI_UNAVAILABLE

  753.         if (yesNo && ! fIsUiAvailable)

  754.             return;

  755. 

  756.         fIsUiVisible = yesNo;

  757. 

  758.         if (! yesNo)

  759.         {

  760.             pData->transientTryCounter = 0;

  761.             return;

  762.         }

  763. 

  764. #ifndef BUILD_BRIDGE

  765.         if ((fDescriptor->hints & NATIVE_PLUGIN_USES_PARENT_ID) == 0 && std::strstr(fDescriptor->label, "file") == nullptr)

  766.             pData->tryTransient();

  767. #endif

  768. 

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

  770.         {

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

  772.             {

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

  774. 

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

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

  777.             }

  778.         }

  779. 

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

  781.         {

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

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

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

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

  786. 

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

  788.         }

  789. 

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

  791.         {

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

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

  794.         }

  795.     }

  796. 

  797.     void uiIdle() override

  798.     {

  799.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  800.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  801. 

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

  803.             fDescriptor->ui_idle(fHandle);

  804. 

  805.         CarlaPlugin::uiIdle();

  806.     }

  807. 

  808.     // -------------------------------------------------------------------

  809.     // Plugin state

  810. 

  811.     void reload() override

  812.     {

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

  814.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  815.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  816.         carla_debug("CarlaPluginNative::reload() - start");

  817. 

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

  819. 

  820.         // Safely disable plugin for reload

  821.         const ScopedDisabler sd(this);

  822. 

  823.         if (pData->active)

  824.             deactivate();

  825. 

  826.         clearBuffers();

  827. 

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

  829. 

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

  831. 

  832.         bool forcedStereoIn, forcedStereoOut;

  833.         forcedStereoIn = forcedStereoOut = false;

  834. 

  835.         bool needsCtrlIn, needsCtrlOut;

  836.         needsCtrlIn = needsCtrlOut = false;

  837. 

  838.         aIns   = fDescriptor->audioIns;

  839.         aOuts  = fDescriptor->audioOuts;

  840.         mIns   = fDescriptor->midiIns;

  841.         mOuts  = fDescriptor->midiOuts;

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

  843. 

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

  845.         {

  846.             if (fHandle2 == nullptr)

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

  848. 

  849.             if (fHandle2 != nullptr)

  850.             {

  851.                 if (aIns == 1)

  852.                 {

  853.                     aIns = 2;

  854.                     forcedStereoIn = true;

  855.                 }

  856. 

  857.                 if (aOuts == 1)

  858.                 {

  859.                     aOuts = 2;

  860.                     forcedStereoOut = true;

  861.                 }

  862.             }

  863.         }

  864. 

  865.         if (aIns > 0)

  866.         {

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

  868.             fAudioInBuffers = new float*[aIns];

  869. 

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

  871.                 fAudioInBuffers[i] = nullptr;

  872.         }

  873. 

  874.         if (aOuts > 0)

  875.         {

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

  877.             fAudioOutBuffers = new float*[aOuts];

  878.             needsCtrlIn = true;

  879. 

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

  881.                 fAudioOutBuffers[i] = nullptr;

  882.         }

  883. 

  884.         if (mIns > 0)

  885.         {

  886.             fMidiIn.createNew(mIns);

  887.             needsCtrlIn = (mIns == 1);

  888.         }

  889. 

  890.         if (mOuts > 0)

  891.         {

  892.             fMidiOut.createNew(mOuts);

  893.             needsCtrlOut = (mOuts == 1);

  894.         }

  895. 

  896.         if (params > 0)

  897.         {

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

  899.         }

  900. 

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

  902.         CarlaString portName;

  903. 

  904.         // Audio Ins

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

  906.         {

  907.             portName.clear();

  908. 

  909.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  910.             {

  911.                 portName  = pData->name;

  912.                 portName += ":";

  913.             }

  914. 

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

  916.             {

  917.                 portName += "input_";

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

  919.             }

  920.             else

  921.                 portName += "input";

  922. 

  923.             portName.truncate(portNameSize);

  924. 

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

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

  927. 

  928.             if (forcedStereoIn)

  929.             {

  930.                 portName += "_2";

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

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

  933.                 break;

  934.             }

  935.         }

  936. 

  937.         // Audio Outs

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

  939.         {

  940.             portName.clear();

  941. 

  942.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  943.             {

  944.                 portName  = pData->name;

  945.                 portName += ":";

  946.             }

  947. 

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

  949.             {

  950.                 portName += "output_";

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

  952.             }

  953.             else

  954.                 portName += "output";

  955. 

  956.             portName.truncate(portNameSize);

  957. 

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

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

  960. 

  961.             if (forcedStereoOut)

  962.             {

  963.                 portName += "_2";

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

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

  966.                 break;

  967.             }

  968.         }

  969. 

  970.         // MIDI Input (only if multiple)

  971.         if (mIns > 1)

  972.         {

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

  974.             {

  975.                 portName.clear();

  976. 

  977.                 if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  978.                 {

  979.                     portName  = pData->name;

  980.                     portName += ":";

  981.                 }

  982. 

  983.                 portName += "midi-in_";

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

  985.                 portName.truncate(portNameSize);

  986. 

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

  988.                 fMidiIn.indexes[j] = j;

  989.             }

  990. 

  991.             pData->event.portIn = fMidiIn.ports[0];

  992.         }

  993. 

  994.         // MIDI Output (only if multiple)

  995.         if (mOuts > 1)

  996.         {

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

  998.             {

  999.                 portName.clear();

  1000. 

  1001.                 if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  1002.                 {

  1003.                     portName  = pData->name;

  1004.                     portName += ":";

  1005.                 }

  1006. 

  1007.                 portName += "midi-out_";

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

  1009.                 portName.truncate(portNameSize);

  1010. 

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

  1012.                 fMidiOut.indexes[j] = j;

  1013.             }

  1014. 

  1015.             pData->event.portOut = fMidiOut.ports[0];

  1016.         }

  1017. 

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

  1019.         {

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

  1021. 

  1022.             CARLA_SAFE_ASSERT_CONTINUE(paramInfo != nullptr);

  1023. 

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

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

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

  1027. 

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

  1029. 

  1030.             // min value

  1031.             min = paramInfo->ranges.min;

  1032. 

  1033.             // max value

  1034.             max = paramInfo->ranges.max;

  1035. 

  1036.             if (min > max)

  1037.                 max = min;

  1038.             else if (max < min)

  1039.                 min = max;

  1040. 

  1041.             if (carla_compareFloats(min, max))

  1042.             {

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

  1044.                 max = min + 0.1f;

  1045.             }

  1046. 

  1047.             // default value

  1048.             def = paramInfo->ranges.def;

  1049. 

  1050.             if (def < min)

  1051.                 def = min;

  1052.             else if (def > max)

  1053.                 def = max;

  1054. 

  1055.             if (paramInfo->hints & NATIVE_PARAMETER_USES_SAMPLE_RATE)

  1056.             {

  1057.                 min *= sampleRate;

  1058.                 max *= sampleRate;

  1059.                 def *= sampleRate;

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

  1061.             }

  1062. 

  1063.             if (paramInfo->hints & NATIVE_PARAMETER_IS_BOOLEAN)

  1064.             {

  1065.                 step = max - min;

  1066.                 stepSmall = step;

  1067.                 stepLarge = step;

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

  1069.             }

  1070.             else if (paramInfo->hints & NATIVE_PARAMETER_IS_INTEGER)

  1071.             {

  1072.                 step = 1.0f;

  1073.                 stepSmall = 1.0f;

  1074.                 stepLarge = 10.0f;

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

  1076.             }

  1077.             else

  1078.             {

  1079.                 float range = max - min;

  1080.                 step = range/100.0f;

  1081.                 stepSmall = range/1000.0f;

  1082.                 stepLarge = range/10.0f;

  1083.             }

  1084. 

  1085.             if (paramInfo->hints & NATIVE_PARAMETER_IS_OUTPUT)

  1086.             {

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

  1088.                 needsCtrlOut = true;

  1089.             }

  1090.             else

  1091.             {

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

  1093.                 needsCtrlIn = true;

  1094.             }

  1095. 

  1096.             // extra parameter hints

  1097.             if (paramInfo->hints & NATIVE_PARAMETER_IS_ENABLED)

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

  1099. 

  1100.             if (paramInfo->hints & NATIVE_PARAMETER_IS_AUTOMABLE)

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

  1102. 

  1103.             if (paramInfo->hints & NATIVE_PARAMETER_IS_LOGARITHMIC)

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

  1105. 

  1106.             if (paramInfo->hints & NATIVE_PARAMETER_USES_SCALEPOINTS)

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

  1108. 

  1109.             if (paramInfo->hints & NATIVE_PARAMETER_USES_CUSTOM_TEXT)

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

  1111. 

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

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

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

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

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

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

  1118.         }

  1119. 

  1120.         if (needsCtrlIn && mIns <= 1)

  1121.         {

  1122.             portName.clear();

  1123. 

  1124.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  1125.             {

  1126.                 portName  = pData->name;

  1127.                 portName += ":";

  1128.             }

  1129. 

  1130.             portName += "events-in";

  1131.             portName.truncate(portNameSize);

  1132. 

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

  1134.         }

  1135. 

  1136.         if (needsCtrlOut && mOuts <= 1)

  1137.         {

  1138.             portName.clear();

  1139. 

  1140.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  1141.             {

  1142.                 portName  = pData->name;

  1143.                 portName += ":";

  1144.             }

  1145. 

  1146.             portName += "events-out";

  1147.             portName.truncate(portNameSize);

  1148. 

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

  1150.         }

  1151. 

  1152.         if (forcedStereoIn || forcedStereoOut)

  1153.             pData->options |= PLUGIN_OPTION_FORCE_STEREO;

  1154.         else

  1155.             pData->options &= ~PLUGIN_OPTION_FORCE_STEREO;

  1156. 

  1157.         // plugin hints

  1158.         pData->hints = 0x0;

  1159. 

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

  1161.             pData->hints |= PLUGIN_CAN_DRYWET;

  1162. 

  1163.         if (aOuts > 0)

  1164.             pData->hints |= PLUGIN_CAN_VOLUME;

  1165. 

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

  1167.             pData->hints |= PLUGIN_CAN_BALANCE;

  1168. 

  1169.         // native plugin hints

  1170.         if (fDescriptor->hints & NATIVE_PLUGIN_IS_RTSAFE)

  1171.             pData->hints |= PLUGIN_IS_RTSAFE;

  1172.         if (fDescriptor->hints & NATIVE_PLUGIN_IS_SYNTH)

  1173.             pData->hints |= PLUGIN_IS_SYNTH;

  1174.         if (fDescriptor->hints & NATIVE_PLUGIN_HAS_UI)

  1175.             pData->hints |= PLUGIN_HAS_CUSTOM_UI;

  1176.         if (fDescriptor->hints & NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS)

  1177.             pData->hints |= PLUGIN_NEEDS_FIXED_BUFFERS;

  1178.         if (fDescriptor->hints & NATIVE_PLUGIN_NEEDS_UI_MAIN_THREAD)

  1179.             pData->hints |= PLUGIN_NEEDS_UI_MAIN_THREAD;

  1180.         if (fDescriptor->hints & NATIVE_PLUGIN_USES_MULTI_PROGS)

  1181.             pData->hints |= PLUGIN_USES_MULTI_PROGS;

  1182. 

  1183.         // extra plugin hints

  1184.         pData->extraHints = 0x0;

  1185. 

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

  1187.             pData->extraHints |= PLUGIN_EXTRA_HINT_CAN_RUN_RACK;

  1188. 

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

  1190.         reloadPrograms(true);

  1191. 

  1192.         if (pData->active)

  1193.             activate();

  1194. 

  1195.         carla_debug("CarlaPluginNative::reload() - end");

  1196.     }

  1197. 

  1198.     void reloadPrograms(const bool doInit) override

  1199.     {

  1200.         carla_debug("CarlaPluginNative::reloadPrograms(%s)", bool2str(doInit));

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

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

  1203. 

  1204.         // Delete old programs

  1205.         pData->midiprog.clear();

  1206. 

  1207.         // Query new programs

  1208.         uint32_t count = 0;

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

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

  1211. 

  1212.         if (count > 0)

  1213.         {

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

  1215. 

  1216.             // Update data

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

  1218.             {

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

  1220.                 CARLA_SAFE_ASSERT_CONTINUE(mpDesc != nullptr);

  1221. 

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

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

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

  1225.             }

  1226.         }

  1227. 

  1228. #if defined(HAVE_LIBLO) && ! defined(BUILD_BRIDGE)

  1229.         // Update OSC Names

  1230.         if (pData->engine->isOscControlRegistered() && pData->id < pData->engine->getCurrentPluginCount())

  1231.         {

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

  1233. 

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

  1235.                 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);

  1236.         }

  1237. #endif

  1238. 

  1239.         if (doInit)

  1240.         {

  1241.             if (count > 0)

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

  1243.         }

  1244.         else

  1245.         {

  1246.             // Check if current program is invalid

  1247.             bool programChanged = false;

  1248. 

  1249.             if (count == oldCount+1)

  1250.             {

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

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

  1253.                 programChanged = true;

  1254.             }

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

  1256.             {

  1257.                 // programs exist now, but not before

  1258.                 pData->midiprog.current = 0;

  1259.                 programChanged = true;

  1260.             }

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

  1262.             {

  1263.                 // programs existed before, but not anymore

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

  1265.                 programChanged = true;

  1266.             }

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

  1268.             {

  1269.                 // current midi program > count

  1270.                 pData->midiprog.current = 0;

  1271.                 programChanged = true;

  1272.             }

  1273.             else

  1274.             {

  1275.                 // no change

  1276.                 pData->midiprog.current = current;

  1277.             }

  1278. 

  1279.             if (programChanged)

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

  1281. 

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

  1283.         }

  1284.     }

  1285. 

  1286.     // -------------------------------------------------------------------

  1287.     // Plugin processing

  1288. 

  1289.     void activate() noexcept override

  1290.     {

  1291.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  1292.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  1293. 

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

  1295.         {

  1296.             try {

  1297.                 fDescriptor->activate(fHandle);

  1298.             } catch(...) {}

  1299. 

  1300.             if (fHandle2 != nullptr)

  1301.             {

  1302.                 try {

  1303.                     fDescriptor->activate(fHandle2);

  1304.                 } catch(...) {}

  1305.             }

  1306.         }

  1307.     }

  1308. 

  1309.     void deactivate() noexcept override

  1310.     {

  1311.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  1312.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  1313. 

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

  1315.         {

  1316.             try {

  1317.                 fDescriptor->deactivate(fHandle);

  1318.             } catch(...) {}

  1319. 

  1320.             if (fHandle2 != nullptr)

  1321.             {

  1322.                 try {

  1323.                     fDescriptor->deactivate(fHandle2);

  1324.                 } catch(...) {}

  1325.             }

  1326.         }

  1327.     }

  1328. 

  1329.     void process(const float** const audioIn, float** const audioOut, const float** const cvIn, float** const cvOut, const uint32_t frames) override

  1330.     {

  1331.         // --------------------------------------------------------------------------------------------------------

  1332.         // Check if active

  1333. 

  1334.         if (! pData->active)

  1335.         {

  1336.             // disable any output sound

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

  1338.                 FloatVectorOperations::clear(audioOut[i], static_cast<int>(frames));

  1339.             for (uint32_t i=0; i < pData->cvOut.count; ++i)

  1340.                 FloatVectorOperations::clear(cvOut[i], static_cast<int>(frames));

  1341.             return;

  1342.         }

  1343. 

  1344.         fMidiEventCount = 0;

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

  1346. 

  1347.         // --------------------------------------------------------------------------------------------------------

  1348.         // Check if needs reset

  1349. 

  1350.         if (pData->needsReset)

  1351.         {

  1352.             if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  1353.             {

  1354.                 fMidiEventCount = MAX_MIDI_CHANNELS*2;

  1355. 

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

  1357.                 {

  1358.                     fMidiEvents[k].data[0] = uint8_t(MIDI_STATUS_CONTROL_CHANGE | (k & MIDI_CHANNEL_BIT));

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

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

  1361.                     fMidiEvents[k].size    = 3;

  1362. 

  1363.                     fMidiEvents[k+i].data[0] = uint8_t(MIDI_STATUS_CONTROL_CHANGE | (k & MIDI_CHANNEL_BIT));

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

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

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

  1367.                 }

  1368.             }

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

  1370.             {

  1371.                 fMidiEventCount = MAX_MIDI_NOTE;

  1372. 

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

  1374.                 {

  1375.                     fMidiEvents[k].data[0] = uint8_t(MIDI_STATUS_NOTE_OFF | (pData->ctrlChannel & MIDI_CHANNEL_BIT));

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

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

  1378.                     fMidiEvents[k].size    = 3;

  1379.                 }

  1380.             }

  1381. 

  1382.             pData->needsReset = false;

  1383.         }

  1384. 

  1385.         // --------------------------------------------------------------------------------------------------------

  1386.         // Set TimeInfo

  1387. 

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

  1389. 

  1390.         fTimeInfo.playing = timeInfo.playing;

  1391.         fTimeInfo.frame   = timeInfo.frame;

  1392.         fTimeInfo.usecs   = timeInfo.usecs;

  1393. 

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

  1395.         {

  1396.             fTimeInfo.bbt.valid = true;

  1397. 

  1398.             fTimeInfo.bbt.bar  = timeInfo.bbt.bar;

  1399.             fTimeInfo.bbt.beat = timeInfo.bbt.beat;

  1400.             fTimeInfo.bbt.tick = timeInfo.bbt.tick;

  1401.             fTimeInfo.bbt.barStartTick = timeInfo.bbt.barStartTick;

  1402. 

  1403.             fTimeInfo.bbt.beatsPerBar = timeInfo.bbt.beatsPerBar;

  1404.             fTimeInfo.bbt.beatType    = timeInfo.bbt.beatType;

  1405. 

  1406.             fTimeInfo.bbt.ticksPerBeat   = timeInfo.bbt.ticksPerBeat;

  1407.             fTimeInfo.bbt.beatsPerMinute = timeInfo.bbt.beatsPerMinute;

  1408.         }

  1409.         else

  1410.             fTimeInfo.bbt.valid = false;

  1411. 

  1412.         // --------------------------------------------------------------------------------------------------------

  1413.         // Event Input and Processing

  1414. 

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

  1416.         {

  1417.             // ----------------------------------------------------------------------------------------------------

  1418.             // MIDI Input (External)

  1419. 

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

  1421.             {

  1422.                 ExternalMidiNote note = { 0, 0, 0 };

  1423. 

  1424.                 for (; fMidiEventCount < kPluginMaxMidiEvents*2 && ! pData->extNotes.data.isEmpty();)

  1425.                 {

  1426.                     note = pData->extNotes.data.getFirst(note, true);

  1427. 

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

  1429. 

  1430.                     NativeMidiEvent& nativeEvent(fMidiEvents[fMidiEventCount++]);

  1431. 

  1432.                     nativeEvent.data[0] = uint8_t((note.velo > 0 ? MIDI_STATUS_NOTE_ON : MIDI_STATUS_NOTE_OFF) | (note.channel & MIDI_CHANNEL_BIT));

  1433.                     nativeEvent.data[1] = note.note;

  1434.                     nativeEvent.data[2] = note.velo;

  1435.                     nativeEvent.size    = 3;

  1436.                 }

  1437. 

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

  1439. 

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

  1441. 

  1442.             // ----------------------------------------------------------------------------------------------------

  1443.             // Event Input (System)

  1444. 

  1445. #ifndef BUILD_BRIDGE

  1446.             bool allNotesOffSent = false;

  1447. #endif

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

  1449. 

  1450.             uint32_t startTime  = 0;

  1451.             uint32_t timeOffset = 0;

  1452.             uint32_t nextBankId;

  1453. 

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

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

  1456.             else

  1457.                 nextBankId = 0;

  1458. 

  1459.             for (uint32_t m=0, max=jmax(1U, fMidiIn.count); m < max; ++m)

  1460.             {

  1461.                 CarlaEngineEventPort* const eventPort(m == 0 ? pData->event.portIn : fMidiIn.ports[m]);

  1462. 

  1463.             for (uint32_t i=0, numEvents=eventPort->getEventCount(); i < numEvents; ++i)

  1464.             {

  1465.                 const EngineEvent& event(eventPort->getEvent(i));

  1466. 

  1467.                 if (event.time >= frames)

  1468.                     continue;

  1469. 

  1470.                 CARLA_ASSERT_INT2(event.time >= timeOffset, event.time, timeOffset);

  1471. 

  1472.                 if (event.time > timeOffset && sampleAccurate)

  1473.                 {

  1474.                     if (processSingle(audioIn, audioOut, cvIn, cvOut, event.time - timeOffset, timeOffset))

  1475.                     {

  1476.                         startTime  = 0;

  1477.                         timeOffset = event.time;

  1478. 

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

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

  1481.                         else

  1482.                             nextBankId = 0;

  1483. 

  1484.                         if (fMidiEventCount > 0)

  1485.                         {

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

  1487.                             fMidiEventCount = 0;

  1488.                         }

  1489.                     }

  1490.                     else

  1491.                         startTime += timeOffset;

  1492.                 }

  1493. 

  1494.                 // Control change

  1495.                 switch (event.type)

  1496.                 {

  1497.                 case kEngineEventTypeNull:

  1498.                     break;

  1499. 

  1500.                 case kEngineEventTypeControl: {

  1501.                     const EngineControlEvent& ctrlEvent = event.ctrl;

  1502. 

  1503.                     switch (ctrlEvent.type)

  1504.                     {

  1505.                     case kEngineControlEventTypeNull:

  1506.                         break;

  1507. 

  1508.                     case kEngineControlEventTypeParameter: {

  1509. #ifndef BUILD_BRIDGE

  1510.                         // Control backend stuff

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

  1512.                         {

  1513.                             float value;

  1514. 

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

  1516.                             {

  1517.                                 value = ctrlEvent.value;

  1518.                                 setDryWet(value, false, false);

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

  1520.                             }

  1521. 

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

  1523.                             {

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

  1525.                                 setVolume(value, false, false);

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

  1527.                             }

  1528. 

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

  1530.                             {

  1531.                                 float left, right;

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

  1533. 

  1534.                                 if (value < 0.0f)

  1535.                                 {

  1536.                                     left  = -1.0f;

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

  1538.                                 }

  1539.                                 else if (value > 0.0f)

  1540.                                 {

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

  1542.                                     right = 1.0f;

  1543.                                 }

  1544.                                 else

  1545.                                 {

  1546.                                     left  = -1.0f;

  1547.                                     right = 1.0f;

  1548.                                 }

  1549. 

  1550.                                 setBalanceLeft(left, false, false);

  1551.                                 setBalanceRight(right, false, false);

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

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

  1554.                             }

  1555.                         }

  1556. #endif

  1557.                         // Control plugin parameters

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

  1559.                         {

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

  1561.                                 continue;

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

  1563.                                 continue;

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

  1565.                                 continue;

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

  1567.                                 continue;

  1568. 

  1569.                             float value;

  1570. 

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

  1572.                             {

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

  1574.                             }

  1575.                             else

  1576.                             {

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

  1578. 

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

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

  1581.                             }

  1582. 

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

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

  1585.                         }

  1586. 

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

  1588.                         {

  1589.                             if (fMidiEventCount >= kPluginMaxMidiEvents*2)

  1590.                                 continue;

  1591. 

  1592.                             NativeMidiEvent& nativeEvent(fMidiEvents[fMidiEventCount++]);

  1593.                             carla_zeroStruct(nativeEvent);

  1594. 

  1595.                             nativeEvent.time    = sampleAccurate ? startTime : event.time;

  1596.                             nativeEvent.data[0] = uint8_t(MIDI_STATUS_CONTROL_CHANGE | (event.channel & MIDI_CHANNEL_BIT));

  1597.                             nativeEvent.data[1] = uint8_t(ctrlEvent.param);

  1598.                             nativeEvent.data[2] = uint8_t(ctrlEvent.value*127.0f);

  1599.                             nativeEvent.size    = 3;

  1600.                         }

  1601.                         break;

  1602.                     }

  1603. 

  1604.                     case kEngineControlEventTypeMidiBank:

  1605.                         if (pData->options & PLUGIN_OPTION_MAP_PROGRAM_CHANGES)

  1606.                         {

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

  1608.                                 nextBankId = ctrlEvent.param;

  1609.                         }

  1610.                         else if (pData->options & PLUGIN_OPTION_SEND_PROGRAM_CHANGES)

  1611.                         {

  1612.                             if (fMidiEventCount >= kPluginMaxMidiEvents*2)

  1613.                                 continue;

  1614. 

  1615.                             NativeMidiEvent& nativeEvent(fMidiEvents[fMidiEventCount++]);

  1616.                             carla_zeroStruct(nativeEvent);

  1617. 

  1618.                             nativeEvent.time    = sampleAccurate ? startTime : event.time;

  1619.                             nativeEvent.data[0] = uint8_t(MIDI_STATUS_CONTROL_CHANGE | (event.channel & MIDI_CHANNEL_BIT));

  1620.                             nativeEvent.data[1] = MIDI_CONTROL_BANK_SELECT;

  1621.                             nativeEvent.data[2] = uint8_t(ctrlEvent.param);

  1622.                             nativeEvent.size    = 3;

  1623.                         }

  1624.                         break;

  1625. 

  1626.                     case kEngineControlEventTypeMidiProgram:

  1627.                         if (pData->options & PLUGIN_OPTION_MAP_PROGRAM_CHANGES)

  1628.                         {

  1629.                             if (event.channel < MAX_MIDI_CHANNELS)

  1630.                             {

  1631.                                 const uint32_t nextProgramId(ctrlEvent.param);

  1632. 

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

  1634.                                 {

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

  1636.                                     {

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

  1638. 

  1639.                                         if (fHandle2 != nullptr)

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

  1641. 

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

  1643. 

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

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

  1646. 

  1647.                                         break;

  1648.                                     }

  1649.                                 }

  1650.                             }

  1651.                         }

  1652.                         else if (pData->options & PLUGIN_OPTION_SEND_PROGRAM_CHANGES)

  1653.                         {

  1654.                             if (fMidiEventCount >= kPluginMaxMidiEvents*2)

  1655.                                 continue;

  1656. 

  1657.                             NativeMidiEvent& nativeEvent(fMidiEvents[fMidiEventCount++]);

  1658.                             carla_zeroStruct(nativeEvent);

  1659. 

  1660.                             nativeEvent.time    = sampleAccurate ? startTime : event.time;

  1661.                             nativeEvent.data[0] = uint8_t(MIDI_STATUS_PROGRAM_CHANGE | (event.channel & MIDI_CHANNEL_BIT));

  1662.                             nativeEvent.data[1] = uint8_t(ctrlEvent.param);

  1663.                             nativeEvent.size    = 2;

  1664.                         }

  1665.                         break;

  1666. 

  1667.                     case kEngineControlEventTypeAllSoundOff:

  1668.                         if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  1669.                         {

  1670.                             if (fMidiEventCount >= kPluginMaxMidiEvents*2)

  1671.                                 continue;

  1672. 

  1673.                             NativeMidiEvent& nativeEvent(fMidiEvents[fMidiEventCount++]);

  1674.                             carla_zeroStruct(nativeEvent);

  1675. 

  1676.                             nativeEvent.time    = sampleAccurate ? startTime : event.time;

  1677.                             nativeEvent.data[0] = uint8_t(MIDI_STATUS_CONTROL_CHANGE | (event.channel & MIDI_CHANNEL_BIT));

  1678.                             nativeEvent.data[1] = MIDI_CONTROL_ALL_SOUND_OFF;

  1679.                             nativeEvent.data[2] = 0;

  1680.                             nativeEvent.size    = 3;

  1681.                         }

  1682.                         break;

  1683. 

  1684.                     case kEngineControlEventTypeAllNotesOff:

  1685.                         if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  1686.                         {

  1687. #ifndef BUILD_BRIDGE

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

  1689.                             {

  1690.                                 allNotesOffSent = true;

  1691.                                 sendMidiAllNotesOffToCallback();

  1692.                             }

  1693. #endif

  1694. 

  1695.                             if (fMidiEventCount >= kPluginMaxMidiEvents*2)

  1696.                                 continue;

  1697. 

  1698.                             NativeMidiEvent& nativeEvent(fMidiEvents[fMidiEventCount++]);

  1699.                             carla_zeroStruct(nativeEvent);

  1700. 

  1701.                             nativeEvent.time    = sampleAccurate ? startTime : event.time;

  1702.                             nativeEvent.data[0] = uint8_t(MIDI_STATUS_CONTROL_CHANGE | (event.channel & MIDI_CHANNEL_BIT));

  1703.                             nativeEvent.data[1] = MIDI_CONTROL_ALL_NOTES_OFF;

  1704.                             nativeEvent.data[2] = 0;

  1705.                             nativeEvent.size    = 3;

  1706.                         }

  1707.                         break;

  1708.                     }

  1709.                     break;

  1710.                 }

  1711. 

  1712.                 case kEngineEventTypeMidi: {

  1713.                     if (fMidiEventCount >= kPluginMaxMidiEvents*2)

  1714.                         continue;

  1715. 

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

  1717. 

  1718.                     if (midiEvent.size > 4)

  1719.                         continue;

  1720. #ifdef CARLA_PROPER_CPP11_SUPPORT

  1721.                     static_assert(4 <= EngineMidiEvent::kDataSize, "Incorrect data");

  1722. #endif

  1723. 

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

  1725. 

  1726.                     if (status == MIDI_STATUS_CHANNEL_PRESSURE && (pData->options & PLUGIN_OPTION_SEND_CHANNEL_PRESSURE) == 0)

  1727.                         continue;

  1728.                     if (status == MIDI_STATUS_CONTROL_CHANGE && (pData->options & PLUGIN_OPTION_SEND_CONTROL_CHANGES) == 0)

  1729.                         continue;

  1730.                     if (status == MIDI_STATUS_POLYPHONIC_AFTERTOUCH && (pData->options & PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH) == 0)

  1731.                         continue;

  1732.                     if (status == MIDI_STATUS_PITCH_WHEEL_CONTROL && (pData->options & PLUGIN_OPTION_SEND_PITCHBEND) == 0)

  1733.                         continue;

  1734. 

  1735.                     // Fix bad note-off

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

  1737.                         status = MIDI_STATUS_NOTE_OFF;

  1738. 

  1739.                     NativeMidiEvent& nativeEvent(fMidiEvents[fMidiEventCount++]);

  1740.                     carla_zeroStruct(nativeEvent);

  1741. 

  1742.                     nativeEvent.port = midiEvent.port;

  1743.                     nativeEvent.time = sampleAccurate ? startTime : event.time;

  1744.                     nativeEvent.size = midiEvent.size;

  1745. 

  1746.                     nativeEvent.data[0] = uint8_t(status | (event.channel & MIDI_CHANNEL_BIT));

  1747.                     nativeEvent.data[1] = midiEvent.size >= 2 ? midiEvent.data[1] : 0;

  1748.                     nativeEvent.data[2] = midiEvent.size >= 3 ? midiEvent.data[2] : 0;

  1749.                     nativeEvent.data[3] = midiEvent.size == 4 ? midiEvent.data[3] : 0;

  1750. 

  1751.                     if (status == MIDI_STATUS_NOTE_ON)

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

  1753.                     else if (status == MIDI_STATUS_NOTE_OFF)

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

  1755.                 } break;

  1756.                 } // switch (event.type)

  1757.             }

  1758. 

  1759.             pData->postRtEvents.trySplice();

  1760. 

  1761.             if (frames > timeOffset)

  1762.                 processSingle(audioIn, audioOut, cvIn, cvOut, frames - timeOffset, timeOffset);

  1763. 

  1764.             } // eventPort

  1765. 

  1766.         } // End of Event Input and Processing

  1767. 

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

  1769.         // Plugin processing (no events)

  1770. 

  1771.         else

  1772.         {

  1773.             processSingle(audioIn, audioOut, cvIn, cvOut, frames, 0);

  1774. 

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

  1776. 

  1777.         // --------------------------------------------------------------------------------------------------------

  1778.         // Control and MIDI Output

  1779. 

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

  1781.         {

  1782. #ifndef BUILD_BRIDGE

  1783.             float value, curValue;

  1784. 

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

  1786.             {

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

  1788.                     continue;

  1789. 

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

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

  1792. 

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

  1794.                 {

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

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

  1797.                 }

  1798.             }

  1799. #endif

  1800. 

  1801.             // reverse lookup MIDI events

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

  1803.             {

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

  1805.                     break;

  1806. 

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

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

  1809. 

  1810.                 if (fMidiOut.count > 1 && port < fMidiOut.count)

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

  1812.                 else

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

  1814.             }

  1815. 

  1816.         } // End of Control and MIDI Output

  1817.     }

  1818. 

  1819.     bool processSingle(const float** const audioIn, float** const audioOut, const float** const cvIn, float** const cvOut, const uint32_t frames, const uint32_t timeOffset)

  1820.     {

  1821.         CARLA_SAFE_ASSERT_RETURN(frames > 0, false);

  1822. 

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

  1824.         {

  1825.             CARLA_SAFE_ASSERT_RETURN(audioIn != nullptr, false);

  1826.         }

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

  1828.         {

  1829.             CARLA_SAFE_ASSERT_RETURN(audioOut != nullptr, false);

  1830.         }

  1831.         if (pData->cvIn.count > 0)

  1832.         {

  1833.             CARLA_SAFE_ASSERT_RETURN(cvIn != nullptr, false);

  1834.         }

  1835.         if (pData->cvOut.count > 0)

  1836.         {

  1837.             CARLA_SAFE_ASSERT_RETURN(cvOut != nullptr, false);

  1838.         }

  1839. 

  1840.         // --------------------------------------------------------------------------------------------------------

  1841.         // Try lock, silence otherwise

  1842. 

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

  1844.         {

  1845.             pData->singleMutex.lock();

  1846.         }

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

  1848.         {

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

  1850.             {

  1851.                 for (uint32_t k=0; k < frames; ++k)

  1852.                     audioOut[i][k+timeOffset] = 0.0f;

  1853.             }

  1854.             for (uint32_t i=0; i < pData->cvOut.count; ++i)

  1855.             {

  1856.                 for (uint32_t k=0; k < frames; ++k)

  1857.                     cvOut[i][k+timeOffset] = 0.0f;

  1858.             }

  1859. 

  1860.             return false;

  1861.         }

  1862. 

  1863.         // --------------------------------------------------------------------------------------------------------

  1864.         // Set audio buffers

  1865. 

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

  1867.             FloatVectorOperations::copy(fAudioInBuffers[i], audioIn[i]+timeOffset, static_cast<int>(frames));

  1868. 

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

  1870.             FloatVectorOperations::clear(fAudioOutBuffers[i], static_cast<int>(frames));

  1871. 

  1872. #if 0

  1873.         // --------------------------------------------------------------------------------------------------------

  1874.         // Set CV buffers

  1875. 

  1876.         for (uint32_t i=0; i < pData->cvIn.count; ++i)

  1877.             FloatVectorOperations::copy(fCvInBuffers[i], cvIn[i]+timeOffset, static_cast<int>(frames));

  1878. 

  1879.         for (uint32_t i=0; i < pData->cvOut.count; ++i)

  1880.             FloatVectorOperations::clear(fCvOutBuffers[i], static_cast<int>(frames));

  1881. #endif

  1882. 

  1883.         // --------------------------------------------------------------------------------------------------------

  1884.         // Run plugin

  1885. 

  1886.         fIsProcessing = true;

  1887. 

  1888.         if (fHandle2 == nullptr)

  1889.         {

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

  1891.         }

  1892.         else

  1893.         {

  1894.             fDescriptor->process(fHandle,

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

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

  1897.                                  frames, fMidiEvents, fMidiEventCount);

  1898. 

  1899.             fDescriptor->process(fHandle2,

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

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

  1902.                                  frames, fMidiEvents, fMidiEventCount);

  1903.         }

  1904. 

  1905.         fIsProcessing = false;

  1906.         fTimeInfo.frame += frames;

  1907. 

  1908. #ifndef BUILD_BRIDGE

  1909.         // --------------------------------------------------------------------------------------------------------

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

  1911. 

  1912.         {

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

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

  1915. 

  1916.             bool isPair;

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

  1918. 

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

  1920.             {

  1921.                 // Dry/Wet

  1922.                 if (doDryWet)

  1923.                 {

  1924.                     for (uint32_t k=0; k < frames; ++k)

  1925.                     {

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

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

  1928.                     }

  1929.                 }

  1930. 

  1931.                 // Balance

  1932.                 if (doBalance)

  1933.                 {

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

  1935. 

  1936.                     if (isPair)

  1937.                     {

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

  1939.                         FloatVectorOperations::copy(oldBufLeft, fAudioOutBuffers[i], static_cast<int>(frames));

  1940.                     }

  1941. 

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

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

  1944. 

  1945.                     for (uint32_t k=0; k < frames; ++k)

  1946.                     {

  1947.                         if (isPair)

  1948.                         {

  1949.                             // left

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

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

  1952.                         }

  1953.                         else

  1954.                         {

  1955.                             // right

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

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

  1958.                         }

  1959.                     }

  1960.                 }

  1961. 

  1962.                 // Volume (and buffer copy)

  1963.                 {

  1964.                     for (uint32_t k=0; k < frames; ++k)

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

  1966.                 }

  1967.             }

  1968. 

  1969.         } // End of Post-processing

  1970. #else

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

  1972.         {

  1973.             for (uint32_t k=0; k < frames; ++k)

  1974.                 audioOut[i][k+timeOffset] = fAudioOutBuffers[i][k];

  1975.         }

  1976. #endif

  1977. 

  1978. #if 0

  1979.         for (uint32_t i=0; i < pData->cvOut.count; ++i)

  1980.         {

  1981.             for (uint32_t k=0; k < frames; ++k)

  1982.                 cvOut[i][k+timeOffset] = fCvOutBuffers[i][k];

  1983.         }

  1984. #endif

  1985. 

  1986.         // --------------------------------------------------------------------------------------------------------

  1987. 

  1988.         pData->singleMutex.unlock();

  1989.         return true;

  1990.     }

  1991. 

  1992.     void bufferSizeChanged(const uint32_t newBufferSize) override

  1993.     {

  1994.         CARLA_ASSERT_INT(newBufferSize > 0, newBufferSize);

  1995.         carla_debug("CarlaPluginNative::bufferSizeChanged(%i)", newBufferSize);

  1996. 

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

  1998.         {

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

  2000.                 delete[] fAudioInBuffers[i];

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

  2002.         }

  2003. 

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

  2005.         {

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

  2007.                 delete[] fAudioOutBuffers[i];

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

  2009.         }

  2010. 

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

  2012.         {

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

  2014. 

  2015.             if (fHandle2 != nullptr)

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

  2017.         }

  2018.     }

  2019. 

  2020.     void sampleRateChanged(const double newSampleRate) override

  2021.     {

  2022.         CARLA_ASSERT_INT(newSampleRate > 0.0, newSampleRate);

  2023.         carla_debug("CarlaPluginNative::sampleRateChanged(%g)", newSampleRate);

  2024. 

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

  2026.         {

  2027.             fDescriptor->dispatcher(fHandle, NATIVE_PLUGIN_OPCODE_SAMPLE_RATE_CHANGED, 0, 0, nullptr, float(newSampleRate));

  2028. 

  2029.             if (fHandle2 != nullptr)

  2030.                 fDescriptor->dispatcher(fHandle2, NATIVE_PLUGIN_OPCODE_SAMPLE_RATE_CHANGED, 0, 0, nullptr, float(newSampleRate));

  2031.         }

  2032.     }

  2033. 

  2034.     void offlineModeChanged(const bool isOffline) override

  2035.     {

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

  2037.         {

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

  2039. 

  2040.             if (fHandle2 != nullptr)

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

  2042.         }

  2043.     }

  2044. 

  2045.     // -------------------------------------------------------------------

  2046.     // Plugin buffers

  2047. 

  2048.     void initBuffers() const noexcept override

  2049.     {

  2050.         fMidiIn.initBuffers();

  2051.         fMidiOut.initBuffers();

  2052. 

  2053.         CarlaPlugin::initBuffers();

  2054.     }

  2055. 

  2056.     void clearBuffers() noexcept override

  2057.     {

  2058.         carla_debug("CarlaPluginNative::clearBuffers() - start");

  2059. 

  2060.         if (fAudioInBuffers != nullptr)

  2061.         {

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

  2063.             {

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

  2065.                 {

  2066.                     delete[] fAudioInBuffers[i];

  2067.                     fAudioInBuffers[i] = nullptr;

  2068.                 }

  2069.             }

  2070. 

  2071.             delete[] fAudioInBuffers;

  2072.             fAudioInBuffers = nullptr;

  2073.         }

  2074. 

  2075.         if (fAudioOutBuffers != nullptr)

  2076.         {

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

  2078.             {

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

  2080.                 {

  2081.                     delete[] fAudioOutBuffers[i];

  2082.                     fAudioOutBuffers[i] = nullptr;

  2083.                 }

  2084.             }

  2085. 

  2086.             delete[] fAudioOutBuffers;

  2087.             fAudioOutBuffers = nullptr;

  2088.         }

  2089. 

  2090.         if (fMidiIn.count > 1)

  2091.             pData->event.portIn = nullptr;

  2092. 

  2093.         if (fMidiOut.count > 1)

  2094.             pData->event.portOut = nullptr;

  2095. 

  2096.         fMidiIn.clear();

  2097.         fMidiOut.clear();

  2098. 

  2099.         CarlaPlugin::clearBuffers();

  2100. 

  2101.         carla_debug("CarlaPluginNative::clearBuffers() - end");

  2102.     }

  2103. 

  2104.     // -------------------------------------------------------------------

  2105.     // Post-poned UI Stuff

  2106. 

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

  2108.     {

  2109.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  2110.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

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

  2112. 

  2113.         if (! fIsUiVisible)

  2114.             return;

  2115. 

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

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

  2118.     }

  2119. 

  2120.     void uiMidiProgramChange(const uint32_t index) noexcept override

  2121.     {

  2122.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  2123.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

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

  2125. 

  2126.         if (! fIsUiVisible)

  2127.             return;

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

  2129.             return;

  2130. 

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

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

  2133.     }

  2134. 

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

  2136.     {

  2137.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  2138.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  2139.         CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2140.         CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

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

  2142. 

  2143.         if (! fIsUiVisible)

  2144.             return;

  2145. 

  2146.         // TODO

  2147.     }

  2148. 

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

  2150.     {

  2151.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  2152.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  2153.         CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2154.         CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

  2155. 

  2156.         if (! fIsUiVisible)

  2157.             return;

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

  2159.             return;

  2160. 

  2161.         // TODO

  2162.     }

  2163. 

  2164.     // -------------------------------------------------------------------

  2165. 

  2166. protected:

  2167.     uint32_t handleGetBufferSize() const noexcept

  2168.     {

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

  2170.     }

  2171. 

  2172.     double handleGetSampleRate() const noexcept

  2173.     {

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

  2175.     }

  2176. 

  2177.     bool handleIsOffline() const noexcept

  2178.     {

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

  2180.     }

  2181. 

  2182.     const NativeTimeInfo* handleGetTimeInfo() const noexcept

  2183.     {

  2184.         CARLA_SAFE_ASSERT_RETURN(fIsProcessing, nullptr);

  2185. 

  2186.         return &fTimeInfo;

  2187.     }

  2188. 

  2189.     bool handleWriteMidiEvent(const NativeMidiEvent* const event)

  2190.     {

  2191.         CARLA_SAFE_ASSERT_RETURN(pData->enabled, false);

  2192.         CARLA_SAFE_ASSERT_RETURN(fIsProcessing, false);

  2193.         CARLA_SAFE_ASSERT_RETURN(fMidiOut.count > 0 || pData->event.portOut != nullptr, false);

  2194.         CARLA_SAFE_ASSERT_RETURN(event != nullptr, false);

  2195.         CARLA_SAFE_ASSERT_RETURN(event->data[0] != 0, false);

  2196. 

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

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

  2199.         {

  2200.             if (fMidiEvents[i].data[0] != 0)

  2201.                 continue;

  2202. 

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

  2204.             return true;

  2205.         }

  2206. 

  2207.         carla_stdout("CarlaPluginNative::handleWriteMidiEvent(%p) - buffer full", event);

  2208.         return false;

  2209.     }

  2210. 

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

  2212.     {

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

  2214.     }

  2215. 

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

  2217.     {

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

  2219.     }

  2220. 

  2221.     void handleUiClosed()

  2222.     {

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

  2224.         fIsUiVisible = false;

  2225.     }

  2226. 

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

  2228.     {

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

  2230.     }

  2231. 

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

  2233.     {

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

  2235.     }

  2236. 

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

  2238.     {

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

  2240. 

  2241.         intptr_t ret = 0;

  2242. 

  2243.         switch (opcode)

  2244.         {

  2245.         case NATIVE_HOST_OPCODE_NULL:

  2246.             break;

  2247.         case NATIVE_HOST_OPCODE_UPDATE_PARAMETER:

  2248.             // TODO

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

  2250.             break;

  2251.         case NATIVE_HOST_OPCODE_UPDATE_MIDI_PROGRAM:

  2252.             // TODO

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

  2254.             break;

  2255.         case NATIVE_HOST_OPCODE_RELOAD_PARAMETERS:

  2256.             reload(); // FIXME

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

  2258.             break;

  2259.         case NATIVE_HOST_OPCODE_RELOAD_MIDI_PROGRAMS:

  2260.             reloadPrograms(false);

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

  2262.             break;

  2263.         case NATIVE_HOST_OPCODE_RELOAD_ALL:

  2264.             reload();

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

  2266.             break;

  2267.         case NATIVE_HOST_OPCODE_UI_UNAVAILABLE:

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

  2269.             fIsUiAvailable = false;

  2270.             break;

  2271.         case NATIVE_HOST_OPCODE_HOST_IDLE:

  2272.             pData->engine->callback(ENGINE_CALLBACK_IDLE, 0, 0, 0, 0.0f, nullptr);

  2273.             break;

  2274.         }

  2275. 

  2276.         return ret;

  2277. 

  2278.         // unused for now

  2279.         (void)index;

  2280.         (void)value;

  2281.         (void)ptr;

  2282.         (void)opt;

  2283.     }

  2284. 

  2285.     // -------------------------------------------------------------------

  2286. 

  2287. public:

  2288.     void* getNativeHandle() const noexcept override

  2289.     {

  2290.         return fHandle;

  2291.     }

  2292. 

  2293.     const void* getNativeDescriptor() const noexcept override

  2294.     {

  2295.         return fDescriptor;

  2296.     }

  2297. 

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

  2299. 

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

  2301.     {

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

  2303. 

  2304.         // ---------------------------------------------------------------

  2305.         // first checks

  2306. 

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

  2308.         {

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

  2310.             return false;

  2311.         }

  2312. 

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

  2314.         {

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

  2316.             return false;

  2317.         }

  2318. 

  2319.         // ---------------------------------------------------------------

  2320.         // get descriptor that matches label

  2321. 

  2322.         sPluginInitializer.initIfNeeded();

  2323. 

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

  2325.         {

  2326.             fDescriptor = it.getValue();

  2327. 

  2328.             CARLA_SAFE_ASSERT_BREAK(fDescriptor != nullptr);

  2329. 

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

  2331. 

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

  2333.                 break;

  2334. 

  2335.             fDescriptor = nullptr;

  2336.         }

  2337. 

  2338.         if (fDescriptor == nullptr)

  2339.         {

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

  2341.             return false;

  2342.         }

  2343. 

  2344.         // ---------------------------------------------------------------

  2345.         // set icon

  2346. 

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

  2348.             pData->iconName = carla_strdup_safe("file");

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

  2350.             pData->iconName = carla_strdup_safe("file");

  2351. 

  2352.         // ---------------------------------------------------------------

  2353.         // get info

  2354. 

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

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

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

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

  2359.         else

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

  2361. 

  2362.         {

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

  2364. 

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

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

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

  2368. 

  2369.             fHost.uiName = carla_strdup(uiName);

  2370.         }

  2371. 

  2372.         // ---------------------------------------------------------------

  2373.         // register client

  2374. 

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

  2376. 

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

  2378.         {

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

  2380.             return false;

  2381.         }

  2382. 

  2383.         // ---------------------------------------------------------------

  2384.         // initialize plugin

  2385. 

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

  2387. 

  2388.         if (fHandle == nullptr)

  2389.         {

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

  2391.             return false;

  2392.         }

  2393. 

  2394.         // ---------------------------------------------------------------

  2395.         // set default options

  2396. 

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

  2398. 

  2399.         pData->options = 0x0;

  2400. 

  2401.         if (getMidiInCount() > 0 || (fDescriptor->hints & NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS) != 0)

  2402.             pData->options |= PLUGIN_OPTION_FIXED_BUFFERS;

  2403. 

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

  2405.             pData->options |= PLUGIN_OPTION_FORCE_STEREO;

  2406. 

  2407.         if (fDescriptor->supports & NATIVE_PLUGIN_SUPPORTS_CHANNEL_PRESSURE)

  2408.             pData->options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  2409.         if (fDescriptor->supports & NATIVE_PLUGIN_SUPPORTS_NOTE_AFTERTOUCH)

  2410.             pData->options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

  2411.         if (fDescriptor->supports & NATIVE_PLUGIN_SUPPORTS_PITCHBEND)

  2412.             pData->options |= PLUGIN_OPTION_SEND_PITCHBEND;

  2413.         if (fDescriptor->supports & NATIVE_PLUGIN_SUPPORTS_ALL_SOUND_OFF)

  2414.             pData->options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  2415. 

  2416.         if (fDescriptor->supports & NATIVE_PLUGIN_SUPPORTS_PROGRAM_CHANGES)

  2417.         {

  2418.             CARLA_SAFE_ASSERT(! hasMidiProgs);

  2419.             pData->options |= PLUGIN_OPTION_SEND_PROGRAM_CHANGES;

  2420. 

  2421.             if (fDescriptor->supports & NATIVE_PLUGIN_SUPPORTS_CONTROL_CHANGES)

  2422.                 pData->options |= PLUGIN_OPTION_SEND_CONTROL_CHANGES;

  2423.         }

  2424.         else if (hasMidiProgs && fDescriptor->category == NATIVE_PLUGIN_CATEGORY_SYNTH)

  2425.             pData->options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  2426. 

  2427.         return true;

  2428.     }

  2429. 

  2430. 

  2431. private:

  2432.     NativePluginHandle   fHandle;

  2433.     NativePluginHandle   fHandle2;

  2434.     NativeHostDescriptor fHost;

  2435.     const NativePluginDescriptor* fDescriptor;

  2436. 

  2437.     bool fIsProcessing;

  2438.     bool fIsUiAvailable;

  2439.     bool fIsUiVisible;

  2440. 

  2441.     float**         fAudioInBuffers;

  2442.     float**         fAudioOutBuffers;

  2443.     uint32_t        fMidiEventCount;

  2444.     NativeMidiEvent fMidiEvents[kPluginMaxMidiEvents*2];

  2445. 

  2446.     int32_t fCurMidiProgs[MAX_MIDI_CHANNELS];

  2447. 

  2448.     NativePluginMidiData fMidiIn;

  2449.     NativePluginMidiData fMidiOut;

  2450. 

  2451.     NativeTimeInfo fTimeInfo;

  2452. 

  2453.     // -------------------------------------------------------------------

  2454. 

  2455.     #define handlePtr ((CarlaPluginNative*)handle)

  2456. 

  2457.     static uint32_t carla_host_get_buffer_size(NativeHostHandle handle) noexcept

  2458.     {

  2459.         return handlePtr->handleGetBufferSize();

  2460.     }

  2461. 

  2462.     static double carla_host_get_sample_rate(NativeHostHandle handle) noexcept

  2463.     {

  2464.         return handlePtr->handleGetSampleRate();

  2465.     }

  2466. 

  2467.     static bool carla_host_is_offline(NativeHostHandle handle) noexcept

  2468.     {

  2469.         return handlePtr->handleIsOffline();

  2470.     }

  2471. 

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

  2473.     {

  2474.         return handlePtr->handleGetTimeInfo();

  2475.     }

  2476. 

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

  2478.     {

  2479.         return handlePtr->handleWriteMidiEvent(event);

  2480.     }

  2481. 

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

  2483.     {

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

  2485.     }

  2486. 

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

  2488.     {

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

  2490.     }

  2491. 

  2492.     static void carla_host_ui_closed(NativeHostHandle handle)

  2493.     {

  2494.         handlePtr->handleUiClosed();

  2495.     }

  2496. 

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

  2498.     {

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

  2500.     }

  2501. 

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

  2503.     {

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

  2505.     }

  2506. 

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

  2508.     {

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

  2510.     }

  2511. 

  2512.     #undef handlePtr

  2513. 

  2514.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaPluginNative)

  2515. };

  2516. 

  2517. // -----------------------------------------------------------------------

  2518. 

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

  2520. {

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

  2522. 

  2523.     CarlaPluginNative* const plugin(new CarlaPluginNative(init.engine, init.id));

  2524. 

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

  2526.     {

  2527.         delete plugin;

  2528.         return nullptr;

  2529.     }

  2530. 

  2531.     return plugin;

  2532. }

  2533. 

  2534. // -----------------------------------------------------------------------

  2535. 

  2536. CARLA_BACKEND_END_NAMESPACE