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.
782 Commits
2 Branches
131MB
Tree: 135a7ce5dd
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '135a7ce5dd'
${ noResults }
Cadence/c++/carla-plugin/lv2.cpp

4693 lines
164KB
Raw Blame History 

  1. /*

  2.  * Carla LV2 Plugin

  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.hpp"

  19. 

  20. #ifdef WANT_LV2

  21. 

  22. #include "carla_lib_utils.hpp"

  23. #include "carla_lv2_utils.hpp"

  24. 

  25. #include "lv2_atom_queue.hpp"

  26. #include "rtmempool/rtmempool.h"

  27. 

  28. #include <set>

  29. 

  30. #include <QtCore/QDir>

  31. #include <QtGui/QDialog>

  32. #include <QtGui/QLayout>

  33. 

  34. #ifdef WANT_SUIL

  35. #include <suil/suil.h>

  36. struct SuilInstanceImpl {

  37.     void*                   lib_handle;

  38.     const LV2UI_Descriptor* descriptor;

  39.     LV2UI_Handle            handle;

  40.     // ...

  41. };

  42. #endif

  43. 

  44. CARLA_BACKEND_START_NAMESPACE

  45. 

  46. /*!

  47.  * @defgroup CarlaBackendLv2Plugin Carla Backend LV2 Plugin

  48.  *

  49.  * The Carla Backend LV2 Plugin.\n

  50.  * http://lv2plug.in/

  51.  * @{

  52.  */

  53. 

  54. // static max values

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

  56. 

  57. /*!

  58.  * @defgroup PluginHints Plugin Hints

  59.  * @{

  60.  */

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

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

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

  64. /**@}*/

  65. 

  66. /*!

  67.  * @defgroup ParameterHints Parameter Hints

  68.  * @{

  69.  */

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

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

  72. /**@}*/

  73. 

  74. /*!

  75.  * @defgroup Lv2FeatureIds LV2 Feature Ids

  76.  *

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

  78.  * @{

  79.  */

  80. const uint32_t lv2_feature_id_bufsize_bounded  =  0;

  81. const uint32_t lv2_feature_id_bufsize_fixed    =  1;

  82. const uint32_t lv2_feature_id_bufsize_powerof2 =  2;

  83. const uint32_t lv2_feature_id_event            =  3;

  84. const uint32_t lv2_feature_id_logs             =  4;

  85. const uint32_t lv2_feature_id_options          =  5;

  86. const uint32_t lv2_feature_id_programs         =  6;

  87. const uint32_t lv2_feature_id_rtmempool        =  7;

  88. const uint32_t lv2_feature_id_state_make_path  =  8;

  89. const uint32_t lv2_feature_id_state_map_path   =  9;

  90. const uint32_t lv2_feature_id_strict_bounds    = 10;

  91. const uint32_t lv2_feature_id_uri_map          = 11;

  92. const uint32_t lv2_feature_id_urid_map         = 12;

  93. const uint32_t lv2_feature_id_urid_unmap       = 13;

  94. const uint32_t lv2_feature_id_worker           = 14;

  95. const uint32_t lv2_feature_id_data_access      = 15;

  96. const uint32_t lv2_feature_id_instance_access  = 16;

  97. const uint32_t lv2_feature_id_ui_parent        = 17;

  98. const uint32_t lv2_feature_id_ui_port_map      = 18;

  99. const uint32_t lv2_feature_id_ui_resize        = 19;

  100. const uint32_t lv2_feature_id_external_ui      = 20;

  101. const uint32_t lv2_feature_id_external_ui_old  = 21;

  102. const uint32_t lv2_feature_count               = 22;

  103. /**@}*/

  104. 

  105. /*!

  106.  * @defgroup Lv2EventTypes LV2 Event Data/Types

  107.  *

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

  109.  * @{

  110.  */

  111. const unsigned int CARLA_EVENT_DATA_ATOM      = 0x01;

  112. const unsigned int CARLA_EVENT_DATA_EVENT     = 0x02;

  113. const unsigned int CARLA_EVENT_DATA_MIDI_LL   = 0x04;

  114. const unsigned int CARLA_EVENT_TYPE_MESSAGE   = 0x10;

  115. const unsigned int CARLA_EVENT_TYPE_MIDI      = 0x20;

  116. /**@}*/

  117. 

  118. /*!

  119.  * @defgroup Lv2UriMapIds LV2 URI Map Ids

  120.  *

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

  122.  * @{

  123.  */

  124. const uint32_t CARLA_URI_MAP_ID_NULL                = 0;

  125. const uint32_t CARLA_URI_MAP_ID_ATOM_CHUNK          = 1;

  126. const uint32_t CARLA_URI_MAP_ID_ATOM_DOUBLE         = 2;

  127. const uint32_t CARLA_URI_MAP_ID_ATOM_INT            = 3;

  128. const uint32_t CARLA_URI_MAP_ID_ATOM_PATH           = 4;

  129. const uint32_t CARLA_URI_MAP_ID_ATOM_SEQUENCE       = 5;

  130. const uint32_t CARLA_URI_MAP_ID_ATOM_STRING         = 6;

  131. const uint32_t CARLA_URI_MAP_ID_ATOM_WORKER         = 7;

  132. const uint32_t CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM  = 8;

  133. const uint32_t CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT = 9;

  134. const uint32_t CARLA_URI_MAP_ID_BUF_MAX_LENGTH      = 10;

  135. const uint32_t CARLA_URI_MAP_ID_BUF_MIN_LENGTH      = 11;

  136. const uint32_t CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE   = 12;

  137. const uint32_t CARLA_URI_MAP_ID_LOG_ERROR           = 13;

  138. const uint32_t CARLA_URI_MAP_ID_LOG_NOTE            = 14;

  139. const uint32_t CARLA_URI_MAP_ID_LOG_TRACE           = 15;

  140. const uint32_t CARLA_URI_MAP_ID_LOG_WARNING         = 16;

  141. const uint32_t CARLA_URI_MAP_ID_MIDI_EVENT          = 17;

  142. const uint32_t CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE   = 18;

  143. const uint32_t CARLA_URI_MAP_ID_COUNT               = 19;

  144. /**@}*/

  145. 

  146. struct Lv2EventData {

  147.     uint32_t type;

  148.     uint32_t rindex;

  149.     CarlaEngineMidiPort* port;

  150.     union {

  151.         LV2_Atom_Sequence* atom;

  152.         LV2_Event_Buffer* event;

  153.         LV2_MIDI* midi;

  154.     };

  155. 

  156.     Lv2EventData()

  157.         : type(0x0),

  158.           rindex(0),

  159.           port(nullptr) {}

  160. };

  161. 

  162. struct Lv2PluginEventData {

  163.     uint32_t count;

  164.     Lv2EventData* data;

  165. 

  166.     Lv2PluginEventData()

  167.         : count(0),

  168.           data(nullptr) {}

  169. };

  170. 

  171. struct Lv2PluginOptions {

  172.     bool init;

  173.     uint32_t eventSize;

  174.     uint32_t bufferSize;

  175.     double   sampleRate;

  176.     LV2_Options_Option oNull;

  177.     LV2_Options_Option oMaxBlockLenth;

  178.     LV2_Options_Option oMinBlockLenth;

  179.     LV2_Options_Option oSequenceSize;

  180.     LV2_Options_Option oSampleRate;

  181. 

  182.     Lv2PluginOptions()

  183.         : init(false),

  184.           eventSize(MAX_EVENT_BUFFER),

  185.           bufferSize(0),

  186.           sampleRate(0.0) {}

  187. };

  188. 

  189. Lv2PluginOptions lv2Options;

  190. 

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

  192. {

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

  194. }

  195. 

  196. class Lv2Plugin : public CarlaPlugin

  197. {

  198. public:

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

  200.         : CarlaPlugin(engine, id)

  201.     {

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

  203. 

  204.         m_type   = PLUGIN_LV2;

  205.         m_count += 1;

  206. 

  207.         handle = h2 = nullptr;

  208.         descriptor  = nullptr;

  209.         rdf_descriptor = nullptr;

  210. 

  211.         ext.state      = nullptr;

  212.         ext.worker     = nullptr;

  213.         ext.programs   = nullptr;

  214.         ext.uiprograms = nullptr;

  215. 

  216.         ui.lib = nullptr;

  217.         ui.handle = nullptr;

  218.         ui.descriptor = nullptr;

  219.         ui.rdf_descriptor = nullptr;

  220. 

  221.         evIn.count = 0;

  222.         evIn.data  = nullptr;

  223. 

  224.         evOut.count = 0;

  225.         evOut.data  = nullptr;

  226. 

  227.         paramBuffers = nullptr;

  228. 

  229.         gui.type = GUI_NONE;

  230.         gui.resizable = false;

  231.         gui.width  = 0;

  232.         gui.height = 0;

  233. 

  234. #ifdef WANT_SUIL

  235.         suil.handle = nullptr;

  236.         suil.host   = nullptr;

  237. #endif

  238. 

  239.         lastTimePosPlaying = false;

  240.         lastTimePosFrame   = 0;

  241. 

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

  243.             customURIDs.push_back(nullptr);

  244. 

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

  246.             features[i] = nullptr;

  247. 

  248.         if (! lv2Options.init)

  249.         {

  250.             lv2Options.init = true;

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

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

  253. 

  254.             lv2Options.oNull.key   = CARLA_URI_MAP_ID_NULL;

  255.             lv2Options.oNull.size  = 0;

  256.             lv2Options.oNull.type  = CARLA_URI_MAP_ID_NULL;

  257.             lv2Options.oNull.value = nullptr;

  258. 

  259.             lv2Options.oMaxBlockLenth.key   = CARLA_URI_MAP_ID_BUF_MAX_LENGTH;

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

  261.             lv2Options.oMaxBlockLenth.type  = CARLA_URI_MAP_ID_ATOM_INT;

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

  263. 

  264.             lv2Options.oMinBlockLenth.key   = CARLA_URI_MAP_ID_BUF_MIN_LENGTH;

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

  266.             lv2Options.oMinBlockLenth.type  = CARLA_URI_MAP_ID_ATOM_INT;

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

  268. 

  269.             lv2Options.oSequenceSize.key   = CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE;

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

  271.             lv2Options.oSequenceSize.type  = CARLA_URI_MAP_ID_ATOM_INT;

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

  273. 

  274.             lv2Options.oSampleRate.key     = CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE;

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

  276.             lv2Options.oSampleRate.type    = CARLA_URI_MAP_ID_ATOM_DOUBLE;

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

  278.         }

  279. 

  280.         // init static data if this is the first lv2-plugin loaded

  281.         if (m_count == 1)

  282.         {

  283.             ft.event                  = new LV2_Event_Feature;

  284.             ft.event->callback_data   = this;

  285.             ft.event->lv2_event_ref   = carla_lv2_event_ref;

  286.             ft.event->lv2_event_unref = carla_lv2_event_unref;

  287. 

  288.             ft.log          = new LV2_Log_Log;

  289.             ft.log->handle  = this;

  290.             ft.log->printf  = carla_lv2_log_printf;

  291.             ft.log->vprintf = carla_lv2_log_vprintf;

  292. 

  293.             ft.rtMemPool = new LV2_RtMemPool_Pool;

  294.             rtmempool_allocator_init(ft.rtMemPool);

  295. 

  296.             ft.stateMakePath         = new LV2_State_Make_Path;

  297.             ft.stateMakePath->handle = this;

  298.             ft.stateMakePath->path   = carla_lv2_state_make_path;

  299. 

  300.             ft.stateMapPath                = new LV2_State_Map_Path;

  301.             ft.stateMapPath->handle        = this;

  302.             ft.stateMapPath->abstract_path = carla_lv2_state_map_abstract_path;

  303.             ft.stateMapPath->absolute_path = carla_lv2_state_map_absolute_path;

  304. 

  305.             ft.options    = new LV2_Options_Option [5];

  306.             ft.options[0] = lv2Options.oMaxBlockLenth;

  307.             ft.options[1] = lv2Options.oMinBlockLenth;

  308.             ft.options[2] = lv2Options.oSequenceSize;

  309.             ft.options[3] = lv2Options.oSampleRate;

  310.             ft.options[4] = lv2Options.oNull;

  311.         }

  312. 

  313.         lv2World.init();

  314.     }

  315. 

  316.     ~Lv2Plugin()

  317.     {

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

  319.         m_count -= 1;

  320. 

  321.         // close UI

  322.         if (m_hints & PLUGIN_HAS_GUI)

  323.         {

  324.             showGui(false);

  325. 

  326.             switch (gui.type)

  327.             {

  328.             case GUI_NONE:

  329.             case GUI_INTERNAL_QT4:

  330.             case GUI_INTERNAL_COCOA:

  331.             case GUI_INTERNAL_HWND:

  332.             case GUI_INTERNAL_X11:

  333.             case GUI_EXTERNAL_LV2:

  334.                 break;

  335. 

  336.             case GUI_EXTERNAL_SUIL:

  337. #ifdef WANT_SUIL

  338.                 if (ui.widget)

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

  340. #endif

  341.                 break;

  342. 

  343.             case GUI_EXTERNAL_OSC:

  344. #ifndef BUILD_BRIDGE

  345.                 if (osc.thread)

  346.                 {

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

  348.                     if (osc.thread->isRunning() && ! osc.thread->wait(x_engine->oscUiTimeout() * 100))

  349.                     {

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

  351.                         osc.thread->terminate();

  352.                     }

  353. 

  354.                     delete osc.thread;

  355.                 }

  356. #endif

  357.                 break;

  358.             }

  359. 

  360. #ifdef WANT_SUIL

  361.             if (suil.handle)

  362.             {

  363.                 suil_instance_free(suil.handle);

  364. 

  365.                 if (suil.host)

  366.                     suil_host_free(suil.host);

  367. 

  368.                 ui.handle = nullptr;

  369.                 ui.descriptor = nullptr;

  370.             }

  371. #endif

  372. 

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

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

  375. 

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

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

  378. 

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

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

  381. 

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

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

  384. 

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

  386.             {

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

  388. 

  389.                 if (uiHost->plugin_human_id)

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

  391. 

  392.                 delete uiHost;

  393.             }

  394. 

  395.             uiLibClose();

  396.         }

  397. 

  398.         if (descriptor)

  399.         {

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

  401.             {

  402.                 if (handle)

  403.                     descriptor->deactivate(handle);

  404.                 if (h2)

  405.                     descriptor->deactivate(h2);

  406.             }

  407. 

  408.             if (descriptor->cleanup)

  409.             {

  410.                 if (handle)

  411.                     descriptor->cleanup(handle);

  412.                 if (h2)

  413.                     descriptor->cleanup(h2);

  414.             }

  415.         }

  416. 

  417.         if (rdf_descriptor)

  418.             delete rdf_descriptor;

  419. 

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

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

  422. 

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

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

  425. 

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

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

  428. 

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

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

  431. 

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

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

  434. 

  435. #ifndef BUILD_BRIDGE

  436.         if (! x_engine->processHighPrecision())

  437. #endif

  438.         {

  439.             features[lv2_feature_id_bufsize_fixed]    = nullptr;

  440.             features[lv2_feature_id_bufsize_powerof2] = nullptr;

  441.         }

  442. 

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

  444.         {

  445.             if (features[i])

  446.                 delete features[i];

  447.         }

  448. 

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

  450.         {

  451.             if (customURIDs[i])

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

  453.         }

  454. 

  455.         customURIDs.clear();

  456. 

  457.         // cleanup all static data if this is the last lv2-plugin loaded

  458.         if (m_count == 0)

  459.         {

  460.             for (auto it = libDescs.begin(); it != libDescs.end(); it++)

  461.             {

  462.                 const LV2_Lib_Descriptor* libDesc(*it);

  463.                 libDesc->cleanup(libDesc->handle);

  464.             }

  465. 

  466.             libDescs.clear();

  467. 

  468.             if (ft.event)

  469.                 delete ft.event;

  470. 

  471.             if (ft.log)

  472.                 delete ft.log;

  473. 

  474.             if (ft.options)

  475.                 delete[] ft.options;

  476. 

  477.             if (ft.rtMemPool)

  478.                 delete ft.rtMemPool;

  479. 

  480.             if (ft.stateMakePath)

  481.                 delete ft.stateMakePath;

  482. 

  483.             if (ft.stateMapPath)

  484.                 delete ft.stateMapPath;

  485. 

  486.             ft.event = nullptr;

  487.             ft.log   = nullptr;

  488.             ft.options   = nullptr;

  489.             ft.rtMemPool = nullptr;

  490.             ft.stateMakePath = nullptr;

  491.             ft.stateMapPath  = nullptr;

  492.         }

  493.     }

  494. 

  495.     // -------------------------------------------------------------------

  496.     // Information (base)

  497. 

  498.     PluginCategory category()

  499.     {

  500.         CARLA_ASSERT(rdf_descriptor);

  501. 

  502.         LV2_Property category = rdf_descriptor->Type;

  503. 

  504.         if (LV2_IS_DELAY(category))

  505.             return PLUGIN_CATEGORY_DELAY;

  506.         if (LV2_IS_DISTORTION(category))

  507.             return PLUGIN_CATEGORY_OTHER;

  508.         if (LV2_IS_DYNAMICS(category))

  509.             return PLUGIN_CATEGORY_DYNAMICS;

  510.         if (LV2_IS_EQ(category))

  511.             return PLUGIN_CATEGORY_EQ;

  512.         if (LV2_IS_FILTER(category))

  513.             return PLUGIN_CATEGORY_FILTER;

  514.         if (LV2_IS_GENERATOR(category))

  515.             return PLUGIN_CATEGORY_SYNTH;

  516.         if (LV2_IS_MODULATOR(category))

  517.             return PLUGIN_CATEGORY_MODULATOR;

  518.         if (LV2_IS_REVERB(category))

  519.             return PLUGIN_CATEGORY_DELAY;

  520.         if (LV2_IS_SIMULATOR(category))

  521.             return PLUGIN_CATEGORY_OTHER;

  522.         if (LV2_IS_SPATIAL(category))

  523.             return PLUGIN_CATEGORY_OTHER;

  524.         if (LV2_IS_SPECTRAL(category))

  525.             return PLUGIN_CATEGORY_UTILITY;

  526.         if (LV2_IS_UTILITY(category))

  527.             return PLUGIN_CATEGORY_UTILITY;

  528. 

  529.         return getPluginCategoryFromName(m_name);

  530.     }

  531. 

  532.     long uniqueId()

  533.     {

  534.         CARLA_ASSERT(rdf_descriptor);

  535. 

  536.         return rdf_descriptor->UniqueID;

  537.     }

  538. 

  539.     // -------------------------------------------------------------------

  540.     // Information (count)

  541. 

  542.     uint32_t midiInCount()

  543.     {

  544.         uint32_t i, count = 0;

  545. 

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

  547.         {

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

  549.                 count += 1;

  550.         }

  551. 

  552.         return count;

  553.     }

  554. 

  555.     uint32_t midiOutCount()

  556.     {

  557.         uint32_t i, count = 0;

  558. 

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

  560.         {

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

  562.                 count += 1;

  563.         }

  564. 

  565.         return count;

  566.     }

  567. 

  568.     uint32_t parameterScalePointCount(const uint32_t parameterId)

  569.     {

  570.         CARLA_ASSERT(parameterId < param.count);

  571.         CARLA_ASSERT(rdf_descriptor);

  572. 

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

  574. 

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

  576.         {

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

  578.             return port->ScalePointCount;

  579.         }

  580. 

  581.         return 0;

  582.     }

  583. 

  584.     // -------------------------------------------------------------------

  585.     // Information (per-plugin data)

  586. 

  587.     double getParameterValue(const uint32_t parameterId)

  588.     {

  589.         CARLA_ASSERT(parameterId < param.count);

  590. 

  591.         return paramBuffers[parameterId];

  592.     }

  593. 

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

  595.     {

  596.         CARLA_ASSERT(parameterId < param.count);

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

  598. 

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

  600. 

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

  602.         {

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

  604. 

  605.             if (scalePointId < port->ScalePointCount)

  606.             {

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

  608.                 return portScalePoint->Value;

  609.             }

  610.         }

  611. 

  612.         return 0.0;

  613.     }

  614. 

  615.     void getLabel(char* const strBuf)

  616.     {

  617.         CARLA_ASSERT(rdf_descriptor);

  618. 

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

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

  621.         else

  622.             CarlaPlugin::getLabel(strBuf);

  623.     }

  624. 

  625.     void getMaker(char* const strBuf)

  626.     {

  627.         CARLA_ASSERT(rdf_descriptor);

  628. 

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

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

  631.         else

  632.             CarlaPlugin::getMaker(strBuf);

  633.     }

  634. 

  635.     void getCopyright(char* const strBuf)

  636.     {

  637.         CARLA_ASSERT(rdf_descriptor);

  638. 

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

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

  641.         else

  642.             CarlaPlugin::getCopyright(strBuf);

  643.     }

  644. 

  645.     void getRealName(char* const strBuf)

  646.     {

  647.         CARLA_ASSERT(rdf_descriptor);

  648. 

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

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

  651.         else

  652.             CarlaPlugin::getRealName(strBuf);

  653.     }

  654. 

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

  656.     {

  657.         CARLA_ASSERT(rdf_descriptor);

  658.         CARLA_ASSERT(parameterId < param.count);

  659. 

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

  661. 

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

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

  664.         else

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

  666.     }

  667. 

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

  669.     {

  670.         CARLA_ASSERT(rdf_descriptor);

  671.         CARLA_ASSERT(parameterId < param.count);

  672. 

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

  674. 

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

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

  677.         else

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

  679.     }

  680. 

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

  682.     {

  683.         CARLA_ASSERT(rdf_descriptor);

  684.         CARLA_ASSERT(parameterId < param.count);

  685. 

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

  687. 

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

  689.         {

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

  691. 

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

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

  694. 

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

  696.             {

  697.                 switch (port->Unit.Type)

  698.                 {

  699.                 case LV2_UNIT_BAR:

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

  701.                     return;

  702.                 case LV2_UNIT_BEAT:

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

  704.                     return;

  705.                 case LV2_UNIT_BPM:

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

  707.                     return;

  708.                 case LV2_UNIT_CENT:

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

  710.                     return;

  711.                 case LV2_UNIT_CM:

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

  713.                     return;

  714.                 case LV2_UNIT_COEF:

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

  716.                     return;

  717.                 case LV2_UNIT_DB:

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

  719.                     return;

  720.                 case LV2_UNIT_DEGREE:

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

  722.                     return;

  723.                 case LV2_UNIT_FRAME:

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

  725.                     return;

  726.                 case LV2_UNIT_HZ:

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

  728.                     return;

  729.                 case LV2_UNIT_INCH:

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

  731.                     return;

  732.                 case LV2_UNIT_KHZ:

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

  734.                     return;

  735.                 case LV2_UNIT_KM:

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

  737.                     return;

  738.                 case LV2_UNIT_M:

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

  740.                     return;

  741.                 case LV2_UNIT_MHZ:

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

  743.                     return;

  744.                 case LV2_UNIT_MIDINOTE:

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

  746.                     return;

  747.                 case LV2_UNIT_MILE:

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

  749.                     return;

  750.                 case LV2_UNIT_MIN:

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

  752.                     return;

  753.                 case LV2_UNIT_MM:

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

  755.                     return;

  756.                 case LV2_UNIT_MS:

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

  758.                     return;

  759.                 case LV2_UNIT_OCT:

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

  761.                     return;

  762.                 case LV2_UNIT_PC:

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

  764.                     return;

  765.                 case LV2_UNIT_S:

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

  767.                     return;

  768.                 case LV2_UNIT_SEMITONE:

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

  770.                     return;

  771.                 }

  772.             }

  773.         }

  774. 

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

  776.     }

  777. 

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

  779.     {

  780.         CARLA_ASSERT(rdf_descriptor);

  781.         CARLA_ASSERT(parameterId < param.count);

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

  783. 

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

  785. 

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

  787.         {

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

  789. 

  790.             if (scalePointId < port->ScalePointCount)

  791.             {

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

  793. 

  794.                 if (portScalePoint->Label)

  795.                 {

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

  797.                     return;

  798.                 }

  799.             }

  800.         }

  801. 

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

  803.     }

  804. 

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

  806.     {

  807.         CARLA_ASSERT(type);

  808.         CARLA_ASSERT(resizable);

  809. 

  810.         *type      = gui.type;

  811.         *resizable = gui.resizable;

  812.     }

  813. 

  814.     // -------------------------------------------------------------------

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

  816. 

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

  818.     {

  819.         CARLA_ASSERT(parameterId < param.count);

  820. 

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

  822. 

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

  824.     }

  825. 

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

  827.     {

  828.         CARLA_ASSERT(type);

  829.         CARLA_ASSERT(key);

  830.         CARLA_ASSERT(value);

  831. 

  832.         if (! type)

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

  834. 

  835.         if (! key)

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

  837. 

  838.         if (! value)

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

  840. 

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

  842. 

  843.         if (ext.state)

  844.         {

  845.             LV2_State_Status status;

  846. 

  847.             if (x_engine->isOffline())

  848.             {

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

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

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

  852.             }

  853.             else

  854.             {

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

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

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

  858.             }

  859. 

  860.             switch (status)

  861.             {

  862.             case LV2_STATE_SUCCESS:

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

  864.                 break;

  865.             case LV2_STATE_ERR_UNKNOWN:

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

  867.                 break;

  868.             case LV2_STATE_ERR_BAD_TYPE:

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

  870.                 break;

  871.             case LV2_STATE_ERR_BAD_FLAGS:

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

  873.                 break;

  874.             case LV2_STATE_ERR_NO_FEATURE:

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

  876.                 break;

  877.             case LV2_STATE_ERR_NO_PROPERTY:

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

  879.                 break;

  880.             }

  881.         }

  882. 

  883.         if (sendGui)

  884.         {

  885.             CustomData cdata;

  886.             cdata.type  = type;

  887.             cdata.key   = key;

  888.             cdata.value = value;

  889.             uiTransferCustomData(&cdata);

  890.         }

  891.     }

  892. 

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

  894.     {

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

  896. 

  897.         if (index < -1)

  898.             index = -1;

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

  900.             return;

  901. 

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

  903.         {

  904.             if (x_engine->isOffline())

  905.             {

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

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

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

  909.             }

  910.             else

  911.             {

  912.                 const ScopedDisabler m(this, block);

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

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

  915.             }

  916.         }

  917. 

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

  919.     }

  920. 

  921.     // -------------------------------------------------------------------

  922.     // Set gui stuff

  923. 

  924.     void setGuiContainer(GuiContainer* const container)

  925.     {

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

  927.         CARLA_ASSERT(container);

  928. 

  929.         switch(gui.type)

  930.         {

  931.         case GUI_NONE:

  932.             break;

  933. 

  934.         case GUI_INTERNAL_QT4:

  935.             if (ui.widget)

  936.             {

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

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

  939.                 CARLA_ASSERT(dialog);

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

  941.                 CARLA_ASSERT(widget);

  942.                 container->setVisible(false);

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

  944.                 widget->adjustSize();

  945.                 widget->setParent(dialog);

  946.                 widget->show();

  947.             }

  948.             break;

  949. 

  950.         case GUI_INTERNAL_COCOA:

  951.         case GUI_INTERNAL_HWND:

  952.         case GUI_INTERNAL_X11:

  953.             if (ui.descriptor)

  954.             {

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

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

  957.                 updateUi();

  958.             }

  959.             break;

  960. 

  961.         case GUI_EXTERNAL_LV2:

  962.         case GUI_EXTERNAL_SUIL:

  963.         case GUI_EXTERNAL_OSC:

  964.             break;

  965.         }

  966.     }

  967. 

  968.     void showGui(const bool yesNo)

  969.     {

  970.         switch(gui.type)

  971.         {

  972.         case GUI_NONE:

  973.         case GUI_INTERNAL_QT4:

  974.             break;

  975. 

  976.         case GUI_INTERNAL_COCOA:

  977.         case GUI_INTERNAL_HWND:

  978.         case GUI_INTERNAL_X11:

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

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

  981.             break;

  982. 

  983.         case GUI_EXTERNAL_LV2:

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

  985.                 initExternalUi();

  986. 

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

  988.             {

  989.                 if (yesNo)

  990.                 {

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

  992.                 }

  993.                 else

  994.                 {

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

  996. 

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

  998.                     {

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

  1000. 

  1001.                         if (ui.descriptor->cleanup)

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

  1003. 

  1004.                         ui.handle = nullptr;

  1005.                     }

  1006.                 }

  1007.             }

  1008.             else

  1009.                 // failed to init UI

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

  1011. 

  1012.             break;

  1013. 

  1014.         case GUI_EXTERNAL_SUIL:

  1015. #ifdef WANT_SUIL

  1016.             if (ui.widget)

  1017.             {

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

  1019. 

  1020.                 if (yesNo)

  1021.                 {

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

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

  1024.                 }

  1025.                 else

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

  1027. 

  1028.                 widget->setVisible(yesNo);

  1029.             }

  1030. #endif

  1031.             break;

  1032. 

  1033.         case GUI_EXTERNAL_OSC:

  1034. #ifndef BUILD_BRIDGE

  1035.             CARLA_ASSERT(osc.thread);

  1036. 

  1037.             if (! osc.thread)

  1038.             {

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

  1040.                 return;

  1041.             }

  1042. 

  1043.             if (yesNo)

  1044.             {

  1045.                 osc.thread->start();

  1046.             }

  1047.             else

  1048.             {

  1049.                 if (osc.data.target)

  1050.                 {

  1051.                     osc_send_hide(&osc.data);

  1052.                     osc_send_quit(&osc.data);

  1053.                     osc.data.free();

  1054.                 }

  1055. 

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

  1057.                     osc.thread->quit();

  1058.             }

  1059. #endif

  1060.             break;

  1061.         }

  1062.     }

  1063. 

  1064.     void idleGui()

  1065.     {

  1066. #ifdef BUILD_BRIDGE

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

  1068. #else

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

  1070. #endif

  1071. 

  1072.         if (haveUI)

  1073.         {

  1074.             // Update event ports

  1075.             if (! atomQueueOut.isEmpty())

  1076.             {

  1077.                 static Lv2AtomQueue queue;

  1078.                 queue.copyDataFrom(&atomQueueOut);

  1079. 

  1080.                 uint32_t portIndex;

  1081.                 const LV2_Atom* atom;

  1082. 

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

  1084.                 {

  1085. #ifndef BUILD_BRIDGE

  1086.                     if (gui.type == GUI_EXTERNAL_OSC)

  1087.                     {

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

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

  1090.                     }

  1091.                     else

  1092. #endif

  1093.                     {

  1094.                         if (ui.descriptor->port_event)

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

  1096.                     }

  1097.                 }

  1098.             }

  1099. 

  1100.             // Update external UI

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

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

  1103.         }

  1104. 

  1105.         CarlaPlugin::idleGui();

  1106.     }

  1107. 

  1108.     // -------------------------------------------------------------------

  1109.     // Plugin state

  1110. 

  1111.     void reload()

  1112.     {

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

  1114.         CARLA_ASSERT(descriptor && rdf_descriptor);

  1115. 

  1116.         // Safely disable plugin for reload

  1117.         const ScopedDisabler m(this);

  1118. 

  1119.         if (x_client->isActive())

  1120.             x_client->deactivate();

  1121. 

  1122.         // Remove client ports

  1123.         removeClientPorts();

  1124. 

  1125.         // Delete old data

  1126.         deleteBuffers();

  1127. 

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

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

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

  1131. 

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

  1133.         const uint32_t portCount = rdf_descriptor->PortCount;

  1134. 

  1135.         bool forcedStereoIn, forcedStereoOut;

  1136.         forcedStereoIn = forcedStereoOut = false;

  1137. 

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

  1139.         {

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

  1141. 

  1142.             if (LV2_IS_PORT_AUDIO(portType))

  1143.             {

  1144.                 if (LV2_IS_PORT_INPUT(portType))

  1145.                     aIns += 1;

  1146.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1147.                     aOuts += 1;

  1148.             }

  1149.             else if (LV2_IS_PORT_CV(portType))

  1150.             {

  1151.                 if (LV2_IS_PORT_INPUT(portType))

  1152.                     cvIns += 1;

  1153.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1154.                     cvOuts += 1;

  1155.             }

  1156.             else if (LV2_IS_PORT_ATOM_SEQUENCE(portType))

  1157.             {

  1158.                 if (LV2_IS_PORT_INPUT(portType))

  1159.                     evIns.push_back(CARLA_EVENT_DATA_ATOM);

  1160.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1161.                     evOuts.push_back(CARLA_EVENT_DATA_ATOM);

  1162.             }

  1163.             else if (LV2_IS_PORT_EVENT(portType))

  1164.             {

  1165.                 if (LV2_IS_PORT_INPUT(portType))

  1166.                     evIns.push_back(CARLA_EVENT_DATA_EVENT);

  1167.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1168.                     evOuts.push_back(CARLA_EVENT_DATA_EVENT);

  1169.             }

  1170.             else if (LV2_IS_PORT_MIDI_LL(portType))

  1171.             {

  1172.                 if (LV2_IS_PORT_INPUT(portType))

  1173.                     evIns.push_back(CARLA_EVENT_DATA_MIDI_LL);

  1174.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1175.                     evOuts.push_back(CARLA_EVENT_DATA_MIDI_LL);

  1176.             }

  1177.             else if (LV2_IS_PORT_CONTROL(portType))

  1178.                 params += 1;

  1179.         }

  1180. 

  1181.         // check extensions

  1182.         ext.state      = nullptr;

  1183.         ext.worker     = nullptr;

  1184.         ext.programs   = nullptr;

  1185. 

  1186.         if (descriptor->extension_data)

  1187.         {

  1188.             if (m_hints & PLUGIN_HAS_EXTENSION_PROGRAMS)

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

  1190. 

  1191.             if (m_hints & PLUGIN_HAS_EXTENSION_STATE)

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

  1193. 

  1194.             if (m_hints & PLUGIN_HAS_EXTENSION_WORKER)

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

  1196.         }

  1197. 

  1198. #ifndef BUILD_BRIDGE

  1199.         if (x_engine->forceStereo() && (aIns == 1 || aOuts == 1) && ! (h2 || ext.state || ext.worker))

  1200.         {

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

  1202. 

  1203.             if (aIns == 1)

  1204.             {

  1205.                 aIns = 2;

  1206.                 forcedStereoIn = true;

  1207.             }

  1208. 

  1209.             if (aOuts == 1)

  1210.             {

  1211.                 aOuts = 2;

  1212.                 forcedStereoOut = true;

  1213.             }

  1214.         }

  1215. #endif

  1216. 

  1217.         if (aIns > 0)

  1218.         {

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

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

  1221.         }

  1222. 

  1223.         if (aOuts > 0)

  1224.         {

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

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

  1227.         }

  1228. 

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

  1230.         {

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

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

  1233. 

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

  1235.             {

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

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

  1238. 

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

  1240.                 {

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

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

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

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

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

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

  1247.                 }

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

  1249.                 {

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

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

  1252.                 }

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

  1254.                 {

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

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

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

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

  1259.                 }

  1260.             }

  1261.         }

  1262. 

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

  1264.         {

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

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

  1267. 

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

  1269.             {

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

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

  1272. 

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

  1274.                 {

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

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

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

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

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

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

  1281.                 }

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

  1283.                 {

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

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

  1286.                 }

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

  1288.                 {

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

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

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

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

  1293.                 }

  1294.             }

  1295.         }

  1296. 

  1297.         if (params > 0)

  1298.         {

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

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

  1301.             paramBuffers = new float[params];

  1302.         }

  1303. 

  1304.         bool needsCtrlIn  = false;

  1305.         bool needsCtrlOut = false;

  1306. 

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

  1308.         CarlaString portName;

  1309. 

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

  1311.         {

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

  1313. 

  1314.             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))

  1315.             {

  1316.                 portName.clear();

  1317. 

  1318. #ifndef BUILD_BRIDGE

  1319.                 if (x_engine->processMode() == PROCESS_MODE_SINGLE_CLIENT)

  1320.                 {

  1321.                     portName  = m_name;

  1322.                     portName += ":";

  1323.                 }

  1324. #endif

  1325.                 portName += rdf_descriptor->Ports[i].Name;

  1326.                 portName.truncate(portNameSize);

  1327.             }

  1328. 

  1329.             if (LV2_IS_PORT_AUDIO(portType))

  1330.             {

  1331.                 if (LV2_IS_PORT_INPUT(portType))

  1332.                 {

  1333.                     j = aIn.count++;

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

  1335.                     aIn.rindexes[j] = i;

  1336. 

  1337.                     if (forcedStereoIn)

  1338.                     {

  1339.                         portName += "_2";

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

  1341.                         aIn.rindexes[1] = i;

  1342.                     }

  1343.                 }

  1344.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1345.                 {

  1346.                     j = aOut.count++;

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

  1348.                     aOut.rindexes[j] = i;

  1349.                     needsCtrlIn = true;

  1350. 

  1351.                     if (forcedStereoOut)

  1352.                     {

  1353.                         portName += "_2";

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

  1355.                         aOut.rindexes[1] = i;

  1356.                     }

  1357.                 }

  1358.                 else

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

  1360.             }

  1361.             else if (LV2_IS_PORT_CV(portType))

  1362.             {

  1363.                 if (LV2_IS_PORT_INPUT(portType))

  1364.                 {

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

  1366.                 }

  1367.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1368.                 {

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

  1370.                 }

  1371.                 else

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

  1373. 

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

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

  1376.             }

  1377.             else if (LV2_IS_PORT_ATOM_SEQUENCE(portType))

  1378.             {

  1379.                 if (LV2_IS_PORT_INPUT(portType))

  1380.                 {

  1381.                     j = evIn.count++;

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

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

  1384. 

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

  1386. 

  1387.                     if (portType & LV2_PORT_SUPPORTS_MIDI_EVENT)

  1388.                     {

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

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

  1391.                     }

  1392.                     if (portType & LV2_PORT_SUPPORTS_PATCH_MESSAGE)

  1393.                     {

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

  1395.                     }

  1396.                 }

  1397.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1398.                 {

  1399.                     j = evOut.count++;

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

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

  1402. 

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

  1404. 

  1405.                     if (portType & LV2_PORT_SUPPORTS_MIDI_EVENT)

  1406.                     {

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

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

  1409.                     }

  1410.                     if (portType & LV2_PORT_SUPPORTS_PATCH_MESSAGE)

  1411.                     {

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

  1413.                     }

  1414.                 }

  1415.                 else

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

  1417.             }

  1418.             else if (LV2_IS_PORT_EVENT(portType))

  1419.             {

  1420.                 if (LV2_IS_PORT_INPUT(portType))

  1421.                 {

  1422.                     j = evIn.count++;

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

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

  1425. 

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

  1427. 

  1428.                     if (portType & LV2_PORT_SUPPORTS_MIDI_EVENT)

  1429.                     {

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

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

  1432.                     }

  1433.                 }

  1434.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1435.                 {

  1436.                     j = evOut.count++;

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

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

  1439. 

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

  1441. 

  1442.                     if (portType & LV2_PORT_SUPPORTS_MIDI_EVENT)

  1443.                     {

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

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

  1446.                     }

  1447.                 }

  1448.                 else

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

  1450.             }

  1451.             else if (LV2_IS_PORT_MIDI_LL(portType))

  1452.             {

  1453.                 if (LV2_IS_PORT_INPUT(portType))

  1454.                 {

  1455.                     j = evIn.count++;

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

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

  1458. 

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

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

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

  1462.                 }

  1463.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1464.                 {

  1465.                     j = evOut.count++;

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

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

  1468. 

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

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

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

  1472.                 }

  1473.                 else

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

  1475.             }

  1476.             else if (LV2_IS_PORT_CONTROL(portType))

  1477.             {

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

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

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

  1481. 

  1482.                 j = param.count++;

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

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

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

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

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

  1488. 

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

  1490. 

  1491.                 // min value

  1492.                 if (LV2_HAVE_MINIMUM_PORT_POINT(portPoints.Hints))

  1493.                     min = portPoints.Minimum;

  1494.                 else

  1495.                     min = 0.0;

  1496. 

  1497.                 // max value

  1498.                 if (LV2_HAVE_MAXIMUM_PORT_POINT(portPoints.Hints))

  1499.                     max = portPoints.Maximum;

  1500.                 else

  1501.                     max = 1.0;

  1502. 

  1503.                 if (min > max)

  1504.                     max = min;

  1505.                 else if (max < min)

  1506.                     min = max;

  1507. 

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

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

  1510.                 {

  1511.                     min = 0.0;

  1512.                     max = 16777215.0; // 0xffffff

  1513.                 }

  1514. 

  1515.                 if (max - min == 0.0)

  1516.                 {

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

  1518.                     max = min + 0.1;

  1519.                 }

  1520. 

  1521.                 // default value

  1522.                 if (LV2_HAVE_DEFAULT_PORT_POINT(portPoints.Hints))

  1523.                 {

  1524.                     def = portPoints.Default;

  1525.                 }

  1526.                 else

  1527.                 {

  1528.                     // no default value

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

  1530.                         def = 0.0;

  1531.                     else

  1532.                         def = min;

  1533.                 }

  1534. 

  1535.                 if (def < min)

  1536.                     def = min;

  1537.                 else if (def > max)

  1538.                     def = max;

  1539. 

  1540.                 if (LV2_IS_PORT_SAMPLE_RATE(portProps))

  1541.                 {

  1542.                     min *= sampleRate;

  1543.                     max *= sampleRate;

  1544.                     def *= sampleRate;

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

  1546.                 }

  1547. 

  1548.                 if (LV2_IS_PORT_TOGGLED(portProps))

  1549.                 {

  1550.                     step = max - min;

  1551.                     stepSmall = step;

  1552.                     stepLarge = step;

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

  1554.                 }

  1555.                 else if (LV2_IS_PORT_INTEGER(portProps))

  1556.                 {

  1557.                     step = 1.0;

  1558.                     stepSmall = 1.0;

  1559.                     stepLarge = 10.0;

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

  1561.                 }

  1562.                 else

  1563.                 {

  1564.                     double range = max - min;

  1565.                     step = range/100.0;

  1566.                     stepSmall = range/1000.0;

  1567.                     stepLarge = range/10.0;

  1568.                 }

  1569. 

  1570.                 if (LV2_IS_PORT_INPUT(portType))

  1571.                 {

  1572.                     if (LV2_IS_PORT_DESIGNATION_LATENCY(portDesignation))

  1573.                     {

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

  1575.                     }

  1576.                     else if (LV2_IS_PORT_DESIGNATION_SAMPLE_RATE(portDesignation))

  1577.                     {

  1578.                         def = sampleRate;

  1579.                         step = 1.0;

  1580.                         stepSmall = 1.0;

  1581.                         stepLarge = 1.0;

  1582. 

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

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

  1585.                     }

  1586.                     else if (LV2_IS_PORT_DESIGNATION_FREEWHEELING(portDesignation))

  1587.                     {

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

  1589.                     }

  1590.                     else if (LV2_IS_PORT_DESIGNATION_TIME(portDesignation))

  1591.                     {

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

  1593.                     }

  1594.                     else

  1595.                     {

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

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

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

  1599.                         needsCtrlIn = true;

  1600.                     }

  1601. 

  1602.                     // MIDI CC value

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

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

  1605.                     {

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

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

  1608.                     }

  1609.                 }

  1610.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1611.                 {

  1612.                     if (LV2_IS_PORT_DESIGNATION_LATENCY(portDesignation))

  1613.                     {

  1614.                         min = 0.0;

  1615.                         max = sampleRate;

  1616.                         def = 0.0;

  1617.                         step = 1.0;

  1618.                         stepSmall = 1.0;

  1619.                         stepLarge = 1.0;

  1620. 

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

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

  1623.                     }

  1624.                     else if (LV2_IS_PORT_DESIGNATION_SAMPLE_RATE(portDesignation))

  1625.                     {

  1626.                         def = sampleRate;

  1627.                         step = 1.0;

  1628.                         stepSmall = 1.0;

  1629.                         stepLarge = 1.0;

  1630. 

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

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

  1633.                     }

  1634.                     else if (LV2_IS_PORT_DESIGNATION_FREEWHEELING(portDesignation))

  1635.                     {

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

  1637.                     }

  1638.                     else if (LV2_IS_PORT_DESIGNATION_TIME(portDesignation))

  1639.                     {

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

  1641.                     }

  1642.                     else

  1643.                     {

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

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

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

  1647.                         needsCtrlOut = true;

  1648.                     }

  1649.                 }

  1650.                 else

  1651.                 {

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

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

  1654.                 }

  1655. 

  1656.                 // extra parameter hints

  1657.                 if (LV2_IS_PORT_ENUMERATION(portProps))

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

  1659. 

  1660.                 if (LV2_IS_PORT_LOGARITHMIC(portProps))

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

  1662. 

  1663.                 if (LV2_IS_PORT_TRIGGER(portProps))

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

  1665. 

  1666.                 if (LV2_IS_PORT_STRICT_BOUNDS(portProps))

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

  1668. 

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

  1670.                 if (LV2_IS_PORT_NOT_ON_GUI(portProps))

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

  1672. 

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

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

  1675. 

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

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

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

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

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

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

  1682. 

  1683.                 // Start parameters in their default values

  1684.                 paramBuffers[j] = def;

  1685. 

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

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

  1688.             }

  1689.             else

  1690.             {

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

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

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

  1694.             }

  1695.         }

  1696. 

  1697.         if (needsCtrlIn)

  1698.         {

  1699.             portName.clear();

  1700. 

  1701. #ifndef BUILD_BRIDGE

  1702.             if (x_engine->processMode() == PROCESS_MODE_SINGLE_CLIENT)

  1703.             {

  1704.                 portName  = m_name;

  1705.                 portName += ":";

  1706.             }

  1707. #endif

  1708.             portName += "control-in";

  1709.             portName.truncate(portNameSize);

  1710. 

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

  1712.         }

  1713. 

  1714.         if (needsCtrlOut)

  1715.         {

  1716.             portName.clear();

  1717. 

  1718. #ifndef BUILD_BRIDGE

  1719.             if (x_engine->processMode() == PROCESS_MODE_SINGLE_CLIENT)

  1720.             {

  1721.                 portName  = m_name;

  1722.                 portName += ":";

  1723.             }

  1724. #endif

  1725.             portName += "control-out";

  1726.             portName.truncate(portNameSize);

  1727. 

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

  1729.         }

  1730. 

  1731.         aIn.count   = aIns;

  1732.         aOut.count  = aOuts;

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

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

  1735.         param.count = params;

  1736. 

  1737.         // plugin checks

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

  1739. 

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

  1741.             m_hints |= PLUGIN_IS_SYNTH;

  1742. 

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

  1744.             m_hints |= PLUGIN_CAN_DRYWET;

  1745. 

  1746.         if (aOuts > 0)

  1747.             m_hints |= PLUGIN_CAN_VOLUME;

  1748. 

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

  1750.             m_hints |= PLUGIN_CAN_BALANCE;

  1751. 

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

  1753.         {

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

  1755.                 m_hints |= PLUGIN_CAN_FORCE_STEREO;

  1756.         }

  1757.         else

  1758.         {

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

  1760.                 m_hints |= PLUGIN_CAN_FORCE_STEREO;

  1761.         }

  1762. 

  1763.         // check latency

  1764.         if (m_hints & PLUGIN_CAN_DRYWET)

  1765.         {

  1766.             bool hasLatency = false;

  1767.             m_latency = 0;

  1768. 

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

  1770.             {

  1771.                 if (param.data[i].type == PARAMETER_LATENCY)

  1772.                 {

  1773.                     // pre-run so plugin can update latency control-port

  1774.                     float tmpIn[2][aIns];

  1775.                     float tmpOut[2][aOuts];

  1776. 

  1777.                     for (j=0; j < aIn.count; j++)

  1778.                     {

  1779.                         tmpIn[j][0] = 0.0f;

  1780.                         tmpIn[j][1] = 0.0f;

  1781. 

  1782.                         if (j == 0 || ! h2)

  1783.                             descriptor->connect_port(handle, aIn.rindexes[j], tmpIn[j]);

  1784.                     }

  1785. 

  1786.                     for (j=0; j < aOut.count; j++)

  1787.                     {

  1788.                         tmpOut[j][0] = 0.0f;

  1789.                         tmpOut[j][1] = 0.0f;

  1790. 

  1791.                         if (j == 0 || ! h2)

  1792.                             descriptor->connect_port(handle, aOut.rindexes[j], tmpOut[j]);

  1793.                     }

  1794. 

  1795.                     if (descriptor->activate)

  1796.                         descriptor->activate(handle);

  1797. 

  1798.                     descriptor->run(handle, 2);

  1799. 

  1800.                     if (descriptor->deactivate)

  1801.                         descriptor->deactivate(handle);

  1802. 

  1803.                     m_latency = rint(paramBuffers[i]);

  1804.                     hasLatency = true;

  1805.                     break;

  1806.                 }

  1807.             }

  1808. 

  1809.             if (hasLatency)

  1810.             {

  1811.                 x_client->setLatency(m_latency);

  1812.                 recreateLatencyBuffers();

  1813.             }

  1814.         }

  1815. 

  1816.         reloadPrograms(true);

  1817. 

  1818.         x_client->activate();

  1819. 

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

  1821.     }

  1822. 

  1823.     void reloadPrograms(const bool init)

  1824.     {

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

  1826.         uint32_t i, oldCount = midiprog.count;

  1827. 

  1828.         // Delete old programs

  1829.         if (midiprog.count > 0)

  1830.         {

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

  1832.             {

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

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

  1835.             }

  1836. 

  1837.             delete[] midiprog.data;

  1838.         }

  1839. 

  1840.         midiprog.count = 0;

  1841.         midiprog.data  = nullptr;

  1842. 

  1843.         // Query new programs

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

  1845.         {

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

  1847.                 midiprog.count += 1;

  1848.         }

  1849. 

  1850.         if (midiprog.count > 0)

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

  1852. 

  1853.         // Update data

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

  1855.         {

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

  1857.             CARLA_ASSERT(pdesc);

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

  1859.             CARLA_ASSERT(pdesc->name);

  1860. 

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

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

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

  1864.         }

  1865. 

  1866. #ifndef BUILD_BRIDGE

  1867.         // Update OSC Names

  1868.         if (x_engine->isOscControlRegisted())

  1869.         {

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

  1871. 

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

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

  1874.         }

  1875. #endif

  1876. 

  1877.         if (init)

  1878.         {

  1879.             if (midiprog.count > 0)

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

  1881.         }

  1882.         else

  1883.         {

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

  1885. 

  1886.             // Check if current program is invalid

  1887.             bool programChanged = false;

  1888. 

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

  1890.             {

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

  1892.                 midiprog.current = oldCount;

  1893.                 programChanged   = true;

  1894.             }

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

  1896.             {

  1897.                 // current midi program > count

  1898.                 midiprog.current = 0;

  1899.                 programChanged   = true;

  1900.             }

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

  1902.             {

  1903.                 // programs exist now, but not before

  1904.                 midiprog.current = 0;

  1905.                 programChanged   = true;

  1906.             }

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

  1908.             {

  1909.                 // programs existed before, but not anymore

  1910.                 midiprog.current = -1;

  1911.                 programChanged   = true;

  1912.             }

  1913. 

  1914.             if (programChanged)

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

  1916.         }

  1917.     }

  1918. 

  1919.     void prepareForSave()

  1920.     {

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

  1922.         {

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

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

  1925.         }

  1926.     }

  1927. 

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

  1929.     // Plugin processing

  1930. 

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

  1932.     {

  1933.         uint32_t i, k;

  1934.         uint32_t midiEventCount = 0;

  1935. 

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

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

  1938. 

  1939.         // handle events from different APIs

  1940.         uint32_t evInAtomOffsets[evIn.count];

  1941.         LV2_Event_Iterator evInEventIters[evIn.count];

  1942.         LV2_MIDIState evInMidiStates[evIn.count];

  1943. 

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

  1945.         {

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

  1947.             {

  1948.                 evInAtomOffsets[i] = 0;

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

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

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

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

  1953.             }

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

  1955.             {

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

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

  1958.             }

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

  1960.             {

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

  1962.                 evInMidiStates[i].frame_count = frames;

  1963.                 evInMidiStates[i].position = 0;

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

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

  1966.             }

  1967.         }

  1968. 

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

  1970.         {

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

  1972.             {

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

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

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

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

  1977.             }

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

  1979.             {

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

  1981.             }

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

  1983.             {

  1984.                 // not needed

  1985.             }

  1986.         }

  1987. 

  1988.         CARLA_PROCESS_CONTINUE_CHECK;

  1989. 

  1990.         // --------------------------------------------------------------------------------------------------------

  1991.         // Input VU

  1992. 

  1993. #ifndef BUILD_BRIDGE

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

  1995. #else

  1996.         if (aIn.count > 0)

  1997. #endif

  1998.         {

  1999.             if (aIn.count == 1)

  2000.             {

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

  2002.                 {

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

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

  2005.                 }

  2006.             }

  2007.             else if (aIn.count > 1)

  2008.             {

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

  2010.                 {

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

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

  2013. 

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

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

  2016.                 }

  2017.             }

  2018.         }

  2019. 

  2020.         CARLA_PROCESS_CONTINUE_CHECK;

  2021. 

  2022.         // --------------------------------------------------------------------------------------------------------

  2023.         // Parameters Input [Automation]

  2024. 

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

  2026.         {

  2027.             bool allNotesOffSent = false;

  2028. 

  2029.             const CarlaEngineControlEvent* cinEvent;

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

  2031. 

  2032.             uint32_t nextBankId = 0;

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

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

  2035. 

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

  2037.             {

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

  2039. 

  2040.                 if (! cinEvent)

  2041.                     continue;

  2042. 

  2043.                 time = cinEvent->time - framesOffset;

  2044. 

  2045.                 if (time >= frames)

  2046.                     continue;

  2047. 

  2048.                 // Control change

  2049.                 switch (cinEvent->type)

  2050.                 {

  2051.                 case CarlaEngineNullEvent:

  2052.                     break;

  2053. 

  2054.                 case CarlaEngineParameterChangeEvent:

  2055.                 {

  2056.                     double value;

  2057. 

  2058.                     // Control backend stuff

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

  2060.                     {

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

  2062.                         {

  2063.                             value = cinEvent->value;

  2064.                             setDryWet(value, false, false);

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

  2066.                             continue;

  2067.                         }

  2068. 

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

  2070.                         {

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

  2072.                             setVolume(value, false, false);

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

  2074.                             continue;

  2075.                         }

  2076. 

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

  2078.                         {

  2079.                             double left, right;

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

  2081. 

  2082.                             if (value < 0.0)

  2083.                             {

  2084.                                 left  = -1.0;

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

  2086.                             }

  2087.                             else if (value > 0.0)

  2088.                             {

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

  2090.                                 right = 1.0;

  2091.                             }

  2092.                             else

  2093.                             {

  2094.                                 left  = -1.0;

  2095.                                 right = 1.0;

  2096.                             }

  2097. 

  2098.                             setBalanceLeft(left, false, false);

  2099.                             setBalanceRight(right, false, false);

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

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

  2102.                             continue;

  2103.                         }

  2104.                     }

  2105. 

  2106.                     // Control plugin parameters

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

  2108.                     {

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

  2110.                             continue;

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

  2112.                             continue;

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

  2114.                             continue;

  2115. 

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

  2117.                         {

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

  2119.                             {

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

  2121.                             }

  2122.                             else

  2123.                             {

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

  2125. 

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

  2127.                                     value = rint(value);

  2128.                             }

  2129. 

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

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

  2132.                         }

  2133.                     }

  2134. 

  2135.                     break;

  2136.                 }

  2137. 

  2138.                 case CarlaEngineMidiBankChangeEvent:

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

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

  2141.                     break;

  2142. 

  2143.                 case CarlaEngineMidiProgramChangeEvent:

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

  2145.                     {

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

  2147. 

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

  2149.                         {

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

  2151.                             {

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

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

  2154.                                 break;

  2155.                             }

  2156.                         }

  2157.                     }

  2158.                     break;

  2159. 

  2160.                 case CarlaEngineAllSoundOffEvent:

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

  2162.                     {

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

  2164.                             sendMidiAllNotesOff();

  2165. 

  2166.                         if (descriptor->deactivate)

  2167.                         {

  2168.                             descriptor->deactivate(handle);

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

  2170.                         }

  2171. 

  2172.                         if (descriptor->activate)

  2173.                         {

  2174.                             descriptor->activate(handle);

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

  2176.                         }

  2177. 

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

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

  2180. 

  2181.                         allNotesOffSent = true;

  2182.                     }

  2183.                     break;

  2184. 

  2185.                 case CarlaEngineAllNotesOffEvent:

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

  2187.                     {

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

  2189.                             sendMidiAllNotesOff();

  2190. 

  2191.                         allNotesOffSent = true;

  2192.                     }

  2193.                     break;

  2194.                 }

  2195.             }

  2196.         } // End of Parameters Input

  2197. 

  2198.         CARLA_PROCESS_CONTINUE_CHECK;

  2199. 

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

  2201.         // Event Input

  2202. 

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

  2204.         {

  2205.             // ----------------------------------------------------------------------------------------------------

  2206.             // MIDI Input (External)

  2207. 

  2208.             {

  2209.                 engineMidiLock();

  2210. 

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

  2212.                 {

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

  2214.                         break;

  2215. 

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

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

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

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

  2220. 

  2221.                     // send to first midi input

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

  2223.                     {

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

  2225.                         {

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

  2227.                             {

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

  2229.                                 aev->time.frames = 0;

  2230.                                 aev->body.type   = CARLA_URI_MAP_ID_MIDI_EVENT;

  2231.                                 aev->body.size   = 3;

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

  2233. 

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

  2235.                                 evInAtomOffsets[k]           += evInPadSize;

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

  2237.                             }

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

  2239.                             {

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

  2241.                             }

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

  2243.                             {

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

  2245.                             }

  2246. 

  2247.                             break;

  2248.                         }

  2249.                     }

  2250. 

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

  2252.                     midiEventCount += 1;

  2253.                 }

  2254. 

  2255.                 engineMidiUnlock();

  2256. 

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

  2258. 

  2259.             CARLA_PROCESS_CONTINUE_CHECK;

  2260. 

  2261.             // ----------------------------------------------------------------------------------------------------

  2262.             // MIDI Input (System)

  2263. 

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

  2265.             {

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

  2267.                     continue;

  2268. 

  2269.                 const CarlaEngineMidiEvent* minEvent;

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

  2271. 

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

  2273.                 {

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

  2275. 

  2276.                     if (! minEvent)

  2277.                         continue;

  2278. 

  2279.                     time = minEvent->time - framesOffset;

  2280. 

  2281.                     if (time >= frames)

  2282.                         continue;

  2283. 

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

  2285.                     uint8_t channel = status & 0x0F;

  2286. 

  2287.                     // Fix bad note-off

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

  2289.                         status -= 0x10;

  2290. 

  2291.                     // only write supported status types

  2292.                     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))

  2293.                     {

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

  2295.                         {

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

  2297.                             aev->time.frames = time;

  2298.                             aev->body.type   = CARLA_URI_MAP_ID_MIDI_EVENT;

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

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

  2301. 

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

  2303.                             evInAtomOffsets[i]           += evInPadSize;

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

  2305.                         }

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

  2307.                         {

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

  2309.                         }

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

  2311.                         {

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

  2313.                         }

  2314. 

  2315.                         if (MIDI_IS_STATUS_NOTE_OFF(status))

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

  2317.                         else if (MIDI_IS_STATUS_NOTE_ON(status))

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

  2319.                     }

  2320. 

  2321.                     midiEventCount += 1;

  2322.                 }

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

  2324. 

  2325.             // ----------------------------------------------------------------------------------------------------

  2326.             // Message Input

  2327. 

  2328.             {

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

  2330.                 {

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

  2332.                         continue;

  2333. 

  2334. #if 0

  2335.                      // send transport info if changed

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

  2337. 

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

  2339.                     {

  2340.                         uint8_t posBuf[256];

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

  2342. 

  2343.                         LV2_Atom_Forge tempForge;

  2344.                         LV2_Atom_Forge* const forge = &tempForge;

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

  2346. 

  2347.                         //LV2_Atom_Forge_Frame frame;

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

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

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

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

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

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

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

  2355. 

  2356.                         if (timeInfo->valid & CarlaEngineTimeBBT)

  2357.                         {

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

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

  2360. 

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

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

  2363. 

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

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

  2366. 

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

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

  2369. 

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

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

  2372. 

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

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

  2375.                         }

  2376. 

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

  2378.                         aev->time.frames = framesOffset;

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

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

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

  2382. 

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

  2384.                         evInAtomOffsets[i]           += evInPadSize;

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

  2386. 

  2387.                         lastTimePosPlaying = timeInfo->playing;

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

  2389.                     }

  2390. #endif

  2391. 

  2392.                     atomQueueIn.lock();

  2393. 

  2394.                     if (! atomQueueIn.isEmpty())

  2395.                     {

  2396.                         uint32_t portIndex;

  2397.                         const LV2_Atom* atom;

  2398. 

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

  2400.                         {

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

  2402.                             {

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

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

  2405.                                 continue;

  2406.                             }

  2407. 

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

  2409.                             aev->time.frames = framesOffset;

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

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

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

  2413. 

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

  2415.                             evInAtomOffsets[i]           += evInPadSize;

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

  2417.                         }

  2418.                     }

  2419. 

  2420.                     atomQueueIn.unlock();

  2421.                 }

  2422.             }

  2423. 

  2424.         } // End of Event Input

  2425. 

  2426.         CARLA_PROCESS_CONTINUE_CHECK;

  2427. 

  2428.         // --------------------------------------------------------------------------------------------------------

  2429.         // Special Parameters

  2430. 

  2431.         {

  2432.             int32_t rindex;

  2433.             const CarlaEngineTimeInfo* const timeInfo = x_engine->getTimeInfo();

  2434. 

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

  2436.             {

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

  2438.                 {

  2439.                     // TODO

  2440.                 }

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

  2442.                 {

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

  2444.                 }

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

  2446.                 {

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

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

  2449. 

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

  2451.                     {

  2452.                     // Non-BBT

  2453.                     case LV2_PORT_DESIGNATION_TIME_FRAME:

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

  2455.                         break;

  2456.                     case LV2_PORT_DESIGNATION_TIME_FRAMES_PER_SECOND:

  2457.                         break;

  2458.                     case LV2_PORT_DESIGNATION_TIME_POSITION:

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

  2460.                         break;

  2461.                     case LV2_PORT_DESIGNATION_TIME_SPEED:

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

  2463.                         break;

  2464.                     // BBT

  2465.                     case LV2_PORT_DESIGNATION_TIME_BAR:

  2466.                         if (timeInfo->valid & CarlaEngineTimeBBT)

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

  2468.                         break;

  2469.                     case LV2_PORT_DESIGNATION_TIME_BAR_BEAT:

  2470.                         if (timeInfo->valid & CarlaEngineTimeBBT)

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

  2472.                         break;

  2473.                     case LV2_PORT_DESIGNATION_TIME_BEAT:

  2474.                         if (timeInfo->valid & CarlaEngineTimeBBT)

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

  2476.                         break;

  2477.                     case LV2_PORT_DESIGNATION_TIME_BEAT_UNIT:

  2478.                         if (timeInfo->valid & CarlaEngineTimeBBT)

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

  2480.                         break;

  2481.                     case LV2_PORT_DESIGNATION_TIME_BEATS_PER_BAR:

  2482.                         if (timeInfo->valid & CarlaEngineTimeBBT)

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

  2484.                         break;

  2485.                     case LV2_PORT_DESIGNATION_TIME_BEATS_PER_MINUTE:

  2486.                         if (timeInfo->valid & CarlaEngineTimeBBT)

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

  2488.                         break;

  2489.                     }

  2490.                 }

  2491.             }

  2492.         }

  2493. 

  2494.         CARLA_PROCESS_CONTINUE_CHECK;

  2495. 

  2496.         // --------------------------------------------------------------------------------------------------------

  2497.         // Plugin processing

  2498. 

  2499.         if (m_active)

  2500.         {

  2501.             if (! m_activeBefore)

  2502.             {

  2503.                 if (evIn.count > 0)

  2504.                 {

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

  2506.                     {

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

  2508.                         midiEvent1[0] = MIDI_STATUS_CONTROL_CHANGE + i;

  2509.                         midiEvent1[1] = MIDI_CONTROL_ALL_SOUND_OFF;

  2510. 

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

  2512.                         midiEvent2[0] = MIDI_STATUS_CONTROL_CHANGE + i;

  2513.                         midiEvent2[1] = MIDI_CONTROL_ALL_SOUND_OFF;

  2514. 

  2515.                         // send to all midi inputs

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

  2517.                         {

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

  2519.                             {

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

  2521.                                 {

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

  2523. 

  2524.                                     // all sound off

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

  2526.                                     aev1->time.frames = 0;

  2527.                                     aev1->body.type   = CARLA_URI_MAP_ID_MIDI_EVENT;

  2528.                                     aev1->body.size   = 2;

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

  2530. 

  2531.                                     evInAtomOffsets[k]           += padSize;

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

  2533. 

  2534.                                     // all notes off

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

  2536.                                     aev2->time.frames = 0;

  2537.                                     aev2->body.type   = CARLA_URI_MAP_ID_MIDI_EVENT;

  2538.                                     aev2->body.size   = 2;

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

  2540. 

  2541.                                     evInAtomOffsets[k]           += padSize;

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

  2543.                                 }

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

  2545.                                 {

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

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

  2548.                                 }

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

  2550.                                 {

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

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

  2553.                                 }

  2554.                             }

  2555.                         }

  2556.                     }

  2557. 

  2558.                     midiEventCount = MAX_MIDI_CHANNELS*2;

  2559.                 }

  2560. 

  2561.                 if (m_latency > 0)

  2562.                 {

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

  2564.                         memset(m_latencyBuffers[i], 0, sizeof(float)*m_latency);

  2565.                 }

  2566. 

  2567.                 if (descriptor->activate)

  2568.                 {

  2569.                     descriptor->activate(handle);

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

  2571.                 }

  2572.             }

  2573. 

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

  2575.             {

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

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

  2578.             }

  2579. 

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

  2581.             {

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

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

  2584.             }

  2585. 

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

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

  2588. 

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

  2590.             {

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

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

  2593.             }

  2594.         }

  2595.         else

  2596.         {

  2597.             if (m_activeBefore)

  2598.             {

  2599.                 if (descriptor->deactivate)

  2600.                 {

  2601.                     descriptor->deactivate(handle);

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

  2603.                 }

  2604.             }

  2605.         }

  2606. 

  2607.         CARLA_PROCESS_CONTINUE_CHECK;

  2608. 

  2609.         // --------------------------------------------------------------------------------------------------------

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

  2611. 

  2612.         if (m_active)

  2613.         {

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

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

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

  2617. 

  2618.             double bal_rangeL, bal_rangeR;

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

  2620. 

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

  2622.             {

  2623.                 // Dry/Wet

  2624.                 if (do_drywet)

  2625.                 {

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

  2627.                     {

  2628.                         if (k < m_latency && m_latency < frames)

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

  2630.                         else

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

  2632. 

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

  2634.                     }

  2635.                 }

  2636. 

  2637.                 // Balance

  2638.                 if (do_balance)

  2639.                 {

  2640.                     if (i%2 == 0)

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

  2642. 

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

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

  2645. 

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

  2647.                     {

  2648.                         if (i%2 == 0)

  2649.                         {

  2650.                             // left output

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

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

  2653.                         }

  2654.                         else

  2655.                         {

  2656.                             // right

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

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

  2659.                         }

  2660.                     }

  2661.                 }

  2662. 

  2663.                 // Volume

  2664.                 if (do_volume)

  2665.                 {

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

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

  2668.                 }

  2669. 

  2670.                 // Output VU

  2671. #ifndef BUILD_BRIDGE

  2672.                 if (x_engine->processMode() != PROCESS_MODE_CONTINUOUS_RACK)

  2673. #endif

  2674.                 {

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

  2676.                     {

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

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

  2679.                     }

  2680.                 }

  2681.             }

  2682. 

  2683.             // Latency, save values for next callback

  2684.             if (m_latency > 0 && m_latency < frames)

  2685.             {

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

  2687.                     memcpy(m_latencyBuffers[i], inBuffer[i] + (frames - m_latency), sizeof(float)*m_latency);

  2688.             }

  2689.         }

  2690.         else

  2691.         {

  2692.             // disable any output sound if not active

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

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

  2695. 

  2696.             aOutsPeak[0] = 0.0;

  2697.             aOutsPeak[1] = 0.0;

  2698. 

  2699.         } // End of Post-processing

  2700. 

  2701.         CARLA_PROCESS_CONTINUE_CHECK;

  2702. 

  2703.         // --------------------------------------------------------------------------------------------------------

  2704.         // Control Output

  2705. 

  2706.         if (param.portCout && m_active)

  2707.         {

  2708.             double value;

  2709. 

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

  2711.             {

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

  2713.                 {

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

  2715. 

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

  2717.                     {

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

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

  2720.                     }

  2721.                 }

  2722.             }

  2723.         } // End of Control Output

  2724. 

  2725.         CARLA_PROCESS_CONTINUE_CHECK;

  2726. 

  2727.         // --------------------------------------------------------------------------------------------------------

  2728.         // Event Output

  2729. 

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

  2731.         {

  2732.             atomQueueOut.lock();

  2733. 

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

  2735.             {

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

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

  2738.                     continue;

  2739. 

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

  2741.                 {

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

  2743.                     int32_t offset = 0;

  2744. 

  2745.                     while (offset < size)

  2746.                     {

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

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

  2749. 

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

  2751.                             break;

  2752. 

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

  2754. 

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

  2756.                         {

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

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

  2759.                         }

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

  2761.                         {

  2762.                             if (! atomQueueOut.isFull())

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

  2764.                         }

  2765. 

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

  2767.                     }

  2768.                 }

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

  2770.                 {

  2771.                     const LV2_Event* ev;

  2772.                     LV2_Event_Iterator iter;

  2773. 

  2774.                     uint8_t* data;

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

  2776. 

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

  2778.                     {

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

  2780. 

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

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

  2783. 

  2784.                         lv2_event_increment(&iter);

  2785.                     }

  2786.                 }

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

  2788.                 {

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

  2790. 

  2791.                     uint32_t eventSize;

  2792.                     double   eventTime;

  2793.                     unsigned char* eventData;

  2794. 

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

  2796.                     {

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

  2798.                         lv2midi_step(&state);

  2799.                     }

  2800.                 }

  2801.             }

  2802. 

  2803.             atomQueueOut.unlock();

  2804. 

  2805.         } // End of Event Output

  2806. 

  2807.         CARLA_PROCESS_CONTINUE_CHECK;

  2808. 

  2809.         // --------------------------------------------------------------------------------------------------------

  2810.         // Peak Values

  2811. 

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

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

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

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

  2816. 

  2817.         m_activeBefore = m_active;

  2818.     }

  2819. 

  2820.     void bufferSizeChanged(const uint32_t newBufferSize)

  2821.     {

  2822.         lv2Options.bufferSize = newBufferSize;

  2823.     }

  2824. 

  2825.     // -------------------------------------------------------------------

  2826.     // Post-poned events

  2827. 

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

  2829.     {

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

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

  2832. 

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

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

  2835.     }

  2836. 

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

  2838.     {

  2839.         CARLA_ASSERT(index < param.count);

  2840. 

  2841.         if (index >= param.count)

  2842.             return;

  2843. 

  2844. #ifndef BUILD_BRIDGE

  2845.         if (gui.type == GUI_EXTERNAL_OSC)

  2846.         {

  2847.             if (osc.data.target)

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

  2849.         }

  2850.         else

  2851. #endif

  2852.         {

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

  2854.             {

  2855.                 float valueF = value;

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

  2857.             }

  2858.         }

  2859.     }

  2860. 

  2861.     void uiMidiProgramChange(const uint32_t index)

  2862.     {

  2863.         CARLA_ASSERT(index < midiprog.count);

  2864. 

  2865.         if (index >= midiprog.count)

  2866.             return;

  2867. 

  2868. #ifndef BUILD_BRIDGE

  2869.         if (gui.type == GUI_EXTERNAL_OSC)

  2870.         {

  2871.             if (osc.data.target)

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

  2873.         }

  2874.         else

  2875. #endif

  2876.         {

  2877.             if (ext.uiprograms)

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

  2879.         }

  2880.     }

  2881. 

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

  2883.     {

  2884.         CARLA_ASSERT(channel < 16);

  2885.         CARLA_ASSERT(note < 128);

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

  2887. 

  2888. #ifndef BUILD_BRIDGE

  2889.         if (gui.type == GUI_EXTERNAL_OSC)

  2890.         {

  2891.             if (osc.data.target)

  2892.             {

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

  2894.                 midiData[1] = MIDI_STATUS_NOTE_ON + channel;

  2895.                 midiData[2] = note;

  2896.                 midiData[3] = velo;

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

  2898.             }

  2899.         }

  2900.         else

  2901. #endif

  2902.         {

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

  2904.             {

  2905.                 LV2_Atom_MidiEvent midiEv;

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

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

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

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

  2910.                 midiEv.data[1] = note;

  2911.                 midiEv.data[2] = velo;

  2912. 

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

  2914.             }

  2915.         }

  2916.     }

  2917. 

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

  2919.     {

  2920.         CARLA_ASSERT(channel < 16);

  2921.         CARLA_ASSERT(note < 128);

  2922. 

  2923. #ifndef BUILD_BRIDGE

  2924.         if (gui.type == GUI_EXTERNAL_OSC)

  2925.         {

  2926.             if (osc.data.target)

  2927.             {

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

  2929.                 midiData[1] = MIDI_STATUS_NOTE_OFF + channel;

  2930.                 midiData[2] = note;

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

  2932.             }

  2933.         }

  2934.         else

  2935. #endif

  2936.         {

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

  2938.             {

  2939.                 LV2_Atom_MidiEvent midiEv;

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

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

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

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

  2944.                 midiEv.data[1] = note;

  2945.                 midiEv.data[2] = 0;

  2946. 

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

  2948.             }

  2949.         }

  2950.     }

  2951. 

  2952.     // -------------------------------------------------------------------

  2953.     // Cleanup

  2954. 

  2955.     void removeClientPorts()

  2956.     {

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

  2958. 

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

  2960.         {

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

  2962.             {

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

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

  2965.             }

  2966.         }

  2967. 

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

  2969.         {

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

  2971.             {

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

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

  2974.             }

  2975.         }

  2976. 

  2977.         CarlaPlugin::removeClientPorts();

  2978. 

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

  2980.     }

  2981. 

  2982.     void initBuffers()

  2983.     {

  2984.         uint32_t i;

  2985. 

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

  2987.         {

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

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

  2990.         }

  2991. 

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

  2993.         {

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

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

  2996.         }

  2997. 

  2998.         CarlaPlugin::initBuffers();

  2999.     }

  3000. 

  3001.     void deleteBuffers()

  3002.     {

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

  3004. 

  3005.         if (evIn.count > 0)

  3006.         {

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

  3008.             {

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

  3010.                 {

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

  3012.                 }

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

  3014.                 {

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

  3016.                 }

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

  3018.                 {

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

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

  3021.                 }

  3022.             }

  3023. 

  3024.             delete[] evIn.data;

  3025.         }

  3026. 

  3027.         if (evOut.count > 0)

  3028.         {

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

  3030.             {

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

  3032.                 {

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

  3034.                 }

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

  3036.                 {

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

  3038.                 }

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

  3040.                 {

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

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

  3043.                 }

  3044.             }

  3045. 

  3046.             delete[] evOut.data;

  3047.         }

  3048. 

  3049.         if (param.count > 0)

  3050.             delete[] paramBuffers;

  3051. 

  3052.         evIn.count = 0;

  3053.         evIn.data  = nullptr;

  3054. 

  3055.         evOut.count = 0;

  3056.         evOut.data  = nullptr;

  3057. 

  3058.         paramBuffers = nullptr;

  3059. 

  3060.         CarlaPlugin::deleteBuffers();

  3061. 

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

  3063.     }

  3064. 

  3065.     // -------------------------------------------------------------------

  3066. 

  3067.     uint32_t getCustomURID(const char* const uri)

  3068.     {

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

  3070.         CARLA_ASSERT(uri);

  3071. 

  3072.         if (! uri)

  3073.             return CARLA_URI_MAP_ID_NULL;

  3074. 

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

  3076.         {

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

  3078.                 return i;

  3079.         }

  3080. 

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

  3082. 

  3083.         return customURIDs.size()-1;

  3084.     }

  3085. 

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

  3087.     {

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

  3089.         CARLA_ASSERT(urid > CARLA_URI_MAP_ID_NULL);

  3090. 

  3091.         if (urid == CARLA_URI_MAP_ID_NULL)

  3092.             return nullptr;

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

  3094.             return customURIDs[urid];

  3095. 

  3096.         return nullptr;

  3097.     }

  3098. 

  3099.     // -------------------------------------------------------------------

  3100. 

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

  3102.     {

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

  3104.         CARLA_ASSERT(portIndex >= 0);

  3105.         CARLA_ASSERT(atom);

  3106. 

  3107.         atomQueueIn.put(portIndex, atom);

  3108.     }

  3109. 

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

  3111.     {

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

  3113.         CARLA_ASSERT(portIndex >= 0);

  3114.         CARLA_ASSERT(atom);

  3115. 

  3116.         atomQueueIn.put(portIndex, atom);

  3117.     }

  3118. 

  3119.     // -------------------------------------------------------------------

  3120. 

  3121.     void handleProgramChanged(const int32_t index)

  3122.     {

  3123.         if (index == -1)

  3124.         {

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

  3126.             reloadPrograms(false);

  3127.         }

  3128.         else

  3129.         {

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

  3131.             {

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

  3133.                 CARLA_ASSERT(progName);

  3134. 

  3135.                 if (prog.names[index])

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

  3137. 

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

  3139.             }

  3140.         }

  3141. 

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

  3143.     }

  3144. 

  3145.     LV2_State_Status handleStateStore(const uint32_t key, const void* const value, const size_t size, const uint32_t type, const uint32_t flags)

  3146.     {

  3147.         CARLA_ASSERT(key > 0);

  3148.         CARLA_ASSERT(value);

  3149. 

  3150.         const char* const stype  = getCustomURIString(type);

  3151.         const char* const uriKey = getCustomURIString(key);

  3152. 

  3153.         // do basic checks

  3154.         if (! uriKey)

  3155.         {

  3156.             qWarning("Lv2Plugin::handleStateStore(%i, %p, " P_SIZE ", %i, %i) - invalid key", key, value, size, type, flags);

  3157.             return LV2_STATE_ERR_NO_PROPERTY;

  3158.         }

  3159. 

  3160.         if (! flags & LV2_STATE_IS_POD)

  3161.         {

  3162.             qWarning("Lv2Plugin::handleStateStore(%i, %p, " P_SIZE ", %i, %i) - invalid flags", key, value, size, type, flags);

  3163.             return LV2_STATE_ERR_BAD_FLAGS;

  3164.         }

  3165. 

  3166.         if (! stype)

  3167.         {

  3168.             qCritical("Lv2Plugin::handleStateStore(%i, %p, " P_SIZE ", %i, %i) - invalid type", key, value, size, type, flags);

  3169.             return LV2_STATE_ERR_BAD_TYPE;

  3170.         }

  3171. 

  3172.         // Check if we already have this key

  3173.         for (size_t i=0; i < custom.size(); i++)

  3174.         {

  3175.             if (strcmp(custom[i].key, uriKey) == 0)

  3176.             {

  3177.                 free((void*)custom[i].value);

  3178. 

  3179.                 if (strcmp(stype, LV2_ATOM__String) == 0 || strcmp(stype, LV2_ATOM__Path) == 0)

  3180.                     custom[i].value = strdup((const char*)value);

  3181.                 else

  3182.                     custom[i].value = strdup(QByteArray((const char*)value, size).toBase64().constData());

  3183. 

  3184.                 return LV2_STATE_SUCCESS;

  3185.             }

  3186.         }

  3187. 

  3188.         // Otherwise store it

  3189.         CustomData newData;

  3190.         newData.type = strdup(stype);

  3191.         newData.key  = strdup(uriKey);

  3192. 

  3193.         if (strcmp(stype, LV2_ATOM__String) == 0 || strcmp(stype, LV2_ATOM__Path) == 0)

  3194.             newData.value = strdup((const char*)value);

  3195.         else

  3196.             newData.value = strdup(QByteArray((const char*)value, size).toBase64().constData());

  3197. 

  3198.         custom.push_back(newData);

  3199. 

  3200.         return LV2_STATE_SUCCESS;

  3201.     }

  3202. 

  3203.     const void* handleStateRetrieve(const uint32_t key, size_t* const size, uint32_t* const type, uint32_t* const flags)

  3204.     {

  3205.         CARLA_ASSERT(key > CARLA_URI_MAP_ID_NULL);

  3206. 

  3207.         const char* const uriKey = getCustomURIString(key);

  3208. 

  3209.         if (! uriKey)

  3210.         {

  3211.             qCritical("Lv2Plugin::handleStateRetrieve(%i, %p, %p, %p) - failed to find key", key, size, type, flags);

  3212.             return nullptr;

  3213.         }

  3214. 

  3215.         const char* stype = nullptr;

  3216.         const char* stringData = nullptr;

  3217. 

  3218.         for (size_t i=0; i < custom.size(); i++)

  3219.         {

  3220.             if (strcmp(custom[i].key, uriKey) == 0)

  3221.             {

  3222.                 stype      = custom[i].type;

  3223.                 stringData = custom[i].value;

  3224.                 break;

  3225.             }

  3226.         }

  3227. 

  3228.         if (! stringData)

  3229.         {

  3230.             qCritical("Lv2Plugin::handleStateRetrieve(%i, %p, %p, %p) - invalid key '%s'", key, size, type, flags, uriKey);

  3231.             return nullptr;

  3232.         }

  3233. 

  3234.         *size  = 0;

  3235.         *type  = key;

  3236.         *flags = LV2_STATE_IS_POD;

  3237. 

  3238.         if (strcmp(stype, LV2_ATOM__String) == 0)

  3239.         {

  3240.             *size = strlen(stringData);

  3241.             return stringData;

  3242.         }

  3243.         else if (strcmp(stype, LV2_ATOM__Path) == 0)

  3244.         {

  3245.             *size = strlen(stringData);

  3246.             return stringData;

  3247.         }

  3248.         else

  3249.         {

  3250.             static QByteArray chunk;

  3251.             chunk = QByteArray::fromBase64(stringData);

  3252.             *size = chunk.size();

  3253.             return chunk.constData();

  3254.         }

  3255. 

  3256.         qCritical("Lv2Plugin::handleStateRetrieve(%i, %p, %p, %p) - invalid key type '%s'", key, size, type, flags, stype);

  3257.         return nullptr;

  3258.     }

  3259. 

  3260.     LV2_Worker_Status handleWorkerSchedule(const uint32_t size, const void* const data)

  3261.     {

  3262.         if (! ext.worker)

  3263.         {

  3264.             qWarning("Lv2Plugin::handleWorkerSchedule(%i, %p) - plugin has no worker", size, data);

  3265.             return LV2_WORKER_ERR_UNKNOWN;

  3266.         }

  3267. 

  3268.         if (x_engine->isOffline())

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

  3270.         else

  3271.             postponeEvent(PluginPostEventCustom, size, 0, 0.0, data);

  3272. 

  3273.         return LV2_WORKER_SUCCESS;

  3274.     }

  3275. 

  3276.     LV2_Worker_Status handleWorkerRespond(const uint32_t size, const void* const data)

  3277.     {

  3278.         LV2_Atom_Worker workerAtom;

  3279.         workerAtom.atom.type = CARLA_URI_MAP_ID_ATOM_WORKER;

  3280.         workerAtom.atom.size = sizeof(LV2_Atom_Worker_Body);

  3281.         workerAtom.body.size = size;

  3282.         workerAtom.body.data = data;

  3283. 

  3284.         atomQueueIn.put(0, (const LV2_Atom*)&workerAtom);

  3285. 

  3286.         return LV2_WORKER_SUCCESS;

  3287.     }

  3288. 

  3289.     void handleExternalUiClosed()

  3290.     {

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

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

  3293. 

  3294.         ui.handle = nullptr;

  3295.         x_engine->callback(CALLBACK_SHOW_GUI, m_id, 0, 0, 0.0, nullptr);

  3296.     }

  3297. 

  3298.     uint32_t handleUiPortMap(const char* const symbol)

  3299.     {

  3300.         CARLA_ASSERT(symbol);

  3301. 

  3302.         if (! symbol)

  3303.             return LV2UI_INVALID_PORT_INDEX;

  3304. 

  3305.         for (uint32_t i=0; i < rdf_descriptor->PortCount; i++)

  3306.         {

  3307.             if (strcmp(rdf_descriptor->Ports[i].Symbol, symbol) == 0)

  3308.                 return i;

  3309.         }

  3310. 

  3311.         return LV2UI_INVALID_PORT_INDEX;

  3312.     }

  3313. 

  3314.     int handleUiResize(const int width, const int height)

  3315.     {

  3316.         CARLA_ASSERT(width > 0);

  3317.         CARLA_ASSERT(height > 0);

  3318. 

  3319.         if (width <= 0 || height <= 0)

  3320.             return 1;

  3321. 

  3322.         gui.width  = width;

  3323.         gui.height = height;

  3324.         x_engine->callback(CALLBACK_RESIZE_GUI, m_id, width, height, 0.0, nullptr);

  3325. 

  3326.         return 0;

  3327.     }

  3328. 

  3329.     void handleUiWrite(const uint32_t rindex, const uint32_t bufferSize, const uint32_t format, const void* const buffer)

  3330.     {

  3331.         if (format == 0)

  3332.         {

  3333.             CARLA_ASSERT(buffer);

  3334.             CARLA_ASSERT(bufferSize == sizeof(float));

  3335. 

  3336.             if (bufferSize != sizeof(float))

  3337.                 return;

  3338. 

  3339.             float value = *(float*)buffer;

  3340. 

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

  3342.             {

  3343.                 if (param.data[i].rindex == (int32_t)rindex)

  3344.                     return setParameterValue(i, value, false, true, true);

  3345.             }

  3346.         }

  3347.         else if (format == CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM)

  3348.         {

  3349.             CARLA_ASSERT(buffer);

  3350. 

  3351.             const LV2_Atom* const atom = (const LV2_Atom*)buffer;

  3352.             handleTransferAtom(rindex, atom);

  3353.         }

  3354.         else if (format == CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT)

  3355.         {

  3356.             CARLA_ASSERT(buffer);

  3357. 

  3358.             const LV2_Atom* const atom = (const LV2_Atom*)buffer;

  3359.             handleTransferEvent(rindex, atom);

  3360.         }

  3361.     }

  3362. 

  3363.     // -------------------------------------------------------------------

  3364. 

  3365. #ifndef BUILD_BRIDGE

  3366.     const char* getUiBridgePath(const LV2_Property type)

  3367.     {

  3368.         const CarlaEngineOptions options(x_engine->getOptions());

  3369. 

  3370.         switch (type)

  3371.         {

  3372.         case LV2_UI_GTK2:

  3373.             return options.bridge_lv2gtk2;

  3374.         case LV2_UI_GTK3:

  3375.             return options.bridge_lv2gtk3;

  3376.         case LV2_UI_QT4:

  3377.             return options.bridge_lv2qt4;

  3378.         case LV2_UI_COCOA:

  3379.             return options.bridge_lv2cocoa;

  3380.         case LV2_UI_WINDOWS:

  3381.             return options.bridge_lv2win;

  3382.         case LV2_UI_X11:

  3383.             return options.bridge_lv2x11;

  3384.         default:

  3385.             return nullptr;

  3386.         }

  3387.     }

  3388. 

  3389.     bool isUiBridgeable(const uint32_t uiId)

  3390.     {

  3391.         CARLA_ASSERT(rdf_descriptor);

  3392.         CARLA_ASSERT(uiId < rdf_descriptor->UICount);

  3393. 

  3394.         if (uiId >= rdf_descriptor->UICount)

  3395.             return false;

  3396. 

  3397.         const LV2_RDF_UI* const rdf_ui = &rdf_descriptor->UIs[uiId];

  3398. 

  3399.         for (uint32_t i=0; i < rdf_ui->FeatureCount; i++)

  3400.         {

  3401.             if (strcmp(rdf_ui->Features[i].URI, LV2_INSTANCE_ACCESS_URI) == 0 || strcmp(rdf_ui->Features[i].URI, LV2_DATA_ACCESS_URI) == 0)

  3402.                 return false;

  3403.         }

  3404. 

  3405.         return true;

  3406.     }

  3407. #endif

  3408. 

  3409.     bool isUiResizable()

  3410.     {

  3411.         CARLA_ASSERT(ui.rdf_descriptor);

  3412. 

  3413.         if (! ui.rdf_descriptor)

  3414.             return false;

  3415. 

  3416.         for (uint32_t i=0; i < ui.rdf_descriptor->FeatureCount; i++)

  3417.         {

  3418.             if (strcmp(ui.rdf_descriptor->Features[i].URI, LV2_UI__fixedSize) == 0 || strcmp(ui.rdf_descriptor->Features[i].URI, LV2_UI__noUserResize) == 0)

  3419.                 return false;

  3420.         }

  3421. 

  3422.         return true;

  3423.     }

  3424. 

  3425.     void initExternalUi()

  3426.     {

  3427.         qDebug("Lv2Plugin::initExternalUi()");

  3428. 

  3429.         ui.widget = nullptr;

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

  3431. 

  3432.         if (ui.handle && ui.widget)

  3433.         {

  3434.             updateUi();

  3435.         }

  3436.         else

  3437.         {

  3438.             qWarning("Lv2Plugin::initExternalUi() - failed to instantiate UI");

  3439.             ui.handle = nullptr;

  3440.             ui.widget = nullptr;

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

  3442.         }

  3443.     }

  3444. 

  3445.     void uiTransferCustomData(const CustomData* const cdata)

  3446.     {

  3447.         if (! (cdata->type && ui.handle && ui.descriptor && ui.descriptor->port_event))

  3448.             return;

  3449. 

  3450.         LV2_URID_Map* const URID_Map = (LV2_URID_Map*)features[lv2_feature_id_urid_map]->data;

  3451.         const LV2_URID uridPatchSet  = getCustomURID(LV2_PATCH__Set);

  3452.         const LV2_URID uridPatchBody = getCustomURID(LV2_PATCH__body);

  3453. 

  3454.         Sratom* const sratom = sratom_new(URID_Map);

  3455.         SerdChunk     chunk  = { nullptr, 0 };

  3456. 

  3457.         LV2_Atom_Forge forge;

  3458.         lv2_atom_forge_init(&forge, URID_Map);

  3459.         lv2_atom_forge_set_sink(&forge, sratom_forge_sink, sratom_forge_deref, &chunk);

  3460. 

  3461.         LV2_Atom_Forge_Frame refFrame, bodyFrame;

  3462.         LV2_Atom_Forge_Ref   ref = lv2_atom_forge_blank(&forge, &refFrame, 1, uridPatchSet);

  3463. 

  3464.         lv2_atom_forge_property_head(&forge, uridPatchBody, CARLA_URI_MAP_ID_NULL);

  3465.         lv2_atom_forge_blank(&forge, &bodyFrame, 2, CARLA_URI_MAP_ID_NULL);

  3466. 

  3467.         lv2_atom_forge_property_head(&forge, getCustomURID(cdata->key), CARLA_URI_MAP_ID_NULL);

  3468. 

  3469.         if (strcmp(cdata->type, LV2_ATOM__String) == 0)

  3470.             lv2_atom_forge_string(&forge, cdata->value, strlen(cdata->value));

  3471.         else if (strcmp(cdata->type, LV2_ATOM__Path) == 0)

  3472.             lv2_atom_forge_path(&forge, cdata->value, strlen(cdata->value));

  3473.         else if (strcmp(cdata->type, LV2_ATOM__Chunk) == 0)

  3474.             lv2_atom_forge_literal(&forge, cdata->value, strlen(cdata->value), CARLA_URI_MAP_ID_ATOM_CHUNK, CARLA_URI_MAP_ID_NULL);

  3475.         else

  3476.             lv2_atom_forge_literal(&forge, cdata->value, strlen(cdata->value), getCustomURID(cdata->key), CARLA_URI_MAP_ID_NULL);

  3477. 

  3478.         lv2_atom_forge_pop(&forge, &bodyFrame);

  3479.         lv2_atom_forge_pop(&forge, &refFrame);

  3480. 

  3481.         uint32_t portIndex = evIn.count > 0 ? evIn.data[0].rindex : 0;

  3482. 

  3483.         const LV2_Atom* const atom = lv2_atom_forge_deref(&forge, ref);

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

  3485. 

  3486.         free((void*)chunk.buf);

  3487.         sratom_free(sratom);

  3488.     }

  3489. 

  3490.     void updateUi()

  3491.     {

  3492.         ext.uiprograms = nullptr;

  3493. 

  3494.         if (ui.handle && ui.descriptor)

  3495.         {

  3496.             if (ui.descriptor->extension_data)

  3497.             {

  3498.                 ext.uiprograms = (const LV2_Programs_UI_Interface*)ui.descriptor->extension_data(LV2_PROGRAMS__UIInterface);

  3499. 

  3500.                 if (ext.uiprograms && ! ext.uiprograms->select_program)

  3501.                     // invalid

  3502.                     ext.uiprograms = nullptr;

  3503. 

  3504.                 if (ext.uiprograms && midiprog.count > 0 && midiprog.current >= 0)

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

  3506.             }

  3507. 

  3508.             if (ui.descriptor->port_event)

  3509.             {

  3510.                 // update control ports

  3511.                 float valueF;

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

  3513.                 {

  3514.                     valueF = getParameterValue(i);

  3515.                     ui.descriptor->port_event(ui.handle, param.data[i].rindex, sizeof(float), CARLA_URI_MAP_ID_NULL, &valueF);

  3516.                 }

  3517.             }

  3518.         }

  3519.     }

  3520. 

  3521.     // ----------------- Event Feature ---------------------------------------------------

  3522. 

  3523.     static uint32_t carla_lv2_event_ref(const LV2_Event_Callback_Data callback_data, LV2_Event* const event)

  3524.     {

  3525.         qDebug("Lv2Plugin::carla_lv2_event_ref(%p, %p)", callback_data, event);

  3526.         CARLA_ASSERT(callback_data);

  3527.         CARLA_ASSERT(event);

  3528. 

  3529.         return 0;

  3530.     }

  3531. 

  3532.     static uint32_t carla_lv2_event_unref(const LV2_Event_Callback_Data callback_data, LV2_Event* const event)

  3533.     {

  3534.         qDebug("Lv2Plugin::carla_lv2_event_unref(%p, %p)", callback_data, event);

  3535.         CARLA_ASSERT(callback_data);

  3536.         CARLA_ASSERT(event);

  3537. 

  3538.         return 0;

  3539.     }

  3540. 

  3541.     // ----------------- Logs Feature ----------------------------------------------------

  3542. 

  3543.     static int carla_lv2_log_printf(const LV2_Log_Handle handle, const LV2_URID type, const char* const fmt, ...)

  3544.     {

  3545.         qDebug("Lv2Plugin::carla_lv2_log_printf(%p, %i, \"%s\", ...)", handle, type, fmt);

  3546.         CARLA_ASSERT(handle);

  3547.         CARLA_ASSERT(type > 0);

  3548. 

  3549. #ifndef DEBUG

  3550.         if (type == CARLA_URI_MAP_ID_LOG_TRACE)

  3551.             return 0;

  3552. #endif

  3553. 

  3554.         va_list args;

  3555.         va_start(args, fmt);

  3556.         const int ret = carla_lv2_log_vprintf(handle, type, fmt, args);

  3557.         va_end(args);

  3558. 

  3559.         return ret;

  3560.     }

  3561. 

  3562.     static int carla_lv2_log_vprintf(const LV2_Log_Handle handle, const LV2_URID type, const char* const fmt, va_list ap)

  3563.     {

  3564.         qDebug("Lv2Plugin::carla_lv2_log_vprintf(%p, %i, \"%s\", ...)", handle, type, fmt);

  3565.         CARLA_ASSERT(handle);

  3566.         CARLA_ASSERT(type > 0);

  3567. 

  3568. #ifndef DEBUG

  3569.         if (type == CARLA_URI_MAP_ID_LOG_TRACE)

  3570.             return 0;

  3571. #endif

  3572. 

  3573.         char buf[8196];

  3574.         vsprintf(buf, fmt, ap);

  3575. 

  3576.         if (*buf == 0)

  3577.             return 0;

  3578. 

  3579.         switch (type)

  3580.         {

  3581.         case CARLA_URI_MAP_ID_LOG_ERROR:

  3582.             qCritical("%s", buf);

  3583.             break;

  3584.         case CARLA_URI_MAP_ID_LOG_NOTE:

  3585.             printf("%s\n", buf);

  3586.             break;

  3587.         case CARLA_URI_MAP_ID_LOG_TRACE:

  3588.             qDebug("%s", buf);

  3589.             break;

  3590.         case CARLA_URI_MAP_ID_LOG_WARNING:

  3591.             qWarning("%s", buf);

  3592.             break;

  3593.         default:

  3594.             break;

  3595.         }

  3596. 

  3597.         return strlen(buf);

  3598.     }

  3599. 

  3600.     // ----------------- Programs Feature ------------------------------------------------

  3601. 

  3602.     static void carla_lv2_program_changed(const LV2_Programs_Handle handle, const int32_t index)

  3603.     {

  3604.         qDebug("Lv2Plugin::carla_lv2_program_changed(%p, %i)", handle, index);

  3605.         CARLA_ASSERT(handle);

  3606. 

  3607.         if (! handle)

  3608.             return;

  3609. 

  3610.         Lv2Plugin* const plugin = (Lv2Plugin*)handle;

  3611.         plugin->handleProgramChanged(index);

  3612.     }

  3613. 

  3614.     // ----------------- State Feature ---------------------------------------------------

  3615. 

  3616.     static char* carla_lv2_state_make_path(const LV2_State_Make_Path_Handle handle, const char* const path)

  3617.     {

  3618.         qDebug("Lv2Plugin::carla_lv2_state_make_path(%p, \"%s\")", handle, path);

  3619.         CARLA_ASSERT(handle);

  3620.         CARLA_ASSERT(path);

  3621. 

  3622.         if (! path)

  3623.             return nullptr;

  3624. 

  3625.         QDir dir;

  3626.         dir.mkpath(path);

  3627.         return strdup(path);

  3628.     }

  3629. 

  3630.     static char* carla_lv2_state_map_abstract_path(const LV2_State_Map_Path_Handle handle, const char* const absolute_path)

  3631.     {

  3632.         qDebug("Lv2Plugin::carla_lv2_state_map_abstract_path(%p, \"%s\")", handle, absolute_path);

  3633.         CARLA_ASSERT(handle);

  3634.         CARLA_ASSERT(absolute_path);

  3635. 

  3636.         if (! absolute_path)

  3637.             return nullptr;

  3638. 

  3639.         QDir dir(absolute_path);

  3640.         return strdup(dir.canonicalPath().toUtf8().constData());

  3641.     }

  3642. 

  3643.     static char* carla_lv2_state_map_absolute_path(const LV2_State_Map_Path_Handle handle, const char* const abstract_path)

  3644.     {

  3645.         qDebug("Lv2Plugin::carla_lv2_state_map_absolute_path(%p, \"%s\")", handle, abstract_path);

  3646.         CARLA_ASSERT(handle);

  3647.         CARLA_ASSERT(abstract_path);

  3648. 

  3649.         if (! abstract_path)

  3650.             return nullptr;

  3651. 

  3652.         QDir dir(abstract_path);

  3653.         return strdup(dir.absolutePath().toUtf8().constData());

  3654.     }

  3655. 

  3656.     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)

  3657.     {

  3658.         qDebug("Lv2Plugin::carla_lv2_state_store(%p, %i, %p, " P_SIZE ", %i, %i)", handle, key, value, size, type, flags);

  3659.         CARLA_ASSERT(handle);

  3660. 

  3661.         if (! handle)

  3662.             return LV2_STATE_ERR_UNKNOWN;

  3663. 

  3664.         Lv2Plugin* const plugin = (Lv2Plugin*)handle;

  3665.         return plugin->handleStateStore(key, value, size, type, flags);

  3666.     }

  3667. 

  3668.     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)

  3669.     {

  3670.         qDebug("Lv2Plugin::carla_lv2_state_retrieve(%p, %i, %p, %p, %p)", handle, key, size, type, flags);

  3671.         CARLA_ASSERT(handle);

  3672. 

  3673.         if (! handle)

  3674.             return nullptr;

  3675. 

  3676.         Lv2Plugin* const plugin = (Lv2Plugin*)handle;

  3677.         return plugin->handleStateRetrieve(key, size, type, flags);

  3678.     }

  3679. 

  3680.     // ----------------- URI-Map Feature -------------------------------------------------

  3681. 

  3682.     static uint32_t carla_lv2_uri_to_id(const LV2_URI_Map_Callback_Data data, const char* const map, const char* const uri)

  3683.     {

  3684.         qDebug("Lv2Plugin::carla_lv2_uri_to_id(%p, \"%s\", \"%s\")", data, map, uri);

  3685.         return carla_lv2_urid_map((LV2_URID_Map_Handle*)data, uri);

  3686.     }

  3687. 

  3688.     // ----------------- URID Feature ----------------------------------------------------

  3689. 

  3690.     static LV2_URID carla_lv2_urid_map(const LV2_URID_Map_Handle handle, const char* const uri)

  3691.     {

  3692.         qDebug("Lv2Plugin::carla_lv2_urid_map(%p, \"%s\")", handle, uri);

  3693.         CARLA_ASSERT(handle);

  3694.         CARLA_ASSERT(uri);

  3695. 

  3696.         if (! uri)

  3697.             return CARLA_URI_MAP_ID_NULL;

  3698. 

  3699.         // Atom types

  3700.         if (strcmp(uri, LV2_ATOM__Chunk) == 0)

  3701.             return CARLA_URI_MAP_ID_ATOM_CHUNK;

  3702.         if (strcmp(uri, LV2_ATOM__Double) == 0)

  3703.             return CARLA_URI_MAP_ID_ATOM_DOUBLE;

  3704.         if (strcmp(uri, LV2_ATOM__Int) == 0)

  3705.             return CARLA_URI_MAP_ID_ATOM_INT;

  3706.         if (strcmp(uri, LV2_ATOM__Path) == 0)

  3707.             return CARLA_URI_MAP_ID_ATOM_PATH;

  3708.         if (strcmp(uri, LV2_ATOM__Sequence) == 0)

  3709.             return CARLA_URI_MAP_ID_ATOM_SEQUENCE;

  3710.         if (strcmp(uri, LV2_ATOM__String) == 0)

  3711.             return CARLA_URI_MAP_ID_ATOM_STRING;

  3712.         if (strcmp(uri, LV2_ATOM__atomTransfer) == 0)

  3713.             return CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM;

  3714.         if (strcmp(uri, LV2_ATOM__eventTransfer) == 0)

  3715.             return CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT;

  3716. 

  3717.         // BufSize types

  3718.         if (strcmp(uri, LV2_BUF_SIZE__maxBlockLength) == 0)

  3719.             return CARLA_URI_MAP_ID_BUF_MAX_LENGTH;

  3720.         if (strcmp(uri, LV2_BUF_SIZE__minBlockLength) == 0)

  3721.             return CARLA_URI_MAP_ID_BUF_MIN_LENGTH;

  3722.         if (strcmp(uri, LV2_BUF_SIZE__sequenceSize) == 0)

  3723.             return CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE;

  3724. 

  3725.         // Log types

  3726.         if (strcmp(uri, LV2_LOG__Error) == 0)

  3727.             return CARLA_URI_MAP_ID_LOG_ERROR;

  3728.         if (strcmp(uri, LV2_LOG__Note) == 0)

  3729.             return CARLA_URI_MAP_ID_LOG_NOTE;

  3730.         if (strcmp(uri, LV2_LOG__Trace) == 0)

  3731.             return CARLA_URI_MAP_ID_LOG_TRACE;

  3732.         if (strcmp(uri, LV2_LOG__Warning) == 0)

  3733.             return CARLA_URI_MAP_ID_LOG_WARNING;

  3734. 

  3735.         // Others

  3736.         if (strcmp(uri, LV2_MIDI__MidiEvent) == 0)

  3737.             return CARLA_URI_MAP_ID_MIDI_EVENT;

  3738.         if (strcmp(uri, LV2_PARAMETERS__sampleRate) == 0)

  3739.             return CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE;

  3740. 

  3741.         if (! handle)

  3742.             return CARLA_URI_MAP_ID_NULL;

  3743. 

  3744.         // Custom types

  3745.         Lv2Plugin* const plugin = (Lv2Plugin*)handle;

  3746.         return plugin->getCustomURID(uri);

  3747.     }

  3748. 

  3749.     static const char* carla_lv2_urid_unmap(const LV2_URID_Map_Handle handle, const LV2_URID urid)

  3750.     {

  3751.         qDebug("Lv2Plugin::carla_lv2_urid_unmap(%p, %i)", handle, urid);

  3752.         CARLA_ASSERT(handle);

  3753.         CARLA_ASSERT(urid > CARLA_URI_MAP_ID_NULL);

  3754. 

  3755.         if (urid == CARLA_URI_MAP_ID_NULL)

  3756.             return nullptr;

  3757. 

  3758.         // Atom types

  3759.         if (urid == CARLA_URI_MAP_ID_ATOM_CHUNK)

  3760.             return LV2_ATOM__Chunk;

  3761.         if (urid == CARLA_URI_MAP_ID_ATOM_DOUBLE)

  3762.             return LV2_ATOM__Double;

  3763.         if (urid == CARLA_URI_MAP_ID_ATOM_INT)

  3764.             return LV2_ATOM__Int;

  3765.         if (urid == CARLA_URI_MAP_ID_ATOM_PATH)

  3766.             return LV2_ATOM__Path;

  3767.         if (urid == CARLA_URI_MAP_ID_ATOM_SEQUENCE)

  3768.             return LV2_ATOM__Sequence;

  3769.         if (urid == CARLA_URI_MAP_ID_ATOM_STRING)

  3770.             return LV2_ATOM__String;

  3771.         if (urid == CARLA_URI_MAP_ID_ATOM_WORKER)

  3772.             return nullptr; // not a valid URID, only used internally

  3773.         if (urid == CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM)

  3774.             return LV2_ATOM__atomTransfer;

  3775.         if (urid == CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT)

  3776.             return LV2_ATOM__eventTransfer;

  3777. 

  3778.         // BufSize types

  3779.         if (urid == CARLA_URI_MAP_ID_BUF_MAX_LENGTH)

  3780.             return LV2_BUF_SIZE__maxBlockLength;

  3781.         if (urid == CARLA_URI_MAP_ID_BUF_MIN_LENGTH)

  3782.             return LV2_BUF_SIZE__minBlockLength;

  3783.         if (urid == CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE)

  3784.             return LV2_BUF_SIZE__sequenceSize;

  3785. 

  3786.         // Log types

  3787.         if (urid == CARLA_URI_MAP_ID_LOG_ERROR)

  3788.             return LV2_LOG__Error;

  3789.         if (urid == CARLA_URI_MAP_ID_LOG_NOTE)

  3790.             return LV2_LOG__Note;

  3791.         if (urid == CARLA_URI_MAP_ID_LOG_TRACE)

  3792.             return LV2_LOG__Trace;

  3793.         if (urid == CARLA_URI_MAP_ID_LOG_WARNING)

  3794.             return LV2_LOG__Warning;

  3795. 

  3796.         // Others

  3797.         if (urid == CARLA_URI_MAP_ID_MIDI_EVENT)

  3798.             return LV2_MIDI__MidiEvent;

  3799.         if (urid == CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE)

  3800.             return LV2_PARAMETERS__sampleRate;

  3801. 

  3802.         if (! handle)

  3803.             return nullptr;

  3804. 

  3805.         // Custom types

  3806.         Lv2Plugin* const plugin = (Lv2Plugin*)handle;

  3807.         return plugin->getCustomURIString(urid);

  3808.     }

  3809. 

  3810.     // ----------------- Worker Feature --------------------------------------------------

  3811. 

  3812.     static LV2_Worker_Status carla_lv2_worker_schedule(const LV2_Worker_Schedule_Handle handle, const uint32_t size, const void* const data)

  3813.     {

  3814.         qDebug("Lv2Plugin::carla_lv2_worker_schedule(%p, %i, %p)", handle, size, data);

  3815.         CARLA_ASSERT(handle);

  3816. 

  3817.         if (! handle)

  3818.             return LV2_WORKER_ERR_UNKNOWN;

  3819. 

  3820.         Lv2Plugin* const plugin = (Lv2Plugin*)handle;

  3821.         return plugin->handleWorkerSchedule(size, data);

  3822.     }

  3823. 

  3824.     static LV2_Worker_Status carla_lv2_worker_respond(const LV2_Worker_Respond_Handle handle, const uint32_t size, const void* const data)

  3825.     {

  3826.         qDebug("Lv2Plugin::carla_lv2_worker_respond(%p, %i, %p)", handle, size, data);

  3827.         CARLA_ASSERT(handle);

  3828. 

  3829.         if (! handle)

  3830.             return LV2_WORKER_ERR_UNKNOWN;

  3831. 

  3832.         Lv2Plugin* const plugin = (Lv2Plugin*)handle;

  3833.         return plugin->handleWorkerRespond(size, data);

  3834.     }

  3835. 

  3836.     // ----------------- UI Port-Map Feature ---------------------------------------------

  3837. 

  3838.     static uint32_t carla_lv2_ui_port_map(const LV2UI_Feature_Handle handle, const char* const symbol)

  3839.     {

  3840.         qDebug("Lv2Plugin::carla_lv2_ui_port_map(%p, \"%s\")", handle, symbol);

  3841.         CARLA_ASSERT(handle);

  3842. 

  3843.         if (! handle)

  3844.             return LV2UI_INVALID_PORT_INDEX;

  3845. 

  3846.         Lv2Plugin* const plugin = (Lv2Plugin*)handle;

  3847.         return plugin->handleUiPortMap(symbol);

  3848.     }

  3849. 

  3850.     // ----------------- UI Resize Feature -----------------------------------------------

  3851. 

  3852.     static int carla_lv2_ui_resize(const LV2UI_Feature_Handle handle, const int width, const int height)

  3853.     {

  3854.         qDebug("Lv2Plugin::carla_lv2_ui_resize(%p, %i, %i)", handle, width, height);

  3855.         CARLA_ASSERT(handle);

  3856. 

  3857.         if (! handle)

  3858.             return 1;

  3859. 

  3860.         Lv2Plugin* const plugin = (Lv2Plugin*)handle;

  3861.         return plugin->handleUiResize(width, height);

  3862.     }

  3863. 

  3864.     // ----------------- External UI Feature ---------------------------------------------

  3865. 

  3866.     static void carla_lv2_external_ui_closed(const LV2UI_Controller controller)

  3867.     {

  3868.         qDebug("Lv2Plugin::carla_lv2_external_ui_closed(%p)", controller);

  3869.         CARLA_ASSERT(controller);

  3870. 

  3871.         if (! controller)

  3872.             return;

  3873. 

  3874.         Lv2Plugin* const plugin = (Lv2Plugin*)controller;

  3875.         plugin->handleExternalUiClosed();

  3876.     }

  3877. 

  3878.     // ----------------- UI Extension ----------------------------------------------------

  3879. 

  3880.     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)

  3881.     {

  3882.         qDebug("Lv2Plugin::carla_lv2_ui_write_function(%p, %i, %i, %i, %p)", controller, port_index, buffer_size, format, buffer);

  3883.         CARLA_ASSERT(controller);

  3884. 

  3885.         if (! controller)

  3886.             return;

  3887. 

  3888.         Lv2Plugin* const plugin = (Lv2Plugin*)controller;

  3889.         plugin->handleUiWrite(port_index, buffer_size, format, buffer);

  3890.     }

  3891. 

  3892.     // -------------------------------------------------------------------

  3893. 

  3894.     bool uiLibOpen(const char* const filename)

  3895.     {

  3896.         ui.lib = lib_open(filename);

  3897.         return bool(ui.lib);

  3898.     }

  3899. 

  3900.     bool uiLibClose()

  3901.     {

  3902.         if (ui.lib)

  3903.             return lib_close(ui.lib);

  3904.         return false;

  3905.     }

  3906. 

  3907.     void* uiLibSymbol(const char* const symbol)

  3908.     {

  3909.         if (ui.lib)

  3910.             return lib_symbol(ui.lib, symbol);

  3911.         return nullptr;

  3912.     }

  3913. 

  3914.     // -------------------------------------------------------------------

  3915. 

  3916.     bool init(const char* const bundle, const char* const name, const char* const URI)

  3917.     {

  3918.         // ---------------------------------------------------------------

  3919.         // get plugin from lv2_rdf (lilv)

  3920. 

  3921.         rdf_descriptor = lv2_rdf_new(URI);

  3922. 

  3923.         if (! rdf_descriptor)

  3924.         {

  3925.             x_engine->setLastError("Failed to find the requested plugin in the LV2 Bundle");

  3926.             return false;

  3927.         }

  3928. 

  3929.         // ---------------------------------------------------------------

  3930.         // open DLL

  3931. 

  3932.         if (! libOpen(rdf_descriptor->Binary))

  3933.         {

  3934.             x_engine->setLastError(libError(rdf_descriptor->Binary));

  3935.             return false;

  3936.         }

  3937. 

  3938.         // ---------------------------------------------------------------

  3939.         // initialize features (part 1)

  3940. 

  3941.         LV2_Programs_Host* const programsFt = new LV2_Programs_Host;

  3942.         programsFt->handle                  = this;

  3943.         programsFt->program_changed         = carla_lv2_program_changed;

  3944. 

  3945.         LV2_URI_Map_Feature* const uriMapFt = new LV2_URI_Map_Feature;

  3946.         uriMapFt->callback_data             = this;

  3947.         uriMapFt->uri_to_id                 = carla_lv2_uri_to_id;

  3948. 

  3949.         LV2_URID_Map* const uridMapFt       = new LV2_URID_Map;

  3950.         uridMapFt->handle                   = this;

  3951.         uridMapFt->map                      = carla_lv2_urid_map;

  3952. 

  3953.         LV2_URID_Unmap* const uridUnmapFt   = new LV2_URID_Unmap;

  3954.         uridUnmapFt->handle                 = this;

  3955.         uridUnmapFt->unmap                  = carla_lv2_urid_unmap;

  3956. 

  3957.         LV2_Worker_Schedule* const workerFt = new LV2_Worker_Schedule;

  3958.         workerFt->handle                    = this;

  3959.         workerFt->schedule_work             = carla_lv2_worker_schedule;

  3960. 

  3961.         // ---------------------------------------------------------------

  3962.         // initialize features (part 2)

  3963. 

  3964.         features[lv2_feature_id_bufsize_bounded]       = new LV2_Feature;

  3965.         features[lv2_feature_id_bufsize_bounded]->URI  = LV2_BUF_SIZE__boundedBlockLength;

  3966.         features[lv2_feature_id_bufsize_bounded]->data = nullptr;

  3967. 

  3968. #ifndef BUILD_BRIDGE

  3969.         if (x_engine->processHighPrecision())

  3970.         {

  3971.             features[lv2_feature_id_bufsize_fixed]          = new LV2_Feature;

  3972.             features[lv2_feature_id_bufsize_fixed]->URI     = LV2_BUF_SIZE__fixedBlockLength;

  3973.             features[lv2_feature_id_bufsize_fixed]->data    = nullptr;

  3974. 

  3975.             features[lv2_feature_id_bufsize_powerof2]       = new LV2_Feature;

  3976.             features[lv2_feature_id_bufsize_powerof2]->URI  = LV2_BUF_SIZE__powerOf2BlockLength;

  3977.             features[lv2_feature_id_bufsize_powerof2]->data = nullptr;

  3978.         }

  3979.         else

  3980. #endif

  3981.         {

  3982.             // fake, used only to keep a valid features-array

  3983.             features[lv2_feature_id_bufsize_fixed]    = features[lv2_feature_id_bufsize_bounded];

  3984.             features[lv2_feature_id_bufsize_powerof2] = features[lv2_feature_id_bufsize_bounded];

  3985.         }

  3986. 

  3987.         features[lv2_feature_id_event]          = new LV2_Feature;

  3988.         features[lv2_feature_id_event]->URI     = LV2_EVENT_URI;

  3989.         features[lv2_feature_id_event]->data    = ft.event;

  3990. 

  3991.         features[lv2_feature_id_logs]           = new LV2_Feature;

  3992.         features[lv2_feature_id_logs]->URI      = LV2_LOG__log;

  3993.         features[lv2_feature_id_logs]->data     = ft.log;

  3994. 

  3995.         features[lv2_feature_id_options]        = new LV2_Feature;

  3996.         features[lv2_feature_id_options]->URI   = LV2_OPTIONS__options;

  3997.         features[lv2_feature_id_options]->data  = ft.options;

  3998. 

  3999.         features[lv2_feature_id_programs]       = new LV2_Feature;

  4000.         features[lv2_feature_id_programs]->URI  = LV2_PROGRAMS__Host;

  4001.         features[lv2_feature_id_programs]->data = programsFt;

  4002. 

  4003.         features[lv2_feature_id_rtmempool]       = new LV2_Feature;

  4004.         features[lv2_feature_id_rtmempool]->URI  = LV2_RTSAFE_MEMORY_POOL__Pool;

  4005.         features[lv2_feature_id_rtmempool]->data = ft.rtMemPool;

  4006. 

  4007.         features[lv2_feature_id_state_make_path]       = new LV2_Feature;

  4008.         features[lv2_feature_id_state_make_path]->URI  = LV2_STATE__makePath;

  4009.         features[lv2_feature_id_state_make_path]->data = ft.stateMakePath;

  4010. 

  4011.         features[lv2_feature_id_state_map_path]        = new LV2_Feature;

  4012.         features[lv2_feature_id_state_map_path]->URI   = LV2_STATE__mapPath;

  4013.         features[lv2_feature_id_state_map_path]->data  = ft.stateMapPath;

  4014. 

  4015.         features[lv2_feature_id_strict_bounds]         = new LV2_Feature;

  4016.         features[lv2_feature_id_strict_bounds]->URI    = LV2_PORT_PROPS__supportsStrictBounds;

  4017.         features[lv2_feature_id_strict_bounds]->data   = nullptr;

  4018. 

  4019.         features[lv2_feature_id_uri_map]          = new LV2_Feature;

  4020.         features[lv2_feature_id_uri_map]->URI     = LV2_URI_MAP_URI;

  4021.         features[lv2_feature_id_uri_map]->data    = uriMapFt;

  4022. 

  4023.         features[lv2_feature_id_urid_map]         = new LV2_Feature;

  4024.         features[lv2_feature_id_urid_map]->URI    = LV2_URID__map;

  4025.         features[lv2_feature_id_urid_map]->data   = uridMapFt;

  4026. 

  4027.         features[lv2_feature_id_urid_unmap]       = new LV2_Feature;

  4028.         features[lv2_feature_id_urid_unmap]->URI  = LV2_URID__unmap;

  4029.         features[lv2_feature_id_urid_unmap]->data = uridUnmapFt;

  4030. 

  4031.         features[lv2_feature_id_worker]           = new LV2_Feature;

  4032.         features[lv2_feature_id_worker]->URI      = LV2_WORKER__schedule;

  4033.         features[lv2_feature_id_worker]->data     = workerFt;

  4034. 

  4035.         // ---------------------------------------------------------------

  4036.         // get DLL main entry

  4037. 

  4038.         const LV2_Lib_Descriptor_Function descLibFn = (LV2_Lib_Descriptor_Function)libSymbol("lv2_lib_descriptor");

  4039. 

  4040.         if (descLibFn)

  4041.         {

  4042.             // -----------------------------------------------------------

  4043.             // get lib descriptor

  4044. 

  4045.             const LV2_Lib_Descriptor* libDesc = descLibFn(rdf_descriptor->Bundle, features);

  4046. 

  4047.             if (! libDesc)

  4048.             {

  4049.                 x_engine->setLastError("Plugin failed to return library descriptor");

  4050.                 return false;

  4051.             }

  4052. 

  4053.             // -----------------------------------------------------------

  4054.             // get descriptor that matches URI

  4055. 

  4056.             uint32_t i = 0;

  4057.             while ((descriptor = libDesc->get_plugin(libDesc->handle, i++)))

  4058.             {

  4059.                 if (strcmp(descriptor->URI, URI) == 0)

  4060.                     break;

  4061.             }

  4062. 

  4063.             if (libDescs.count(libDesc) > 0)

  4064.             {

  4065.                 if (! descriptor)

  4066.                     libDesc->cleanup(libDesc->handle);

  4067.             }

  4068.             else

  4069.                 libDescs.insert(libDesc);

  4070.         }

  4071.         else

  4072.         {

  4073.             const LV2_Descriptor_Function descFn = (LV2_Descriptor_Function)libSymbol("lv2_descriptor");

  4074. 

  4075.             // -----------------------------------------------------------

  4076.             // if no descriptor function found, return error

  4077. 

  4078.             if (! descFn)

  4079.             {

  4080.                 x_engine->setLastError("Could not find the LV2 Descriptor in the plugin library");

  4081.                 return false;

  4082.             }

  4083. 

  4084.             // -----------------------------------------------------------

  4085.             // get descriptor that matches URI

  4086. 

  4087.             uint32_t i = 0;

  4088.             while ((descriptor = descFn(i++)))

  4089.             {

  4090.                 if (strcmp(descriptor->URI, URI) == 0)

  4091.                     break;

  4092.             }

  4093.         }

  4094. 

  4095.         if (! descriptor)

  4096.         {

  4097.             x_engine->setLastError("Could not find the requested plugin URI in the plugin library");

  4098.             return false;

  4099.         }

  4100. 

  4101.         // ---------------------------------------------------------------

  4102.         // check supported port-types and features

  4103. 

  4104.         bool canContinue = true;

  4105. 

  4106.         // Check supported ports

  4107.         for (uint32_t i=0; i < rdf_descriptor->PortCount; i++)

  4108.         {

  4109.             LV2_Property PortType = rdf_descriptor->Ports[i].Type;

  4110.             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)))

  4111.             {

  4112.                 if (! LV2_IS_PORT_OPTIONAL(rdf_descriptor->Ports[i].Properties))

  4113.                 {

  4114.                     x_engine->setLastError("Plugin requires a port that is not currently supported");

  4115.                     canContinue = false;

  4116.                     break;

  4117.                 }

  4118.             }

  4119.         }

  4120. 

  4121.         // Check supported features

  4122.         for (uint32_t i=0; i < rdf_descriptor->FeatureCount && canContinue; i++)

  4123.         {

  4124.             if (LV2_IS_FEATURE_REQUIRED(rdf_descriptor->Features[i].Type) && ! is_lv2_feature_supported(rdf_descriptor->Features[i].URI))

  4125.             {

  4126.                 QString msg = QString("Plugin requires a feature that is not supported:\n%1").arg(rdf_descriptor->Features[i].URI);

  4127.                 x_engine->setLastError(msg.toUtf8().constData());

  4128.                 canContinue = false;

  4129.                 break;

  4130.             }

  4131.         }

  4132. 

  4133.         // Check extensions

  4134.         for (uint32_t i=0; i < rdf_descriptor->ExtensionCount; i++)

  4135.         {

  4136.             if (strcmp(rdf_descriptor->Extensions[i], LV2_PROGRAMS__Interface) == 0)

  4137.                 m_hints |= PLUGIN_HAS_EXTENSION_PROGRAMS;

  4138.             else if (strcmp(rdf_descriptor->Extensions[i], LV2_STATE__interface) == 0)

  4139.                 m_hints |= PLUGIN_HAS_EXTENSION_STATE;

  4140.             else if (strcmp(rdf_descriptor->Extensions[i], LV2_WORKER__interface) == 0)

  4141.                 m_hints |= PLUGIN_HAS_EXTENSION_WORKER;

  4142.             else

  4143.                 qDebug("Plugin has non-supported extension: '%s'", rdf_descriptor->Extensions[i]);

  4144.         }

  4145. 

  4146.         if (! canContinue)

  4147.         {

  4148.             // error already set

  4149.             return false;

  4150.         }

  4151. 

  4152.         // ---------------------------------------------------------------

  4153.         // get info

  4154. 

  4155.         m_filename = strdup(bundle);

  4156. 

  4157.         if (name)

  4158.             m_name = x_engine->getUniquePluginName(name);

  4159.         else

  4160.             m_name = x_engine->getUniquePluginName(rdf_descriptor->Name);

  4161. 

  4162.         // ---------------------------------------------------------------

  4163.         // register client

  4164. 

  4165.         x_client = x_engine->addClient(this);

  4166. 

  4167.         if (! x_client->isOk())

  4168.         {

  4169.             x_engine->setLastError("Failed to register plugin client");

  4170.             return false;

  4171.         }

  4172. 

  4173.         // ---------------------------------------------------------------

  4174.         // initialize plugin

  4175. 

  4176.         handle = descriptor->instantiate(descriptor, x_engine->getSampleRate(), rdf_descriptor->Bundle, features);

  4177. 

  4178.         if (! handle)

  4179.         {

  4180.             x_engine->setLastError("Plugin failed to initialize");

  4181.             return false;

  4182.         }

  4183. 

  4184.         // ---------------------------------------------------------------

  4185.         // gui stuff

  4186. 

  4187.         if (rdf_descriptor->UICount == 0)

  4188.             return true;

  4189. 

  4190.         // -----------------------------------------------------------

  4191.         // find more appropriate ui

  4192. 

  4193.         int eQt4, eCocoa, eHWND, eX11, eGtk2, eGtk3, iCocoa, iHWND, iX11, iQt4, iExt, iSuil, iFinal;

  4194.         eQt4 = eCocoa = eHWND = eX11 = eGtk2 = eGtk3 = iQt4 = iCocoa = iHWND = iX11 = iExt = iSuil = iFinal = -1;

  4195. 

  4196.         for (uint32_t i=0; i < rdf_descriptor->UICount; i++)

  4197.         {

  4198.             switch (rdf_descriptor->UIs[i].Type)

  4199.             {

  4200.             case LV2_UI_QT4:

  4201. #ifndef BUILD_BRIDGE

  4202.                 if (isUiBridgeable(i) && x_engine->preferUiBridges())

  4203.                     eQt4 = i;

  4204. #endif

  4205.                 iQt4 = i;

  4206.                 break;

  4207. 

  4208.             case LV2_UI_COCOA:

  4209. #ifndef BUILD_BRIDGE

  4210.                 if (isUiBridgeable(i) && x_engine->preferUiBridges())

  4211.                     eCocoa = i;

  4212. #endif

  4213.                 iCocoa = i;

  4214.                 break;

  4215. 

  4216.             case LV2_UI_WINDOWS:

  4217. #ifndef BUILD_BRIDGE

  4218.                 if (isUiBridgeable(i) && x_engine->preferUiBridges())

  4219.                     eHWND = i;

  4220. #endif

  4221.                 iHWND = i;

  4222.                 break;

  4223. 

  4224.             case LV2_UI_X11:

  4225. #ifndef BUILD_BRIDGE

  4226.                 if (isUiBridgeable(i) && x_engine->preferUiBridges())

  4227.                     eX11 = i;

  4228. #endif

  4229.                 iX11 = i;

  4230.                 break;

  4231. 

  4232.             case LV2_UI_GTK2:

  4233. #ifdef BUILD_BRIDGE

  4234.                 if (false)

  4235. #else

  4236. # ifdef WANT_SUIL

  4237.                 if (isUiBridgeable(i) && x_engine->preferUiBridges())

  4238. # else

  4239.                 if (isUiBridgeable(i))

  4240. # endif

  4241. #endif

  4242.                     eGtk2 = i;

  4243. #ifdef WANT_SUIL

  4244.                 iSuil = i;

  4245. #endif

  4246.                 break;

  4247. 

  4248. #ifndef BUILD_BRIDGE

  4249.             case LV2_UI_GTK3:

  4250.                 if (isUiBridgeable(i))

  4251.                     eGtk3 = i;

  4252.                 break;

  4253. #endif

  4254. 

  4255.             case LV2_UI_EXTERNAL:

  4256.             case LV2_UI_OLD_EXTERNAL:

  4257.                 iExt = i;

  4258.                 break;

  4259. 

  4260.             default:

  4261.                 break;

  4262.             }

  4263.         }

  4264. 

  4265.         if (eQt4 >= 0)

  4266.             iFinal = eQt4;

  4267.         else if (eCocoa >= 0)

  4268.             iFinal = eCocoa;

  4269.         else if (eHWND >= 0)

  4270.             iFinal = eHWND;

  4271.         else if (eX11 >= 0)

  4272.             iFinal = eX11;

  4273.         else if (eGtk2 >= 0)

  4274.             iFinal = eGtk2;

  4275.         else if (eGtk3 >= 0)

  4276.             iFinal = eGtk3;

  4277.         else if (iQt4 >= 0)

  4278.             iFinal = iQt4;

  4279.         else if (iCocoa >= 0)

  4280.             iFinal = iCocoa;

  4281.         else if (iHWND >= 0)

  4282.             iFinal = iHWND;

  4283.         else if (iX11 >= 0)

  4284.             iFinal = iX11;

  4285.         else if (iExt >= 0)

  4286.             iFinal = iExt;

  4287.         else if (iSuil >= 0)

  4288.             iFinal = iSuil;

  4289. 

  4290. #ifndef BUILD_BRIDGE

  4291.         const bool isBridged = (iFinal == eQt4 || iFinal == eCocoa || iFinal == eHWND || iFinal == eX11 || iFinal == eGtk2 || iFinal == eGtk3);

  4292. #endif

  4293. #ifdef WANT_SUIL

  4294.         const bool isSuil = (iFinal == iSuil && !isBridged);

  4295. #endif

  4296. 

  4297.         if (iFinal < 0)

  4298.         {

  4299.             qWarning("Failed to find an appropriate LV2 UI for this plugin");

  4300.             return true;

  4301.         }

  4302. 

  4303.         ui.rdf_descriptor = &rdf_descriptor->UIs[iFinal];

  4304. 

  4305.         // -----------------------------------------------------------

  4306.         // check supported ui features

  4307. 

  4308.         canContinue = true;

  4309. 

  4310.         for (uint32_t i=0; i < ui.rdf_descriptor->FeatureCount; i++)

  4311.         {

  4312.             if (LV2_IS_FEATURE_REQUIRED(ui.rdf_descriptor->Features[i].Type) && is_lv2_ui_feature_supported(ui.rdf_descriptor->Features[i].URI) == false)

  4313.             {

  4314.                 qCritical("Plugin UI requires a feature that is not supported:\n%s", ui.rdf_descriptor->Features[i].URI);

  4315.                 canContinue = false;

  4316.                 break;

  4317.             }

  4318.         }

  4319. 

  4320.         if (! canContinue)

  4321.         {

  4322.             ui.rdf_descriptor = nullptr;

  4323.             return true;

  4324.         }

  4325. 

  4326. #ifdef WANT_SUIL

  4327.         if (isSuil)

  4328.         {

  4329.             // -------------------------------------------------------

  4330.             // init suil host

  4331. 

  4332.             suil.host = suil_host_new(carla_lv2_ui_write_function, carla_lv2_ui_port_map, nullptr, nullptr);

  4333.         }

  4334.         else

  4335. #endif

  4336.         {

  4337.             // -------------------------------------------------------

  4338.             // open DLL

  4339. 

  4340.             if (! uiLibOpen(ui.rdf_descriptor->Binary))

  4341.             {

  4342.                 qCritical("Could not load UI library, error was:\n%s", libError(ui.rdf_descriptor->Binary));

  4343.                 ui.rdf_descriptor = nullptr;

  4344.                 return true;

  4345.             }

  4346. 

  4347.             // -------------------------------------------------------

  4348.             // get DLL main entry

  4349. 

  4350.             LV2UI_DescriptorFunction ui_descFn = (LV2UI_DescriptorFunction)uiLibSymbol("lv2ui_descriptor");

  4351. 

  4352.             if (! ui_descFn)

  4353.             {

  4354.                 qCritical("Could not find the LV2UI Descriptor in the UI library");

  4355.                 uiLibClose();

  4356.                 ui.lib = nullptr;

  4357.                 ui.rdf_descriptor = nullptr;

  4358.                 return true;

  4359.             }

  4360. 

  4361.             // -------------------------------------------------------

  4362.             // get descriptor that matches URI

  4363. 

  4364.             uint32_t i = 0;

  4365.             while ((ui.descriptor = ui_descFn(i++)))

  4366.             {

  4367.                 if (strcmp(ui.descriptor->URI, ui.rdf_descriptor->URI) == 0)

  4368.                     break;

  4369.             }

  4370. 

  4371.             if (! ui.descriptor)

  4372.             {

  4373.                 qCritical("Could not find the requested GUI in the plugin UI library");

  4374.                 uiLibClose();

  4375.                 ui.lib = nullptr;

  4376.                 ui.rdf_descriptor = nullptr;

  4377.                 return true;

  4378.             }

  4379.         }

  4380. 

  4381.         // -----------------------------------------------------------

  4382.         // initialize ui according to type

  4383. 

  4384.         const LV2_Property uiType = ui.rdf_descriptor->Type;

  4385. 

  4386. #ifndef BUILD_BRIDGE

  4387.         if (isBridged)

  4388.         {

  4389.             // -------------------------------------------------------

  4390.             // initialize ui bridge

  4391. 

  4392.             if (const char* const oscBinary = getUiBridgePath(uiType))

  4393.             {

  4394.                 gui.type = GUI_EXTERNAL_OSC;

  4395.                 osc.thread = new CarlaPluginThread(x_engine, this, CarlaPluginThread::PLUGIN_THREAD_LV2_GUI);

  4396.                 osc.thread->setOscData(oscBinary, descriptor->URI, ui.descriptor->URI);

  4397.             }

  4398.         }

  4399.         else

  4400. #endif

  4401.         {

  4402.             // -------------------------------------------------------

  4403.             // initialize ui features

  4404. 

  4405.             QString guiTitle = QString("%1 (GUI)").arg(m_name);

  4406. 

  4407.             LV2_Extension_Data_Feature* const uiDataFt = new LV2_Extension_Data_Feature;

  4408.             uiDataFt->data_access                      = descriptor->extension_data;

  4409. 

  4410.             LV2UI_Port_Map* const uiPortMapFt = new LV2UI_Port_Map;

  4411.             uiPortMapFt->handle               = this;

  4412.             uiPortMapFt->port_index           = carla_lv2_ui_port_map;

  4413. 

  4414.             LV2UI_Resize* const uiResizeFt    = new LV2UI_Resize;

  4415.             uiResizeFt->handle                = this;

  4416.             uiResizeFt->ui_resize             = carla_lv2_ui_resize;

  4417. 

  4418.             LV2_External_UI_Host* const uiExternalHostFt = new LV2_External_UI_Host;

  4419.             uiExternalHostFt->ui_closed                  = carla_lv2_external_ui_closed;

  4420.             uiExternalHostFt->plugin_human_id            = strdup(guiTitle.toUtf8().constData());

  4421. 

  4422.             features[lv2_feature_id_data_access]           = new LV2_Feature;

  4423.             features[lv2_feature_id_data_access]->URI      = LV2_DATA_ACCESS_URI;

  4424.             features[lv2_feature_id_data_access]->data     = uiDataFt;

  4425. 

  4426.             features[lv2_feature_id_instance_access]       = new LV2_Feature;

  4427.             features[lv2_feature_id_instance_access]->URI  = LV2_INSTANCE_ACCESS_URI;

  4428.             features[lv2_feature_id_instance_access]->data = handle;

  4429. 

  4430.             features[lv2_feature_id_ui_parent]             = new LV2_Feature;

  4431.             features[lv2_feature_id_ui_parent]->URI        = LV2_UI__parent;

  4432.             features[lv2_feature_id_ui_parent]->data       = nullptr;

  4433. 

  4434.             features[lv2_feature_id_ui_port_map]           = new LV2_Feature;

  4435.             features[lv2_feature_id_ui_port_map]->URI      = LV2_UI__portMap;

  4436.             features[lv2_feature_id_ui_port_map]->data     = uiPortMapFt;

  4437. 

  4438.             features[lv2_feature_id_ui_resize]             = new LV2_Feature;

  4439.             features[lv2_feature_id_ui_resize]->URI        = LV2_UI__resize;

  4440.             features[lv2_feature_id_ui_resize]->data       = uiResizeFt;

  4441. 

  4442.             features[lv2_feature_id_external_ui]           = new LV2_Feature;

  4443.             features[lv2_feature_id_external_ui]->URI      = LV2_EXTERNAL_UI__Host;

  4444.             features[lv2_feature_id_external_ui]->data     = uiExternalHostFt;

  4445. 

  4446.             features[lv2_feature_id_external_ui_old]       = new LV2_Feature;

  4447.             features[lv2_feature_id_external_ui_old]->URI  = LV2_EXTERNAL_UI_DEPRECATED_URI;

  4448.             features[lv2_feature_id_external_ui_old]->data = uiExternalHostFt;

  4449. 

  4450.             // -------------------------------------------------------

  4451.             // initialize ui

  4452. 

  4453.             switch (uiType)

  4454.             {

  4455.             case LV2_UI_QT4:

  4456.                 qDebug("Will use LV2 Qt4 UI");

  4457.                 gui.type      = GUI_INTERNAL_QT4;

  4458.                 gui.resizable = isUiResizable();

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

  4460.                 m_hints      |= PLUGIN_USES_SINGLE_THREAD;

  4461.                 break;

  4462. 

  4463.             case LV2_UI_COCOA:

  4464.                 qDebug("Will use LV2 Cocoa UI");

  4465.                 gui.type      = GUI_INTERNAL_COCOA;

  4466.                 gui.resizable = isUiResizable();

  4467.                 break;

  4468. 

  4469.             case LV2_UI_WINDOWS:

  4470.                 qDebug("Will use LV2 Windows UI");

  4471.                 gui.type      = GUI_INTERNAL_HWND;

  4472.                 gui.resizable = isUiResizable();

  4473.                 break;

  4474. 

  4475.             case LV2_UI_X11:

  4476.                 qDebug("Will use LV2 X11 UI");

  4477.                 gui.type      = GUI_INTERNAL_X11;

  4478.                 gui.resizable = isUiResizable();

  4479.                 break;

  4480. 

  4481.             case LV2_UI_GTK2:

  4482. #ifdef WANT_SUIL

  4483.                 qDebug("Will use LV2 Gtk2 UI (suil)");

  4484.                 gui.type      = GUI_EXTERNAL_SUIL;

  4485.                 gui.resizable = isUiResizable();

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

  4487.                 m_hints      |= PLUGIN_USES_SINGLE_THREAD;

  4488. 

  4489.                 if (suil.handle)

  4490.                 {

  4491.                     ui.handle     = ((SuilInstanceImpl*)suil.handle)->handle;

  4492.                     ui.descriptor = ((SuilInstanceImpl*)suil.handle)->descriptor;

  4493.                     ui.widget     = suil_instance_get_widget(suil.handle);

  4494. 

  4495.                     if (ui.widget)

  4496.                     {

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

  4498.                         widget->setWindowTitle(guiTitle);

  4499.                     }

  4500.                 }

  4501. #else

  4502.                 qDebug("Will use LV2 Gtk2 UI, NOT!");

  4503. #endif

  4504.                 break;

  4505. 

  4506.             case LV2_UI_GTK3:

  4507.                 qDebug("Will use LV2 Gtk3 UI, NOT!");

  4508.                 break;

  4509. 

  4510.             case LV2_UI_EXTERNAL:

  4511.             case LV2_UI_OLD_EXTERNAL:

  4512.                 qDebug("Will use LV2 External UI");

  4513.                 gui.type = GUI_EXTERNAL_LV2;

  4514.                 break;

  4515.             }

  4516.         }

  4517. 

  4518.         if (gui.type != GUI_NONE)

  4519.             m_hints |= PLUGIN_HAS_GUI;

  4520. 

  4521.         return true;

  4522.     }

  4523. 

  4524. private:

  4525.     LV2_Handle handle, h2;

  4526.     const LV2_Descriptor* descriptor;

  4527.     const LV2_RDF_Descriptor* rdf_descriptor;

  4528.     LV2_Feature* features[lv2_feature_count+1];

  4529. 

  4530.     struct {

  4531.         const LV2_State_Interface* state;

  4532.         const LV2_Worker_Interface* worker;

  4533.         const LV2_Programs_Interface* programs;

  4534.         const LV2_Programs_UI_Interface* uiprograms;

  4535.     } ext;

  4536. 

  4537.     struct {

  4538.         void* lib;

  4539.         LV2UI_Handle handle;

  4540.         LV2UI_Widget widget;

  4541.         const LV2UI_Descriptor* descriptor;

  4542.         const LV2_RDF_UI* rdf_descriptor;

  4543.     } ui;

  4544. 

  4545.     struct {

  4546.         GuiType type;

  4547.         bool resizable;

  4548.         int width;

  4549.         int height;

  4550.     } gui;

  4551. 

  4552. #ifdef WANT_SUIL

  4553.     struct {

  4554.         SuilHost* host;

  4555.         SuilInstance* handle;

  4556.         QByteArray pos;

  4557.     } suil;

  4558. #endif

  4559. 

  4560.     Lv2AtomQueue atomQueueIn;

  4561.     Lv2AtomQueue atomQueueOut;

  4562.     Lv2PluginEventData evIn;

  4563.     Lv2PluginEventData evOut;

  4564.     float* paramBuffers;

  4565.     std::vector<const char*> customURIDs;

  4566. 

  4567.     bool     lastTimePosPlaying;

  4568.     uint32_t lastTimePosFrame;

  4569. 

  4570.     static unsigned int m_count;

  4571.     static std::set<const LV2_Lib_Descriptor*> libDescs;

  4572. 

  4573.     static struct Ft {

  4574.         LV2_Event_Feature* event;

  4575.         LV2_Log_Log* log;

  4576.         LV2_Options_Option* options;

  4577.         LV2_RtMemPool_Pool* rtMemPool;

  4578.         LV2_State_Make_Path* stateMakePath;

  4579.         LV2_State_Map_Path* stateMapPath;

  4580.     } ft;

  4581. };

  4582. 

  4583. /**@}*/

  4584. 

  4585. // -------------------------------------------------------------------

  4586. // static data

  4587. 

  4588. unsigned int Lv2Plugin::m_count = 0;

  4589. std::set<const LV2_Lib_Descriptor*> Lv2Plugin::libDescs;

  4590. 

  4591. Lv2Plugin::Ft Lv2Plugin::ft = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr };

  4592. 

  4593. // -------------------------------------------------------------------------------------------------------------------

  4594. 

  4595. #ifndef BUILD_BRIDGE

  4596. int CarlaEngineOsc::handleMsgLv2AtomTransfer(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  4597. {

  4598.     qDebug("CarlaOsc::handleMsgLv2AtomTransfer()");

  4599.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(3, "iss");

  4600. 

  4601.     const int32_t portIndex   = argv[0]->i;

  4602.     const char* const typeStr = (const char*)&argv[1]->s;

  4603.     const char* const atomBuf = (const char*)&argv[2]->s;

  4604. 

  4605.     QByteArray chunk;

  4606.     chunk = QByteArray::fromBase64(atomBuf);

  4607. 

  4608.     LV2_Atom* const atom = (LV2_Atom*)chunk.constData();

  4609.     CarlaBackend::Lv2Plugin* const lv2plugin = (CarlaBackend::Lv2Plugin*)plugin;

  4610. 

  4611.     atom->type = lv2plugin->getCustomURID(typeStr);

  4612.     lv2plugin->handleTransferAtom(portIndex, atom);

  4613. 

  4614.     return 0;

  4615. }

  4616. 

  4617. int CarlaEngineOsc::handleMsgLv2EventTransfer(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  4618. {

  4619.     qDebug("CarlaOsc::handleMsgLv2EventTransfer()");

  4620.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(3, "iss");

  4621. 

  4622.     const int32_t portIndex   = argv[0]->i;

  4623.     const char* const typeStr = (const char*)&argv[1]->s;

  4624.     const char* const atomBuf = (const char*)&argv[2]->s;

  4625. 

  4626.     QByteArray chunk;

  4627.     chunk = QByteArray::fromBase64(atomBuf);

  4628. 

  4629.     LV2_Atom* const atom = (LV2_Atom*)chunk.constData();

  4630.     CarlaBackend::Lv2Plugin* const lv2plugin = (CarlaBackend::Lv2Plugin*)plugin;

  4631. 

  4632.     atom->type = lv2plugin->getCustomURID(typeStr);

  4633.     lv2plugin->handleTransferEvent(portIndex, atom);

  4634. 

  4635.     return 0;

  4636. }

  4637. #endif

  4638. 

  4639. CARLA_BACKEND_END_NAMESPACE

  4640. 

  4641. #else // WANT_LV2

  4642. # warning Building without LV2 support

  4643. #endif

  4644. 

  4645. CARLA_BACKEND_START_NAMESPACE

  4646. 

  4647. CarlaPlugin* CarlaPlugin::newLV2(const initializer& init)

  4648. {

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

  4650. 

  4651. #ifdef WANT_LV2

  4652.     short id = init.engine->getNewPluginId();

  4653. 

  4654.     if (id < 0 || id > init.engine->maxPluginNumber())

  4655.     {

  4656.         init.engine->setLastError("Maximum number of plugins reached");

  4657.         return nullptr;

  4658.     }

  4659. 

  4660.     Lv2Plugin* const plugin = new Lv2Plugin(init.engine, id);

  4661. 

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

  4663.     {

  4664.         delete plugin;

  4665.         return nullptr;

  4666.     }

  4667. 

  4668.     plugin->reload();

  4669. 

  4670. # ifndef BUILD_BRIDGE

  4671.     if (init.engine->processMode() == PROCESS_MODE_CONTINUOUS_RACK)

  4672.     {

  4673.         if (! (plugin->hints() & PLUGIN_CAN_FORCE_STEREO))

  4674.         {

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

  4676.             delete plugin;

  4677.             return nullptr;

  4678.         }

  4679.     }

  4680. # endif

  4681. 

  4682.     plugin->registerToOscControl();

  4683.     plugin->updateUi();

  4684. 

  4685.     return plugin;

  4686. #else

  4687.     init.engine->setLastError("LV2 support not available");

  4688.     return nullptr;

  4689. #endif

  4690. }

  4691. 

  4692. CARLA_BACKEND_END_NAMESPACE