falkTX
/
Cadence
mirror of https://github.com/falkTX/Cadence
1
0
Fork 0
Code Releases 3 Activity
Collection of tools useful for audio production
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
571 Commits
2 Branches
142MB
Tree: 32b33d3620
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '32b33d3620'
${ noResults }
Cadence/c++/carla-backend/lv2.cpp

4536 lines
159KB
Raw Blame History 

  1. /*

  2.  * Carla Backend

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

  4.  *

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

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

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

  8.  * any later version.

  9.  *

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

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

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

  13.  * GNU General Public License for more details.

  14.  *

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

  16.  */

  17. 

  18. #include "carla_plugin.h"

  19. 

  20. #ifdef WANT_LV2

  21. 

  22. #include "carla_lv2.h"

  23. 

  24. #include "lv2_atom_queue.h"

  25. #include "rtmempool/rtmempool.h"

  26. 

  27. #include <QtCore/QDir>

  28. #include <QtGui/QLayout>

  29. 

  30. #ifdef HAVE_SUIL

  31. #include <suil/suil.h>

  32. struct SuilInstanceImpl {

  33.     void*                   lib_handle;

  34.     const LV2UI_Descriptor* descriptor;

  35.     LV2UI_Handle            handle;

  36.     // ...

  37. };

  38. #endif

  39. 

  40. CARLA_BACKEND_START_NAMESPACE

  41. 

  42. /*!

  43.  * @defgroup CarlaBackendLv2Plugin Carla Backend LV2 Plugin

  44.  *

  45.  * The Carla Backend LV2 Plugin.\n

  46.  * http://lv2plug.in/

  47.  * @{

  48.  */

  49. 

  50. // static max values

  51. const unsigned int MAX_EVENT_BUFFER = 8192; // 0x2000

  52. 

  53. /*!

  54.  * @defgroup PluginHints Plugin Hints

  55.  * @{

  56.  */

  57. const unsigned int PLUGIN_HAS_EXTENSION_PROGRAMS = 0x1000; //!< LV2 Plugin has Programs extension

  58. const unsigned int PLUGIN_HAS_EXTENSION_STATE    = 0x2000; //!< LV2 Plugin has State extension

  59. const unsigned int PLUGIN_HAS_EXTENSION_WORKER   = 0x4000; //!< LV2 Plugin has Worker extension

  60. /**@}*/

  61. 

  62. /*!

  63.  * @defgroup ParameterHints Parameter Hints

  64.  * @{

  65.  */

  66. const unsigned int PARAMETER_IS_STRICT_BOUNDS = 0x1000; //!< LV2 Parameter needs strict bounds

  67. const unsigned int PARAMETER_IS_TRIGGER       = 0x2000; //!< LV2 Parameter is trigger (current value should be changed to its default after run())

  68. /**@}*/

  69. 

  70. /*!

  71.  * @defgroup Lv2FeatureIds LV2 Feature Ids

  72.  *

  73.  * Static index list of the internal LV2 Feature Ids.

  74.  * @{

  75.  */

  76. const uint32_t lv2_feature_id_bufsize_bounded  =  0;

  77. const uint32_t lv2_feature_id_bufsize_fixed    =  1;

  78. const uint32_t lv2_feature_id_bufsize_powerof2 =  2;

  79. const uint32_t lv2_feature_id_event            =  3;

  80. const uint32_t lv2_feature_id_logs             =  4;

  81. const uint32_t lv2_feature_id_options          =  5;

  82. const uint32_t lv2_feature_id_programs         =  6;

  83. const uint32_t lv2_feature_id_rtmempool        =  7;

  84. const uint32_t lv2_feature_id_state_make_path  =  8;

  85. const uint32_t lv2_feature_id_state_map_path   =  9;

  86. const uint32_t lv2_feature_id_strict_bounds    = 10;

  87. const uint32_t lv2_feature_id_uri_map          = 11;

  88. const uint32_t lv2_feature_id_urid_map         = 12;

  89. const uint32_t lv2_feature_id_urid_unmap       = 13;

  90. const uint32_t lv2_feature_id_worker           = 14;

  91. const uint32_t lv2_feature_id_data_access      = 15;

  92. const uint32_t lv2_feature_id_instance_access  = 16;

  93. const uint32_t lv2_feature_id_ui_parent        = 17;

  94. const uint32_t lv2_feature_id_ui_port_map      = 18;

  95. const uint32_t lv2_feature_id_ui_resize        = 19;

  96. const uint32_t lv2_feature_id_external_ui      = 20;

  97. const uint32_t lv2_feature_id_external_ui_old  = 21;

  98. const uint32_t lv2_feature_count               = 22;

  99. /**@}*/

  100. 

  101. /*!

  102.  * @defgroup Lv2EventTypes LV2 Event Data/Types

  103.  *

  104.  * Data and buffer types for LV2 EventData ports.

  105.  * @{

  106.  */

  107. const unsigned int CARLA_EVENT_DATA_ATOM      = 0x01;

  108. const unsigned int CARLA_EVENT_DATA_EVENT     = 0x02;

  109. const unsigned int CARLA_EVENT_DATA_MIDI_LL   = 0x04;

  110. const unsigned int CARLA_EVENT_TYPE_MESSAGE   = 0x10;

  111. const unsigned int CARLA_EVENT_TYPE_MIDI      = 0x20;

  112. /**@}*/

  113. 

  114. /*!

  115.  * @defgroup Lv2UriMapIds LV2 URI Map Ids

  116.  *

  117.  * Static index list of the internal LV2 URI Map Ids.

  118.  * @{

  119.  */

  120. const uint32_t CARLA_URI_MAP_ID_NULL                = 0;

  121. const uint32_t CARLA_URI_MAP_ID_ATOM_CHUNK          = 1;

  122. const uint32_t CARLA_URI_MAP_ID_ATOM_DOUBLE         = 2;

  123. const uint32_t CARLA_URI_MAP_ID_ATOM_INT            = 3;

  124. const uint32_t CARLA_URI_MAP_ID_ATOM_PATH           = 4;

  125. const uint32_t CARLA_URI_MAP_ID_ATOM_SEQUENCE       = 5;

  126. const uint32_t CARLA_URI_MAP_ID_ATOM_STRING         = 6;

  127. const uint32_t CARLA_URI_MAP_ID_ATOM_WORKER         = 7;

  128. const uint32_t CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM  = 8;

  129. const uint32_t CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT = 9;

  130. const uint32_t CARLA_URI_MAP_ID_BUF_MAX_LENGTH      = 10;

  131. const uint32_t CARLA_URI_MAP_ID_BUF_MIN_LENGTH      = 11;

  132. const uint32_t CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE   = 12;

  133. const uint32_t CARLA_URI_MAP_ID_LOG_ERROR           = 13;

  134. const uint32_t CARLA_URI_MAP_ID_LOG_NOTE            = 14;

  135. const uint32_t CARLA_URI_MAP_ID_LOG_TRACE           = 15;

  136. const uint32_t CARLA_URI_MAP_ID_LOG_WARNING         = 16;

  137. const uint32_t CARLA_URI_MAP_ID_MIDI_EVENT          = 17;

  138. const uint32_t CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE   = 18;

  139. const uint32_t CARLA_URI_MAP_ID_COUNT               = 19;

  140. /**@}*/

  141. 

  142. struct Lv2EventData {

  143.     uint32_t type;

  144.     uint32_t rindex;

  145.     CarlaEngineMidiPort* port;

  146.     union {

  147.         LV2_Atom_Sequence* atom;

  148.         LV2_Event_Buffer* event;

  149.         LV2_MIDI* midi;

  150.     };

  151. 

  152.     Lv2EventData()

  153.         : type(0),

  154.           rindex(0),

  155.           port(nullptr) {}

  156. };

  157. 

  158. struct Lv2PluginEventData {

  159.     uint32_t count;

  160.     Lv2EventData* data;

  161. 

  162.     Lv2PluginEventData()

  163.         : count(0),

  164.           data(nullptr) {}

  165. };

  166. 

  167. struct Lv2PluginOptions {

  168.     bool init;

  169.     uint32_t eventSize;

  170.     uint32_t bufferSize;

  171.     double   sampleRate;

  172.     LV2_Options_Option oNull;

  173.     LV2_Options_Option oMaxBlockLenth;

  174.     LV2_Options_Option oMinBlockLenth;

  175.     LV2_Options_Option oSequenceSize;

  176.     LV2_Options_Option oSampleRate;

  177. 

  178.     Lv2PluginOptions()

  179.         : init(false),

  180.           eventSize(MAX_EVENT_BUFFER),

  181.           bufferSize(0),

  182.           sampleRate(0.0) {}

  183. };

  184. 

  185. Lv2PluginOptions lv2Options;

  186. 

  187. const char* lv2bridge2str(const LV2_Property type)

  188. {

  189.     switch (type)

  190.     {

  191. #ifndef BUILD_BRIDGE

  192.     case LV2_UI_GTK2:

  193.         return carlaOptions.bridge_lv2gtk2;

  194.     case LV2_UI_GTK3:

  195.         return carlaOptions.bridge_lv2gtk3;

  196.     case LV2_UI_QT4:

  197.         return carlaOptions.bridge_lv2qt4;

  198.     case LV2_UI_COCOA:

  199.         return nullptr; //carlaOptions.bridge_lv2cocoa;

  200.     case LV2_UI_WINDOWS:

  201.         return nullptr; //carlaOptions.bridge_lv2hwnd;

  202.     case LV2_UI_X11:

  203.         return carlaOptions.bridge_lv2x11;

  204. #endif

  205.     default:

  206.         return nullptr;

  207.     }

  208. }

  209. 

  210. LV2_Atom_Event* getLv2AtomEvent(LV2_Atom_Sequence* const atom, const uint32_t offset)

  211. {

  212.     return (LV2_Atom_Event*)((char*)LV2_ATOM_CONTENTS(LV2_Atom_Sequence, atom) + offset);

  213. }

  214. 

  215. class Lv2Plugin : public CarlaPlugin

  216. {

  217. public:

  218.     Lv2Plugin(CarlaEngine* const engine, const unsigned short id)

  219.         : CarlaPlugin(engine, id)

  220.     {

  221.         qDebug("Lv2Plugin::Lv2Plugin()");

  222. 

  223.         m_type = PLUGIN_LV2;

  224. 

  225.         handle = h2 = nullptr;

  226.         descriptor  = nullptr;

  227.         rdf_descriptor = nullptr;

  228. 

  229.         ext.state      = nullptr;

  230.         ext.worker     = nullptr;

  231.         ext.programs   = nullptr;

  232.         ext.uiprograms = nullptr;

  233. 

  234.         ui.lib = nullptr;

  235.         ui.handle = nullptr;

  236.         ui.descriptor = nullptr;

  237.         ui.rdf_descriptor = nullptr;

  238. 

  239.         evIn.count = 0;

  240.         evIn.data  = nullptr;

  241. 

  242.         evOut.count = 0;

  243.         evOut.data  = nullptr;

  244. 

  245.         paramBuffers = nullptr;

  246. 

  247.         gui.type = GUI_NONE;

  248.         gui.resizable = false;

  249.         gui.width  = 0;

  250.         gui.height = 0;

  251. 

  252. #ifdef HAVE_SUIL

  253.         suil.handle = nullptr;

  254.         suil.host   = nullptr;

  255. #endif

  256. 

  257.         lastTimePosPlaying = false;

  258.         lastTimePosFrame   = 0;

  259. 

  260.         for (uint32_t i=0; i < CARLA_URI_MAP_ID_COUNT; i++)

  261.             customURIDs.push_back(nullptr);

  262. 

  263.         for (uint32_t i=0; i < lv2_feature_count+1; i++)

  264.             features[i] = nullptr;

  265. 

  266.         if (! lv2Options.init)

  267.         {

  268.             lv2Options.init = true;

  269.             lv2Options.bufferSize = x_engine->getBufferSize();

  270.             lv2Options.sampleRate = x_engine->getSampleRate();

  271. 

  272.             lv2Options.oNull.key   = CARLA_URI_MAP_ID_NULL;

  273.             lv2Options.oNull.size  = 0;

  274.             lv2Options.oNull.type  = CARLA_URI_MAP_ID_NULL;

  275.             lv2Options.oNull.value = nullptr;

  276. 

  277.             lv2Options.oMaxBlockLenth.key   = CARLA_URI_MAP_ID_BUF_MAX_LENGTH;

  278.             lv2Options.oMaxBlockLenth.size  = sizeof(uint32_t);

  279.             lv2Options.oMaxBlockLenth.type  = CARLA_URI_MAP_ID_ATOM_INT;

  280.             lv2Options.oMaxBlockLenth.value = &lv2Options.bufferSize;

  281. 

  282.             lv2Options.oMinBlockLenth.key   = CARLA_URI_MAP_ID_BUF_MIN_LENGTH;

  283.             lv2Options.oMinBlockLenth.size  = sizeof(uint32_t);

  284.             lv2Options.oMinBlockLenth.type  = CARLA_URI_MAP_ID_ATOM_INT;

  285.             lv2Options.oMinBlockLenth.value = &lv2Options.bufferSize;

  286. 

  287.             lv2Options.oSequenceSize.key   = CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE;

  288.             lv2Options.oSequenceSize.size  = sizeof(uint32_t);

  289.             lv2Options.oSequenceSize.type  = CARLA_URI_MAP_ID_ATOM_INT;

  290.             lv2Options.oSequenceSize.value = &lv2Options.eventSize;

  291. 

  292.             lv2Options.oSampleRate.key     = CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE;

  293.             lv2Options.oSampleRate.size    = sizeof(double);

  294.             lv2Options.oSampleRate.type    = CARLA_URI_MAP_ID_ATOM_DOUBLE;

  295.             lv2Options.oSampleRate.value   = &lv2Options.sampleRate;

  296.         }

  297. 

  298.         Lv2World.init();

  299.     }

  300. 

  301.     ~Lv2Plugin()

  302.     {

  303.         qDebug("Lv2Plugin::~Lv2Plugin()");

  304. 

  305.         // close UI

  306.         if (m_hints & PLUGIN_HAS_GUI)

  307.         {

  308.             showGui(false);

  309. 

  310.             switch (gui.type)

  311.             {

  312.             case GUI_NONE:

  313.             case GUI_INTERNAL_QT4:

  314.             case GUI_INTERNAL_COCOA:

  315.             case GUI_INTERNAL_HWND:

  316.             case GUI_INTERNAL_X11:

  317.             case GUI_EXTERNAL_LV2:

  318.                 break;

  319. 

  320.             case GUI_EXTERNAL_SUIL:

  321. #ifdef HAVE_SUIL

  322.                 if (ui.widget)

  323.                     ((QWidget*)ui.widget)->close();

  324. #endif

  325.                 break;

  326. 

  327.             case GUI_EXTERNAL_OSC:

  328. #ifndef BUILD_BRIDGE

  329.                 if (osc.thread)

  330.                 {

  331.                     // Wait a bit first, try safe quit, then force kill

  332.                     if (osc.thread->isRunning() && ! osc.thread->wait(carlaOptions.oscUiTimeout * 100))

  333.                     {

  334.                         qWarning("Failed to properly stop LV2 OSC GUI thread");

  335.                         osc.thread->terminate();

  336.                     }

  337. 

  338.                     delete osc.thread;

  339.                 }

  340. #endif

  341.                 break;

  342.             }

  343. 

  344. #ifdef HAVE_SUIL

  345.             if (suil.handle)

  346.             {

  347.                 suil_instance_free(suil.handle);

  348. 

  349.                 if (suil.host)

  350.                     suil_host_free(suil.host);

  351. 

  352.                 ui.handle = nullptr;

  353.                 ui.descriptor = nullptr;

  354.             }

  355. #endif

  356. 

  357.             if (ui.handle && ui.descriptor && ui.descriptor->cleanup)

  358.                 ui.descriptor->cleanup(ui.handle);

  359. 

  360.             if (features[lv2_feature_id_data_access] && features[lv2_feature_id_data_access]->data)

  361.                 delete (LV2_Extension_Data_Feature*)features[lv2_feature_id_data_access]->data;

  362. 

  363.             if (features[lv2_feature_id_ui_port_map] && features[lv2_feature_id_ui_port_map]->data)

  364.                 delete (LV2UI_Port_Map*)features[lv2_feature_id_ui_port_map]->data;

  365. 

  366.             if (features[lv2_feature_id_ui_resize] && features[lv2_feature_id_ui_resize]->data)

  367.                 delete (LV2UI_Resize*)features[lv2_feature_id_ui_resize]->data;

  368. 

  369.             if (features[lv2_feature_id_external_ui] && features[lv2_feature_id_external_ui]->data)

  370.             {

  371.                 const LV2_External_UI_Host* const uiHost = (const LV2_External_UI_Host*)features[lv2_feature_id_external_ui]->data;

  372. 

  373.                 if (uiHost->plugin_human_id)

  374.                     free((void*)uiHost->plugin_human_id);

  375. 

  376.                 delete uiHost;

  377.             }

  378. 

  379.             uiLibClose();

  380.         }

  381. 

  382.         if (descriptor)

  383.         {

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

  385.             {

  386.                 if (handle)

  387.                     descriptor->deactivate(handle);

  388.                 if (h2)

  389.                     descriptor->deactivate(h2);

  390.             }

  391. 

  392.             if (descriptor->cleanup)

  393.             {

  394.                 if (handle)

  395.                     descriptor->cleanup(handle);

  396.                 if (h2)

  397.                     descriptor->cleanup(h2);

  398.             }

  399.         }

  400. 

  401.         if (rdf_descriptor)

  402.             lv2_rdf_free(rdf_descriptor);

  403. 

  404.         if (features[lv2_feature_id_event] && features[lv2_feature_id_event]->data)

  405.             delete (LV2_Event_Feature*)features[lv2_feature_id_event]->data;

  406. 

  407.         if (features[lv2_feature_id_logs] && features[lv2_feature_id_logs]->data)

  408.             delete (LV2_Log_Log*)features[lv2_feature_id_logs]->data;

  409. 

  410.         if (features[lv2_feature_id_options] && features[lv2_feature_id_options]->data)

  411.         {

  412.             const LV2_Options_Option* const options = (const LV2_Options_Option*)features[lv2_feature_id_options]->data;

  413.             delete[] options;

  414.         }

  415. 

  416.         if (features[lv2_feature_id_programs] && features[lv2_feature_id_programs]->data)

  417.             delete (LV2_Programs_Host*)features[lv2_feature_id_programs]->data;

  418. 

  419.         if (features[lv2_feature_id_rtmempool] && features[lv2_feature_id_rtmempool]->data)

  420.             delete (LV2_RtMemPool_Pool*)features[lv2_feature_id_rtmempool]->data;

  421. 

  422.         if (features[lv2_feature_id_state_make_path] && features[lv2_feature_id_state_make_path]->data)

  423.             delete (LV2_State_Make_Path*)features[lv2_feature_id_state_make_path]->data;

  424. 

  425.         if (features[lv2_feature_id_state_map_path] && features[lv2_feature_id_state_map_path]->data)

  426.             delete (LV2_State_Map_Path*)features[lv2_feature_id_state_map_path]->data;

  427. 

  428.         if (features[lv2_feature_id_uri_map] && features[lv2_feature_id_uri_map]->data)

  429.             delete (LV2_URI_Map_Feature*)features[lv2_feature_id_uri_map]->data;

  430. 

  431.         if (features[lv2_feature_id_urid_map] && features[lv2_feature_id_urid_map]->data)

  432.             delete (LV2_URID_Map*)features[lv2_feature_id_urid_map]->data;

  433. 

  434.         if (features[lv2_feature_id_urid_unmap] && features[lv2_feature_id_urid_unmap]->data)

  435.             delete (LV2_URID_Unmap*)features[lv2_feature_id_urid_unmap]->data;

  436. 

  437.         if (features[lv2_feature_id_worker] && features[lv2_feature_id_worker]->data)

  438.             delete (LV2_Worker_Schedule*)features[lv2_feature_id_worker]->data;

  439. 

  440. #ifndef BUILD_BRIDGE

  441.         if (! carlaOptions.processHighPrecision)

  442. #endif

  443.         {

  444.             features[lv2_feature_id_bufsize_fixed]    = nullptr;

  445.             features[lv2_feature_id_bufsize_powerof2] = nullptr;

  446.         }

  447. 

  448.         for (uint32_t i=0; i < lv2_feature_count; i++)

  449.         {

  450.             if (features[i])

  451.                 delete features[i];

  452.         }

  453. 

  454.         for (size_t i=0; i < customURIDs.size(); i++)

  455.         {

  456.             if (customURIDs[i])

  457.                 free((void*)customURIDs[i]);

  458.         }

  459. 

  460.         customURIDs.clear();

  461.     }

  462. 

  463.     // -------------------------------------------------------------------

  464.     // Information (base)

  465. 

  466.     PluginCategory category()

  467.     {

  468.         CARLA_ASSERT(rdf_descriptor);

  469. 

  470.         LV2_Property category = rdf_descriptor->Type;

  471. 

  472.         if (LV2_IS_DELAY(category))

  473.             return PLUGIN_CATEGORY_DELAY;

  474.         if (LV2_IS_DISTORTION(category))

  475.             return PLUGIN_CATEGORY_OTHER;

  476.         if (LV2_IS_DYNAMICS(category))

  477.             return PLUGIN_CATEGORY_DYNAMICS;

  478.         if (LV2_IS_EQ(category))

  479.             return PLUGIN_CATEGORY_EQ;

  480.         if (LV2_IS_FILTER(category))

  481.             return PLUGIN_CATEGORY_FILTER;

  482.         if (LV2_IS_GENERATOR(category))

  483.             return PLUGIN_CATEGORY_SYNTH;

  484.         if (LV2_IS_MODULATOR(category))

  485.             return PLUGIN_CATEGORY_MODULATOR;

  486.         if (LV2_IS_REVERB(category))

  487.             return PLUGIN_CATEGORY_DELAY;

  488.         if (LV2_IS_SIMULATOR(category))

  489.             return PLUGIN_CATEGORY_OTHER;

  490.         if (LV2_IS_SPATIAL(category))

  491.             return PLUGIN_CATEGORY_OTHER;

  492.         if (LV2_IS_SPECTRAL(category))

  493.             return PLUGIN_CATEGORY_UTILITY;

  494.         if (LV2_IS_UTILITY(category))

  495.             return PLUGIN_CATEGORY_UTILITY;

  496. 

  497.         return getPluginCategoryFromName(m_name);

  498.     }

  499. 

  500.     long uniqueId()

  501.     {

  502.         CARLA_ASSERT(rdf_descriptor);

  503. 

  504.         return rdf_descriptor->UniqueID;

  505.     }

  506. 

  507.     // -------------------------------------------------------------------

  508.     // Information (count)

  509. 

  510.     uint32_t midiInCount()

  511.     {

  512.         uint32_t i, count = 0;

  513. 

  514.         for (i=0; i < evIn.count; i++)

  515.         {

  516.             if (evIn.data[i].type & CARLA_EVENT_TYPE_MIDI)

  517.                 count += 1;

  518.         }

  519. 

  520.         return count;

  521.     }

  522. 

  523.     uint32_t midiOutCount()

  524.     {

  525.         uint32_t i, count = 0;

  526. 

  527.         for (i=0; i < evOut.count; i++)

  528.         {

  529.             if (evOut.data[i].type & CARLA_EVENT_TYPE_MIDI)

  530.                 count += 1;

  531.         }

  532. 

  533.         return count;

  534.     }

  535. 

  536.     uint32_t parameterScalePointCount(const uint32_t parameterId)

  537.     {

  538.         CARLA_ASSERT(parameterId < param.count);

  539.         CARLA_ASSERT(rdf_descriptor);

  540. 

  541.         int32_t rindex = param.data[parameterId].rindex;

  542. 

  543.         if (rdf_descriptor && rindex < (int32_t)rdf_descriptor->PortCount)

  544.         {

  545.             const LV2_RDF_Port* const port = &rdf_descriptor->Ports[rindex];

  546.             return port->ScalePointCount;

  547.         }

  548. 

  549.         return 0;

  550.     }

  551. 

  552.     // -------------------------------------------------------------------

  553.     // Information (per-plugin data)

  554. 

  555.     double getParameterValue(const uint32_t parameterId)

  556.     {

  557.         CARLA_ASSERT(parameterId < param.count);

  558. 

  559.         return paramBuffers[parameterId];

  560.     }

  561. 

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

  563.     {

  564.         CARLA_ASSERT(parameterId < param.count);

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

  566. 

  567.         int32_t rindex = param.data[parameterId].rindex;

  568. 

  569.         if (rdf_descriptor && rindex < (int32_t)rdf_descriptor->PortCount)

  570.         {

  571.             const LV2_RDF_Port* const port = &rdf_descriptor->Ports[rindex];

  572. 

  573.             if (scalePointId < port->ScalePointCount)

  574.             {

  575.                 const LV2_RDF_PortScalePoint* const portScalePoint = &port->ScalePoints[scalePointId];

  576.                 return portScalePoint->Value;

  577.             }

  578.         }

  579. 

  580.         return 0.0;

  581.     }

  582. 

  583.     void getLabel(char* const strBuf)

  584.     {

  585.         CARLA_ASSERT(rdf_descriptor);

  586. 

  587.         if (rdf_descriptor && rdf_descriptor->URI)

  588.             strncpy(strBuf, rdf_descriptor->URI, STR_MAX);

  589.         else

  590.             CarlaPlugin::getLabel(strBuf);

  591.     }

  592. 

  593.     void getMaker(char* const strBuf)

  594.     {

  595.         CARLA_ASSERT(rdf_descriptor);

  596. 

  597.         if (rdf_descriptor && rdf_descriptor->Author)

  598.             strncpy(strBuf, rdf_descriptor->Author, STR_MAX);

  599.         else

  600.             CarlaPlugin::getMaker(strBuf);

  601.     }

  602. 

  603.     void getCopyright(char* const strBuf)

  604.     {

  605.         CARLA_ASSERT(rdf_descriptor);

  606. 

  607.         if (rdf_descriptor && rdf_descriptor->License)

  608.             strncpy(strBuf, rdf_descriptor->License, STR_MAX);

  609.         else

  610.             CarlaPlugin::getCopyright(strBuf);

  611.     }

  612. 

  613.     void getRealName(char* const strBuf)

  614.     {

  615.         CARLA_ASSERT(rdf_descriptor);

  616. 

  617.         if (rdf_descriptor && rdf_descriptor->Name)

  618.             strncpy(strBuf, rdf_descriptor->Name, STR_MAX);

  619.         else

  620.             CarlaPlugin::getRealName(strBuf);

  621.     }

  622. 

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

  624.     {

  625.         CARLA_ASSERT(rdf_descriptor);

  626.         CARLA_ASSERT(parameterId < param.count);

  627. 

  628.         int32_t rindex = param.data[parameterId].rindex;

  629. 

  630.         if (rdf_descriptor && rindex < (int32_t)rdf_descriptor->PortCount)

  631.             strncpy(strBuf, rdf_descriptor->Ports[rindex].Name, STR_MAX);

  632.         else

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

  634.     }

  635. 

  636.     void getParameterSymbol(const uint32_t parameterId, char* const strBuf)

  637.     {

  638.         CARLA_ASSERT(rdf_descriptor);

  639.         CARLA_ASSERT(parameterId < param.count);

  640. 

  641.         int32_t rindex = param.data[parameterId].rindex;

  642. 

  643.         if (rdf_descriptor && rindex < (int32_t)rdf_descriptor->PortCount)

  644.             strncpy(strBuf, rdf_descriptor->Ports[rindex].Symbol, STR_MAX);

  645.         else

  646.             CarlaPlugin::getParameterSymbol(parameterId, strBuf);

  647.     }

  648. 

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

  650.     {

  651.         CARLA_ASSERT(rdf_descriptor);

  652.         CARLA_ASSERT(parameterId < param.count);

  653. 

  654.         int32_t rindex = param.data[parameterId].rindex;

  655. 

  656.         if (rdf_descriptor && rindex < (int32_t)rdf_descriptor->PortCount)

  657.         {

  658.             const LV2_RDF_Port* const port = &rdf_descriptor->Ports[rindex];

  659. 

  660.             if (LV2_HAVE_UNIT_SYMBOL(port->Unit.Hints) && port->Unit.Symbol)

  661.                 strncpy(strBuf, port->Unit.Symbol, STR_MAX);

  662. 

  663.             else if (LV2_HAVE_UNIT(port->Unit.Hints))

  664.             {

  665.                 switch (port->Unit.Type)

  666.                 {

  667.                 case LV2_UNIT_BAR:

  668.                     strncpy(strBuf, "bars", STR_MAX);

  669.                     return;

  670.                 case LV2_UNIT_BEAT:

  671.                     strncpy(strBuf, "beats", STR_MAX);

  672.                     return;

  673.                 case LV2_UNIT_BPM:

  674.                     strncpy(strBuf, "BPM", STR_MAX);

  675.                     return;

  676.                 case LV2_UNIT_CENT:

  677.                     strncpy(strBuf, "ct", STR_MAX);

  678.                     return;

  679.                 case LV2_UNIT_CM:

  680.                     strncpy(strBuf, "cm", STR_MAX);

  681.                     return;

  682.                 case LV2_UNIT_COEF:

  683.                     strncpy(strBuf, "(coef)", STR_MAX);

  684.                     return;

  685.                 case LV2_UNIT_DB:

  686.                     strncpy(strBuf, "dB", STR_MAX);

  687.                     return;

  688.                 case LV2_UNIT_DEGREE:

  689.                     strncpy(strBuf, "deg", STR_MAX);

  690.                     return;

  691.                 case LV2_UNIT_FRAME:

  692.                     strncpy(strBuf, "frames", STR_MAX);

  693.                     return;

  694.                 case LV2_UNIT_HZ:

  695.                     strncpy(strBuf, "Hz", STR_MAX);

  696.                     return;

  697.                 case LV2_UNIT_INCH:

  698.                     strncpy(strBuf, "in", STR_MAX);

  699.                     return;

  700.                 case LV2_UNIT_KHZ:

  701.                     strncpy(strBuf, "kHz", STR_MAX);

  702.                     return;

  703.                 case LV2_UNIT_KM:

  704.                     strncpy(strBuf, "km", STR_MAX);

  705.                     return;

  706.                 case LV2_UNIT_M:

  707.                     strncpy(strBuf, "m", STR_MAX);

  708.                     return;

  709.                 case LV2_UNIT_MHZ:

  710.                     strncpy(strBuf, "MHz", STR_MAX);

  711.                     return;

  712.                 case LV2_UNIT_MIDINOTE:

  713.                     strncpy(strBuf, "note", STR_MAX);

  714.                     return;

  715.                 case LV2_UNIT_MILE:

  716.                     strncpy(strBuf, "mi", STR_MAX);

  717.                     return;

  718.                 case LV2_UNIT_MIN:

  719.                     strncpy(strBuf, "min", STR_MAX);

  720.                     return;

  721.                 case LV2_UNIT_MM:

  722.                     strncpy(strBuf, "mm", STR_MAX);

  723.                     return;

  724.                 case LV2_UNIT_MS:

  725.                     strncpy(strBuf, "ms", STR_MAX);

  726.                     return;

  727.                 case LV2_UNIT_OCT:

  728.                     strncpy(strBuf, "oct", STR_MAX);

  729.                     return;

  730.                 case LV2_UNIT_PC:

  731.                     strncpy(strBuf, "%", STR_MAX);

  732.                     return;

  733.                 case LV2_UNIT_S:

  734.                     strncpy(strBuf, "s", STR_MAX);

  735.                     return;

  736.                 case LV2_UNIT_SEMITONE:

  737.                     strncpy(strBuf, "semi", STR_MAX);

  738.                     return;

  739.                 }

  740.             }

  741.         }

  742. 

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

  744.     }

  745. 

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

  747.     {

  748.         CARLA_ASSERT(rdf_descriptor);

  749.         CARLA_ASSERT(parameterId < param.count);

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

  751. 

  752.         int32_t rindex = param.data[parameterId].rindex;

  753. 

  754.         if (rdf_descriptor && rindex < (int32_t)rdf_descriptor->PortCount)

  755.         {

  756.             const LV2_RDF_Port* const port = &rdf_descriptor->Ports[rindex];

  757. 

  758.             if (scalePointId < port->ScalePointCount)

  759.             {

  760.                 const LV2_RDF_PortScalePoint* const portScalePoint = &port->ScalePoints[scalePointId];

  761. 

  762.                 if (portScalePoint->Label)

  763.                 {

  764.                     strncpy(strBuf, portScalePoint->Label, STR_MAX);

  765.                     return;

  766.                 }

  767.             }

  768.         }

  769. 

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

  771.     }

  772. 

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

  774.     {

  775.         CARLA_ASSERT(type);

  776.         CARLA_ASSERT(resizable);

  777. 

  778.         *type      = gui.type;

  779.         *resizable = gui.resizable;

  780.     }

  781. 

  782.     // -------------------------------------------------------------------

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

  784. 

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

  786.     {

  787.         CARLA_ASSERT(parameterId < param.count);

  788. 

  789.         paramBuffers[parameterId] = fixParameterValue(value, param.ranges[parameterId]);

  790. 

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

  792.     }

  793. 

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

  795.     {

  796.         CARLA_ASSERT(type != CUSTOM_DATA_INVALID);

  797.         CARLA_ASSERT(key);

  798.         CARLA_ASSERT(value);

  799. 

  800.         if (type == CUSTOM_DATA_INVALID)

  801.             return qCritical("Lv2Plugin::setCustomData(%s, \"%s\", \"%s\", %s) - type is invalid", CustomDataType2str(type), key, value, bool2str(sendGui));

  802. 

  803.         if (! key)

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

  805. 

  806.         if (! value)

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

  808. 

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

  810. 

  811.         if (ext.state)

  812.         {

  813.             const char* const stype = getCustomDataTypeString(type);

  814.             LV2_State_Status status;

  815. 

  816.             if (x_engine->isOffline())

  817.             {

  818.                 const CarlaEngine::ScopedLocker m(x_engine);

  819.                 status = ext.state->restore(handle, carla_lv2_state_retrieve, this, 0, features);

  820.                 if (h2) ext.state->restore(h2, carla_lv2_state_retrieve, this, 0, features);

  821.             }

  822.             else

  823.             {

  824.                 const CarlaPlugin::ScopedDisabler m(this);

  825.                 status = ext.state->restore(handle, carla_lv2_state_retrieve, this, 0, features);

  826.                 if (h2) ext.state->restore(h2, carla_lv2_state_retrieve, this, 0, features);

  827.             }

  828. 

  829.             switch (status)

  830.             {

  831.             case LV2_STATE_SUCCESS:

  832.                 qDebug("Lv2Plugin::setCustomData(%s, %s, <value>, %s) - success", stype, key, bool2str(sendGui));

  833.                 break;

  834.             case LV2_STATE_ERR_UNKNOWN:

  835.                 qWarning("Lv2Plugin::setCustomData(%s, %s, <value>, %s) - unknown error", stype, key, bool2str(sendGui));

  836.                 break;

  837.             case LV2_STATE_ERR_BAD_TYPE:

  838.                 qWarning("Lv2Plugin::setCustomData(%s, %s, <value>, %s) - error, bad type", stype, key, bool2str(sendGui));

  839.                 break;

  840.             case LV2_STATE_ERR_BAD_FLAGS:

  841.                 qWarning("Lv2Plugin::setCustomData(%s, %s, <value>, %s) - error, bad flags", stype, key, bool2str(sendGui));

  842.                 break;

  843.             case LV2_STATE_ERR_NO_FEATURE:

  844.                 qWarning("Lv2Plugin::setCustomData(%s, %s, <value>, %s) - error, missing feature", stype, key, bool2str(sendGui));

  845.                 break;

  846.             case LV2_STATE_ERR_NO_PROPERTY:

  847.                 qWarning("Lv2Plugin::setCustomData(%s, %s, <value>, %s) - error, missing property", stype, key, bool2str(sendGui));

  848.                 break;

  849.             }

  850.         }

  851. 

  852.         if (sendGui)

  853.         {

  854.             CustomData cdata;

  855.             cdata.type  = type;

  856.             cdata.key   = key;

  857.             cdata.value = value;

  858.             uiTransferCustomData(&cdata);

  859.         }

  860.     }

  861. 

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

  863.     {

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

  865. 

  866.         if (index < -1)

  867.             index = -1;

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

  869.             return;

  870. 

  871.         if (ext.programs && index >= 0)

  872.         {

  873.             if (x_engine->isOffline())

  874.             {

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

  876.                 ext.programs->select_program(handle, midiprog.data[index].bank, midiprog.data[index].program);

  877.                 if (h2) ext.programs->select_program(h2, midiprog.data[index].bank, midiprog.data[index].program);

  878.             }

  879.             else

  880.             {

  881.                 const ScopedDisabler m(this, block);

  882.                 ext.programs->select_program(handle, midiprog.data[index].bank, midiprog.data[index].program);

  883.                 if (h2) ext.programs->select_program(h2, midiprog.data[index].bank, midiprog.data[index].program);

  884.             }

  885.         }

  886. 

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

  888.     }

  889. 

  890.     // -------------------------------------------------------------------

  891.     // Set gui stuff

  892. 

  893.     void setGuiContainer(GuiContainer* const container)

  894.     {

  895.         qDebug("Lv2Plugin::setGuiContainer(%p)", container);

  896.         CARLA_ASSERT(container);

  897. 

  898.         switch(gui.type)

  899.         {

  900.         case GUI_NONE:

  901.             break;

  902. 

  903.         case GUI_INTERNAL_QT4:

  904.             if (ui.widget)

  905.             {

  906.                 QDialog* const dialog = (QDialog*)container->parent();

  907.                 QWidget* const widget = (QWidget*)ui.widget;

  908.                 CARLA_ASSERT(dialog);

  909.                 CARLA_ASSERT(dialog->layout());

  910.                 CARLA_ASSERT(widget);

  911.                 container->setVisible(false);

  912.                 dialog->layout()->addWidget(widget);

  913.                 widget->adjustSize();

  914.                 widget->setParent(dialog);

  915.                 widget->show();

  916.             }

  917.             break;

  918. 

  919.         case GUI_INTERNAL_COCOA:

  920.         case GUI_INTERNAL_HWND:

  921.         case GUI_INTERNAL_X11:

  922.             if (ui.descriptor)

  923.             {

  924.                 features[lv2_feature_id_ui_parent]->data = (void*)container->winId();

  925.                 ui.handle = ui.descriptor->instantiate(ui.descriptor, descriptor->URI, ui.rdf_descriptor->Bundle, carla_lv2_ui_write_function, this, &ui.widget, features);

  926.                 updateUi();

  927.             }

  928.             break;

  929. 

  930.         case GUI_EXTERNAL_LV2:

  931.         case GUI_EXTERNAL_SUIL:

  932.         case GUI_EXTERNAL_OSC:

  933.             break;

  934.         }

  935.     }

  936. 

  937.     void showGui(const bool yesNo)

  938.     {

  939.         switch(gui.type)

  940.         {

  941.         case GUI_NONE:

  942.         case GUI_INTERNAL_QT4:

  943.             break;

  944. 

  945.         case GUI_INTERNAL_COCOA:

  946.         case GUI_INTERNAL_HWND:

  947.         case GUI_INTERNAL_X11:

  948.             if (yesNo && gui.width > 0 && gui.height > 0)

  949.                 x_engine->callback(CALLBACK_RESIZE_GUI, m_id, gui.width, gui.height, 0.0);

  950.             break;

  951. 

  952.         case GUI_EXTERNAL_LV2:

  953.             if (yesNo && ! ui.handle)

  954.                 initExternalUi();

  955. 

  956.             if (ui.handle && ui.descriptor && ui.widget)

  957.             {

  958.                 if (yesNo)

  959.                 {

  960.                     LV2_EXTERNAL_UI_SHOW((LV2_External_UI_Widget*)ui.widget);

  961.                 }

  962.                 else

  963.                 {

  964.                     LV2_EXTERNAL_UI_HIDE((LV2_External_UI_Widget*)ui.widget);

  965. 

  966.                     if (rdf_descriptor->Author && strcmp(rdf_descriptor->Author, "linuxDSP") == 0)

  967.                     {

  968.                         qWarning("linuxDSP LV2 UI hack (force close instead of hide)");

  969. 

  970.                         if (ui.descriptor->cleanup)

  971.                             ui.descriptor->cleanup(ui.handle);

  972. 

  973.                         ui.handle = nullptr;

  974.                     }

  975.                 }

  976.             }

  977.             else

  978.                 // failed to init UI

  979.                 x_engine->callback(CALLBACK_SHOW_GUI, m_id, -1, 0, 0.0);

  980. 

  981.             break;

  982. 

  983.         case GUI_EXTERNAL_SUIL:

  984. #ifdef HAVE_SUIL

  985.             if (ui.widget)

  986.             {

  987.                 QWidget* const widget = (QWidget*)ui.widget;

  988. 

  989.                 if (yesNo)

  990.                 {

  991.                     if (! suil.pos.isNull())

  992.                         widget->restoreGeometry(suil.pos);

  993.                 }

  994.                 else

  995.                     suil.pos = widget->saveGeometry();

  996. 

  997.                 widget->setVisible(yesNo);

  998.             }

  999. #endif

  1000.             break;

  1001. 

  1002.         case GUI_EXTERNAL_OSC:

  1003. #ifndef BUILD_BRIDGE

  1004.             CARLA_ASSERT(osc.thread);

  1005. 

  1006.             if (! osc.thread)

  1007.             {

  1008.                 qCritical("Lv2Plugin::showGui(%s) - attempt to show gui, but it does not exist!", bool2str(yesNo));

  1009.                 return;

  1010.             }

  1011. 

  1012.             if (yesNo)

  1013.             {

  1014.                 osc.thread->start();

  1015.             }

  1016.             else

  1017.             {

  1018.                 if (osc.data.target)

  1019.                 {

  1020.                     osc_send_hide(&osc.data);

  1021.                     osc_send_quit(&osc.data);

  1022.                     osc_clear_data(&osc.data);

  1023.                 }

  1024. 

  1025.                 if (! osc.thread->wait(500))

  1026.                     osc.thread->quit();

  1027.             }

  1028. #endif

  1029.             break;

  1030.         }

  1031.     }

  1032. 

  1033.     void idleGui()

  1034.     {

  1035. #ifdef BUILD_BRIDGE

  1036.         const bool haveUI = (gui.type != GUI_EXTERNAL_OSC && ui.handle && ui.descriptor);

  1037. #else

  1038.         const bool haveUI = (gui.type == GUI_EXTERNAL_OSC && osc.data.target) || (ui.handle && ui.descriptor);

  1039. #endif

  1040. 

  1041.         if (haveUI)

  1042.         {

  1043.             // Update event ports

  1044.             if (! atomQueueOut.isEmpty())

  1045.             {

  1046.                 static Lv2AtomQueue queue;

  1047.                 queue.copyDataFrom(&atomQueueOut);

  1048. 

  1049.                 uint32_t portIndex;

  1050.                 const LV2_Atom* atom;

  1051. 

  1052.                 while (queue.get(&portIndex, &atom, false))

  1053.                 {

  1054. #ifndef BUILD_BRIDGE

  1055.                     if (gui.type == GUI_EXTERNAL_OSC)

  1056.                     {

  1057.                         QByteArray chunk((const char*)atom, sizeof(LV2_Atom) + atom->size);

  1058.                         osc_send_lv2_transfer_event(&osc.data, portIndex, getCustomURIString(atom->type), chunk.toBase64().constData());

  1059.                     }

  1060.                     else

  1061. #endif

  1062.                     {

  1063.                         if (ui.descriptor->port_event)

  1064.                             ui.descriptor->port_event(ui.handle, portIndex, atom->size, CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT, atom);

  1065.                     }

  1066.                 }

  1067.             }

  1068. 

  1069.             // Update external UI

  1070.             if (gui.type == GUI_EXTERNAL_LV2 && ui.widget)

  1071.                 LV2_EXTERNAL_UI_RUN((LV2_External_UI_Widget*)ui.widget);

  1072.         }

  1073. 

  1074.         CarlaPlugin::idleGui();

  1075.     }

  1076. 

  1077.     // -------------------------------------------------------------------

  1078.     // Plugin state

  1079. 

  1080.     void reload()

  1081.     {

  1082.         qDebug("Lv2Plugin::reload() - start");

  1083.         CARLA_ASSERT(descriptor && rdf_descriptor);

  1084. 

  1085.         // Safely disable plugin for reload

  1086.         const ScopedDisabler m(this);

  1087. 

  1088.         if (x_client->isActive())

  1089.             x_client->deactivate();

  1090. 

  1091.         // Remove client ports

  1092.         removeClientPorts();

  1093. 

  1094.         // Delete old data

  1095.         deleteBuffers();

  1096. 

  1097.         uint32_t aIns, aOuts, cvIns, cvOuts, params, j;

  1098.         aIns = aOuts = cvIns = cvOuts = params = 0;

  1099.         std::vector<uint32_t> evIns, evOuts;

  1100. 

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

  1102.         const uint32_t portCount = rdf_descriptor->PortCount;

  1103. 

  1104.         bool forcedStereoIn, forcedStereoOut;

  1105.         forcedStereoIn = forcedStereoOut = false;

  1106. 

  1107.         for (uint32_t i=0; i < portCount; i++)

  1108.         {

  1109.             const LV2_Property portType = rdf_descriptor->Ports[i].Type;

  1110. 

  1111.             if (LV2_IS_PORT_AUDIO(portType))

  1112.             {

  1113.                 if (LV2_IS_PORT_INPUT(portType))

  1114.                     aIns += 1;

  1115.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1116.                     aOuts += 1;

  1117.             }

  1118.             else if (LV2_IS_PORT_CV(portType))

  1119.             {

  1120.                 if (LV2_IS_PORT_INPUT(portType))

  1121.                     cvIns += 1;

  1122.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1123.                     cvOuts += 1;

  1124.             }

  1125.             else if (LV2_IS_PORT_ATOM_SEQUENCE(portType))

  1126.             {

  1127.                 if (LV2_IS_PORT_INPUT(portType))

  1128.                     evIns.push_back(CARLA_EVENT_DATA_ATOM);

  1129.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1130.                     evOuts.push_back(CARLA_EVENT_DATA_ATOM);

  1131.             }

  1132.             else if (LV2_IS_PORT_EVENT(portType))

  1133.             {

  1134.                 if (LV2_IS_PORT_INPUT(portType))

  1135.                     evIns.push_back(CARLA_EVENT_DATA_EVENT);

  1136.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1137.                     evOuts.push_back(CARLA_EVENT_DATA_EVENT);

  1138.             }

  1139.             else if (LV2_IS_PORT_MIDI_LL(portType))

  1140.             {

  1141.                 if (LV2_IS_PORT_INPUT(portType))

  1142.                     evIns.push_back(CARLA_EVENT_DATA_MIDI_LL);

  1143.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1144.                     evOuts.push_back(CARLA_EVENT_DATA_MIDI_LL);

  1145.             }

  1146.             else if (LV2_IS_PORT_CONTROL(portType))

  1147.                 params += 1;

  1148.         }

  1149. 

  1150.         // check extensions

  1151.         ext.state      = nullptr;

  1152.         ext.worker     = nullptr;

  1153.         ext.programs   = nullptr;

  1154. 

  1155.         if (descriptor->extension_data)

  1156.         {

  1157.             if (m_hints & PLUGIN_HAS_EXTENSION_PROGRAMS)

  1158.                 ext.programs = (const LV2_Programs_Interface*)descriptor->extension_data(LV2_PROGRAMS__Interface);

  1159. 

  1160.             if (m_hints & PLUGIN_HAS_EXTENSION_STATE)

  1161.                 ext.state = (const LV2_State_Interface*)descriptor->extension_data(LV2_STATE__interface);

  1162. 

  1163.             if (m_hints & PLUGIN_HAS_EXTENSION_WORKER)

  1164.                 ext.worker = (const LV2_Worker_Interface*)descriptor->extension_data(LV2_WORKER__interface);

  1165.         }

  1166. 

  1167. #ifndef BUILD_BRIDGE

  1168.         if (carlaOptions.forceStereo && (aIns == 1 || aOuts == 1) && ! (h2 || ext.state || ext.worker))

  1169.         {

  1170.             h2 = descriptor->instantiate(descriptor, sampleRate, rdf_descriptor->Bundle, features);

  1171. 

  1172.             if (aIns == 1)

  1173.             {

  1174.                 aIns = 2;

  1175.                 forcedStereoIn = true;

  1176.             }

  1177. 

  1178.             if (aOuts == 1)

  1179.             {

  1180.                 aOuts = 2;

  1181.                 forcedStereoOut = true;

  1182.             }

  1183.         }

  1184. #endif

  1185. 

  1186.         if (aIns > 0)

  1187.         {

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

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

  1190.         }

  1191. 

  1192.         if (aOuts > 0)

  1193.         {

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

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

  1196.         }

  1197. 

  1198.         if (evIns.size() > 0)

  1199.         {

  1200.             const size_t size = evIns.size();

  1201.             evIn.data = new Lv2EventData[size];

  1202. 

  1203.             for (j=0; j < size; j++)

  1204.             {

  1205.                 evIn.data[j].port = nullptr;

  1206.                 evIn.data[j].type = 0;

  1207. 

  1208.                 if (evIns[j] == CARLA_EVENT_DATA_ATOM)

  1209.                 {

  1210.                     evIn.data[j].type = CARLA_EVENT_DATA_ATOM;

  1211.                     evIn.data[j].atom = (LV2_Atom_Sequence*)malloc(sizeof(LV2_Atom_Sequence) + MAX_EVENT_BUFFER);

  1212.                     evIn.data[j].atom->atom.size = sizeof(LV2_Atom_Sequence_Body);

  1213.                     evIn.data[j].atom->atom.type = CARLA_URI_MAP_ID_ATOM_SEQUENCE;

  1214.                     evIn.data[j].atom->body.unit = CARLA_URI_MAP_ID_NULL;

  1215.                     evIn.data[j].atom->body.pad  = 0;

  1216.                 }

  1217.                 else if (evIns[j] == CARLA_EVENT_DATA_EVENT)

  1218.                 {

  1219.                     evIn.data[j].type  = CARLA_EVENT_DATA_EVENT;

  1220.                     evIn.data[j].event = lv2_event_buffer_new(MAX_EVENT_BUFFER, LV2_EVENT_AUDIO_STAMP);

  1221.                 }

  1222.                 else if (evIns[j] == CARLA_EVENT_DATA_MIDI_LL)

  1223.                 {

  1224.                     evIn.data[j].type  = CARLA_EVENT_DATA_MIDI_LL;

  1225.                     evIn.data[j].midi  = new LV2_MIDI;

  1226.                     evIn.data[j].midi->capacity = MAX_EVENT_BUFFER;

  1227.                     evIn.data[j].midi->data     = new unsigned char [MAX_EVENT_BUFFER];

  1228.                 }

  1229.             }

  1230.         }

  1231. 

  1232.         if (evOuts.size() > 0)

  1233.         {

  1234.             const size_t size = evOuts.size();

  1235.             evOut.data = new Lv2EventData[size];

  1236. 

  1237.             for (j=0; j < size; j++)

  1238.             {

  1239.                 evOut.data[j].port = nullptr;

  1240.                 evOut.data[j].type = 0;

  1241. 

  1242.                 if (evOuts[j] == CARLA_EVENT_DATA_ATOM)

  1243.                 {

  1244.                     evOut.data[j].type = CARLA_EVENT_DATA_ATOM;

  1245.                     evOut.data[j].atom = (LV2_Atom_Sequence*)malloc(sizeof(LV2_Atom_Sequence) + MAX_EVENT_BUFFER);

  1246.                     evOut.data[j].atom->atom.size = sizeof(LV2_Atom_Sequence_Body);

  1247.                     evOut.data[j].atom->atom.type = CARLA_URI_MAP_ID_ATOM_SEQUENCE;

  1248.                     evOut.data[j].atom->body.unit = CARLA_URI_MAP_ID_NULL;

  1249.                     evOut.data[j].atom->body.pad  = 0;

  1250.                 }

  1251.                 else if (evOuts[j] == CARLA_EVENT_DATA_EVENT)

  1252.                 {

  1253.                     evOut.data[j].type  = CARLA_EVENT_DATA_EVENT;

  1254.                     evOut.data[j].event = lv2_event_buffer_new(MAX_EVENT_BUFFER, LV2_EVENT_AUDIO_STAMP);

  1255.                 }

  1256.                 else if (evOuts[j] == CARLA_EVENT_DATA_MIDI_LL)

  1257.                 {

  1258.                     evOut.data[j].type  = CARLA_EVENT_DATA_MIDI_LL;

  1259.                     evOut.data[j].midi  = new LV2_MIDI;

  1260.                     evOut.data[j].midi->capacity = MAX_EVENT_BUFFER;

  1261.                     evOut.data[j].midi->data     = new unsigned char [MAX_EVENT_BUFFER];

  1262.                 }

  1263.             }

  1264.         }

  1265. 

  1266.         if (params > 0)

  1267.         {

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

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

  1270.             paramBuffers = new float[params];

  1271.         }

  1272. 

  1273.         const int portNameSize = CarlaEngine::maxPortNameSize() - 2;

  1274.         char portName[portNameSize];

  1275.         bool needsCtrlIn  = false;

  1276.         bool needsCtrlOut = false;

  1277. 

  1278.         for (uint32_t i=0; i < portCount; i++)

  1279.         {

  1280.             const LV2_Property portType = rdf_descriptor->Ports[i].Type;

  1281. 

  1282.             if (LV2_IS_PORT_AUDIO(portType) || LV2_IS_PORT_ATOM_SEQUENCE(portType) || LV2_IS_PORT_CV(portType) || LV2_IS_PORT_EVENT(portType) || LV2_IS_PORT_MIDI_LL(portType))

  1283.             {

  1284. #ifndef BUILD_BRIDGE

  1285.                 if (carlaOptions.processMode != PROCESS_MODE_MULTIPLE_CLIENTS)

  1286.                 {

  1287.                     strcpy(portName, m_name);

  1288.                     strcat(portName, ":");

  1289.                     strncat(portName, rdf_descriptor->Ports[i].Name, portNameSize/2);

  1290.                 }

  1291.                 else

  1292. #endif

  1293.                     strncpy(portName, rdf_descriptor->Ports[i].Name, portNameSize);

  1294.             }

  1295. 

  1296.             if (LV2_IS_PORT_AUDIO(portType))

  1297.             {

  1298.                 if (LV2_IS_PORT_INPUT(portType))

  1299.                 {

  1300.                     j = aIn.count++;

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

  1302.                     aIn.rindexes[j] = i;

  1303. 

  1304.                     if (forcedStereoIn)

  1305.                     {

  1306.                         strcat(portName, "_");

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

  1308.                         aIn.rindexes[1] = i;

  1309.                     }

  1310.                 }

  1311.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1312.                 {

  1313.                     j = aOut.count++;

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

  1315.                     aOut.rindexes[j] = i;

  1316.                     needsCtrlIn = true;

  1317. 

  1318.                     if (forcedStereoOut)

  1319.                     {

  1320.                         strcat(portName, "_");

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

  1322.                         aOut.rindexes[1] = i;

  1323.                     }

  1324.                 }

  1325.                 else

  1326.                     qWarning("WARNING - Got a broken Port (Audio, but not input or output)");

  1327.             }

  1328.             else if (LV2_IS_PORT_CV(portType))

  1329.             {

  1330.                 if (LV2_IS_PORT_INPUT(portType))

  1331.                 {

  1332.                     qWarning("WARNING - CV Ports are not supported yet");

  1333.                 }

  1334.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1335.                 {

  1336.                     qWarning("WARNING - CV Ports are not supported yet");

  1337.                 }

  1338.                 else

  1339.                     qWarning("WARNING - Got a broken Port (CV, but not input or output)");

  1340. 

  1341.                 descriptor->connect_port(handle, i, nullptr);

  1342.                 if (h2) descriptor->connect_port(h2, i, nullptr);

  1343.             }

  1344.             else if (LV2_IS_PORT_ATOM_SEQUENCE(portType))

  1345.             {

  1346.                 if (LV2_IS_PORT_INPUT(portType))

  1347.                 {

  1348.                     j = evIn.count++;

  1349.                     descriptor->connect_port(handle, i, evIn.data[j].atom);

  1350.                     if (h2) descriptor->connect_port(h2, i, evIn.data[j].atom);

  1351. 

  1352.                     evIn.data[j].rindex = i;

  1353. 

  1354.                     if (portType & LV2_PORT_SUPPORTS_MIDI_EVENT)

  1355.                     {

  1356.                         evIn.data[j].type |= CARLA_EVENT_TYPE_MIDI;

  1357.                         evIn.data[j].port  = (CarlaEngineMidiPort*)x_client->addPort(CarlaEnginePortTypeMIDI, portName, true);

  1358.                     }

  1359.                     if (portType & LV2_PORT_SUPPORTS_PATCH_MESSAGE)

  1360.                     {

  1361.                         evIn.data[j].type |= CARLA_EVENT_TYPE_MESSAGE;

  1362.                     }

  1363.                 }

  1364.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1365.                 {

  1366.                     j = evOut.count++;

  1367.                     descriptor->connect_port(handle, i, evOut.data[j].atom);

  1368.                     if (h2) descriptor->connect_port(h2, i, evOut.data[j].atom);

  1369. 

  1370.                     evOut.data[j].rindex = i;

  1371. 

  1372.                     if (portType & LV2_PORT_SUPPORTS_MIDI_EVENT)

  1373.                     {

  1374.                         evOut.data[j].type |= CARLA_EVENT_TYPE_MIDI;

  1375.                         evOut.data[j].port  = (CarlaEngineMidiPort*)x_client->addPort(CarlaEnginePortTypeMIDI, portName, false);

  1376.                     }

  1377.                     if (portType & LV2_PORT_SUPPORTS_PATCH_MESSAGE)

  1378.                     {

  1379.                         evOut.data[j].type |= CARLA_EVENT_TYPE_MESSAGE;

  1380.                     }

  1381.                 }

  1382.                 else

  1383.                     qWarning("WARNING - Got a broken Port (Atom Sequence, but not input or output)");

  1384.             }

  1385.             else if (LV2_IS_PORT_EVENT(portType))

  1386.             {

  1387.                 if (LV2_IS_PORT_INPUT(portType))

  1388.                 {

  1389.                     j = evIn.count++;

  1390.                     descriptor->connect_port(handle, i, evIn.data[j].event);

  1391.                     if (h2) descriptor->connect_port(h2, i, evIn.data[j].event);

  1392. 

  1393.                     evIn.data[j].rindex = i;

  1394. 

  1395.                     if (portType & LV2_PORT_SUPPORTS_MIDI_EVENT)

  1396.                     {

  1397.                         evIn.data[j].type |= CARLA_EVENT_TYPE_MIDI;

  1398.                         evIn.data[j].port  = (CarlaEngineMidiPort*)x_client->addPort(CarlaEnginePortTypeMIDI, portName, true);

  1399.                     }

  1400.                 }

  1401.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1402.                 {

  1403.                     j = evOut.count++;

  1404.                     descriptor->connect_port(handle, i, evOut.data[j].event);

  1405.                     if (h2) descriptor->connect_port(h2, i, evOut.data[j].event);

  1406. 

  1407.                     evOut.data[j].rindex = i;

  1408. 

  1409.                     if (portType & LV2_PORT_SUPPORTS_MIDI_EVENT)

  1410.                     {

  1411.                         evOut.data[j].type |= CARLA_EVENT_TYPE_MIDI;

  1412.                         evOut.data[j].port  = (CarlaEngineMidiPort*)x_client->addPort(CarlaEnginePortTypeMIDI, portName, false);

  1413.                     }

  1414.                 }

  1415.                 else

  1416.                     qWarning("WARNING - Got a broken Port (Event, but not input or output)");

  1417.             }

  1418.             else if (LV2_IS_PORT_MIDI_LL(portType))

  1419.             {

  1420.                 if (LV2_IS_PORT_INPUT(portType))

  1421.                 {

  1422.                     j = evIn.count++;

  1423.                     descriptor->connect_port(handle, i, evIn.data[j].midi);

  1424.                     if (h2) descriptor->connect_port(h2, i, evIn.data[j].midi);

  1425. 

  1426.                     evIn.data[j].type  |= CARLA_EVENT_TYPE_MIDI;

  1427.                     evIn.data[j].port   = (CarlaEngineMidiPort*)x_client->addPort(CarlaEnginePortTypeMIDI, portName, true);

  1428.                     evIn.data[j].rindex = i;

  1429.                 }

  1430.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1431.                 {

  1432.                     j = evOut.count++;

  1433.                     descriptor->connect_port(handle, i, evOut.data[j].midi);

  1434.                     if (h2) descriptor->connect_port(h2, i, evOut.data[j].midi);

  1435. 

  1436.                     evOut.data[j].type  |= CARLA_EVENT_TYPE_MIDI;

  1437.                     evOut.data[j].port   = (CarlaEngineMidiPort*)x_client->addPort(CarlaEnginePortTypeMIDI, portName, false);

  1438.                     evOut.data[j].rindex = i;

  1439.                 }

  1440.                 else

  1441.                     qWarning("WARNING - Got a broken Port (Midi, but not input or output)");

  1442.             }

  1443.             else if (LV2_IS_PORT_CONTROL(portType))

  1444.             {

  1445.                 const LV2_Property portProps = rdf_descriptor->Ports[i].Properties;

  1446.                 const LV2_Property portDesignation = rdf_descriptor->Ports[i].Designation;

  1447.                 const LV2_RDF_PortPoints portPoints = rdf_descriptor->Ports[i].Points;

  1448. 

  1449.                 j = param.count++;

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

  1451.                 param.data[j].rindex = i;

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

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

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

  1455. 

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

  1457. 

  1458.                 // min value

  1459.                 if (LV2_HAVE_MINIMUM_PORT_POINT(portPoints.Hints))

  1460.                     min = portPoints.Minimum;

  1461.                 else

  1462.                     min = 0.0;

  1463. 

  1464.                 // max value

  1465.                 if (LV2_HAVE_MAXIMUM_PORT_POINT(portPoints.Hints))

  1466.                     max = portPoints.Maximum;

  1467.                 else

  1468.                     max = 1.0;

  1469. 

  1470.                 if (min > max)

  1471.                     max = min;

  1472.                 else if (max < min)

  1473.                     min = max;

  1474. 

  1475.                 // stupid hack for ir.lv2 (broken plugin)

  1476.                 if (strcmp(rdf_descriptor->URI, "http://factorial.hu/plugins/lv2/ir") == 0 && strncmp(rdf_descriptor->Ports[i].Name, "FileHash", 8) == 0)

  1477.                 {

  1478.                     min = 0.0;

  1479.                     max = 16777215.0; // 0xffffff

  1480.                 }

  1481. 

  1482.                 if (max - min == 0.0)

  1483.                 {

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

  1485.                     max = min + 0.1;

  1486.                 }

  1487. 

  1488.                 // default value

  1489.                 if (LV2_HAVE_DEFAULT_PORT_POINT(portPoints.Hints))

  1490.                 {

  1491.                     def = portPoints.Default;

  1492.                 }

  1493.                 else

  1494.                 {

  1495.                     // no default value

  1496.                     if (min < 0.0 && max > 0.0)

  1497.                         def = 0.0;

  1498.                     else

  1499.                         def = min;

  1500.                 }

  1501. 

  1502.                 if (def < min)

  1503.                     def = min;

  1504.                 else if (def > max)

  1505.                     def = max;

  1506. 

  1507.                 if (LV2_IS_PORT_SAMPLE_RATE(portProps))

  1508.                 {

  1509.                     min *= sampleRate;

  1510.                     max *= sampleRate;

  1511.                     def *= sampleRate;

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

  1513.                 }

  1514. 

  1515.                 if (LV2_IS_PORT_TOGGLED(portProps))

  1516.                 {

  1517.                     step = max - min;

  1518.                     stepSmall = step;

  1519.                     stepLarge = step;

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

  1521.                 }

  1522.                 else if (LV2_IS_PORT_INTEGER(portProps))

  1523.                 {

  1524.                     step = 1.0;

  1525.                     stepSmall = 1.0;

  1526.                     stepLarge = 10.0;

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

  1528.                 }

  1529.                 else

  1530.                 {

  1531.                     double range = max - min;

  1532.                     step = range/100.0;

  1533.                     stepSmall = range/1000.0;

  1534.                     stepLarge = range/10.0;

  1535.                 }

  1536. 

  1537.                 if (LV2_IS_PORT_INPUT(portType))

  1538.                 {

  1539.                     if (LV2_IS_PORT_DESIGNATION_LATENCY(portDesignation))

  1540.                     {

  1541.                         qWarning("Plugin has latency input port, this should not happen!");

  1542.                     }

  1543.                     else if (LV2_IS_PORT_DESIGNATION_SAMPLE_RATE(portDesignation))

  1544.                     {

  1545.                         def = sampleRate;

  1546.                         step = 1.0;

  1547.                         stepSmall = 1.0;

  1548.                         stepLarge = 1.0;

  1549. 

  1550.                         param.data[j].type  = PARAMETER_SAMPLE_RATE;

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

  1552.                     }

  1553.                     else if (LV2_IS_PORT_DESIGNATION_FREEWHEELING(portDesignation))

  1554.                     {

  1555.                         param.data[j].type = PARAMETER_LV2_FREEWHEEL;

  1556.                     }

  1557.                     else if (LV2_IS_PORT_DESIGNATION_TIME(portDesignation))

  1558.                     {

  1559.                         param.data[j].type = PARAMETER_LV2_TIME;

  1560.                     }

  1561.                     else

  1562.                     {

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

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

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

  1566.                         needsCtrlIn = true;

  1567.                     }

  1568. 

  1569.                     // MIDI CC value

  1570.                     const LV2_RDF_PortMidiMap* const portMidiMap = &rdf_descriptor->Ports[i].MidiMap;

  1571.                     if (LV2_IS_PORT_MIDI_MAP_CC(portMidiMap->Type))

  1572.                     {

  1573.                         if (! MIDI_IS_CONTROL_BANK_SELECT(portMidiMap->Number))

  1574.                             param.data[j].midiCC = portMidiMap->Number;

  1575.                     }

  1576.                 }

  1577.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1578.                 {

  1579.                     if (LV2_IS_PORT_DESIGNATION_LATENCY(portDesignation))

  1580.                     {

  1581.                         min = 0.0;

  1582.                         max = sampleRate;

  1583.                         def = 0.0;

  1584.                         step = 1.0;

  1585.                         stepSmall = 1.0;

  1586.                         stepLarge = 1.0;

  1587. 

  1588.                         param.data[j].type  = PARAMETER_LATENCY;

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

  1590.                     }

  1591.                     else if (LV2_IS_PORT_DESIGNATION_SAMPLE_RATE(portDesignation))

  1592.                     {

  1593.                         def = sampleRate;

  1594.                         step = 1.0;

  1595.                         stepSmall = 1.0;

  1596.                         stepLarge = 1.0;

  1597. 

  1598.                         param.data[j].type  = PARAMETER_SAMPLE_RATE;

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

  1600.                     }

  1601.                     else if (LV2_IS_PORT_DESIGNATION_FREEWHEELING(portDesignation))

  1602.                     {

  1603.                         qWarning("Plugin has freewheeling output port, this should not happen!");

  1604.                     }

  1605.                     else if (LV2_IS_PORT_DESIGNATION_TIME(portDesignation))

  1606.                     {

  1607.                         param.data[j].type = PARAMETER_LV2_TIME;

  1608.                     }

  1609.                     else

  1610.                     {

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

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

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

  1614.                         needsCtrlOut = true;

  1615.                     }

  1616.                 }

  1617.                 else

  1618.                 {

  1619.                     param.data[j].type = PARAMETER_UNKNOWN;

  1620.                     qWarning("WARNING - Got a broken Port (Control, but not input or output)");

  1621.                 }

  1622. 

  1623.                 // extra parameter hints

  1624.                 if (LV2_IS_PORT_ENUMERATION(portProps))

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

  1626. 

  1627.                 if (LV2_IS_PORT_LOGARITHMIC(portProps))

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

  1629. 

  1630.                 if (LV2_IS_PORT_TRIGGER(portProps))

  1631.                     param.data[j].hints |= PARAMETER_IS_TRIGGER;

  1632. 

  1633.                 if (LV2_IS_PORT_STRICT_BOUNDS(portProps))

  1634.                     param.data[j].hints |= PARAMETER_IS_STRICT_BOUNDS;

  1635. 

  1636.                 // check if parameter is not enabled or automable

  1637.                 if (LV2_IS_PORT_NOT_ON_GUI(portProps))

  1638.                     param.data[j].hints &= ~PARAMETER_IS_ENABLED;

  1639. 

  1640.                 if (LV2_IS_PORT_CAUSES_ARTIFACTS(portProps) || LV2_IS_PORT_EXPENSIVE(portProps) || LV2_IS_PORT_NOT_AUTOMATIC(portProps))

  1641.                     param.data[j].hints &= ~PARAMETER_IS_AUTOMABLE;

  1642. 

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

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

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

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

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

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

  1649. 

  1650.                 // Start parameters in their default values

  1651.                 paramBuffers[j] = def;

  1652. 

  1653.                 descriptor->connect_port(handle, i, &paramBuffers[j]);

  1654.                 if (h2) descriptor->connect_port(h2, i, &paramBuffers[j]);

  1655.             }

  1656.             else

  1657.             {

  1658.                 // Port Type not supported, but it's optional anyway

  1659.                 descriptor->connect_port(handle, i, nullptr);

  1660.                 if (h2) descriptor->connect_port(h2, i, nullptr);

  1661.             }

  1662.         }

  1663. 

  1664.         if (needsCtrlIn)

  1665.         {

  1666. #ifndef BUILD_BRIDGE

  1667.             if (carlaOptions.processMode != PROCESS_MODE_MULTIPLE_CLIENTS)

  1668.             {

  1669.                 strcpy(portName, m_name);

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

  1671.             }

  1672.             else

  1673. #endif

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

  1675. 

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

  1677.         }

  1678. 

  1679.         if (needsCtrlOut)

  1680.         {

  1681. #ifndef BUILD_BRIDGE

  1682.             if (carlaOptions.processMode != PROCESS_MODE_MULTIPLE_CLIENTS)

  1683.             {

  1684.                 strcpy(portName, m_name);

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

  1686.             }

  1687.             else

  1688. #endif

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

  1690. 

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

  1692.         }

  1693. 

  1694.         aIn.count   = aIns;

  1695.         aOut.count  = aOuts;

  1696.         evIn.count  = evIns.size();

  1697.         evOut.count = evOuts.size();

  1698.         param.count = params;

  1699. 

  1700.         // plugin checks

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

  1702. 

  1703.         if (LV2_IS_GENERATOR(rdf_descriptor->Type))

  1704.             m_hints |= PLUGIN_IS_SYNTH;

  1705. 

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

  1707.             m_hints |= PLUGIN_CAN_DRYWET;

  1708. 

  1709.         if (aOuts > 0)

  1710.             m_hints |= PLUGIN_CAN_VOLUME;

  1711. 

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

  1713.             m_hints |= PLUGIN_CAN_BALANCE;

  1714. 

  1715.         if (ext.state || ext.worker)

  1716.         {

  1717.             if ((aIns == 0 || aIns == 2) && (aOuts == 0 || aOuts == 2) && evIn.count <= 1 && evOut.count <= 1)

  1718.                 m_hints |= PLUGIN_CAN_FORCE_STEREO;

  1719.         }

  1720.         else

  1721.         {

  1722.             if (aIns <= 2 && aOuts <= 2 && (aIns == aOuts || aIns == 0 || aOuts == 0) && evIn.count <= 1 && evOut.count <= 1)

  1723.                 m_hints |= PLUGIN_CAN_FORCE_STEREO;

  1724.         }

  1725. 

  1726.         reloadPrograms(true);

  1727. 

  1728.         x_client->activate();

  1729. 

  1730.         qDebug("Lv2Plugin::reload() - end");

  1731.     }

  1732. 

  1733.     void reloadPrograms(const bool init)

  1734.     {

  1735.         qDebug("Lv2Plugin::reloadPrograms(%s)", bool2str(init));

  1736.         uint32_t i, oldCount = midiprog.count;

  1737. 

  1738.         // Delete old programs

  1739.         if (midiprog.count > 0)

  1740.         {

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

  1742.             {

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

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

  1745.             }

  1746. 

  1747.             delete[] midiprog.data;

  1748.         }

  1749. 

  1750.         midiprog.count = 0;

  1751.         midiprog.data  = nullptr;

  1752. 

  1753.         // Query new programs

  1754.         if (ext.programs && ext.programs->get_program && ext.programs->select_program)

  1755.         {

  1756.             while (ext.programs->get_program(handle, midiprog.count))

  1757.                 midiprog.count += 1;

  1758.         }

  1759. 

  1760.         if (midiprog.count > 0)

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

  1762. 

  1763.         // Update data

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

  1765.         {

  1766.             const LV2_Program_Descriptor* const pdesc = ext.programs->get_program(handle, i);

  1767.             CARLA_ASSERT(pdesc);

  1768.             CARLA_ASSERT(pdesc->program < 128);

  1769.             CARLA_ASSERT(pdesc->name);

  1770. 

  1771.             midiprog.data[i].bank    = pdesc->bank;

  1772.             midiprog.data[i].program = pdesc->program;

  1773.             midiprog.data[i].name    = strdup(pdesc->name);

  1774.         }

  1775. 

  1776. #ifndef BUILD_BRIDGE

  1777.         // Update OSC Names

  1778.         if (x_engine->isOscControlRegisted())

  1779.         {

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

  1781. 

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

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

  1784.         }

  1785. #endif

  1786. 

  1787.         if (init)

  1788.         {

  1789.             if (midiprog.count > 0)

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

  1791.         }

  1792.         else

  1793.         {

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

  1795. 

  1796.             // Check if current program is invalid

  1797.             bool programChanged = false;

  1798. 

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

  1800.             {

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

  1802.                 midiprog.current = oldCount;

  1803.                 programChanged   = true;

  1804.             }

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

  1806.             {

  1807.                 // current midi program > count

  1808.                 midiprog.current = 0;

  1809.                 programChanged   = true;

  1810.             }

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

  1812.             {

  1813.                 // programs exist now, but not before

  1814.                 midiprog.current = 0;

  1815.                 programChanged   = true;

  1816.             }

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

  1818.             {

  1819.                 // programs existed before, but not anymore

  1820.                 midiprog.current = -1;

  1821.                 programChanged   = true;

  1822.             }

  1823. 

  1824.             if (programChanged)

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

  1826.         }

  1827.     }

  1828. 

  1829.     void prepareForSave()

  1830.     {

  1831.         if (ext.state && ext.state->save)

  1832.         {

  1833.             ext.state->save(handle, carla_lv2_state_store, this, LV2_STATE_IS_POD, features);

  1834.             if (h2) ext.state->save(h2, carla_lv2_state_store, this, LV2_STATE_IS_POD, features);

  1835.         }

  1836.     }

  1837. 

  1838.     // -------------------------------------------------------------------

  1839.     // Plugin processing

  1840. 

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

  1842.     {

  1843.         uint32_t i, k;

  1844.         uint32_t midiEventCount = 0;

  1845. 

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

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

  1848. 

  1849.         // handle events from different APIs

  1850.         uint32_t evInAtomOffsets[evIn.count];

  1851.         LV2_Event_Iterator evInEventIters[evIn.count];

  1852.         LV2_MIDIState evInMidiStates[evIn.count];

  1853. 

  1854.         for (i=0; i < evIn.count; i++)

  1855.         {

  1856.             if (evIn.data[i].type & CARLA_EVENT_DATA_ATOM)

  1857.             {

  1858.                 evInAtomOffsets[i] = 0;

  1859.                 evIn.data[i].atom->atom.size = 0;

  1860.                 evIn.data[i].atom->atom.type = CARLA_URI_MAP_ID_ATOM_SEQUENCE;

  1861.                 evIn.data[i].atom->body.unit = CARLA_URI_MAP_ID_NULL;

  1862.                 evIn.data[i].atom->body.pad  = 0;

  1863.             }

  1864.             else if (evIn.data[i].type & CARLA_EVENT_DATA_EVENT)

  1865.             {

  1866.                 lv2_event_buffer_reset(evIn.data[i].event, LV2_EVENT_AUDIO_STAMP, (uint8_t*)(evIn.data[i].event + 1));

  1867.                 lv2_event_begin(&evInEventIters[i], evIn.data[i].event);

  1868.             }

  1869.             else if (evIn.data[i].type & CARLA_EVENT_DATA_MIDI_LL)

  1870.             {

  1871.                 evInMidiStates[i].midi = evIn.data[i].midi;

  1872.                 evInMidiStates[i].frame_count = frames;

  1873.                 evInMidiStates[i].position = 0;

  1874.                 evInMidiStates[i].midi->event_count = 0;

  1875.                 evInMidiStates[i].midi->size = 0;

  1876.             }

  1877.         }

  1878. 

  1879.         for (i=0; i < evOut.count; i++)

  1880.         {

  1881.             if (evOut.data[i].type & CARLA_EVENT_DATA_ATOM)

  1882.             {

  1883.                 evOut.data[i].atom->atom.size = 0;

  1884.                 evOut.data[i].atom->atom.type = CARLA_URI_MAP_ID_ATOM_SEQUENCE;

  1885.                 evOut.data[i].atom->body.unit = CARLA_URI_MAP_ID_NULL;

  1886.                 evOut.data[i].atom->body.pad  = 0;

  1887.             }

  1888.             else if (evOut.data[i].type & CARLA_EVENT_DATA_EVENT)

  1889.             {

  1890.                 lv2_event_buffer_reset(evOut.data[i].event, LV2_EVENT_AUDIO_STAMP, (uint8_t*)(evOut.data[i].event + 1));

  1891.             }

  1892.             else if (evOut.data[i].type & CARLA_EVENT_DATA_MIDI_LL)

  1893.             {

  1894.                 // not needed

  1895.             }

  1896.         }

  1897. 

  1898.         CARLA_PROCESS_CONTINUE_CHECK;

  1899. 

  1900.         // --------------------------------------------------------------------------------------------------------

  1901.         // Input VU

  1902. 

  1903.         if (aIn.count > 0)

  1904.         {

  1905.             if (aIn.count == 1)

  1906.             {

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

  1908.                 {

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

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

  1911.                 }

  1912.             }

  1913.             else if (aIn.count > 1)

  1914.             {

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

  1916.                 {

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

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

  1919. 

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

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

  1922.                 }

  1923.             }

  1924.         }

  1925. 

  1926.         CARLA_PROCESS_CONTINUE_CHECK;

  1927. 

  1928.         // --------------------------------------------------------------------------------------------------------

  1929.         // Parameters Input [Automation]

  1930. 

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

  1932.         {

  1933.             bool allNotesOffSent = false;

  1934. 

  1935.             const CarlaEngineControlEvent* cinEvent;

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

  1937. 

  1938.             uint32_t nextBankId = 0;

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

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

  1941. 

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

  1943.             {

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

  1945. 

  1946.                 if (! cinEvent)

  1947.                     continue;

  1948. 

  1949.                 time = cinEvent->time - framesOffset;

  1950. 

  1951.                 if (time >= frames)

  1952.                     continue;

  1953. 

  1954.                 // Control change

  1955.                 switch (cinEvent->type)

  1956.                 {

  1957.                 case CarlaEngineEventNull:

  1958.                     break;

  1959. 

  1960.                 case CarlaEngineEventControlChange:

  1961.                 {

  1962.                     double value;

  1963. 

  1964.                     // Control backend stuff

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

  1966.                     {

  1967.                         if (MIDI_IS_CONTROL_BREATH_CONTROLLER(cinEvent->controller) && (m_hints & PLUGIN_CAN_DRYWET) > 0)

  1968.                         {

  1969.                             value = cinEvent->value;

  1970.                             setDryWet(value, false, false);

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

  1972.                             continue;

  1973.                         }

  1974. 

  1975.                         if (MIDI_IS_CONTROL_CHANNEL_VOLUME(cinEvent->controller) && (m_hints & PLUGIN_CAN_VOLUME) > 0)

  1976.                         {

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

  1978.                             setVolume(value, false, false);

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

  1980.                             continue;

  1981.                         }

  1982. 

  1983.                         if (MIDI_IS_CONTROL_BALANCE(cinEvent->controller) && (m_hints & PLUGIN_CAN_BALANCE) > 0)

  1984.                         {

  1985.                             double left, right;

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

  1987. 

  1988.                             if (value < 0.0)

  1989.                             {

  1990.                                 left  = -1.0;

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

  1992.                             }

  1993.                             else if (value > 0.0)

  1994.                             {

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

  1996.                                 right = 1.0;

  1997.                             }

  1998.                             else

  1999.                             {

  2000.                                 left  = -1.0;

  2001.                                 right = 1.0;

  2002.                             }

  2003. 

  2004.                             setBalanceLeft(left, false, false);

  2005.                             setBalanceRight(right, false, false);

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

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

  2008.                             continue;

  2009.                         }

  2010.                     }

  2011. 

  2012.                     // Control plugin parameters

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

  2014.                     {

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

  2016.                             continue;

  2017.                         if (param.data[k].midiCC != cinEvent->controller)

  2018.                             continue;

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

  2020.                             continue;

  2021. 

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

  2023.                         {

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

  2025.                             {

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

  2027.                             }

  2028.                             else

  2029.                             {

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

  2031. 

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

  2033.                                     value = rint(value);

  2034.                             }

  2035. 

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

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

  2038.                         }

  2039.                     }

  2040. 

  2041.                     break;

  2042.                 }

  2043. 

  2044.                 case CarlaEngineEventMidiBankChange:

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

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

  2047.                     break;

  2048. 

  2049.                 case CarlaEngineEventMidiProgramChange:

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

  2051.                     {

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

  2053. 

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

  2055.                         {

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

  2057.                             {

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

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

  2060.                                 break;

  2061.                             }

  2062.                         }

  2063.                     }

  2064.                     break;

  2065. 

  2066.                 case CarlaEngineEventAllSoundOff:

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

  2068.                     {

  2069.                         if (evIn.count > 0 && ! allNotesOffSent)

  2070.                             sendMidiAllNotesOff();

  2071. 

  2072.                         if (descriptor->deactivate)

  2073.                         {

  2074.                             descriptor->deactivate(handle);

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

  2076.                         }

  2077. 

  2078.                         if (descriptor->activate)

  2079.                         {

  2080.                             descriptor->activate(handle);

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

  2082.                         }

  2083. 

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

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

  2086. 

  2087.                         allNotesOffSent = true;

  2088.                     }

  2089.                     break;

  2090. 

  2091.                 case CarlaEngineEventAllNotesOff:

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

  2093.                     {

  2094.                         if (evIn.count > 0 && ! allNotesOffSent)

  2095.                             sendMidiAllNotesOff();

  2096. 

  2097.                         allNotesOffSent = true;

  2098.                     }

  2099.                     break;

  2100.                 }

  2101.             }

  2102.         } // End of Parameters Input

  2103. 

  2104.         CARLA_PROCESS_CONTINUE_CHECK;

  2105. 

  2106.         // --------------------------------------------------------------------------------------------------------

  2107.         // Event Input

  2108. 

  2109.         if (evIn.count > 0 && m_active && m_activeBefore)

  2110.         {

  2111.             // ----------------------------------------------------------------------------------------------------

  2112.             // MIDI Input (External)

  2113. 

  2114.             {

  2115.                 engineMidiLock();

  2116. 

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

  2118.                 {

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

  2120.                         break;

  2121. 

  2122.                     uint8_t midiEvent[3] = { 0 };

  2123.                     midiEvent[0] = m_ctrlInChannel + extMidiNotes[i].velo ? MIDI_STATUS_NOTE_ON : MIDI_STATUS_NOTE_OFF;

  2124.                     midiEvent[1] = extMidiNotes[i].note;

  2125.                     midiEvent[2] = extMidiNotes[i].velo;

  2126. 

  2127.                     // send to first midi input

  2128.                     for (k=0; k < evIn.count; k++)

  2129.                     {

  2130.                         if (evIn.data[k].type & CARLA_EVENT_TYPE_MIDI)

  2131.                         {

  2132.                             if (evIn.data[k].type & CARLA_EVENT_DATA_ATOM)

  2133.                             {

  2134.                                 LV2_Atom_Event* const aev = getLv2AtomEvent(evIn.data[k].atom, evInAtomOffsets[k]);

  2135.                                 aev->time.frames = 0;

  2136.                                 aev->body.type   = CARLA_URI_MAP_ID_MIDI_EVENT;

  2137.                                 aev->body.size   = 3;

  2138.                                 memcpy(LV2_ATOM_BODY(&aev->body), midiEvent, 3);

  2139. 

  2140.                                 const uint32_t evInPadSize    = lv2_atom_pad_size(sizeof(LV2_Atom_Event) + 3);

  2141.                                 evInAtomOffsets[k]           += evInPadSize;

  2142.                                 evIn.data[k].atom->atom.size += evInPadSize;

  2143.                             }

  2144.                             else if (evIn.data[k].type & CARLA_EVENT_DATA_EVENT)

  2145.                             {

  2146.                                 lv2_event_write(&evInEventIters[k], 0, 0, CARLA_URI_MAP_ID_MIDI_EVENT, 3, midiEvent);

  2147.                             }

  2148.                             else if (evIn.data[k].type & CARLA_EVENT_DATA_MIDI_LL)

  2149.                             {

  2150.                                 lv2midi_put_event(&evInMidiStates[k], 0, 3, midiEvent);

  2151.                             }

  2152. 

  2153.                             break;

  2154.                         }

  2155.                     }

  2156. 

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

  2158.                     midiEventCount += 1;

  2159.                 }

  2160. 

  2161.                 engineMidiUnlock();

  2162. 

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

  2164. 

  2165.             CARLA_PROCESS_CONTINUE_CHECK;

  2166. 

  2167.             // ----------------------------------------------------------------------------------------------------

  2168.             // MIDI Input (System)

  2169. 

  2170.             for (i=0; i < evIn.count; i++)

  2171.             {

  2172.                 if (! evIn.data[i].port)

  2173.                     continue;

  2174. 

  2175.                 const CarlaEngineMidiEvent* minEvent;

  2176.                 uint32_t time, nEvents = evIn.data[i].port->getEventCount();

  2177. 

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

  2179.                 {

  2180.                     minEvent = evIn.data[i].port->getEvent(k);

  2181. 

  2182.                     if (! minEvent)

  2183.                         continue;

  2184. 

  2185.                     time = minEvent->time - framesOffset;

  2186. 

  2187.                     if (time >= frames)

  2188.                         continue;

  2189. 

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

  2191.                     uint8_t channel = status & 0x0F;

  2192. 

  2193.                     // Fix bad note-off

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

  2195.                         status -= 0x10;

  2196. 

  2197.                     // only write supported status types

  2198.                     if (MIDI_IS_STATUS_NOTE_OFF(status) || MIDI_IS_STATUS_NOTE_ON(status) || MIDI_IS_STATUS_POLYPHONIC_AFTERTOUCH(status) || MIDI_IS_STATUS_AFTERTOUCH(status) || MIDI_IS_STATUS_PITCH_WHEEL_CONTROL(status))

  2199.                     {

  2200.                         if (evIn.data[i].type & CARLA_EVENT_DATA_ATOM)

  2201.                         {

  2202.                             LV2_Atom_Event* const aev = getLv2AtomEvent(evIn.data[i].atom, evInAtomOffsets[i]);

  2203.                             aev->time.frames = time;

  2204.                             aev->body.type   = CARLA_URI_MAP_ID_MIDI_EVENT;

  2205.                             aev->body.size   = minEvent->size;

  2206.                             memcpy(LV2_ATOM_BODY(&aev->body), minEvent->data, minEvent->size);

  2207. 

  2208.                             const uint32_t evInPadSize    = lv2_atom_pad_size(sizeof(LV2_Atom_Event) + minEvent->size);

  2209.                             evInAtomOffsets[i]           += evInPadSize;

  2210.                             evIn.data[i].atom->atom.size += evInPadSize;

  2211.                         }

  2212.                         else if (evIn.data[i].type & CARLA_EVENT_DATA_EVENT)

  2213.                         {

  2214.                             lv2_event_write(&evInEventIters[i], time, 0, CARLA_URI_MAP_ID_MIDI_EVENT, minEvent->size, minEvent->data);

  2215.                         }

  2216.                         else if (evIn.data[i].type & CARLA_EVENT_DATA_MIDI_LL)

  2217.                         {

  2218.                             lv2midi_put_event(&evInMidiStates[i], time, minEvent->size, minEvent->data);

  2219.                         }

  2220. 

  2221.                         if (MIDI_IS_STATUS_NOTE_OFF(status))

  2222.                             postponeEvent(PluginPostEventNoteOff, channel, minEvent->data[1], 0.0);

  2223.                         else if (MIDI_IS_STATUS_NOTE_ON(status))

  2224.                             postponeEvent(PluginPostEventNoteOn, channel, minEvent->data[1], minEvent->data[2]);

  2225.                     }

  2226. 

  2227.                     midiEventCount += 1;

  2228.                 }

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

  2230. 

  2231.             // ----------------------------------------------------------------------------------------------------

  2232.             // Message Input

  2233. 

  2234.             {

  2235.                 for (i=0; i < evIn.count; i++)

  2236.                 {

  2237.                     if (! evIn.data[i].type & CARLA_EVENT_TYPE_MESSAGE)

  2238.                         continue;

  2239. 

  2240. #if 0

  2241.                      // send transport info if changed

  2242.                     const CarlaTimeInfo* const timeInfo = x_engine->getTimeInfo();

  2243. 

  2244.                     if (timeInfo->playing != lastTimePosPlaying || timeInfo->frame != lastTimePosFrame)

  2245.                     {

  2246.                         uint8_t posBuf[256];

  2247.                         LV2_Atom* const lv2Pos = (LV2_Atom*)posBuf;

  2248. 

  2249.                         LV2_Atom_Forge tempForge;

  2250.                         LV2_Atom_Forge* const forge = &tempForge;

  2251.                         lv2_atom_forge_set_buffer(forge, posBuf, sizeof(uint8_t)*256);

  2252. 

  2253.                         //LV2_Atom_Forge_Frame frame;

  2254.                         //lv2_atom_forge_blank(forge, &frame, 1, jalv->urids.time_Position);

  2255.                         //lv2_atom_forge_property_head(forge, jalv->urids.time_frame, 0);

  2256.                         lv2_atom_forge_long(forge, timeInfo->frame);

  2257.                         //lv2_atom_forge_property_head(forge, jalv->urids.time_position, 0);

  2258.                         lv2_atom_forge_long(forge, timeInfo->time);

  2259.                         //lv2_atom_forge_property_head(forge, jalv->urids.time_speed, 0);

  2260.                         lv2_atom_forge_float(forge, timeInfo->playing ? 1.0 : 0.0);

  2261. 

  2262.                         if (timeInfo->valid & CarlaEngineTimeBBT)

  2263.                         {

  2264.                             //lv2_atom_forge_property_head(forge, jalv->urids.time_bar, 0);

  2265.                             lv2_atom_forge_float(forge, timeInfo->bbt.bar - 1);

  2266. 

  2267.                             //lv2_atom_forge_property_head(forge, jalv->urids.time_barBeat, 0);

  2268.                             lv2_atom_forge_float(forge, timeInfo->bbt.beat - 1 + (timeInfo->bbt.tick / timeInfo->bbt.ticks_per_beat));

  2269. 

  2270.                             //lv2_atom_forge_property_head(forge, jalv->urids.time_beat, 0);

  2271.                             lv2_atom_forge_float(forge, timeInfo->bbt.beat - 1); // FIXME: -1 ?

  2272. 

  2273.                             //lv2_atom_forge_property_head(forge, jalv->urids.time_beatUnit, 0);

  2274.                             lv2_atom_forge_float(forge, timeInfo->bbt.beat_type);

  2275. 

  2276.                             //lv2_atom_forge_property_head(forge, jalv->urids.time_beatsPerBar, 0);

  2277.                             lv2_atom_forge_float(forge, timeInfo->bbt.beats_per_bar);

  2278. 

  2279.                             //lv2_atom_forge_property_head(forge, jalv->urids.time_beatsPerMinute, 0);

  2280.                             lv2_atom_forge_float(forge, timeInfo->bbt.beats_per_minute);

  2281.                         }

  2282. 

  2283.                         LV2_Atom_Event* const aev = getLv2AtomEvent(evIn.data[i].atom, evInAtomOffsets[i]);

  2284.                         aev->time.frames = framesOffset;

  2285.                         aev->body.type   = lv2Pos->type;

  2286.                         aev->body.size   = lv2Pos->size;

  2287.                         memcpy(LV2_ATOM_BODY(&aev->body), LV2_ATOM_BODY(lv2Pos), lv2Pos->size);

  2288. 

  2289.                         const uint32_t evInPadSize    = lv2_atom_pad_size(sizeof(LV2_Atom_Event) + lv2Pos->size);

  2290.                         evInAtomOffsets[i]           += evInPadSize;

  2291.                         evIn.data[i].atom->atom.size += evInPadSize;

  2292. 

  2293.                         lastTimePosPlaying = timeInfo->playing;

  2294.                         lastTimePosFrame   = timeInfo->playing ? timeInfo->frame + frames : timeInfo->frame;

  2295.                     }

  2296. #endif

  2297. 

  2298.                     atomQueueIn.lock();

  2299. 

  2300.                     if (! atomQueueIn.isEmpty())

  2301.                     {

  2302.                         uint32_t portIndex;

  2303.                         const LV2_Atom* atom;

  2304. 

  2305.                         while (atomQueueIn.get(&portIndex, &atom, false))

  2306.                         {

  2307.                             if (atom->type == CARLA_URI_MAP_ID_ATOM_WORKER)

  2308.                             {

  2309.                                 const LV2_Atom_Worker* const atomWorker = (const LV2_Atom_Worker*)atom;

  2310.                                 ext.worker->work_response(handle, atomWorker->body.size, atomWorker->body.data);

  2311.                                 continue;

  2312.                             }

  2313. 

  2314.                             LV2_Atom_Event* const aev = getLv2AtomEvent(evIn.data[i].atom, evInAtomOffsets[i]);

  2315.                             aev->time.frames = framesOffset;

  2316.                             aev->body.type   = atom->type;

  2317.                             aev->body.size   = atom->size;

  2318.                             memcpy(LV2_ATOM_BODY(&aev->body), LV2_ATOM_BODY(atom), atom->size);

  2319. 

  2320.                             const uint32_t evInPadSize    = lv2_atom_pad_size(sizeof(LV2_Atom_Event) + atom->size);

  2321.                             evInAtomOffsets[i]           += evInPadSize;

  2322.                             evIn.data[i].atom->atom.size += evInPadSize;

  2323.                         }

  2324.                     }

  2325. 

  2326.                     atomQueueIn.unlock();

  2327.                 }

  2328.             }

  2329. 

  2330.         } // End of Event Input

  2331. 

  2332.         CARLA_PROCESS_CONTINUE_CHECK;

  2333. 

  2334.         // --------------------------------------------------------------------------------------------------------

  2335.         // Special Parameters

  2336. 

  2337.         {

  2338.             int32_t rindex;

  2339.             const CarlaTimeInfo* const timeInfo = x_engine->getTimeInfo();

  2340. 

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

  2342.             {

  2343.                 if (param.data[k].type == PARAMETER_LATENCY)

  2344.                 {

  2345.                     // TODO

  2346.                 }

  2347.                 else if (param.data[k].type == PARAMETER_LV2_FREEWHEEL)

  2348.                 {

  2349.                     setParameterValue(k, x_engine->isOffline() ? 1.0 : 0.0, false, false, false);

  2350.                 }

  2351.                 else if (param.data[k].type == PARAMETER_LV2_TIME)

  2352.                 {

  2353.                     rindex = param.data[k].rindex;

  2354.                     CARLA_ASSERT(rindex >= 0 && rindex < (int32_t)rdf_descriptor->PortCount);

  2355. 

  2356.                     switch (rdf_descriptor->Ports[rindex].Designation)

  2357.                     {

  2358.                     // Non-BBT

  2359.                     case LV2_PORT_DESIGNATION_TIME_FRAME:

  2360.                         setParameterValue(k, timeInfo->frame, false, false, false);

  2361.                         break;

  2362.                     case LV2_PORT_DESIGNATION_TIME_FRAMES_PER_SECOND:

  2363.                         break;

  2364.                     case LV2_PORT_DESIGNATION_TIME_POSITION:

  2365.                         setParameterValue(k, timeInfo->time, false, false, false);

  2366.                         break;

  2367.                     case LV2_PORT_DESIGNATION_TIME_SPEED:

  2368.                         setParameterValue(k, timeInfo->playing ? 1.0 : 0.0, false, false, false);

  2369.                         break;

  2370.                     // BBT

  2371.                     case LV2_PORT_DESIGNATION_TIME_BAR:

  2372.                         if (timeInfo->valid & CarlaEngineTimeBBT)

  2373.                             setParameterValue(k, timeInfo->bbt.bar - 1, false, false, false);

  2374.                         break;

  2375.                     case LV2_PORT_DESIGNATION_TIME_BAR_BEAT:

  2376.                         if (timeInfo->valid & CarlaEngineTimeBBT)

  2377.                             setParameterValue(k, timeInfo->bbt.beat - 1 + (timeInfo->bbt.tick / timeInfo->bbt.ticks_per_beat), false, false, false);

  2378.                         break;

  2379.                     case LV2_PORT_DESIGNATION_TIME_BEAT:

  2380.                         if (timeInfo->valid & CarlaEngineTimeBBT)  // FIXME: -1 ?

  2381.                             setParameterValue(k, timeInfo->bbt.beat - 1, false, false, false);

  2382.                         break;

  2383.                     case LV2_PORT_DESIGNATION_TIME_BEAT_UNIT:

  2384.                         if (timeInfo->valid & CarlaEngineTimeBBT)

  2385.                             setParameterValue(k, timeInfo->bbt.beat_type, false, false, false);

  2386.                         break;

  2387.                     case LV2_PORT_DESIGNATION_TIME_BEATS_PER_BAR:

  2388.                         if (timeInfo->valid & CarlaEngineTimeBBT)

  2389.                             setParameterValue(k, timeInfo->bbt.beats_per_bar, false, false, false);

  2390.                         break;

  2391.                     case LV2_PORT_DESIGNATION_TIME_BEATS_PER_MINUTE:

  2392.                         if (timeInfo->valid & CarlaEngineTimeBBT)

  2393.                             setParameterValue(k, timeInfo->bbt.beats_per_minute, false, false, false);

  2394.                         break;

  2395.                     }

  2396.                 }

  2397.             }

  2398.         }

  2399. 

  2400.         CARLA_PROCESS_CONTINUE_CHECK;

  2401. 

  2402.         // --------------------------------------------------------------------------------------------------------

  2403.         // Plugin processing

  2404. 

  2405.         if (m_active)

  2406.         {

  2407.             if (! m_activeBefore)

  2408.             {

  2409.                 if (evIn.count > 0)

  2410.                 {

  2411.                     for (i=0; i < MAX_MIDI_CHANNELS; i++)

  2412.                     {

  2413.                         uint8_t midiEvent1[2] = { 0 };

  2414.                         midiEvent1[0] = MIDI_STATUS_CONTROL_CHANGE + i;

  2415.                         midiEvent1[1] = MIDI_CONTROL_ALL_SOUND_OFF;

  2416. 

  2417.                         uint8_t midiEvent2[2] = { 0 };

  2418.                         midiEvent2[0] = MIDI_STATUS_CONTROL_CHANGE + i;

  2419.                         midiEvent2[1] = MIDI_CONTROL_ALL_SOUND_OFF;

  2420. 

  2421.                         // send to all midi inputs

  2422.                         for (k=0; k < evIn.count; k++)

  2423.                         {

  2424.                             if (evIn.data[k].type & CARLA_EVENT_TYPE_MIDI)

  2425.                             {

  2426.                                 if (evIn.data[k].type & CARLA_EVENT_DATA_ATOM)

  2427.                                 {

  2428.                                     const uint32_t padSize = lv2_atom_pad_size(sizeof(LV2_Atom_Event) + 2);

  2429. 

  2430.                                     // all sound off

  2431.                                     LV2_Atom_Event* const aev1 = getLv2AtomEvent(evIn.data[k].atom, evInAtomOffsets[k]);

  2432.                                     aev1->time.frames = 0;

  2433.                                     aev1->body.type   = CARLA_URI_MAP_ID_MIDI_EVENT;

  2434.                                     aev1->body.size   = 2;

  2435.                                     memcpy(LV2_ATOM_BODY(&aev1->body), midiEvent1, 2);

  2436. 

  2437.                                     evInAtomOffsets[k]           += padSize;

  2438.                                     evIn.data[k].atom->atom.size += padSize;

  2439. 

  2440.                                     // all notes off

  2441.                                     LV2_Atom_Event* const aev2 = getLv2AtomEvent(evIn.data[k].atom, evInAtomOffsets[k]);

  2442.                                     aev2->time.frames = 0;

  2443.                                     aev2->body.type   = CARLA_URI_MAP_ID_MIDI_EVENT;

  2444.                                     aev2->body.size   = 2;

  2445.                                     memcpy(LV2_ATOM_BODY(&aev2->body), midiEvent2, 2);

  2446. 

  2447.                                     evInAtomOffsets[k]           += padSize;

  2448.                                     evIn.data[k].atom->atom.size += padSize;

  2449.                                 }

  2450.                                 else if (evIn.data[k].type & CARLA_EVENT_DATA_EVENT)

  2451.                                 {

  2452.                                     lv2_event_write(&evInEventIters[k], 0, 0, CARLA_URI_MAP_ID_MIDI_EVENT, 2, midiEvent1);

  2453.                                     lv2_event_write(&evInEventIters[k], 0, 0, CARLA_URI_MAP_ID_MIDI_EVENT, 2, midiEvent2);

  2454.                                 }

  2455.                                 else if (evIn.data[k].type & CARLA_EVENT_DATA_MIDI_LL)

  2456.                                 {

  2457.                                     lv2midi_put_event(&evInMidiStates[k], 0, 2, midiEvent1);

  2458.                                     lv2midi_put_event(&evInMidiStates[k], 0, 2, midiEvent2);

  2459.                                 }

  2460.                             }

  2461.                         }

  2462.                     }

  2463. 

  2464.                     midiEventCount = MAX_MIDI_CHANNELS*2;

  2465.                 }

  2466. 

  2467.                 if (descriptor->activate)

  2468.                 {

  2469.                     descriptor->activate(handle);

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

  2471.                 }

  2472.             }

  2473. 

  2474.             for (i=0; i < aIn.count; i++)

  2475.             {

  2476.                 if (i == 0 || ! h2) descriptor->connect_port(handle, aIn.rindexes[i], inBuffer[i]);

  2477.                 if (i == 1 && h2) descriptor->connect_port(h2, aIn.rindexes[i], inBuffer[i]);

  2478.             }

  2479. 

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

  2481.             {

  2482.                 if (i == 0 || ! h2) descriptor->connect_port(handle, aOut.rindexes[i], outBuffer[i]);

  2483.                 if (i == 1 && h2)   descriptor->connect_port(h2, aOut.rindexes[i], outBuffer[i]);

  2484.             }

  2485. 

  2486.             descriptor->run(handle, frames);

  2487.             if (h2) descriptor->run(h2, frames);

  2488. 

  2489.             if (ext.worker && ext.worker->end_run)

  2490.             {

  2491.                 ext.worker->end_run(handle);

  2492.                 if (h2) ext.worker->end_run(h2);

  2493.             }

  2494.         }

  2495.         else

  2496.         {

  2497.             if (m_activeBefore)

  2498.             {

  2499.                 if (descriptor->deactivate)

  2500.                 {

  2501.                     descriptor->deactivate(handle);

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

  2503.                 }

  2504.             }

  2505.         }

  2506. 

  2507.         CARLA_PROCESS_CONTINUE_CHECK;

  2508. 

  2509.         // --------------------------------------------------------------------------------------------------------

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

  2511. 

  2512.         if (m_active)

  2513.         {

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

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

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

  2517. 

  2518.             double bal_rangeL, bal_rangeR;

  2519.             float oldBufLeft[do_balance ? frames : 0];

  2520. 

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

  2522.             {

  2523.                 // Dry/Wet

  2524.                 if (do_drywet)

  2525.                 {

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

  2527.                     {

  2528.                         if (aOut.count == 1)

  2529.                             outBuffer[i][k] = (outBuffer[i][k]*x_dryWet)+(inBuffer[0][k]*(1.0-x_dryWet));

  2530.                         else

  2531.                             outBuffer[i][k] = (outBuffer[i][k]*x_dryWet)+(inBuffer[i][k]*(1.0-x_dryWet));

  2532.                     }

  2533.                 }

  2534. 

  2535.                 // Balance

  2536.                 if (do_balance)

  2537.                 {

  2538.                     if (i%2 == 0)

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

  2540. 

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

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

  2543. 

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

  2545.                     {

  2546.                         if (i%2 == 0)

  2547.                         {

  2548.                             // left output

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

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

  2551.                         }

  2552.                         else

  2553.                         {

  2554.                             // right

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

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

  2557.                         }

  2558.                     }

  2559.                 }

  2560. 

  2561.                 // Volume

  2562.                 if (do_volume)

  2563.                 {

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

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

  2566.                 }

  2567. 

  2568.                 // Output VU

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

  2570.                 {

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

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

  2573.                 }

  2574.             }

  2575.         }

  2576.         else

  2577.         {

  2578.             // disable any output sound if not active

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

  2580.                 zeroF(outBuffer[i], frames);

  2581. 

  2582.             aOutsPeak[0] = 0.0;

  2583.             aOutsPeak[1] = 0.0;

  2584. 

  2585.         } // End of Post-processing

  2586. 

  2587.         CARLA_PROCESS_CONTINUE_CHECK;

  2588. 

  2589.         // --------------------------------------------------------------------------------------------------------

  2590.         // Control Output

  2591. 

  2592.         if (param.portCout && m_active)

  2593.         {

  2594.             double value;

  2595. 

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

  2597.             {

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

  2599.                 {

  2600.                     fixParameterValue(paramBuffers[k], param.ranges[k]);

  2601. 

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

  2603.                     {

  2604.                         value = (paramBuffers[k] - param.ranges[k].min) / (param.ranges[k].max - param.ranges[k].min);

  2605.                         param.portCout->writeEvent(CarlaEngineEventControlChange, framesOffset, param.data[k].midiChannel, param.data[k].midiCC, value);

  2606.                     }

  2607.                 }

  2608.             }

  2609.         } // End of Control Output

  2610. 

  2611.         CARLA_PROCESS_CONTINUE_CHECK;

  2612. 

  2613.         // --------------------------------------------------------------------------------------------------------

  2614.         // Event Output

  2615. 

  2616.         if (evOut.count > 0 && m_active)

  2617.         {

  2618.             atomQueueOut.lock();

  2619. 

  2620.             for (i=0; i < evOut.count; i++)

  2621.             {

  2622.                 // midi events need the midi port to send events to

  2623.                 if ((evOut.data[i].type & CARLA_EVENT_TYPE_MIDI) > 0 && ! evOut.data[i].port)

  2624.                     continue;

  2625. 

  2626.                 if (evOut.data[i].type & CARLA_EVENT_DATA_ATOM)

  2627.                 {

  2628.                     int32_t size   = evOut.data[i].atom->atom.size - sizeof(LV2_Atom_Sequence_Body);

  2629.                     int32_t offset = 0;

  2630. 

  2631.                     while (offset < size)

  2632.                     {

  2633.                         qDebug("output event??, offset:%i, size:%i", offset, size);

  2634.                         const LV2_Atom_Event* const aev = (LV2_Atom_Event*)((char*)LV2_ATOM_CONTENTS(LV2_Atom_Sequence, evOut.data[i].atom) + offset);

  2635. 

  2636.                         if ((! aev) || aev->body.type == CARLA_URI_MAP_ID_NULL)

  2637.                             break;

  2638. 

  2639.                         qDebug("output event ------------------------------ YES!");

  2640. 

  2641.                         if (aev->body.type == CARLA_URI_MAP_ID_MIDI_EVENT)

  2642.                         {

  2643.                             const unsigned char* const data = (unsigned char*)LV2_ATOM_BODY(&aev->body);

  2644.                             evOut.data[i].port->writeEvent(aev->time.frames, data, aev->body.size);

  2645.                         }

  2646.                         else if (aev->body.type == CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT)

  2647.                         {

  2648.                             if (! atomQueueOut.isFull())

  2649.                                 atomQueueOut.put(evOut.data[i].rindex, &aev->body);

  2650.                         }

  2651. 

  2652.                         offset += lv2_atom_pad_size(sizeof(LV2_Atom_Event) + aev->body.size);

  2653.                     }

  2654.                 }

  2655.                 else if (evOut.data[i].type & CARLA_EVENT_DATA_EVENT)

  2656.                 {

  2657.                     const LV2_Event* ev;

  2658.                     LV2_Event_Iterator iter;

  2659. 

  2660.                     uint8_t* data;

  2661.                     lv2_event_begin(&iter, evOut.data[i].event);

  2662. 

  2663.                     for (k=0; k < iter.buf->event_count; k++)

  2664.                     {

  2665.                         ev = lv2_event_get(&iter, &data);

  2666. 

  2667.                         if (ev && ev->type == CARLA_URI_MAP_ID_MIDI_EVENT && data)

  2668.                             evOut.data[i].port->writeEvent(ev->frames, data, ev->size);

  2669. 

  2670.                         lv2_event_increment(&iter);

  2671.                     }

  2672.                 }

  2673.                 else if (evOut.data[i].type & CARLA_EVENT_DATA_MIDI_LL)

  2674.                 {

  2675.                     LV2_MIDIState state = { evOut.data[i].midi, frames, 0 };

  2676. 

  2677.                     uint32_t eventSize;

  2678.                     double   eventTime;

  2679.                     unsigned char* eventData;

  2680. 

  2681.                     while (lv2midi_get_event(&state, &eventTime, &eventSize, &eventData) < frames)

  2682.                     {

  2683.                         evOut.data[i].port->writeEvent(eventTime, eventData, eventSize);

  2684.                         lv2midi_step(&state);

  2685.                     }

  2686.                 }

  2687.             }

  2688. 

  2689.             atomQueueOut.unlock();

  2690. 

  2691.         } // End of Event Output

  2692. 

  2693.         CARLA_PROCESS_CONTINUE_CHECK;

  2694. 

  2695.         // --------------------------------------------------------------------------------------------------------

  2696.         // Peak Values

  2697. 

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

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

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

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

  2702. 

  2703.         m_activeBefore = m_active;

  2704.     }

  2705. 

  2706.     void bufferSizeChanged(const uint32_t newBufferSize)

  2707.     {

  2708.         lv2Options.bufferSize = newBufferSize;

  2709.     }

  2710. 

  2711.     // -------------------------------------------------------------------

  2712.     // Post-poned events

  2713. 

  2714.     void postEventHandleCustom(const int32_t size, const int32_t, const double, const void* const data)

  2715.     {

  2716.         qDebug("Lv2Plugin::postEventHandleCustom(%i, %p)", size, data);

  2717.         CARLA_ASSERT(ext.worker && ext.worker->work);

  2718. 

  2719.         if (ext.worker && ext.worker->work)

  2720.             ext.worker->work(handle, carla_lv2_worker_respond, this, size, data);

  2721.     }

  2722. 

  2723.     void uiParameterChange(const uint32_t index, const double value)

  2724.     {

  2725.         CARLA_ASSERT(index < param.count);

  2726. 

  2727.         if (index >= param.count)

  2728.             return;

  2729. 

  2730. #ifndef BUILD_BRIDGE

  2731.         if (gui.type == GUI_EXTERNAL_OSC)

  2732.         {

  2733.             if (osc.data.target)

  2734.                 osc_send_control(&osc.data, param.data[index].rindex, value);

  2735.         }

  2736.         else

  2737. #endif

  2738.         {

  2739.             if (ui.handle && ui.descriptor && ui.descriptor->port_event)

  2740.             {

  2741.                 float valueF = value;

  2742.                 ui.descriptor->port_event(ui.handle, param.data[index].rindex, sizeof(float), 0, &valueF);

  2743.             }

  2744.         }

  2745.     }

  2746. 

  2747.     void uiMidiProgramChange(const uint32_t index)

  2748.     {

  2749.         CARLA_ASSERT(index < midiprog.count);

  2750. 

  2751.         if (index >= midiprog.count)

  2752.             return;

  2753. 

  2754. #ifndef BUILD_BRIDGE

  2755.         if (gui.type == GUI_EXTERNAL_OSC)

  2756.         {

  2757.             if (osc.data.target)

  2758.                 osc_send_midi_program(&osc.data, midiprog.data[index].bank, midiprog.data[index].program);

  2759.         }

  2760.         else

  2761. #endif

  2762.         {

  2763.             if (ext.uiprograms)

  2764.                 ext.uiprograms->select_program(ui.handle, midiprog.data[index].bank, midiprog.data[index].program);

  2765.         }

  2766.     }

  2767. 

  2768.     void uiNoteOn(const uint8_t channel, const uint8_t note, const uint8_t velo)

  2769.     {

  2770.         CARLA_ASSERT(channel < 16);

  2771.         CARLA_ASSERT(note < 128);

  2772.         CARLA_ASSERT(velo > 0 && velo < 128);

  2773. 

  2774. #ifndef BUILD_BRIDGE

  2775.         if (gui.type == GUI_EXTERNAL_OSC)

  2776.         {

  2777.             if (osc.data.target)

  2778.             {

  2779.                 uint8_t midiData[4] = { 0 };

  2780.                 midiData[1] = MIDI_STATUS_NOTE_ON + channel;

  2781.                 midiData[2] = note;

  2782.                 midiData[3] = velo;

  2783.                 osc_send_midi(&osc.data, midiData);

  2784.             }

  2785.         }

  2786.         else

  2787. #endif

  2788.         {

  2789.             if (ui.handle && ui.descriptor && ui.descriptor->port_event)

  2790.             {

  2791.                 LV2_Atom_MidiEvent midiEv;

  2792.                 midiEv.event.time.frames = 0;

  2793.                 midiEv.event.body.type   = CARLA_URI_MAP_ID_MIDI_EVENT;

  2794.                 midiEv.event.body.size   = 3;

  2795.                 midiEv.data[0] = MIDI_STATUS_NOTE_OFF + channel;

  2796.                 midiEv.data[1] = note;

  2797.                 midiEv.data[2] = velo;

  2798. 

  2799.                 ui.descriptor->port_event(ui.handle, 0, 3, CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM, &midiEv);

  2800.             }

  2801.         }

  2802.     }

  2803. 

  2804.     void uiNoteOff(const uint8_t channel, const uint8_t note)

  2805.     {

  2806.         CARLA_ASSERT(channel < 16);

  2807.         CARLA_ASSERT(note < 128);

  2808. 

  2809. #ifndef BUILD_BRIDGE

  2810.         if (gui.type == GUI_EXTERNAL_OSC)

  2811.         {

  2812.             if (osc.data.target)

  2813.             {

  2814.                 uint8_t midiData[4] = { 0 };

  2815.                 midiData[1] = MIDI_STATUS_NOTE_OFF + channel;

  2816.                 midiData[2] = note;

  2817.                 osc_send_midi(&osc.data, midiData);

  2818.             }

  2819.         }

  2820.         else

  2821. #endif

  2822.         {

  2823.             if (ui.handle && ui.descriptor && ui.descriptor->port_event)

  2824.             {

  2825.                 LV2_Atom_MidiEvent midiEv;

  2826.                 midiEv.event.time.frames = 0;

  2827.                 midiEv.event.body.type   = CARLA_URI_MAP_ID_MIDI_EVENT;

  2828.                 midiEv.event.body.size   = 3;

  2829.                 midiEv.data[0] = MIDI_STATUS_NOTE_OFF + channel;

  2830.                 midiEv.data[1] = note;

  2831.                 midiEv.data[2] = 0;

  2832. 

  2833.                 ui.descriptor->port_event(ui.handle, 0, 3, CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM, &midiEv);

  2834.             }

  2835.         }

  2836.     }

  2837. 

  2838.     // -------------------------------------------------------------------

  2839.     // Cleanup

  2840. 

  2841.     void removeClientPorts()

  2842.     {

  2843.         qDebug("Lv2Plugin::removeClientPorts() - start");

  2844. 

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

  2846.         {

  2847.             if (evIn.data[i].port)

  2848.             {

  2849.                 delete evIn.data[i].port;

  2850.                 evIn.data[i].port = nullptr;

  2851.             }

  2852.         }

  2853. 

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

  2855.         {

  2856.             if (evOut.data[i].port)

  2857.             {

  2858.                 delete evOut.data[i].port;

  2859.                 evOut.data[i].port = nullptr;

  2860.             }

  2861.         }

  2862. 

  2863.         CarlaPlugin::removeClientPorts();

  2864. 

  2865.         qDebug("Lv2Plugin::removeClientPorts() - end");

  2866.     }

  2867. 

  2868.     void initBuffers()

  2869.     {

  2870.         uint32_t i;

  2871. 

  2872.         for (i=0; i < evIn.count; i++)

  2873.         {

  2874.             if (evIn.data[i].port)

  2875.                 evIn.data[i].port->initBuffer(x_engine);

  2876.         }

  2877. 

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

  2879.         {

  2880.             if (evOut.data[i].port)

  2881.                 evOut.data[i].port->initBuffer(x_engine);

  2882.         }

  2883. 

  2884.         CarlaPlugin::initBuffers();

  2885.     }

  2886. 

  2887.     void deleteBuffers()

  2888.     {

  2889.         qDebug("Lv2Plugin::deleteBuffers() - start");

  2890. 

  2891.         if (evIn.count > 0)

  2892.         {

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

  2894.             {

  2895.                 if (evIn.data[i].type & CARLA_EVENT_DATA_ATOM)

  2896.                 {

  2897.                     free(evIn.data[i].atom);

  2898.                 }

  2899.                 else if (evIn.data[i].type & CARLA_EVENT_DATA_EVENT)

  2900.                 {

  2901.                     free(evIn.data[i].event);

  2902.                 }

  2903.                 else if (evIn.data[i].type & CARLA_EVENT_DATA_MIDI_LL)

  2904.                 {

  2905.                     delete[] evIn.data[i].midi->data;

  2906.                     delete evIn.data[i].midi;

  2907.                 }

  2908.             }

  2909. 

  2910.             delete[] evIn.data;

  2911.         }

  2912. 

  2913.         if (evOut.count > 0)

  2914.         {

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

  2916.             {

  2917.                 if (evOut.data[i].type & CARLA_EVENT_DATA_ATOM)

  2918.                 {

  2919.                     free(evOut.data[i].atom);

  2920.                 }

  2921.                 else if (evOut.data[i].type & CARLA_EVENT_DATA_EVENT)

  2922.                 {

  2923.                     free(evOut.data[i].event);

  2924.                 }

  2925.                 else if (evOut.data[i].type & CARLA_EVENT_DATA_MIDI_LL)

  2926.                 {

  2927.                     delete[] evOut.data[i].midi->data;

  2928.                     delete evOut.data[i].midi;

  2929.                 }

  2930.             }

  2931. 

  2932.             delete[] evOut.data;

  2933.         }

  2934. 

  2935.         if (param.count > 0)

  2936.             delete[] paramBuffers;

  2937. 

  2938.         evIn.count = 0;

  2939.         evIn.data  = nullptr;

  2940. 

  2941.         evOut.count = 0;

  2942.         evOut.data  = nullptr;

  2943. 

  2944.         paramBuffers = nullptr;

  2945. 

  2946.         CarlaPlugin::deleteBuffers();

  2947. 

  2948.         qDebug("Lv2Plugin::deleteBuffers() - end");

  2949.     }

  2950. 

  2951.     // -------------------------------------------------------------------

  2952. 

  2953.     uint32_t getCustomURID(const char* const uri)

  2954.     {

  2955.         qDebug("Lv2Plugin::getCustomURID(%s)", uri);

  2956.         CARLA_ASSERT(uri);

  2957. 

  2958.         if (! uri)

  2959.             return CARLA_URI_MAP_ID_NULL;

  2960. 

  2961.         for (size_t i=0; i < customURIDs.size(); i++)

  2962.         {

  2963.             if (customURIDs[i] && strcmp(customURIDs[i], uri) == 0)

  2964.                 return i;

  2965.         }

  2966. 

  2967.         customURIDs.push_back(strdup(uri));

  2968. 

  2969.         return customURIDs.size()-1;

  2970.     }

  2971. 

  2972.     const char* getCustomURIString(const LV2_URID urid) const

  2973.     {

  2974.         qDebug("Lv2Plugin::getCustomURIString(%i)", urid);

  2975.         CARLA_ASSERT(urid > CARLA_URI_MAP_ID_NULL);

  2976. 

  2977.         if (urid == CARLA_URI_MAP_ID_NULL)

  2978.             return nullptr;

  2979.         if (urid < customURIDs.size())

  2980.             return customURIDs[urid];

  2981. 

  2982.         return nullptr;

  2983.     }

  2984. 

  2985.     // -------------------------------------------------------------------

  2986. 

  2987.     void handleTransferAtom(const int32_t portIndex, const LV2_Atom* const atom)

  2988.     {

  2989.         qDebug("Lv2Plugin::handleTransferAtom(%i, %p)", portIndex, atom);

  2990.         CARLA_ASSERT(portIndex >= 0);

  2991.         CARLA_ASSERT(atom);

  2992. 

  2993.         atomQueueIn.put(portIndex, atom);

  2994.     }

  2995. 

  2996.     void handleTransferEvent(const int32_t portIndex, const LV2_Atom* const atom)

  2997.     {

  2998.         qDebug("Lv2Plugin::handleTransferEvent(%i, %p)", portIndex, atom);

  2999.         CARLA_ASSERT(portIndex >= 0);

  3000.         CARLA_ASSERT(atom);

  3001. 

  3002.         atomQueueIn.put(portIndex, atom);

  3003.     }

  3004. 

  3005.     // -------------------------------------------------------------------

  3006. 

  3007.     void handleProgramChanged(const int32_t index)

  3008.     {

  3009.         if (index == -1)

  3010.         {

  3011.             const CarlaPlugin::ScopedDisabler m(this);

  3012.             reloadPrograms(false);

  3013.         }

  3014.         else

  3015.         {

  3016.             if (index >= 0 && index < (int32_t)prog.count && ext.programs)

  3017.             {

  3018.                 const char* const progName = ext.programs->get_program(handle, index)->name;

  3019.                 CARLA_ASSERT(progName);

  3020. 

  3021.                 if (prog.names[index])

  3022.                     free((void*)prog.names[index]);

  3023. 

  3024.                 prog.names[index] = strdup(progName);

  3025.             }

  3026.         }

  3027. 

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

  3029.     }

  3030. 

  3031.     LV2_State_Status handleStateStore(const uint32_t key, const void* const value, const size_t size, const uint32_t type, const uint32_t flags)

  3032.     {

  3033.         CARLA_ASSERT(key > 0);

  3034.         CARLA_ASSERT(value);

  3035. 

  3036.         CustomDataType dtype;

  3037.         const char* const uriKey = getCustomURIString(key);

  3038. 

  3039.         if (type == CARLA_URI_MAP_ID_ATOM_CHUNK)

  3040.             dtype = CUSTOM_DATA_CHUNK;

  3041.         else if (type == CARLA_URI_MAP_ID_ATOM_PATH)

  3042.             dtype = CUSTOM_DATA_PATH;

  3043.         else if (type == CARLA_URI_MAP_ID_ATOM_STRING)

  3044.             dtype = CUSTOM_DATA_STRING;

  3045.         else if (type >= CARLA_URI_MAP_ID_COUNT)

  3046.             dtype = CUSTOM_DATA_BINARY;

  3047.         else

  3048.             dtype = CUSTOM_DATA_INVALID;

  3049. 

  3050.         // do basic checks

  3051.         if (! uriKey)

  3052.         {

  3053.             qWarning("Lv2Plugin::handleStateStore(%i, %p, " P_SIZE ", %i, %i) - invalid key", key, value, size, type, flags);

  3054.             return LV2_STATE_ERR_NO_PROPERTY;

  3055.         }

  3056. 

  3057.         if (! flags & LV2_STATE_IS_POD)

  3058.         {

  3059.             qWarning("Lv2Plugin::handleStateStore(%i, %p, " P_SIZE ", %i, %i) - invalid flags", key, value, size, type, flags);

  3060.             return LV2_STATE_ERR_BAD_FLAGS;

  3061.         }

  3062. 

  3063.         if (dtype == CUSTOM_DATA_INVALID)

  3064.         {

  3065.             qCritical("Lv2Plugin::handleStateStore(%i, %p, " P_SIZE ", %i, %i) - invalid type '%s'", key, value, size, type, flags, CustomDataType2str(dtype));

  3066.             return LV2_STATE_ERR_BAD_TYPE;

  3067.         }

  3068. 

  3069.         // Check if we already have this key

  3070.         for (size_t i=0; i < custom.size(); i++)

  3071.         {

  3072.             if (strcmp(custom[i].key, uriKey) == 0)

  3073.             {

  3074.                 free((void*)custom[i].value);

  3075. 

  3076.                 if (dtype == CUSTOM_DATA_STRING || dtype == CUSTOM_DATA_PATH)

  3077.                     custom[i].value = strdup((const char*)value);

  3078.                 else

  3079.                     custom[i].value = strdup(QByteArray((const char*)value, size).toBase64().constData());

  3080. 

  3081.                 return LV2_STATE_SUCCESS;

  3082.             }

  3083.         }

  3084. 

  3085.         // Otherwise store it

  3086.         CustomData newData;

  3087.         newData.type = dtype;

  3088.         newData.key  = strdup(uriKey);

  3089. 

  3090.         if (dtype == CUSTOM_DATA_STRING || dtype == CUSTOM_DATA_PATH)

  3091.             newData.value = strdup((const char*)value);

  3092.         else

  3093.             newData.value = strdup(QByteArray((const char*)value, size).toBase64().constData());

  3094. 

  3095.         custom.push_back(newData);

  3096. 

  3097.         return LV2_STATE_SUCCESS;

  3098.     }

  3099. 

  3100.     const void* handleStateRetrieve(const uint32_t key, size_t* const size, uint32_t* const type, uint32_t* const flags)

  3101.     {

  3102.         CARLA_ASSERT(key > CARLA_URI_MAP_ID_NULL);

  3103. 

  3104.         const char* const uriKey = getCustomURIString(key);

  3105. 

  3106.         if (! uriKey)

  3107.         {

  3108.             qCritical("Lv2Plugin::handleStateRetrieve(%i, %p, %p, %p) - failed to find key", key, size, type, flags);

  3109.             return nullptr;

  3110.         }

  3111. 

  3112.         const char* stringData = nullptr;

  3113.         CustomDataType dtype = CUSTOM_DATA_INVALID;

  3114. 

  3115.         for (size_t i=0; i < custom.size(); i++)

  3116.         {

  3117.             if (strcmp(custom[i].key, uriKey) == 0)

  3118.             {

  3119.                 dtype      = custom[i].type;

  3120.                 stringData = custom[i].value;

  3121.                 break;

  3122.             }

  3123.         }

  3124. 

  3125.         if (! stringData)

  3126.         {

  3127.             qCritical("Lv2Plugin::handleStateRetrieve(%i, %p, %p, %p) - invalid key '%s'", key, size, type, flags, uriKey);

  3128.             return nullptr;

  3129.         }

  3130. 

  3131.         *size  = 0;

  3132.         *type  = 0;

  3133.         *flags = LV2_STATE_IS_POD;

  3134. 

  3135.         if (dtype == CUSTOM_DATA_STRING)

  3136.         {

  3137.             *size = strlen(stringData);

  3138.             *type = CARLA_URI_MAP_ID_ATOM_STRING;

  3139.             return stringData;

  3140.         }

  3141.         if (dtype == CUSTOM_DATA_PATH)

  3142.         {

  3143.             *size = strlen(stringData);

  3144.             *type = CARLA_URI_MAP_ID_ATOM_PATH;

  3145.             return stringData;

  3146.         }

  3147.         if (dtype == CUSTOM_DATA_CHUNK || dtype == CUSTOM_DATA_BINARY)

  3148.         {

  3149.             static QByteArray chunk;

  3150.             chunk = QByteArray::fromBase64(stringData);

  3151. 

  3152.             *size = chunk.size();

  3153.             *type = (dtype == CUSTOM_DATA_CHUNK) ? CARLA_URI_MAP_ID_ATOM_CHUNK : key;

  3154.             return chunk.constData();

  3155.         }

  3156. 

  3157.         qCritical("Lv2Plugin::handleStateRetrieve(%i, %p, %p, %p) - invalid key type '%s'", key, size, type, flags, CustomDataType2str(dtype));

  3158.         return nullptr;

  3159.     }

  3160. 

  3161.     LV2_Worker_Status handleWorkerSchedule(const uint32_t size, const void* const data)

  3162.     {

  3163.         if (! ext.worker)

  3164.         {

  3165.             qWarning("Lv2Plugin::handleWorkerSchedule(%i, %p) - plugin has no worker", size, data);

  3166.             return LV2_WORKER_ERR_UNKNOWN;

  3167.         }

  3168. 

  3169.         if (x_engine->isOffline())

  3170.             ext.worker->work(handle, carla_lv2_worker_respond, this, size, data);

  3171.         else

  3172.             postponeEvent(PluginPostEventCustom, size, 0, 0.0, data);

  3173. 

  3174.         return LV2_WORKER_SUCCESS;

  3175.     }

  3176. 

  3177.     LV2_Worker_Status handleWorkerRespond(const uint32_t size, const void* const data)

  3178.     {

  3179.         LV2_Atom_Worker workerAtom;

  3180.         workerAtom.atom.type = CARLA_URI_MAP_ID_ATOM_WORKER;

  3181.         workerAtom.atom.size = sizeof(LV2_Atom_Worker_Body);

  3182.         workerAtom.body.size = size;

  3183.         workerAtom.body.data = data;

  3184. 

  3185.         atomQueueIn.put(0, (const LV2_Atom*)&workerAtom);

  3186. 

  3187.         return LV2_WORKER_SUCCESS;

  3188.     }

  3189. 

  3190.     void handleExternalUiClosed()

  3191.     {

  3192.         if (ui.handle && ui.descriptor && ui.descriptor->cleanup)

  3193.             ui.descriptor->cleanup(ui.handle);

  3194. 

  3195.         ui.handle = nullptr;

  3196.         x_engine->callback(CALLBACK_SHOW_GUI, m_id, 0, 0, 0.0);

  3197.     }

  3198. 

  3199.     uint32_t handleUiPortMap(const char* const symbol)

  3200.     {

  3201.         CARLA_ASSERT(symbol);

  3202. 

  3203.         if (! symbol)

  3204.             return LV2UI_INVALID_PORT_INDEX;

  3205. 

  3206.         for (uint32_t i=0; i < rdf_descriptor->PortCount; i++)

  3207.         {

  3208.             if (strcmp(rdf_descriptor->Ports[i].Symbol, symbol) == 0)

  3209.                 return i;

  3210.         }

  3211. 

  3212.         return LV2UI_INVALID_PORT_INDEX;

  3213.     }

  3214. 

  3215.     int handleUiResize(const int width, const int height)

  3216.     {

  3217.         CARLA_ASSERT(width > 0);

  3218.         CARLA_ASSERT(height > 0);

  3219. 

  3220.         if (width <= 0 || height <= 0)

  3221.             return 1;

  3222. 

  3223.         gui.width  = width;

  3224.         gui.height = height;

  3225.         x_engine->callback(CALLBACK_RESIZE_GUI, m_id, width, height, 0.0);

  3226. 

  3227.         return 0;

  3228.     }

  3229. 

  3230.     void handleUiWrite(const uint32_t rindex, const uint32_t bufferSize, const uint32_t format, const void* const buffer)

  3231.     {

  3232.         if (format == 0)

  3233.         {

  3234.             CARLA_ASSERT(buffer);

  3235.             CARLA_ASSERT(bufferSize == sizeof(float));

  3236. 

  3237.             if (bufferSize != sizeof(float))

  3238.                 return;

  3239. 

  3240.             float value = *(float*)buffer;

  3241. 

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

  3243.             {

  3244.                 if (param.data[i].rindex == (int32_t)rindex)

  3245.                     return setParameterValue(i, value, false, true, true);

  3246.             }

  3247.         }

  3248.         else if (format == CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM)

  3249.         {

  3250.             CARLA_ASSERT(buffer);

  3251. 

  3252.             const LV2_Atom* const atom = (const LV2_Atom*)buffer;

  3253.             handleTransferAtom(rindex, atom);

  3254.         }

  3255.         else if (format == CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT)

  3256.         {

  3257.             CARLA_ASSERT(buffer);

  3258. 

  3259.             const LV2_Atom* const atom = (const LV2_Atom*)buffer;

  3260.             handleTransferEvent(rindex, atom);

  3261.         }

  3262.     }

  3263. 

  3264.     // -------------------------------------------------------------------

  3265. 

  3266. #ifndef BUILD_BRIDGE

  3267.     bool isUiBridgeable(const uint32_t uiId)

  3268.     {

  3269.         CARLA_ASSERT(rdf_descriptor);

  3270.         CARLA_ASSERT(uiId < rdf_descriptor->UICount);

  3271. 

  3272.         if (uiId >= rdf_descriptor->UICount)

  3273.             return false;

  3274. 

  3275.         const LV2_RDF_UI* const rdf_ui = &rdf_descriptor->UIs[uiId];

  3276. 

  3277.         for (uint32_t i=0; i < rdf_ui->FeatureCount; i++)

  3278.         {

  3279.             if (strcmp(rdf_ui->Features[i].URI, LV2_INSTANCE_ACCESS_URI) == 0 || strcmp(rdf_ui->Features[i].URI, LV2_DATA_ACCESS_URI) == 0)

  3280.                 return false;

  3281.         }

  3282. 

  3283.         return true;

  3284.     }

  3285. #endif

  3286. 

  3287.     bool isUiResizable()

  3288.     {

  3289.         CARLA_ASSERT(ui.rdf_descriptor);

  3290. 

  3291.         if (! ui.rdf_descriptor)

  3292.             return false;

  3293. 

  3294.         for (uint32_t i=0; i < ui.rdf_descriptor->FeatureCount; i++)

  3295.         {

  3296.             if (strcmp(ui.rdf_descriptor->Features[i].URI, LV2_UI__fixedSize) == 0 || strcmp(ui.rdf_descriptor->Features[i].URI, LV2_UI__noUserResize) == 0)

  3297.                 return false;

  3298.         }

  3299. 

  3300.         return true;

  3301.     }

  3302. 

  3303.     void initExternalUi()

  3304.     {

  3305.         qDebug("Lv2Plugin::initExternalUi()");

  3306. 

  3307.         ui.widget = nullptr;

  3308.         ui.handle = ui.descriptor->instantiate(ui.descriptor, descriptor->URI, ui.rdf_descriptor->Bundle, carla_lv2_ui_write_function, this, &ui.widget, features);

  3309. 

  3310.         if (ui.handle && ui.widget)

  3311.         {

  3312.             updateUi();

  3313.         }

  3314.         else

  3315.         {

  3316.             qWarning("Lv2Plugin::initExternalUi() - failed to instantiate UI");

  3317.             ui.handle = nullptr;

  3318.             ui.widget = nullptr;

  3319.             x_engine->callback(CALLBACK_SHOW_GUI, m_id, -1, 0, 0.0);

  3320.         }

  3321.     }

  3322. 

  3323.     void uiTransferCustomData(const CustomData* const cdata)

  3324.     {

  3325.         if (cdata->type == CUSTOM_DATA_INVALID || ! (ui.handle && ui.descriptor && ui.descriptor->port_event))

  3326.             return;

  3327. 

  3328.         LV2_URID_Map* const URID_Map = (LV2_URID_Map*)features[lv2_feature_id_urid_map]->data;

  3329.         const LV2_URID uridPatchSet  = getCustomURID(LV2_PATCH__Set);

  3330.         const LV2_URID uridPatchBody = getCustomURID(LV2_PATCH__body);

  3331. 

  3332.         Sratom* const sratom = sratom_new(URID_Map);

  3333.         SerdChunk     chunk  = { nullptr, 0 };

  3334. 

  3335.         LV2_Atom_Forge forge;

  3336.         lv2_atom_forge_init(&forge, URID_Map);

  3337.         lv2_atom_forge_set_sink(&forge, sratom_forge_sink, sratom_forge_deref, &chunk);

  3338. 

  3339.         LV2_Atom_Forge_Frame refFrame, bodyFrame;

  3340.         LV2_Atom_Forge_Ref   ref = lv2_atom_forge_blank(&forge, &refFrame, 1, uridPatchSet);

  3341. 

  3342.         lv2_atom_forge_property_head(&forge, uridPatchBody, CARLA_URI_MAP_ID_NULL);

  3343.         lv2_atom_forge_blank(&forge, &bodyFrame, 2, CARLA_URI_MAP_ID_NULL);

  3344. 

  3345.         lv2_atom_forge_property_head(&forge, getCustomURID(cdata->key), CARLA_URI_MAP_ID_NULL);

  3346. 

  3347.         if (cdata->type == CUSTOM_DATA_STRING)

  3348.             lv2_atom_forge_string(&forge, cdata->value, strlen(cdata->value));

  3349.         else if (cdata->type == CUSTOM_DATA_PATH)

  3350.             lv2_atom_forge_path(&forge, cdata->value, strlen(cdata->value));

  3351.         else if (cdata->type == CUSTOM_DATA_CHUNK)

  3352.             lv2_atom_forge_literal(&forge, cdata->value, strlen(cdata->value), CARLA_URI_MAP_ID_ATOM_CHUNK, CARLA_URI_MAP_ID_NULL);

  3353.         else

  3354.             lv2_atom_forge_literal(&forge, cdata->value, strlen(cdata->value), getCustomURID(cdata->key), CARLA_URI_MAP_ID_NULL);

  3355. 

  3356.         lv2_atom_forge_pop(&forge, &bodyFrame);

  3357.         lv2_atom_forge_pop(&forge, &refFrame);

  3358. 

  3359.         uint32_t portIndex = evIn.count > 0 ? evIn.data[0].rindex : 0;

  3360. 

  3361.         const LV2_Atom* const atom = lv2_atom_forge_deref(&forge, ref);

  3362.         ui.descriptor->port_event(ui.handle, portIndex, atom->size, CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT, atom);

  3363. 

  3364.         free((void*)chunk.buf);

  3365.         sratom_free(sratom);

  3366.     }

  3367. 

  3368.     void updateUi()

  3369.     {

  3370.         ext.uiprograms = nullptr;

  3371. 

  3372.         if (ui.handle && ui.descriptor)

  3373.         {

  3374.             if (ui.descriptor->extension_data)

  3375.             {

  3376.                 ext.uiprograms = (const LV2_Programs_UI_Interface*)ui.descriptor->extension_data(LV2_PROGRAMS__UIInterface);

  3377. 

  3378.                 if (ext.uiprograms && ! ext.uiprograms->select_program)

  3379.                     // invalid

  3380.                     ext.uiprograms = nullptr;

  3381. 

  3382.                 if (ext.uiprograms && midiprog.count > 0 && midiprog.current >= 0)

  3383.                     ext.uiprograms->select_program(ui.handle, midiprog.data[midiprog.current].bank, midiprog.data[midiprog.current].program);

  3384.             }

  3385. 

  3386.             if (ui.descriptor->port_event)

  3387.             {

  3388.                 // update control ports

  3389.                 float valueF;

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

  3391.                 {

  3392.                     valueF = getParameterValue(i);

  3393.                     ui.descriptor->port_event(ui.handle, param.data[i].rindex, sizeof(float), CARLA_URI_MAP_ID_NULL, &valueF);

  3394.                 }

  3395.             }

  3396.         }

  3397.     }

  3398. 

  3399.     // ----------------- Event Feature ---------------------------------------------------

  3400. 

  3401.     static uint32_t carla_lv2_event_ref(const LV2_Event_Callback_Data callback_data, LV2_Event* const event)

  3402.     {

  3403.         qDebug("Lv2Plugin::carla_lv2_event_ref(%p, %p)", callback_data, event);

  3404.         CARLA_ASSERT(callback_data);

  3405.         CARLA_ASSERT(event);

  3406. 

  3407.         return 0;

  3408.     }

  3409. 

  3410.     static uint32_t carla_lv2_event_unref(const LV2_Event_Callback_Data callback_data, LV2_Event* const event)

  3411.     {

  3412.         qDebug("Lv2Plugin::carla_lv2_event_unref(%p, %p)", callback_data, event);

  3413.         CARLA_ASSERT(callback_data);

  3414.         CARLA_ASSERT(event);

  3415. 

  3416.         return 0;

  3417.     }

  3418. 

  3419.     // ----------------- Logs Feature ----------------------------------------------------

  3420. 

  3421.     static int carla_lv2_log_printf(const LV2_Log_Handle handle, const LV2_URID type, const char* const fmt, ...)

  3422.     {

  3423.         qDebug("Lv2Plugin::carla_lv2_log_printf(%p, %i, \"%s\", ...)", handle, type, fmt);

  3424.         CARLA_ASSERT(handle);

  3425.         CARLA_ASSERT(type > 0);

  3426. 

  3427. #ifndef DEBUG

  3428.         if (type == CARLA_URI_MAP_ID_LOG_TRACE)

  3429.             return 0;

  3430. #endif

  3431. 

  3432.         va_list args;

  3433.         va_start(args, fmt);

  3434.         const int ret = carla_lv2_log_vprintf(handle, type, fmt, args);

  3435.         va_end(args);

  3436. 

  3437.         return ret;

  3438.     }

  3439. 

  3440.     static int carla_lv2_log_vprintf(const LV2_Log_Handle handle, const LV2_URID type, const char* const fmt, va_list ap)

  3441.     {

  3442.         qDebug("Lv2Plugin::carla_lv2_log_vprintf(%p, %i, \"%s\", ...)", handle, type, fmt);

  3443.         CARLA_ASSERT(handle);

  3444.         CARLA_ASSERT(type > 0);

  3445. 

  3446. #ifndef DEBUG

  3447.         if (type == CARLA_URI_MAP_ID_LOG_TRACE)

  3448.             return 0;

  3449. #endif

  3450. 

  3451.         char buf[8196];

  3452.         vsprintf(buf, fmt, ap);

  3453. 

  3454.         if (*buf == 0)

  3455.             return 0;

  3456. 

  3457.         switch (type)

  3458.         {

  3459.         case CARLA_URI_MAP_ID_LOG_ERROR:

  3460.             qCritical("%s", buf);

  3461.             break;

  3462.         case CARLA_URI_MAP_ID_LOG_NOTE:

  3463.             printf("%s\n", buf);

  3464.             break;

  3465.         case CARLA_URI_MAP_ID_LOG_TRACE:

  3466.             qDebug("%s", buf);

  3467.             break;

  3468.         case CARLA_URI_MAP_ID_LOG_WARNING:

  3469.             qWarning("%s", buf);

  3470.             break;

  3471.         default:

  3472.             break;

  3473.         }

  3474. 

  3475.         return strlen(buf);

  3476.     }

  3477. 

  3478.     // ----------------- Programs Feature ------------------------------------------------

  3479. 

  3480.     static void carla_lv2_program_changed(const LV2_Programs_Handle handle, const int32_t index)

  3481.     {

  3482.         qDebug("Lv2Plugin::carla_lv2_program_changed(%p, %i)", handle, index);

  3483.         CARLA_ASSERT(handle);

  3484. 

  3485.         if (! handle)

  3486.             return;

  3487. 

  3488.         Lv2Plugin* const plugin = (Lv2Plugin*)handle;

  3489.         plugin->handleProgramChanged(index);

  3490.     }

  3491. 

  3492.     // ----------------- State Feature ---------------------------------------------------

  3493. 

  3494.     static char* carla_lv2_state_make_path(const LV2_State_Make_Path_Handle handle, const char* const path)

  3495.     {

  3496.         qDebug("Lv2Plugin::carla_lv2_state_make_path(%p, \"%s\")", handle, path);

  3497.         CARLA_ASSERT(handle);

  3498.         CARLA_ASSERT(path);

  3499. 

  3500.         if (! path)

  3501.             return nullptr;

  3502. 

  3503.         QDir dir;

  3504.         dir.mkpath(path);

  3505.         return strdup(path);

  3506.     }

  3507. 

  3508.     static char* carla_lv2_state_map_abstract_path(const LV2_State_Map_Path_Handle handle, const char* const absolute_path)

  3509.     {

  3510.         qDebug("Lv2Plugin::carla_lv2_state_map_abstract_path(%p, \"%s\")", handle, absolute_path);

  3511.         CARLA_ASSERT(handle);

  3512.         CARLA_ASSERT(absolute_path);

  3513. 

  3514.         if (! absolute_path)

  3515.             return nullptr;

  3516. 

  3517.         QDir dir(absolute_path);

  3518.         return strdup(dir.canonicalPath().toUtf8().constData());

  3519.     }

  3520. 

  3521.     static char* carla_lv2_state_map_absolute_path(const LV2_State_Map_Path_Handle handle, const char* const abstract_path)

  3522.     {

  3523.         qDebug("Lv2Plugin::carla_lv2_state_map_absolute_path(%p, \"%s\")", handle, abstract_path);

  3524.         CARLA_ASSERT(handle);

  3525.         CARLA_ASSERT(abstract_path);

  3526. 

  3527.         if (! abstract_path)

  3528.             return nullptr;

  3529. 

  3530.         QDir dir(abstract_path);

  3531.         return strdup(dir.absolutePath().toUtf8().constData());

  3532.     }

  3533. 

  3534.     static LV2_State_Status carla_lv2_state_store(const LV2_State_Handle handle, const uint32_t key, const void* const value, const size_t size, const uint32_t type, const uint32_t flags)

  3535.     {

  3536.         qDebug("Lv2Plugin::carla_lv2_state_store(%p, %i, %p, " P_SIZE ", %i, %i)", handle, key, value, size, type, flags);

  3537.         CARLA_ASSERT(handle);

  3538. 

  3539.         if (! handle)

  3540.             return LV2_STATE_ERR_UNKNOWN;

  3541. 

  3542.         Lv2Plugin* const plugin = (Lv2Plugin*)handle;

  3543.         return plugin->handleStateStore(key, value, size, type, flags);

  3544.     }

  3545. 

  3546.     static const void* carla_lv2_state_retrieve(const LV2_State_Handle handle, const uint32_t key, size_t* const size, uint32_t* const type, uint32_t* const flags)

  3547.     {

  3548.         qDebug("Lv2Plugin::carla_lv2_state_retrieve(%p, %i, %p, %p, %p)", handle, key, size, type, flags);

  3549.         CARLA_ASSERT(handle);

  3550. 

  3551.         if (! handle)

  3552.             return nullptr;

  3553. 

  3554.         Lv2Plugin* const plugin = (Lv2Plugin*)handle;

  3555.         return plugin->handleStateRetrieve(key, size, type, flags);

  3556.     }

  3557. 

  3558.     // ----------------- URI-Map Feature -------------------------------------------------

  3559. 

  3560.     static uint32_t carla_lv2_uri_to_id(const LV2_URI_Map_Callback_Data data, const char* const map, const char* const uri)

  3561.     {

  3562.         qDebug("Lv2Plugin::carla_lv2_uri_to_id(%p, \"%s\", \"%s\")", data, map, uri);

  3563.         return carla_lv2_urid_map((LV2_URID_Map_Handle*)data, uri);

  3564.     }

  3565. 

  3566.     // ----------------- URID Feature ----------------------------------------------------

  3567. 

  3568.     static LV2_URID carla_lv2_urid_map(const LV2_URID_Map_Handle handle, const char* const uri)

  3569.     {

  3570.         qDebug("Lv2Plugin::carla_lv2_urid_map(%p, \"%s\")", handle, uri);

  3571.         CARLA_ASSERT(handle);

  3572.         CARLA_ASSERT(uri);

  3573. 

  3574.         if (! uri)

  3575.             return CARLA_URI_MAP_ID_NULL;

  3576. 

  3577.         // Atom types

  3578.         if (strcmp(uri, LV2_ATOM__Chunk) == 0)

  3579.             return CARLA_URI_MAP_ID_ATOM_CHUNK;

  3580.         if (strcmp(uri, LV2_ATOM__Double) == 0)

  3581.             return CARLA_URI_MAP_ID_ATOM_DOUBLE;

  3582.         if (strcmp(uri, LV2_ATOM__Int) == 0)

  3583.             return CARLA_URI_MAP_ID_ATOM_INT;

  3584.         if (strcmp(uri, LV2_ATOM__Path) == 0)

  3585.             return CARLA_URI_MAP_ID_ATOM_PATH;

  3586.         if (strcmp(uri, LV2_ATOM__Sequence) == 0)

  3587.             return CARLA_URI_MAP_ID_ATOM_SEQUENCE;

  3588.         if (strcmp(uri, LV2_ATOM__String) == 0)

  3589.             return CARLA_URI_MAP_ID_ATOM_STRING;

  3590.         if (strcmp(uri, LV2_ATOM__atomTransfer) == 0)

  3591.             return CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM;

  3592.         if (strcmp(uri, LV2_ATOM__eventTransfer) == 0)

  3593.             return CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT;

  3594. 

  3595.         // BufSize types

  3596.         if (strcmp(uri, LV2_BUF_SIZE__maxBlockLength) == 0)

  3597.             return CARLA_URI_MAP_ID_BUF_MAX_LENGTH;

  3598.         if (strcmp(uri, LV2_BUF_SIZE__minBlockLength) == 0)

  3599.             return CARLA_URI_MAP_ID_BUF_MIN_LENGTH;

  3600.         if (strcmp(uri, LV2_BUF_SIZE__sequenceSize) == 0)

  3601.             return CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE;

  3602. 

  3603.         // Log types

  3604.         if (strcmp(uri, LV2_LOG__Error) == 0)

  3605.             return CARLA_URI_MAP_ID_LOG_ERROR;

  3606.         if (strcmp(uri, LV2_LOG__Note) == 0)

  3607.             return CARLA_URI_MAP_ID_LOG_NOTE;

  3608.         if (strcmp(uri, LV2_LOG__Trace) == 0)

  3609.             return CARLA_URI_MAP_ID_LOG_TRACE;

  3610.         if (strcmp(uri, LV2_LOG__Warning) == 0)

  3611.             return CARLA_URI_MAP_ID_LOG_WARNING;

  3612. 

  3613.         // Others

  3614.         if (strcmp(uri, LV2_MIDI__MidiEvent) == 0)

  3615.             return CARLA_URI_MAP_ID_MIDI_EVENT;

  3616.         if (strcmp(uri, LV2_PARAMETERS__sampleRate) == 0)

  3617.             return CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE;

  3618. 

  3619.         if (! handle)

  3620.             return CARLA_URI_MAP_ID_NULL;

  3621. 

  3622.         // Custom types

  3623.         Lv2Plugin* const plugin = (Lv2Plugin*)handle;

  3624.         return plugin->getCustomURID(uri);

  3625.     }

  3626. 

  3627.     static const char* carla_lv2_urid_unmap(const LV2_URID_Map_Handle handle, const LV2_URID urid)

  3628.     {

  3629.         qDebug("Lv2Plugin::carla_lv2_urid_unmap(%p, %i)", handle, urid);

  3630.         CARLA_ASSERT(handle);

  3631.         CARLA_ASSERT(urid > CARLA_URI_MAP_ID_NULL);

  3632. 

  3633.         if (urid == CARLA_URI_MAP_ID_NULL)

  3634.             return nullptr;

  3635. 

  3636.         // Atom types

  3637.         if (urid == CARLA_URI_MAP_ID_ATOM_CHUNK)

  3638.             return LV2_ATOM__Chunk;

  3639.         if (urid == CARLA_URI_MAP_ID_ATOM_DOUBLE)

  3640.             return LV2_ATOM__Double;

  3641.         if (urid == CARLA_URI_MAP_ID_ATOM_INT)

  3642.             return LV2_ATOM__Int;

  3643.         if (urid == CARLA_URI_MAP_ID_ATOM_PATH)

  3644.             return LV2_ATOM__Path;

  3645.         if (urid == CARLA_URI_MAP_ID_ATOM_SEQUENCE)

  3646.             return LV2_ATOM__Sequence;

  3647.         if (urid == CARLA_URI_MAP_ID_ATOM_STRING)

  3648.             return LV2_ATOM__String;

  3649.         if (urid == CARLA_URI_MAP_ID_ATOM_WORKER)

  3650.             return nullptr; // not a valid URID, only used internally

  3651.         if (urid == CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM)

  3652.             return LV2_ATOM__atomTransfer;

  3653.         if (urid == CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT)

  3654.             return LV2_ATOM__eventTransfer;

  3655. 

  3656.         // BufSize types

  3657.         if (urid == CARLA_URI_MAP_ID_BUF_MAX_LENGTH)

  3658.             return LV2_BUF_SIZE__maxBlockLength;

  3659.         if (urid == CARLA_URI_MAP_ID_BUF_MIN_LENGTH)

  3660.             return LV2_BUF_SIZE__minBlockLength;

  3661.         if (urid == CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE)

  3662.             return LV2_BUF_SIZE__sequenceSize;

  3663. 

  3664.         // Log types

  3665.         if (urid == CARLA_URI_MAP_ID_LOG_ERROR)

  3666.             return LV2_LOG__Error;

  3667.         if (urid == CARLA_URI_MAP_ID_LOG_NOTE)

  3668.             return LV2_LOG__Note;

  3669.         if (urid == CARLA_URI_MAP_ID_LOG_TRACE)

  3670.             return LV2_LOG__Trace;

  3671.         if (urid == CARLA_URI_MAP_ID_LOG_WARNING)

  3672.             return LV2_LOG__Warning;

  3673. 

  3674.         // Others

  3675.         if (urid == CARLA_URI_MAP_ID_MIDI_EVENT)

  3676.             return LV2_MIDI__MidiEvent;

  3677.         if (urid == CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE)

  3678.             return LV2_PARAMETERS__sampleRate;

  3679. 

  3680.         if (! handle)

  3681.             return nullptr;

  3682. 

  3683.         // Custom types

  3684.         Lv2Plugin* const plugin = (Lv2Plugin*)handle;

  3685.         return plugin->getCustomURIString(urid);

  3686.     }

  3687. 

  3688.     // ----------------- Worker Feature --------------------------------------------------

  3689. 

  3690.     static LV2_Worker_Status carla_lv2_worker_schedule(const LV2_Worker_Schedule_Handle handle, const uint32_t size, const void* const data)

  3691.     {

  3692.         qDebug("Lv2Plugin::carla_lv2_worker_schedule(%p, %i, %p)", handle, size, data);

  3693.         CARLA_ASSERT(handle);

  3694. 

  3695.         if (! handle)

  3696.             return LV2_WORKER_ERR_UNKNOWN;

  3697. 

  3698.         Lv2Plugin* const plugin = (Lv2Plugin*)handle;

  3699.         return plugin->handleWorkerSchedule(size, data);

  3700.     }

  3701. 

  3702.     static LV2_Worker_Status carla_lv2_worker_respond(const LV2_Worker_Respond_Handle handle, const uint32_t size, const void* const data)

  3703.     {

  3704.         qDebug("Lv2Plugin::carla_lv2_worker_respond(%p, %i, %p)", handle, size, data);

  3705.         CARLA_ASSERT(handle);

  3706. 

  3707.         if (! handle)

  3708.             return LV2_WORKER_ERR_UNKNOWN;

  3709. 

  3710.         Lv2Plugin* const plugin = (Lv2Plugin*)handle;

  3711.         return plugin->handleWorkerRespond(size, data);

  3712.     }

  3713. 

  3714.     // ----------------- UI Port-Map Feature ---------------------------------------------

  3715. 

  3716.     static uint32_t carla_lv2_ui_port_map(const LV2UI_Feature_Handle handle, const char* const symbol)

  3717.     {

  3718.         qDebug("Lv2Plugin::carla_lv2_ui_port_map(%p, \"%s\")", handle, symbol);

  3719.         CARLA_ASSERT(handle);

  3720. 

  3721.         if (! handle)

  3722.             return LV2UI_INVALID_PORT_INDEX;

  3723. 

  3724.         Lv2Plugin* const plugin = (Lv2Plugin*)handle;

  3725.         return plugin->handleUiPortMap(symbol);

  3726.     }

  3727. 

  3728.     // ----------------- UI Resize Feature -----------------------------------------------

  3729. 

  3730.     static int carla_lv2_ui_resize(const LV2UI_Feature_Handle handle, const int width, const int height)

  3731.     {

  3732.         qDebug("Lv2Plugin::carla_lv2_ui_resize(%p, %i, %i)", handle, width, height);

  3733.         CARLA_ASSERT(handle);

  3734. 

  3735.         if (! handle)

  3736.             return 1;

  3737. 

  3738.         Lv2Plugin* const plugin = (Lv2Plugin*)handle;

  3739.         return plugin->handleUiResize(width, height);

  3740.     }

  3741. 

  3742.     // ----------------- External UI Feature ---------------------------------------------

  3743. 

  3744.     static void carla_lv2_external_ui_closed(const LV2UI_Controller controller)

  3745.     {

  3746.         qDebug("Lv2Plugin::carla_lv2_external_ui_closed(%p)", controller);

  3747.         CARLA_ASSERT(controller);

  3748. 

  3749.         if (! controller)

  3750.             return;

  3751. 

  3752.         Lv2Plugin* const plugin = (Lv2Plugin*)controller;

  3753.         plugin->handleExternalUiClosed();

  3754.     }

  3755. 

  3756.     // ----------------- UI Extension ----------------------------------------------------

  3757. 

  3758.     static void carla_lv2_ui_write_function(const LV2UI_Controller controller, const uint32_t port_index, const uint32_t buffer_size, const uint32_t format, const void* const buffer)

  3759.     {

  3760.         qDebug("Lv2Plugin::carla_lv2_ui_write_function(%p, %i, %i, %i, %p)", controller, port_index, buffer_size, format, buffer);

  3761.         CARLA_ASSERT(controller);

  3762. 

  3763.         if (! controller)

  3764.             return;

  3765. 

  3766.         Lv2Plugin* const plugin = (Lv2Plugin*)controller;

  3767.         plugin->handleUiWrite(port_index, buffer_size, format, buffer);

  3768.     }

  3769. 

  3770.     // -------------------------------------------------------------------

  3771. 

  3772.     bool uiLibOpen(const char* const filename)

  3773.     {

  3774.         ui.lib = lib_open(filename);

  3775.         return bool(ui.lib);

  3776.     }

  3777. 

  3778.     bool uiLibClose()

  3779.     {

  3780.         if (ui.lib)

  3781.             return lib_close(ui.lib);

  3782.         return false;

  3783.     }

  3784. 

  3785.     void* uiLibSymbol(const char* const symbol)

  3786.     {

  3787.         if (ui.lib)

  3788.             return lib_symbol(ui.lib, symbol);

  3789.         return nullptr;

  3790.     }

  3791. 

  3792.     // -------------------------------------------------------------------

  3793. 

  3794.     bool init(const char* const bundle, const char* const name, const char* const URI)

  3795.     {

  3796.         // ---------------------------------------------------------------

  3797.         // get plugin from lv2_rdf (lilv)

  3798. 

  3799.         rdf_descriptor = lv2_rdf_new(URI);

  3800. 

  3801.         if (! rdf_descriptor)

  3802.         {

  3803.             setLastError("Failed to find the requested plugin in the LV2 Bundle");

  3804.             return false;

  3805.         }

  3806. 

  3807.         // ---------------------------------------------------------------

  3808.         // open DLL

  3809. 

  3810.         if (! libOpen(rdf_descriptor->Binary))

  3811.         {

  3812.             setLastError(libError(rdf_descriptor->Binary));

  3813.             return false;

  3814.         }

  3815. 

  3816.         // ---------------------------------------------------------------

  3817.         // get DLL main entry

  3818. 

  3819.         const LV2_Descriptor_Function descFn = (LV2_Descriptor_Function)libSymbol("lv2_descriptor");

  3820. 

  3821.         if (! descFn)

  3822.         {

  3823.             setLastError("Could not find the LV2 Descriptor in the plugin library");

  3824.             return false;

  3825.         }

  3826. 

  3827.         // ---------------------------------------------------------------

  3828.         // get descriptor that matches URI

  3829. 

  3830.         uint32_t i = 0;

  3831.         while ((descriptor = descFn(i++)))

  3832.         {

  3833.             if (strcmp(descriptor->URI, URI) == 0)

  3834.                 break;

  3835.         }

  3836. 

  3837.         if (! descriptor)

  3838.         {

  3839.             setLastError("Could not find the requested plugin URI in the plugin library");

  3840.             return false;

  3841.         }

  3842. 

  3843.         // ---------------------------------------------------------------

  3844.         // check supported port-types and features

  3845. 

  3846.         bool canContinue = true;

  3847. 

  3848.         // Check supported ports

  3849.         for (i=0; i < rdf_descriptor->PortCount; i++)

  3850.         {

  3851.             LV2_Property PortType = rdf_descriptor->Ports[i].Type;

  3852.             if (! bool(LV2_IS_PORT_AUDIO(PortType) || LV2_IS_PORT_CONTROL(PortType) || LV2_IS_PORT_ATOM_SEQUENCE(PortType) || LV2_IS_PORT_EVENT(PortType) || LV2_IS_PORT_MIDI_LL(PortType)))

  3853.             {

  3854.                 if (! LV2_IS_PORT_OPTIONAL(rdf_descriptor->Ports[i].Properties))

  3855.                 {

  3856.                     setLastError("Plugin requires a port that is not currently supported");

  3857.                     canContinue = false;

  3858.                     break;

  3859.                 }

  3860.             }

  3861.         }

  3862. 

  3863.         // Check supported features

  3864.         for (i=0; i < rdf_descriptor->FeatureCount && canContinue; i++)

  3865.         {

  3866.             if (LV2_IS_FEATURE_REQUIRED(rdf_descriptor->Features[i].Type) && ! is_lv2_feature_supported(rdf_descriptor->Features[i].URI))

  3867.             {

  3868.                 QString msg = QString("Plugin requires a feature that is not supported:\n%1").arg(rdf_descriptor->Features[i].URI);

  3869.                 setLastError(msg.toUtf8().constData());

  3870.                 canContinue = false;

  3871.                 break;

  3872.             }

  3873.         }

  3874. 

  3875.         // Check extensions

  3876.         for (i=0; i < rdf_descriptor->ExtensionCount; i++)

  3877.         {

  3878.             if (strcmp(rdf_descriptor->Extensions[i], LV2_PROGRAMS__Interface) == 0)

  3879.                 m_hints |= PLUGIN_HAS_EXTENSION_PROGRAMS;

  3880.             else if (strcmp(rdf_descriptor->Extensions[i], LV2_STATE__interface) == 0)

  3881.                 m_hints |= PLUGIN_HAS_EXTENSION_STATE;

  3882.             else if (strcmp(rdf_descriptor->Extensions[i], LV2_WORKER__interface) == 0)

  3883.                 m_hints |= PLUGIN_HAS_EXTENSION_WORKER;

  3884.             else

  3885.                 qDebug("Plugin has non-supported extension: '%s'", rdf_descriptor->Extensions[i]);

  3886.         }

  3887. 

  3888.         if (! canContinue)

  3889.         {

  3890.             // error already set

  3891.             return false;

  3892.         }

  3893. 

  3894.         // ---------------------------------------------------------------

  3895.         // initialize features

  3896. 

  3897.         LV2_Event_Feature* const eventFt = new LV2_Event_Feature;

  3898.         eventFt->callback_data           = this;

  3899.         eventFt->lv2_event_ref           = carla_lv2_event_ref;

  3900.         eventFt->lv2_event_unref         = carla_lv2_event_unref;

  3901. 

  3902.         LV2_Log_Log* const logFt         = new LV2_Log_Log;

  3903.         logFt->handle                    = this;

  3904.         logFt->printf                    = carla_lv2_log_printf;

  3905.         logFt->vprintf                   = carla_lv2_log_vprintf;

  3906. 

  3907.         LV2_Programs_Host* const programsFt        = new LV2_Programs_Host;

  3908.         programsFt->handle                         = this;

  3909.         programsFt->program_changed                = carla_lv2_program_changed;

  3910. 

  3911.         LV2_RtMemPool_Pool* const rtMemPoolFt      = new LV2_RtMemPool_Pool;

  3912.         rtmempool_allocator_init(rtMemPoolFt);

  3913. 

  3914.         LV2_State_Make_Path* const stateMakePathFt = new LV2_State_Make_Path;

  3915.         stateMakePathFt->handle                    = this;

  3916.         stateMakePathFt->path                      = carla_lv2_state_make_path;

  3917. 

  3918.         LV2_State_Map_Path* const stateMapPathFt   = new LV2_State_Map_Path;

  3919.         stateMapPathFt->handle                     = this;

  3920.         stateMapPathFt->abstract_path              = carla_lv2_state_map_abstract_path;

  3921.         stateMapPathFt->absolute_path              = carla_lv2_state_map_absolute_path;

  3922. 

  3923.         LV2_URI_Map_Feature* const uriMapFt = new LV2_URI_Map_Feature;

  3924.         uriMapFt->callback_data             = this;

  3925.         uriMapFt->uri_to_id                 = carla_lv2_uri_to_id;

  3926. 

  3927.         LV2_URID_Map* const uridMapFt       = new LV2_URID_Map;

  3928.         uridMapFt->handle                   = this;

  3929.         uridMapFt->map                      = carla_lv2_urid_map;

  3930. 

  3931.         LV2_URID_Unmap* const uridUnmapFt   = new LV2_URID_Unmap;

  3932.         uridUnmapFt->handle                 = this;

  3933.         uridUnmapFt->unmap                  = carla_lv2_urid_unmap;

  3934. 

  3935.         LV2_Worker_Schedule* const workerFt = new LV2_Worker_Schedule;

  3936.         workerFt->handle                    = this;

  3937.         workerFt->schedule_work             = carla_lv2_worker_schedule;

  3938. 

  3939.         LV2_Options_Option* const optionsFt = new LV2_Options_Option [5];

  3940.         optionsFt[0] = lv2Options.oMaxBlockLenth;

  3941.         optionsFt[1] = lv2Options.oMinBlockLenth;

  3942.         optionsFt[2] = lv2Options.oSequenceSize;

  3943.         optionsFt[3] = lv2Options.oSampleRate;

  3944.         optionsFt[4] = lv2Options.oNull;

  3945. 

  3946.         features[lv2_feature_id_bufsize_bounded]       = new LV2_Feature;

  3947.         features[lv2_feature_id_bufsize_bounded]->URI  = LV2_BUF_SIZE__boundedBlockLength;

  3948.         features[lv2_feature_id_bufsize_bounded]->data = nullptr;

  3949. 

  3950. #ifndef BUILD_BRIDGE

  3951.         if (carlaOptions.processHighPrecision)

  3952.         {

  3953.             features[lv2_feature_id_bufsize_fixed]          = new LV2_Feature;

  3954.             features[lv2_feature_id_bufsize_fixed]->URI     = LV2_BUF_SIZE__fixedBlockLength;

  3955.             features[lv2_feature_id_bufsize_fixed]->data    = nullptr;

  3956. 

  3957.             features[lv2_feature_id_bufsize_powerof2]       = new LV2_Feature;

  3958.             features[lv2_feature_id_bufsize_powerof2]->URI  = LV2_BUF_SIZE__powerOf2BlockLength;

  3959.             features[lv2_feature_id_bufsize_powerof2]->data = nullptr;

  3960.         }

  3961.         else

  3962. #endif

  3963.         {

  3964.             // fake, used to keep a valid array

  3965.             features[lv2_feature_id_bufsize_fixed]    = features[lv2_feature_id_bufsize_bounded];

  3966.             features[lv2_feature_id_bufsize_powerof2] = features[lv2_feature_id_bufsize_bounded];

  3967.         }

  3968. 

  3969.         features[lv2_feature_id_event]          = new LV2_Feature;

  3970.         features[lv2_feature_id_event]->URI     = LV2_EVENT_URI;

  3971.         features[lv2_feature_id_event]->data    = eventFt;

  3972. 

  3973.         features[lv2_feature_id_logs]           = new LV2_Feature;

  3974.         features[lv2_feature_id_logs]->URI      = LV2_LOG__log;

  3975.         features[lv2_feature_id_logs]->data     = logFt;

  3976. 

  3977.         features[lv2_feature_id_options]        = new LV2_Feature;

  3978.         features[lv2_feature_id_options]->URI   = LV2_OPTIONS__options;

  3979.         features[lv2_feature_id_options]->data  = optionsFt;

  3980. 

  3981.         features[lv2_feature_id_programs]       = new LV2_Feature;

  3982.         features[lv2_feature_id_programs]->URI  = LV2_PROGRAMS__Host;

  3983.         features[lv2_feature_id_programs]->data = programsFt;

  3984. 

  3985.         features[lv2_feature_id_rtmempool]       = new LV2_Feature;

  3986.         features[lv2_feature_id_rtmempool]->URI  = LV2_RTSAFE_MEMORY_POOL__Pool;

  3987.         features[lv2_feature_id_rtmempool]->data = rtMemPoolFt;

  3988. 

  3989.         features[lv2_feature_id_state_make_path]       = new LV2_Feature;

  3990.         features[lv2_feature_id_state_make_path]->URI  = LV2_STATE__makePath;

  3991.         features[lv2_feature_id_state_make_path]->data = stateMakePathFt;

  3992. 

  3993.         features[lv2_feature_id_state_map_path]        = new LV2_Feature;

  3994.         features[lv2_feature_id_state_map_path]->URI   = LV2_STATE__mapPath;

  3995.         features[lv2_feature_id_state_map_path]->data  = stateMapPathFt;

  3996. 

  3997.         features[lv2_feature_id_strict_bounds]         = new LV2_Feature;

  3998.         features[lv2_feature_id_strict_bounds]->URI    = LV2_PORT_PROPS__supportsStrictBounds;

  3999.         features[lv2_feature_id_strict_bounds]->data   = nullptr;

  4000. 

  4001.         features[lv2_feature_id_uri_map]          = new LV2_Feature;

  4002.         features[lv2_feature_id_uri_map]->URI     = LV2_URI_MAP_URI;

  4003.         features[lv2_feature_id_uri_map]->data    = uriMapFt;

  4004. 

  4005.         features[lv2_feature_id_urid_map]         = new LV2_Feature;

  4006.         features[lv2_feature_id_urid_map]->URI    = LV2_URID__map;

  4007.         features[lv2_feature_id_urid_map]->data   = uridMapFt;

  4008. 

  4009.         features[lv2_feature_id_urid_unmap]       = new LV2_Feature;

  4010.         features[lv2_feature_id_urid_unmap]->URI  = LV2_URID__unmap;

  4011.         features[lv2_feature_id_urid_unmap]->data = uridUnmapFt;

  4012. 

  4013.         features[lv2_feature_id_worker]           = new LV2_Feature;

  4014.         features[lv2_feature_id_worker]->URI      = LV2_WORKER__schedule;

  4015.         features[lv2_feature_id_worker]->data     = workerFt;

  4016. 

  4017.         // ---------------------------------------------------------------

  4018.         // initialize plugin

  4019. 

  4020.         handle = descriptor->instantiate(descriptor, x_engine->getSampleRate(), rdf_descriptor->Bundle, features);

  4021. 

  4022.         if (! handle)

  4023.         {

  4024.             setLastError("Plugin failed to initialize");

  4025.             return false;

  4026.         }

  4027. 

  4028.         // ---------------------------------------------------------------

  4029.         // get info

  4030. 

  4031.         m_filename = strdup(bundle);

  4032. 

  4033.         if (name)

  4034.             m_name = x_engine->getUniqueName(name);

  4035.         else

  4036.             m_name = x_engine->getUniqueName(rdf_descriptor->Name);

  4037. 

  4038.         // ---------------------------------------------------------------

  4039.         // register client

  4040. 

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

  4042. 

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

  4044.         {

  4045.             setLastError("Failed to register plugin client");

  4046.             return false;

  4047.         }

  4048. 

  4049.         // ---------------------------------------------------------------

  4050.         // gui stuff

  4051. 

  4052.         if (rdf_descriptor->UICount == 0)

  4053.             return true;

  4054. 

  4055.         // -----------------------------------------------------------

  4056.         // find more appropriate ui

  4057. 

  4058.         int eQt4, eCocoa, eHWND, eX11, eGtk2, eGtk3, iCocoa, iHWND, iX11, iQt4, iExt, iSuil, iFinal;

  4059.         eQt4 = eCocoa = eHWND = eX11 = eGtk2 = eGtk3 = iQt4 = iCocoa = iHWND = iX11 = iExt = iSuil = iFinal = -1;

  4060. 

  4061.         for (i=0; i < rdf_descriptor->UICount; i++)

  4062.         {

  4063.             switch (rdf_descriptor->UIs[i].Type)

  4064.             {

  4065.             case LV2_UI_QT4:

  4066. #ifndef BUILD_BRIDGE

  4067.                 if (isUiBridgeable(i) && carlaOptions.preferUiBridges)

  4068.                     eQt4 = i;

  4069. #endif

  4070.                 iQt4 = i;

  4071.                 break;

  4072. 

  4073.             case LV2_UI_COCOA:

  4074. #ifndef BUILD_BRIDGE

  4075.                 if (isUiBridgeable(i) && carlaOptions.preferUiBridges)

  4076.                     eCocoa = i;

  4077. #endif

  4078.                 iCocoa = i;

  4079.                 break;

  4080. 

  4081.             case LV2_UI_WINDOWS:

  4082. #ifndef BUILD_BRIDGE

  4083.                 if (isUiBridgeable(i) && carlaOptions.preferUiBridges)

  4084.                     eHWND = i;

  4085. #endif

  4086.                 iHWND = i;

  4087.                 break;

  4088. 

  4089.             case LV2_UI_X11:

  4090. #ifndef BUILD_BRIDGE

  4091.                 if (isUiBridgeable(i) && carlaOptions.preferUiBridges)

  4092.                     eX11 = i;

  4093. #endif

  4094.                 iX11 = i;

  4095.                 break;

  4096. 

  4097.             case LV2_UI_GTK2:

  4098. #ifdef BUILD_BRIDGE

  4099.                 if (false)

  4100. #else

  4101. #  ifdef HAVE_SUIL

  4102.                 if (isUiBridgeable(i) && carlaOptions.preferUiBridges)

  4103. #  else

  4104.                 if (isUiBridgeable(i))

  4105. #  endif

  4106. #endif

  4107.                     eGtk2 = i;

  4108. #ifdef HAVE_SUIL

  4109.                 iSuil = i;

  4110. #endif

  4111.                 break;

  4112. 

  4113. #ifndef BUILD_BRIDGE

  4114.             case LV2_UI_GTK3:

  4115.                 if (isUiBridgeable(i))

  4116.                     eGtk3 = i;

  4117.                 break;

  4118. #endif

  4119. 

  4120.             case LV2_UI_EXTERNAL:

  4121.             case LV2_UI_OLD_EXTERNAL:

  4122.                 iExt = i;

  4123.                 break;

  4124. 

  4125.             default:

  4126.                 break;

  4127.             }

  4128.         }

  4129. 

  4130.         if (eQt4 >= 0)

  4131.             iFinal = eQt4;

  4132.         else if (eCocoa >= 0)

  4133.             iFinal = eCocoa;

  4134.         else if (eHWND >= 0)

  4135.             iFinal = eHWND;

  4136.         else if (eX11 >= 0)

  4137.             iFinal = eX11;

  4138.         else if (eGtk2 >= 0)

  4139.             iFinal = eGtk2;

  4140.         else if (eGtk3 >= 0)

  4141.             iFinal = eGtk3;

  4142.         else if (iQt4 >= 0)

  4143.             iFinal = iQt4;

  4144.         else if (iCocoa >= 0)

  4145.             iFinal = iCocoa;

  4146.         else if (iHWND >= 0)

  4147.             iFinal = iHWND;

  4148.         else if (iX11 >= 0)

  4149.             iFinal = iX11;

  4150.         else if (iExt >= 0)

  4151.             iFinal = iExt;

  4152.         else if (iSuil >= 0)

  4153.             iFinal = iSuil;

  4154. 

  4155. #ifndef BUILD_BRIDGE

  4156.         const bool isBridged = (iFinal == eQt4 || iFinal == eCocoa || iFinal == eHWND || iFinal == eX11 || iFinal == eGtk2 || iFinal == eGtk3);

  4157. #endif

  4158. #ifdef HAVE_SUIL

  4159.         const bool isSuil = (iFinal == iSuil && !isBridged);

  4160. #endif

  4161. 

  4162.         if (iFinal < 0)

  4163.         {

  4164.             qWarning("Failed to find an appropriate LV2 UI for this plugin");

  4165.             return true;

  4166.         }

  4167. 

  4168.         ui.rdf_descriptor = &rdf_descriptor->UIs[iFinal];

  4169. 

  4170.         // -----------------------------------------------------------

  4171.         // check supported ui features

  4172. 

  4173.         canContinue = true;

  4174. 

  4175.         for (i=0; i < ui.rdf_descriptor->FeatureCount; i++)

  4176.         {

  4177.             if (LV2_IS_FEATURE_REQUIRED(ui.rdf_descriptor->Features[i].Type) && is_lv2_ui_feature_supported(ui.rdf_descriptor->Features[i].URI) == false)

  4178.             {

  4179.                 qCritical("Plugin UI requires a feature that is not supported:\n%s", ui.rdf_descriptor->Features[i].URI);

  4180.                 canContinue = false;

  4181.                 break;

  4182.             }

  4183.         }

  4184. 

  4185.         if (! canContinue)

  4186.         {

  4187.             ui.rdf_descriptor = nullptr;

  4188.             return true;

  4189.         }

  4190. 

  4191. #ifdef HAVE_SUIL

  4192.         if (isSuil)

  4193.         {

  4194.             // -------------------------------------------------------

  4195.             // init suil host

  4196. 

  4197.             suil.host = suil_host_new(carla_lv2_ui_write_function, carla_lv2_ui_port_map, nullptr, nullptr);

  4198.         }

  4199.         else

  4200. #endif

  4201.         {

  4202.             // -------------------------------------------------------

  4203.             // open DLL

  4204. 

  4205.             if (! uiLibOpen(ui.rdf_descriptor->Binary))

  4206.             {

  4207.                 qCritical("Could not load UI library, error was:\n%s", libError(ui.rdf_descriptor->Binary));

  4208.                 ui.rdf_descriptor = nullptr;

  4209.                 return true;

  4210.             }

  4211. 

  4212.             // -------------------------------------------------------

  4213.             // get DLL main entry

  4214. 

  4215.             LV2UI_DescriptorFunction ui_descFn = (LV2UI_DescriptorFunction)uiLibSymbol("lv2ui_descriptor");

  4216. 

  4217.             if (! ui_descFn)

  4218.             {

  4219.                 qCritical("Could not find the LV2UI Descriptor in the UI library");

  4220.                 uiLibClose();

  4221.                 ui.lib = nullptr;

  4222.                 ui.rdf_descriptor = nullptr;

  4223.                 return true;

  4224.             }

  4225. 

  4226.             // -------------------------------------------------------

  4227.             // get descriptor that matches URI

  4228. 

  4229.             i = 0;

  4230.             while ((ui.descriptor = ui_descFn(i++)))

  4231.             {

  4232.                 if (strcmp(ui.descriptor->URI, ui.rdf_descriptor->URI) == 0)

  4233.                     break;

  4234.             }

  4235. 

  4236.             if (! ui.descriptor)

  4237.             {

  4238.                 qCritical("Could not find the requested GUI in the plugin UI library");

  4239.                 uiLibClose();

  4240.                 ui.lib = nullptr;

  4241.                 ui.rdf_descriptor = nullptr;

  4242.                 return true;

  4243.             }

  4244.         }

  4245. 

  4246.         // -----------------------------------------------------------

  4247.         // initialize ui according to type

  4248. 

  4249.         const LV2_Property uiType = ui.rdf_descriptor->Type;

  4250. 

  4251. #ifndef BUILD_BRIDGE

  4252.         if (isBridged)

  4253.         {

  4254.             // -------------------------------------------------------

  4255.             // initialize ui bridge

  4256. 

  4257.             if (const char* const oscBinary = lv2bridge2str(uiType))

  4258.             {

  4259.                 gui.type = GUI_EXTERNAL_OSC;

  4260.                 osc.thread = new CarlaPluginThread(x_engine, this, CarlaPluginThread::PLUGIN_THREAD_LV2_GUI);

  4261.                 osc.thread->setOscData(oscBinary, descriptor->URI, ui.descriptor->URI);

  4262.             }

  4263.         }

  4264.         else

  4265. #endif

  4266.         {

  4267.             // -------------------------------------------------------

  4268.             // initialize ui features

  4269. 

  4270.             QString guiTitle = QString("%1 (GUI)").arg(m_name);

  4271. 

  4272.             LV2_Extension_Data_Feature* const uiDataFt = new LV2_Extension_Data_Feature;

  4273.             uiDataFt->data_access                      = descriptor->extension_data;

  4274. 

  4275.             LV2UI_Port_Map* const uiPortMapFt = new LV2UI_Port_Map;

  4276.             uiPortMapFt->handle               = this;

  4277.             uiPortMapFt->port_index           = carla_lv2_ui_port_map;

  4278. 

  4279.             LV2UI_Resize* const uiResizeFt    = new LV2UI_Resize;

  4280.             uiResizeFt->handle                = this;

  4281.             uiResizeFt->ui_resize             = carla_lv2_ui_resize;

  4282. 

  4283.             LV2_External_UI_Host* const uiExternalHostFt = new LV2_External_UI_Host;

  4284.             uiExternalHostFt->ui_closed                  = carla_lv2_external_ui_closed;

  4285.             uiExternalHostFt->plugin_human_id            = strdup(guiTitle.toUtf8().constData());

  4286. 

  4287.             features[lv2_feature_id_data_access]           = new LV2_Feature;

  4288.             features[lv2_feature_id_data_access]->URI      = LV2_DATA_ACCESS_URI;

  4289.             features[lv2_feature_id_data_access]->data     = uiDataFt;

  4290. 

  4291.             features[lv2_feature_id_instance_access]       = new LV2_Feature;

  4292.             features[lv2_feature_id_instance_access]->URI  = LV2_INSTANCE_ACCESS_URI;

  4293.             features[lv2_feature_id_instance_access]->data = handle;

  4294. 

  4295.             features[lv2_feature_id_ui_parent]             = new LV2_Feature;

  4296.             features[lv2_feature_id_ui_parent]->URI        = LV2_UI__parent;

  4297.             features[lv2_feature_id_ui_parent]->data       = nullptr;

  4298. 

  4299.             features[lv2_feature_id_ui_port_map]           = new LV2_Feature;

  4300.             features[lv2_feature_id_ui_port_map]->URI      = LV2_UI__portMap;

  4301.             features[lv2_feature_id_ui_port_map]->data     = uiPortMapFt;

  4302. 

  4303.             features[lv2_feature_id_ui_resize]             = new LV2_Feature;

  4304.             features[lv2_feature_id_ui_resize]->URI        = LV2_UI__resize;

  4305.             features[lv2_feature_id_ui_resize]->data       = uiResizeFt;

  4306. 

  4307.             features[lv2_feature_id_external_ui]           = new LV2_Feature;

  4308.             features[lv2_feature_id_external_ui]->URI      = LV2_EXTERNAL_UI__Host;

  4309.             features[lv2_feature_id_external_ui]->data     = uiExternalHostFt;

  4310. 

  4311.             features[lv2_feature_id_external_ui_old]       = new LV2_Feature;

  4312.             features[lv2_feature_id_external_ui_old]->URI  = LV2_EXTERNAL_UI_DEPRECATED_URI;

  4313.             features[lv2_feature_id_external_ui_old]->data = uiExternalHostFt;

  4314. 

  4315.             // -------------------------------------------------------

  4316.             // initialize ui

  4317. 

  4318.             switch (uiType)

  4319.             {

  4320.             case LV2_UI_QT4:

  4321.                 qDebug("Will use LV2 Qt4 UI");

  4322.                 gui.type      = GUI_INTERNAL_QT4;

  4323.                 gui.resizable = isUiResizable();

  4324.                 ui.handle     = ui.descriptor->instantiate(ui.descriptor, descriptor->URI, ui.rdf_descriptor->Bundle, carla_lv2_ui_write_function, this, &ui.widget, features);

  4325.                 m_hints      |= PLUGIN_USES_SINGLE_THREAD;

  4326.                 break;

  4327. 

  4328.             case LV2_UI_COCOA:

  4329.                 qDebug("Will use LV2 Cocoa UI");

  4330.                 gui.type      = GUI_INTERNAL_COCOA;

  4331.                 gui.resizable = isUiResizable();

  4332.                 break;

  4333. 

  4334.             case LV2_UI_WINDOWS:

  4335.                 qDebug("Will use LV2 Windows UI");

  4336.                 gui.type      = GUI_INTERNAL_HWND;

  4337.                 gui.resizable = isUiResizable();

  4338.                 break;

  4339. 

  4340.             case LV2_UI_X11:

  4341.                 qDebug("Will use LV2 X11 UI");

  4342.                 gui.type      = GUI_INTERNAL_X11;

  4343.                 gui.resizable = isUiResizable();

  4344.                 break;

  4345. 

  4346.             case LV2_UI_GTK2:

  4347. #ifdef HAVE_SUIL

  4348.                 qDebug("Will use LV2 Gtk2 UI (suil)");

  4349.                 gui.type      = GUI_EXTERNAL_SUIL;

  4350.                 gui.resizable = isUiResizable();

  4351.                 suil.handle   = suil_instance_new(suil.host, this, LV2_UI__Qt4UI, rdf_descriptor->URI, ui.rdf_descriptor->URI, get_lv2_ui_uri(ui.rdf_descriptor->Type), ui.rdf_descriptor->Bundle, ui.rdf_descriptor->Binary, features);

  4352.                 m_hints      |= PLUGIN_USES_SINGLE_THREAD;

  4353. 

  4354.                 if (suil.handle)

  4355.                 {

  4356.                     ui.handle     = ((SuilInstanceImpl*)suil.handle)->handle;

  4357.                     ui.descriptor = ((SuilInstanceImpl*)suil.handle)->descriptor;

  4358.                     ui.widget     = suil_instance_get_widget(suil.handle);

  4359. 

  4360.                     if (ui.widget)

  4361.                     {

  4362.                         QWidget* const widget = (QWidget*)ui.widget;

  4363.                         widget->setWindowTitle(guiTitle);

  4364.                     }

  4365.                 }

  4366. #else

  4367.                 qDebug("Will use LV2 Gtk2 UI, NOT!");

  4368. #endif

  4369.                 break;

  4370. 

  4371.             case LV2_UI_GTK3:

  4372.                 qDebug("Will use LV2 Gtk3 UI, NOT!");

  4373.                 break;

  4374. 

  4375.             case LV2_UI_EXTERNAL:

  4376.             case LV2_UI_OLD_EXTERNAL:

  4377.                 qDebug("Will use LV2 External UI");

  4378.                 gui.type = GUI_EXTERNAL_LV2;

  4379.                 break;

  4380.             }

  4381.         }

  4382. 

  4383.         if (gui.type != GUI_NONE)

  4384.             m_hints |= PLUGIN_HAS_GUI;

  4385. 

  4386.         return true;

  4387.     }

  4388. 

  4389. private:

  4390.     LV2_Handle handle, h2;

  4391.     const LV2_Descriptor* descriptor;

  4392.     const LV2_RDF_Descriptor* rdf_descriptor;

  4393.     LV2_Feature* features[lv2_feature_count+1];

  4394. 

  4395.     struct {

  4396.         const LV2_State_Interface* state;

  4397.         const LV2_Worker_Interface* worker;

  4398.         const LV2_Programs_Interface* programs;

  4399.         const LV2_Programs_UI_Interface* uiprograms;

  4400.     } ext;

  4401. 

  4402.     struct {

  4403.         void* lib;

  4404.         LV2UI_Handle handle;

  4405.         LV2UI_Widget widget;

  4406.         const LV2UI_Descriptor* descriptor;

  4407.         const LV2_RDF_UI* rdf_descriptor;

  4408.     } ui;

  4409. 

  4410.     struct {

  4411.         GuiType type;

  4412.         bool resizable;

  4413.         int width;

  4414.         int height;

  4415.     } gui;

  4416. 

  4417. #ifdef HAVE_SUIL

  4418.     struct {

  4419.         SuilHost* host;

  4420.         SuilInstance* handle;

  4421.         QByteArray pos;

  4422.     } suil;

  4423. #endif

  4424. 

  4425.     Lv2AtomQueue atomQueueIn;

  4426.     Lv2AtomQueue atomQueueOut;

  4427.     Lv2PluginEventData evIn;

  4428.     Lv2PluginEventData evOut;

  4429.     float* paramBuffers;

  4430.     std::vector<const char*> customURIDs;

  4431. 

  4432.     bool     lastTimePosPlaying;

  4433.     uint32_t lastTimePosFrame;

  4434. };

  4435. 

  4436. /**@}*/

  4437. 

  4438. // -------------------------------------------------------------------------------------------------------------------

  4439. 

  4440. int CarlaOsc::handleMsgLv2AtomTransfer(CARLA_OSC_HANDLE_ARGS2)

  4441. {

  4442.     qDebug("CarlaOsc::handleMsgLv2AtomTransfer()");

  4443.     CARLA_OSC_CHECK_OSC_TYPES(3, "iss");

  4444. 

  4445.     const int32_t portIndex   = argv[0]->i;

  4446.     const char* const typeStr = (const char*)&argv[1]->s;

  4447.     const char* const atomBuf = (const char*)&argv[2]->s;

  4448. 

  4449.     QByteArray chunk;

  4450.     chunk = QByteArray::fromBase64(atomBuf);

  4451. 

  4452.     LV2_Atom* const atom = (LV2_Atom*)chunk.constData();

  4453.     CarlaBackend::Lv2Plugin* const lv2plugin = (CarlaBackend::Lv2Plugin*)plugin;

  4454. 

  4455.     atom->type = lv2plugin->getCustomURID(typeStr);

  4456.     lv2plugin->handleTransferAtom(portIndex, atom);

  4457. 

  4458.     return 0;

  4459. }

  4460. 

  4461. int CarlaOsc::handleMsgLv2EventTransfer(CARLA_OSC_HANDLE_ARGS2)

  4462. {

  4463.     qDebug("CarlaOsc::handleMsgLv2EventTransfer()");

  4464.     CARLA_OSC_CHECK_OSC_TYPES(3, "iss");

  4465. 

  4466.     const int32_t portIndex   = argv[0]->i;

  4467.     const char* const typeStr = (const char*)&argv[1]->s;

  4468.     const char* const atomBuf = (const char*)&argv[2]->s;

  4469. 

  4470.     QByteArray chunk;

  4471.     chunk = QByteArray::fromBase64(atomBuf);

  4472. 

  4473.     LV2_Atom* const atom = (LV2_Atom*)chunk.constData();

  4474.     CarlaBackend::Lv2Plugin* const lv2plugin = (CarlaBackend::Lv2Plugin*)plugin;

  4475. 

  4476.     atom->type = lv2plugin->getCustomURID(typeStr);

  4477.     lv2plugin->handleTransferEvent(portIndex, atom);

  4478. 

  4479.     return 0;

  4480. }

  4481. 

  4482. CARLA_BACKEND_END_NAMESPACE

  4483. 

  4484. #else // WANT_LV2

  4485. #  warning Building without LV2 support

  4486. #endif

  4487. 

  4488. CARLA_BACKEND_START_NAMESPACE

  4489. 

  4490. CarlaPlugin* CarlaPlugin::newLV2(const initializer& init)

  4491. {

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

  4493. 

  4494. #ifdef WANT_LV2

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

  4496. 

  4497.     if (id < 0 || id > CarlaEngine::maxPluginNumber())

  4498.     {

  4499.         setLastError("Maximum number of plugins reached");

  4500.         return nullptr;

  4501.     }

  4502. 

  4503.     Lv2Plugin* const plugin = new Lv2Plugin(init.engine, id);

  4504. 

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

  4506.     {

  4507.         delete plugin;

  4508.         return nullptr;

  4509.     }

  4510. 

  4511.     plugin->reload();

  4512. 

  4513. #  ifndef BUILD_BRIDGE

  4514.     if (carlaOptions.processMode == PROCESS_MODE_CONTINUOUS_RACK)

  4515.     {

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

  4517.         {

  4518.             setLastError("Carla's rack mode can only work with Mono (simple) or Stereo LV2 plugins, sorry!");

  4519.             delete plugin;

  4520.             return nullptr;

  4521.         }

  4522.     }

  4523. #  endif

  4524. 

  4525.     plugin->registerToOscControl();

  4526.     plugin->updateUi();

  4527. 

  4528.     return plugin;

  4529. #else

  4530.     setLastError("LV2 support not available");

  4531.     return nullptr;

  4532. #endif

  4533. }

  4534. 

  4535. CARLA_BACKEND_END_NAMESPACE