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.
460 Commits
2 Branches
19MB
Tree: 399aa7346f
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '399aa7346f'
${ noResults }
Cadence/c++/carla-backend/lv2.cpp

4441 lines
156KB
Raw Blame History 

  1. /*

  2.  * Carla Backend

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

  4.  *

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

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

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

  8.  * any later version.

  9.  *

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

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

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

  13.  * GNU General Public License for more details.

  14.  *

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

  16.  */

  17. 

  18. #include "carla_plugin.h"

  19. #include "carla_lv2.h"

  20. #include "rtmempool/rtmempool.h"

  21. 

  22. #include <QtCore/QDir>

  23. #include <QtGui/QLayout>

  24. 

  25. #ifdef HAVE_SUIL

  26. #include <suil/suil.h>

  27. struct SuilInstanceImpl {

  28.     void*                   lib_handle;

  29.     const LV2UI_Descriptor* descriptor;

  30.     LV2UI_Handle            handle;

  31.     // ...

  32. };

  33. #endif

  34. 

  35. CARLA_BACKEND_START_NAMESPACE

  36. 

  37. /*!

  38.  * @defgroup CarlaBackendLv2Plugin Carla Backend LV2 Plugin

  39.  *

  40.  * The Carla Backend LV2 Plugin.\n

  41.  * http://lv2plug.in/

  42.  * @{

  43.  */

  44. 

  45. // static max values

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

  47. //const unsigned int MAX_EVENT_BUFFER = (sizeof(LV2_Atom_Event) + 4) * MAX_MIDI_EVENTS;

  48. 

  49. /*!

  50.  * @defgroup PluginHints Plugin Hints

  51.  * @{

  52.  */

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

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

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

  56. /**@}*/

  57. 

  58. /*!

  59.  * @defgroup ParameterHints Parameter Hints

  60.  * @{

  61.  */

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

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

  64. /**@}*/

  65. 

  66. /*!

  67.  * @defgroup Lv2FeatureIds LV2 Feature Ids

  68.  *

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

  70.  * \see CarlaPlugin::hints

  71.  * @{

  72.  */

  73. const uint32_t lv2_feature_id_bufsize_bounded  =  0;

  74. const uint32_t lv2_feature_id_bufsize_fixed    =  1;

  75. const uint32_t lv2_feature_id_bufsize_powerof2 =  2;

  76. const uint32_t lv2_feature_id_event            =  3;

  77. const uint32_t lv2_feature_id_logs             =  4;

  78. const uint32_t lv2_feature_id_options          =  5;

  79. const uint32_t lv2_feature_id_programs         =  6;

  80. const uint32_t lv2_feature_id_rtmempool        =  7;

  81. const uint32_t lv2_feature_id_state_make_path  =  8;

  82. const uint32_t lv2_feature_id_state_map_path   =  9;

  83. const uint32_t lv2_feature_id_strict_bounds    = 10;

  84. const uint32_t lv2_feature_id_uri_map          = 11;

  85. const uint32_t lv2_feature_id_urid_map         = 12;

  86. const uint32_t lv2_feature_id_urid_unmap       = 13;

  87. const uint32_t lv2_feature_id_worker           = 14;

  88. const uint32_t lv2_feature_id_data_access      = 15;

  89. const uint32_t lv2_feature_id_instance_access  = 16;

  90. const uint32_t lv2_feature_id_ui_parent        = 17;

  91. const uint32_t lv2_feature_id_ui_port_map      = 18;

  92. const uint32_t lv2_feature_id_ui_resize        = 19;

  93. const uint32_t lv2_feature_id_external_ui      = 20;

  94. const uint32_t lv2_feature_id_external_ui_old  = 21;

  95. const uint32_t lv2_feature_count               = 22;

  96. /**@}*/

  97. 

  98. /*!

  99.  * @defgroup Lv2EventTypes LV2 Event Data/Types

  100.  *

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

  102.  * \see CarlaPlugin::hints

  103.  * @{

  104.  */

  105. const unsigned int CARLA_EVENT_DATA_ATOM      = 0x01;

  106. const unsigned int CARLA_EVENT_DATA_EVENT     = 0x02;

  107. const unsigned int CARLA_EVENT_DATA_MIDI_LL   = 0x04;

  108. const unsigned int CARLA_EVENT_TYPE_MESSAGE   = 0x10;

  109. const unsigned int CARLA_EVENT_TYPE_MIDI      = 0x20;

  110. /**@}*/

  111. 

  112. /*!

  113.  * @defgroup Lv2UriMapIds LV2 URI Map Ids

  114.  *

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

  116.  * \see CarlaPlugin::hints

  117.  * @{

  118.  */

  119. const uint32_t CARLA_URI_MAP_ID_NULL                = 0;

  120. const uint32_t CARLA_URI_MAP_ID_ATOM_CHUNK          = 1;

  121. const uint32_t CARLA_URI_MAP_ID_ATOM_DOUBLE         = 2;

  122. const uint32_t CARLA_URI_MAP_ID_ATOM_INT            = 3;

  123. const uint32_t CARLA_URI_MAP_ID_ATOM_PATH           = 4;

  124. const uint32_t CARLA_URI_MAP_ID_ATOM_SEQUENCE       = 5;

  125. const uint32_t CARLA_URI_MAP_ID_ATOM_STRING         = 6;

  126. const uint32_t CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM  = 7;

  127. const uint32_t CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT = 8;

  128. const uint32_t CARLA_URI_MAP_ID_BUF_MAX_LENGTH      = 9;

  129. const uint32_t CARLA_URI_MAP_ID_BUF_MIN_LENGTH      = 10;

  130. const uint32_t CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE   = 11;

  131. const uint32_t CARLA_URI_MAP_ID_LOG_ERROR           = 12;

  132. const uint32_t CARLA_URI_MAP_ID_LOG_NOTE            = 13;

  133. const uint32_t CARLA_URI_MAP_ID_LOG_TRACE           = 14;

  134. const uint32_t CARLA_URI_MAP_ID_LOG_WARNING         = 15;

  135. const uint32_t CARLA_URI_MAP_ID_MIDI_EVENT          = 16;

  136. const uint32_t CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE   = 17;

  137. const uint32_t CARLA_URI_MAP_ID_COUNT               = 18;

  138. /**@}*/

  139. 

  140. struct Lv2EventData {

  141.     uint32_t type;

  142.     CarlaEngineMidiPort* port;

  143.     union {

  144.         LV2_Atom_Sequence* atom;

  145.         LV2_Event_Buffer* event;

  146.         LV2_MIDI* midi;

  147.     };

  148. 

  149.     Lv2EventData()

  150.         : type(0),

  151.           port(nullptr) {}

  152. };

  153. 

  154. struct Lv2PluginEventData {

  155.     uint32_t count;

  156.     Lv2EventData* data;

  157. 

  158.     Lv2PluginEventData()

  159.         : count(0),

  160.           data(nullptr) {}

  161. };

  162. 

  163. struct Lv2PluginOptions {

  164.     bool init;

  165.     uint32_t eventSize;

  166.     uint32_t bufferSize;

  167.     double   sampleRate;

  168.     LV2_Options_Option oNull;

  169.     LV2_Options_Option oMaxBlockLenth;

  170.     LV2_Options_Option oMinBlockLenth;

  171.     LV2_Options_Option oSequenceSize;

  172.     LV2_Options_Option oSampleRate;

  173. 

  174.     Lv2PluginOptions()

  175.         : init(false),

  176.           eventSize(MAX_EVENT_BUFFER),

  177.           bufferSize(0),

  178.           sampleRate(0.0) {}

  179. };

  180. 

  181. Lv2PluginOptions lv2Options;

  182. 

  183. const char* lv2bridge2str(const LV2_Property type)

  184. {

  185.     switch (type)

  186.     {

  187. #ifndef BUILD_BRIDGE

  188.     case LV2_UI_GTK2:

  189.         return carlaOptions.bridge_lv2gtk2;

  190.     case LV2_UI_QT4:

  191.         return carlaOptions.bridge_lv2qt4;

  192.     case LV2_UI_COCOA:

  193.         return nullptr; //carlaOptions.bridge_lv2cocoa;

  194.     case LV2_UI_WINDOWS:

  195.         return nullptr; //carlaOptions.bridge_lv2hwnd;

  196.     case LV2_UI_X11:

  197.         return carlaOptions.bridge_lv2x11;

  198. #endif

  199.     default:

  200.         return nullptr;

  201.     }

  202. }

  203. 

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

  205. {

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

  207. }

  208. 

  209. class Lv2Plugin : public CarlaPlugin

  210. {

  211. public:

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

  213.         : CarlaPlugin(engine, id)

  214.     {

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

  216. 

  217.         m_type = PLUGIN_LV2;

  218. 

  219.         handle = h2 = nullptr;

  220.         descriptor  = nullptr;

  221.         rdf_descriptor = nullptr;

  222. 

  223.         ext.state      = nullptr;

  224.         ext.worker     = nullptr;

  225.         ext.programs   = nullptr;

  226.         ext.uiprograms = nullptr;

  227. 

  228.         ui.lib = nullptr;

  229.         ui.handle = nullptr;

  230.         ui.descriptor = nullptr;

  231.         ui.rdf_descriptor = nullptr;

  232. 

  233.         evIn.count = 0;

  234.         evIn.data  = nullptr;

  235. 

  236.         evOut.count = 0;

  237.         evOut.data  = nullptr;

  238. 

  239.         paramBuffers = nullptr;

  240. 

  241.         gui.type = GUI_NONE;

  242.         gui.resizable = false;

  243.         gui.width  = 0;

  244.         gui.height = 0;

  245. 

  246. #ifdef HAVE_SUIL

  247.         suil.handle = nullptr;

  248.         suil.host   = nullptr;

  249. #endif

  250. 

  251.         lastTimePosPlaying = false;

  252.         lastTimePosFrame   = 0;

  253. 

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

  255.             customURIDs.push_back(nullptr);

  256. 

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

  258.             features[i] = nullptr;

  259. 

  260.         if (! lv2Options.init)

  261.         {

  262.             lv2Options.init = true;

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

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

  265. 

  266.             lv2Options.oNull.key   = CARLA_URI_MAP_ID_NULL;

  267.             lv2Options.oNull.size  = 0;

  268.             lv2Options.oNull.type  = CARLA_URI_MAP_ID_NULL;

  269.             lv2Options.oNull.value = nullptr;

  270. 

  271.             lv2Options.oMaxBlockLenth.key   = CARLA_URI_MAP_ID_BUF_MAX_LENGTH;

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

  273.             lv2Options.oMaxBlockLenth.type  = CARLA_URI_MAP_ID_ATOM_INT;

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

  275. 

  276.             lv2Options.oMinBlockLenth.key   = CARLA_URI_MAP_ID_BUF_MIN_LENGTH;

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

  278.             lv2Options.oMinBlockLenth.type  = CARLA_URI_MAP_ID_ATOM_INT;

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

  280. 

  281.             lv2Options.oSequenceSize.key   = CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE;

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

  283.             lv2Options.oSequenceSize.type  = CARLA_URI_MAP_ID_ATOM_INT;

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

  285. 

  286.             lv2Options.oSampleRate.key     = CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE;

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

  288.             lv2Options.oSampleRate.type    = CARLA_URI_MAP_ID_ATOM_DOUBLE;

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

  290.         }

  291.     }

  292. 

  293.     ~Lv2Plugin()

  294.     {

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

  296. 

  297.         // close UI

  298.         if (m_hints & PLUGIN_HAS_GUI)

  299.         {

  300.             showGui(false);

  301. 

  302.             switch (gui.type)

  303.             {

  304.             case GUI_NONE:

  305.             case GUI_INTERNAL_QT4:

  306.             case GUI_INTERNAL_COCOA:

  307.             case GUI_INTERNAL_HWND:

  308.             case GUI_INTERNAL_X11:

  309.             case GUI_EXTERNAL_LV2:

  310.                 break;

  311. 

  312.             case GUI_EXTERNAL_SUIL:

  313. #ifdef HAVE_SUIL

  314.                 if (ui.widget)

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

  316. #endif

  317.                 break;

  318. 

  319.             case GUI_EXTERNAL_OSC:

  320. #ifndef BUILD_BRIDGE

  321.                 if (osc.thread)

  322.                 {

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

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

  325.                     {

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

  327.                         osc.thread->terminate();

  328.                     }

  329. 

  330.                     delete osc.thread;

  331.                 }

  332. #endif

  333.                 break;

  334.             }

  335. 

  336. #ifdef HAVE_SUIL

  337.             if (suil.handle)

  338.             {

  339.                 suil_instance_free(suil.handle);

  340. 

  341.                 if (suil.host)

  342.                     suil_host_free(suil.host);

  343. 

  344.                 ui.handle = nullptr;

  345.                 ui.descriptor = nullptr;

  346.             }

  347. #endif

  348. 

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

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

  351. 

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

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

  354. 

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

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

  357. 

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

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

  360. 

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

  362.             {

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

  364. 

  365.                 if (uiHost->plugin_human_id)

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

  367. 

  368.                 delete uiHost;

  369.             }

  370. 

  371.             uiLibClose();

  372.         }

  373. 

  374.         if (descriptor)

  375.         {

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

  377.             {

  378.                 if (handle)

  379.                     descriptor->deactivate(handle);

  380.                 if (h2)

  381.                     descriptor->deactivate(h2);

  382.             }

  383. 

  384.             if (descriptor->cleanup)

  385.             {

  386.                 if (handle)

  387.                     descriptor->cleanup(handle);

  388.                 if (h2)

  389.                     descriptor->cleanup(h2);

  390.             }

  391.         }

  392. 

  393.         if (rdf_descriptor)

  394.             lv2_rdf_free(rdf_descriptor);

  395. 

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

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

  398. 

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

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

  401. 

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

  403.         {

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

  405.             delete[] options;

  406.         }

  407. 

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

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

  410. 

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

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

  413. 

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

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

  416. 

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

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

  419. 

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

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

  422. 

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

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

  425. 

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

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

  428. 

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

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

  431. 

  432. #ifndef BUILD_BRIDGE

  433.         if (! carlaOptions.processHighPrecision)

  434. #endif

  435.         {

  436.             features[lv2_feature_id_bufsize_fixed]    = nullptr;

  437.             features[lv2_feature_id_bufsize_powerof2] = nullptr;

  438.         }

  439. 

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

  441.         {

  442.             if (features[i])

  443.                 delete features[i];

  444.         }

  445. 

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

  447.         {

  448.             if (customURIDs[i])

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

  450.         }

  451. 

  452.         customURIDs.clear();

  453.     }

  454. 

  455.     // -------------------------------------------------------------------

  456.     // Information (base)

  457. 

  458.     PluginCategory category()

  459.     {

  460.         Q_ASSERT(rdf_descriptor);

  461. 

  462.         LV2_Property category = rdf_descriptor->Type;

  463. 

  464.         if (LV2_IS_DELAY(category))

  465.             return PLUGIN_CATEGORY_DELAY;

  466.         if (LV2_IS_DISTORTION(category))

  467.             return PLUGIN_CATEGORY_OTHER;

  468.         if (LV2_IS_DYNAMICS(category))

  469.             return PLUGIN_CATEGORY_DYNAMICS;

  470.         if (LV2_IS_EQ(category))

  471.             return PLUGIN_CATEGORY_EQ;

  472.         if (LV2_IS_FILTER(category))

  473.             return PLUGIN_CATEGORY_FILTER;

  474.         if (LV2_IS_GENERATOR(category))

  475.             return PLUGIN_CATEGORY_SYNTH;

  476.         if (LV2_IS_MODULATOR(category))

  477.             return PLUGIN_CATEGORY_MODULATOR;

  478.         if (LV2_IS_REVERB(category))

  479.             return PLUGIN_CATEGORY_DELAY;

  480.         if (LV2_IS_SIMULATOR(category))

  481.             return PLUGIN_CATEGORY_OTHER;

  482.         if (LV2_IS_SPATIAL(category))

  483.             return PLUGIN_CATEGORY_OTHER;

  484.         if (LV2_IS_SPECTRAL(category))

  485.             return PLUGIN_CATEGORY_UTILITY;

  486.         if (LV2_IS_UTILITY(category))

  487.             return PLUGIN_CATEGORY_UTILITY;

  488. 

  489.         return getPluginCategoryFromName(m_name);

  490.     }

  491. 

  492.     long uniqueId()

  493.     {

  494.         Q_ASSERT(rdf_descriptor);

  495. 

  496.         return rdf_descriptor->UniqueID;

  497.     }

  498. 

  499.     // -------------------------------------------------------------------

  500.     // Information (count)

  501. 

  502.     uint32_t midiInCount()

  503.     {

  504.         uint32_t i, count = 0;

  505. 

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

  507.         {

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

  509.                 count += 1;

  510.         }

  511. 

  512.         return count;

  513.     }

  514. 

  515.     uint32_t midiOutCount()

  516.     {

  517.         uint32_t i, count = 0;

  518. 

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

  520.         {

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

  522.                 count += 1;

  523.         }

  524. 

  525.         return count;

  526.     }

  527. 

  528.     uint32_t parameterScalePointCount(const uint32_t parameterId)

  529.     {

  530.         Q_ASSERT(parameterId < param.count);

  531.         Q_ASSERT(rdf_descriptor);

  532. 

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

  534. 

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

  536.         {

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

  538.             return port->ScalePointCount;

  539.         }

  540. 

  541.         return 0;

  542.     }

  543. 

  544.     // -------------------------------------------------------------------

  545.     // Information (per-plugin data)

  546. 

  547.     double getParameterValue(const uint32_t parameterId)

  548.     {

  549.         Q_ASSERT(parameterId < param.count);

  550. 

  551.         return paramBuffers[parameterId];

  552.     }

  553. 

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

  555.     {

  556.         Q_ASSERT(parameterId < param.count);

  557.         Q_ASSERT(scalePointId < parameterScalePointCount(parameterId));

  558. 

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

  560. 

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

  562.         {

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

  564. 

  565.             if (scalePointId < port->ScalePointCount)

  566.             {

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

  568.                 return portScalePoint->Value;

  569.             }

  570.         }

  571. 

  572.         return 0.0;

  573.     }

  574. 

  575.     void getLabel(char* const strBuf)

  576.     {

  577.         Q_ASSERT(rdf_descriptor);

  578. 

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

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

  581.         else

  582.             CarlaPlugin::getLabel(strBuf);

  583.     }

  584. 

  585.     void getMaker(char* const strBuf)

  586.     {

  587.         Q_ASSERT(rdf_descriptor);

  588. 

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

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

  591.         else

  592.             CarlaPlugin::getMaker(strBuf);

  593.     }

  594. 

  595.     void getCopyright(char* const strBuf)

  596.     {

  597.         Q_ASSERT(rdf_descriptor);

  598. 

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

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

  601.         else

  602.             CarlaPlugin::getCopyright(strBuf);

  603.     }

  604. 

  605.     void getRealName(char* const strBuf)

  606.     {

  607.         Q_ASSERT(rdf_descriptor);

  608. 

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

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

  611.         else

  612.             CarlaPlugin::getRealName(strBuf);

  613.     }

  614. 

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

  616.     {

  617.         Q_ASSERT(rdf_descriptor);

  618.         Q_ASSERT(parameterId < param.count);

  619. 

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

  621. 

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

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

  624.         else

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

  626.     }

  627. 

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

  629.     {

  630.         Q_ASSERT(rdf_descriptor);

  631.         Q_ASSERT(parameterId < param.count);

  632. 

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

  634. 

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

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

  637.         else

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

  639.     }

  640. 

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

  642.     {

  643.         Q_ASSERT(rdf_descriptor);

  644.         Q_ASSERT(parameterId < param.count);

  645. 

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

  647. 

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

  649.         {

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

  651. 

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

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

  654. 

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

  656.             {

  657.                 switch (port->Unit.Type)

  658.                 {

  659.                 case LV2_UNIT_BAR:

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

  661.                     return;

  662.                 case LV2_UNIT_BEAT:

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

  664.                     return;

  665.                 case LV2_UNIT_BPM:

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

  667.                     return;

  668.                 case LV2_UNIT_CENT:

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

  670.                     return;

  671.                 case LV2_UNIT_CM:

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

  673.                     return;

  674.                 case LV2_UNIT_COEF:

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

  676.                     return;

  677.                 case LV2_UNIT_DB:

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

  679.                     return;

  680.                 case LV2_UNIT_DEGREE:

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

  682.                     return;

  683.                 case LV2_UNIT_FRAME:

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

  685.                     return;

  686.                 case LV2_UNIT_HZ:

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

  688.                     return;

  689.                 case LV2_UNIT_INCH:

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

  691.                     return;

  692.                 case LV2_UNIT_KHZ:

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

  694.                     return;

  695.                 case LV2_UNIT_KM:

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

  697.                     return;

  698.                 case LV2_UNIT_M:

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

  700.                     return;

  701.                 case LV2_UNIT_MHZ:

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

  703.                     return;

  704.                 case LV2_UNIT_MIDINOTE:

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

  706.                     return;

  707.                 case LV2_UNIT_MILE:

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

  709.                     return;

  710.                 case LV2_UNIT_MIN:

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

  712.                     return;

  713.                 case LV2_UNIT_MM:

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

  715.                     return;

  716.                 case LV2_UNIT_MS:

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

  718.                     return;

  719.                 case LV2_UNIT_OCT:

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

  721.                     return;

  722.                 case LV2_UNIT_PC:

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

  724.                     return;

  725.                 case LV2_UNIT_S:

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

  727.                     return;

  728.                 case LV2_UNIT_SEMITONE:

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

  730.                     return;

  731.                 }

  732.             }

  733.         }

  734. 

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

  736.     }

  737. 

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

  739.     {

  740.         Q_ASSERT(rdf_descriptor);

  741.         Q_ASSERT(parameterId < param.count);

  742.         Q_ASSERT(scalePointId < parameterScalePointCount(parameterId));

  743. 

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

  745. 

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

  747.         {

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

  749. 

  750.             if (scalePointId < port->ScalePointCount)

  751.             {

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

  753. 

  754.                 if (portScalePoint->Label)

  755.                 {

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

  757.                     return;

  758.                 }

  759.             }

  760.         }

  761. 

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

  763.     }

  764. 

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

  766.     {

  767.         Q_ASSERT(type);

  768.         Q_ASSERT(resizable);

  769. 

  770.         *type      = gui.type;

  771.         *resizable = gui.resizable;

  772.     }

  773. 

  774.     // -------------------------------------------------------------------

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

  776. 

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

  778.     {

  779.         Q_ASSERT(parameterId < param.count);

  780. 

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

  782. 

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

  784.     }

  785. 

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

  787.     {

  788.         Q_ASSERT(type != CUSTOM_DATA_INVALID);

  789.         Q_ASSERT(key);

  790.         Q_ASSERT(value);

  791. 

  792.         if (type == CUSTOM_DATA_INVALID)

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

  794. 

  795.         if (! key)

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

  797. 

  798.         if (! value)

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

  800. 

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

  802. 

  803.         if (ext.state)

  804.         {

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

  806.             LV2_State_Status status;

  807. 

  808.             if (x_engine->isOffline())

  809.             {

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

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

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

  813.             }

  814.             else

  815.             {

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

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

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

  819.             }

  820. 

  821.             switch (status)

  822.             {

  823.             case LV2_STATE_SUCCESS:

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

  825.                 break;

  826.             case LV2_STATE_ERR_UNKNOWN:

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

  828.                 break;

  829.             case LV2_STATE_ERR_BAD_TYPE:

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

  831.                 break;

  832.             case LV2_STATE_ERR_BAD_FLAGS:

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

  834.                 break;

  835.             case LV2_STATE_ERR_NO_FEATURE:

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

  837.                 break;

  838.             case LV2_STATE_ERR_NO_PROPERTY:

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

  840.                 break;

  841.             }

  842.         }

  843. 

  844.         if (sendGui)

  845.         {

  846.             CustomData cdata;

  847.             cdata.type  = type;

  848.             cdata.key   = key;

  849.             cdata.value = value;

  850.             uiTransferEvent(&cdata);

  851.         }

  852.     }

  853. 

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

  855.     {

  856.         Q_ASSERT(index >= -1 && index < (int32_t)midiprog.count);

  857. 

  858.         if (index < -1)

  859.             index = -1;

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

  861.             return;

  862. 

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

  864.         {

  865.             if (x_engine->isOffline())

  866.             {

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

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

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

  870.             }

  871.             else

  872.             {

  873.                 const ScopedDisabler m(this, block);

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

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

  876.             }

  877.         }

  878. 

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

  880.     }

  881. 

  882.     // -------------------------------------------------------------------

  883.     // Set gui stuff

  884. 

  885.     void setGuiData(QDialog* const dialog)

  886.     {

  887.         switch(gui.type)

  888.         {

  889.         case GUI_NONE:

  890.             break;

  891. 

  892.         case GUI_INTERNAL_QT4:

  893.             if (ui.widget)

  894.             {

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

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

  897.                 widget->adjustSize();

  898.                 widget->setParent(dialog);

  899.                 widget->show();

  900.             }

  901.             break;

  902. 

  903.         case GUI_INTERNAL_COCOA:

  904.         case GUI_INTERNAL_HWND:

  905.         case GUI_INTERNAL_X11:

  906.             if (ui.descriptor)

  907.             {

  908.                 features[lv2_feature_id_ui_parent]->data = (void*)dialog->winId();

  909.                 ui.handle = ui.descriptor->instantiate(ui.descriptor,

  910.                                                        descriptor->URI, ui.rdf_descriptor->Bundle,

  911.                                                        carla_lv2_ui_write_function, this, &ui.widget,features);

  912.                 updateUi();

  913.             }

  914.             break;

  915. 

  916.         case GUI_EXTERNAL_LV2:

  917.         case GUI_EXTERNAL_SUIL:

  918.         case GUI_EXTERNAL_OSC:

  919.             break;

  920.         }

  921.     }

  922. 

  923.     void showGui(const bool yesNo)

  924.     {

  925.         switch(gui.type)

  926.         {

  927.         case GUI_NONE:

  928.         case GUI_INTERNAL_QT4:

  929.             break;

  930. 

  931.         case GUI_INTERNAL_COCOA:

  932.         case GUI_INTERNAL_HWND:

  933.         case GUI_INTERNAL_X11:

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

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

  936.             break;

  937. 

  938.         case GUI_EXTERNAL_LV2:

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

  940.                 initExternalUi();

  941. 

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

  943.             {

  944.                 if (yesNo)

  945.                 {

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

  947.                 }

  948.                 else

  949.                 {

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

  951. 

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

  953.                     {

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

  955. 

  956.                         if (ui.descriptor->cleanup)

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

  958. 

  959.                         ui.handle = nullptr;

  960.                     }

  961.                 }

  962.             }

  963.             else

  964.                 // failed to init UI

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

  966. 

  967.             break;

  968. 

  969.         case GUI_EXTERNAL_SUIL:

  970. #ifdef HAVE_SUIL

  971.             if (ui.widget)

  972.             {

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

  974. 

  975.                 if (yesNo)

  976.                 {

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

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

  979.                 }

  980.                 else

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

  982. 

  983.                 widget->setVisible(yesNo);

  984.             }

  985. #endif

  986.             break;

  987. 

  988.         case GUI_EXTERNAL_OSC:

  989. #ifndef BUILD_BRIDGE

  990.             Q_ASSERT(osc.thread);

  991. 

  992.             if (! osc.thread)

  993.             {

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

  995.                 return;

  996.             }

  997. 

  998.             if (yesNo)

  999.             {

  1000.                 osc.thread->start();

  1001.             }

  1002.             else

  1003.             {

  1004.                 if (osc.data.target)

  1005.                 {

  1006.                     osc_send_hide(&osc.data);

  1007.                     osc_send_quit(&osc.data);

  1008.                     osc_clear_data(&osc.data);

  1009.                 }

  1010. 

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

  1012.                     osc.thread->quit();

  1013.             }

  1014. #endif

  1015.             break;

  1016.         }

  1017.     }

  1018. 

  1019.     void idleGui()

  1020.     {

  1021.         // Update external UI

  1022.         if (gui.type == GUI_EXTERNAL_LV2 && ui.handle && ui.descriptor && ui.widget)

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

  1024. 

  1025.         CarlaPlugin::idleGui();

  1026.     }

  1027. 

  1028.     // -------------------------------------------------------------------

  1029.     // Plugin state

  1030. 

  1031.     void reload()

  1032.     {

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

  1034.         Q_ASSERT(descriptor && rdf_descriptor);

  1035. 

  1036.         // Safely disable plugin for reload

  1037.         const ScopedDisabler m(this);

  1038. 

  1039.         if (x_client->isActive())

  1040.             x_client->deactivate();

  1041. 

  1042.         // Remove client ports

  1043.         removeClientPorts();

  1044. 

  1045.         // Delete old data

  1046.         deleteBuffers();

  1047. 

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

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

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

  1051. 

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

  1053.         const uint32_t portCount = rdf_descriptor->PortCount;

  1054. 

  1055.         bool forcedStereoIn, forcedStereoOut;

  1056.         forcedStereoIn = forcedStereoOut = false;

  1057. 

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

  1059.         {

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

  1061. 

  1062.             if (LV2_IS_PORT_AUDIO(portType))

  1063.             {

  1064.                 if (LV2_IS_PORT_INPUT(portType))

  1065.                     aIns += 1;

  1066.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1067.                     aOuts += 1;

  1068.             }

  1069.             else if (LV2_IS_PORT_CV(portType))

  1070.             {

  1071.                 if (LV2_IS_PORT_INPUT(portType))

  1072.                     cvIns += 1;

  1073.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1074.                     cvOuts += 1;

  1075.             }

  1076.             else if (LV2_IS_PORT_ATOM_SEQUENCE(portType))

  1077.             {

  1078.                 if (LV2_IS_PORT_INPUT(portType))

  1079.                     evIns.push_back(CARLA_EVENT_DATA_ATOM);

  1080.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1081.                     evOuts.push_back(CARLA_EVENT_DATA_ATOM);

  1082.             }

  1083.             else if (LV2_IS_PORT_EVENT(portType))

  1084.             {

  1085.                 if (LV2_IS_PORT_INPUT(portType))

  1086.                     evIns.push_back(CARLA_EVENT_DATA_EVENT);

  1087.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1088.                     evOuts.push_back(CARLA_EVENT_DATA_EVENT);

  1089.             }

  1090.             else if (LV2_IS_PORT_MIDI_LL(portType))

  1091.             {

  1092.                 if (LV2_IS_PORT_INPUT(portType))

  1093.                     evIns.push_back(CARLA_EVENT_DATA_MIDI_LL);

  1094.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1095.                     evOuts.push_back(CARLA_EVENT_DATA_MIDI_LL);

  1096.             }

  1097.             else if (LV2_IS_PORT_CONTROL(portType))

  1098.                 params += 1;

  1099.         }

  1100. 

  1101. #ifndef BUILD_BRIDGE

  1102.         if (carlaOptions.forceStereo && (aIns == 1 || aOuts == 1) && ! h2)

  1103.         {

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

  1105. 

  1106.             if (aIns == 1)

  1107.             {

  1108.                 aIns = 2;

  1109.                 forcedStereoIn = true;

  1110.             }

  1111. 

  1112.             if (aOuts == 1)

  1113.             {

  1114.                 aOuts = 2;

  1115.                 forcedStereoOut = true;

  1116.             }

  1117.         }

  1118. #endif

  1119. 

  1120.         if (aIns > 0)

  1121.         {

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

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

  1124.         }

  1125. 

  1126.         if (aOuts > 0)

  1127.         {

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

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

  1130.         }

  1131. 

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

  1133.         {

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

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

  1136. 

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

  1138.             {

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

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

  1141. 

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

  1143.                 {

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

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

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

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

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

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

  1150.                 }

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

  1152.                 {

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

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

  1155.                 }

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

  1157.                 {

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

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

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

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

  1162.                 }

  1163.             }

  1164.         }

  1165. 

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

  1167.         {

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

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

  1170. 

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

  1172.             {

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

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

  1175. 

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

  1177.                 {

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

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

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

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

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

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

  1184.                 }

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

  1186.                 {

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

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

  1189.                 }

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

  1191.                 {

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

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

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

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

  1196.                 }

  1197.             }

  1198.         }

  1199. 

  1200.         if (params > 0)

  1201.         {

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

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

  1204.             paramBuffers = new float[params];

  1205.         }

  1206. 

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

  1208.         char portName[portNameSize];

  1209.         bool needsCtrlIn  = false;

  1210.         bool needsCtrlOut = false;

  1211. 

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

  1213.         {

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

  1215. 

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

  1217.             {

  1218. #ifndef BUILD_BRIDGE

  1219.                 if (carlaOptions.processMode != PROCESS_MODE_MULTIPLE_CLIENTS)

  1220.                 {

  1221.                     strcpy(portName, m_name);

  1222.                     strcat(portName, ":");

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

  1224.                 }

  1225.                 else

  1226. #endif

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

  1228.             }

  1229. 

  1230.             if (LV2_IS_PORT_AUDIO(portType))

  1231.             {

  1232.                 if (LV2_IS_PORT_INPUT(portType))

  1233.                 {

  1234.                     j = aIn.count++;

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

  1236.                     aIn.rindexes[j] = i;

  1237. 

  1238.                     if (forcedStereoIn)

  1239.                     {

  1240.                         strcat(portName, "_");

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

  1242.                         aIn.rindexes[1] = i;

  1243.                     }

  1244.                 }

  1245.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1246.                 {

  1247.                     j = aOut.count++;

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

  1249.                     aOut.rindexes[j] = i;

  1250.                     needsCtrlIn = true;

  1251. 

  1252.                     if (forcedStereoOut)

  1253.                     {

  1254.                         strcat(portName, "_");

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

  1256.                         aOut.rindexes[1] = i;

  1257.                     }

  1258.                 }

  1259.                 else

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

  1261.             }

  1262.             else if (LV2_IS_PORT_CV(portType))

  1263.             {

  1264.                 if (LV2_IS_PORT_INPUT(portType))

  1265.                 {

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

  1267.                 }

  1268.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1269.                 {

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

  1271.                 }

  1272.                 else

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

  1274. 

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

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

  1277.             }

  1278.             else if (LV2_IS_PORT_ATOM_SEQUENCE(portType))

  1279.             {

  1280.                 if (LV2_IS_PORT_INPUT(portType))

  1281.                 {

  1282.                     j = evIn.count++;

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

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

  1285. 

  1286.                     if (portType & LV2_PORT_SUPPORTS_MIDI_EVENT)

  1287.                     {

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

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

  1290.                     }

  1291.                     if (portType & LV2_PORT_SUPPORTS_PATCH_MESSAGE)

  1292.                     {

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

  1294.                     }

  1295.                 }

  1296.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1297.                 {

  1298.                     j = evOut.count++;

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

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

  1301. 

  1302.                     if (portType & LV2_PORT_SUPPORTS_MIDI_EVENT)

  1303.                     {

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

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

  1306.                     }

  1307.                     if (portType & LV2_PORT_SUPPORTS_PATCH_MESSAGE)

  1308.                     {

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

  1310.                     }

  1311.                 }

  1312.                 else

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

  1314.             }

  1315.             else if (LV2_IS_PORT_EVENT(portType))

  1316.             {

  1317.                 if (LV2_IS_PORT_INPUT(portType))

  1318.                 {

  1319.                     j = evIn.count++;

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

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

  1322. 

  1323.                     if (portType & LV2_PORT_SUPPORTS_MIDI_EVENT)

  1324.                     {

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

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

  1327.                     }

  1328.                 }

  1329.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1330.                 {

  1331.                     j = evOut.count++;

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

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

  1334. 

  1335.                     if (portType & LV2_PORT_SUPPORTS_MIDI_EVENT)

  1336.                     {

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

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

  1339.                     }

  1340.                 }

  1341.                 else

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

  1343.             }

  1344.             else if (LV2_IS_PORT_MIDI_LL(portType))

  1345.             {

  1346.                 if (LV2_IS_PORT_INPUT(portType))

  1347.                 {

  1348.                     j = evIn.count++;

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

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

  1351. 

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

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

  1354.                 }

  1355.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1356.                 {

  1357.                     j = evOut.count++;

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

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

  1360. 

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

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

  1363.                 }

  1364.                 else

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

  1366.             }

  1367.             else if (LV2_IS_PORT_CONTROL(portType))

  1368.             {

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

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

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

  1372. 

  1373.                 j = param.count++;

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

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

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

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

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

  1379. 

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

  1381. 

  1382.                 // min value

  1383.                 if (LV2_HAVE_MINIMUM_PORT_POINT(portPoints.Hints))

  1384.                     min = portPoints.Minimum;

  1385.                 else

  1386.                     min = 0.0;

  1387. 

  1388.                 // max value

  1389.                 if (LV2_HAVE_MAXIMUM_PORT_POINT(portPoints.Hints))

  1390.                     max = portPoints.Maximum;

  1391.                 else

  1392.                     max = 1.0;

  1393. 

  1394.                 if (min > max)

  1395.                     max = min;

  1396.                 else if (max < min)

  1397.                     min = max;

  1398. 

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

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

  1401.                 {

  1402.                     min = 0.0;

  1403.                     max = 16777215.0; // 0xffffff

  1404.                 }

  1405. 

  1406.                 if (max - min == 0.0)

  1407.                 {

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

  1409.                     max = min + 0.1;

  1410.                 }

  1411. 

  1412.                 // default value

  1413.                 if (LV2_HAVE_DEFAULT_PORT_POINT(portPoints.Hints))

  1414.                 {

  1415.                     def = portPoints.Default;

  1416.                 }

  1417.                 else

  1418.                 {

  1419.                     // no default value

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

  1421.                         def = 0.0;

  1422.                     else

  1423.                         def = min;

  1424.                 }

  1425. 

  1426.                 if (def < min)

  1427.                     def = min;

  1428.                 else if (def > max)

  1429.                     def = max;

  1430. 

  1431.                 if (LV2_IS_PORT_SAMPLE_RATE(portProps))

  1432.                 {

  1433.                     min *= sampleRate;

  1434.                     max *= sampleRate;

  1435.                     def *= sampleRate;

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

  1437.                 }

  1438. 

  1439.                 if (LV2_IS_PORT_TOGGLED(portProps))

  1440.                 {

  1441.                     step = max - min;

  1442.                     stepSmall = step;

  1443.                     stepLarge = step;

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

  1445.                 }

  1446.                 else if (LV2_IS_PORT_INTEGER(portProps))

  1447.                 {

  1448.                     step = 1.0;

  1449.                     stepSmall = 1.0;

  1450.                     stepLarge = 10.0;

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

  1452.                 }

  1453.                 else

  1454.                 {

  1455.                     double range = max - min;

  1456.                     step = range/100.0;

  1457.                     stepSmall = range/1000.0;

  1458.                     stepLarge = range/10.0;

  1459.                 }

  1460. 

  1461.                 if (LV2_IS_PORT_INPUT(portType))

  1462.                 {

  1463.                     if (LV2_IS_PORT_DESIGNATION_LATENCY(portDesignation))

  1464.                     {

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

  1466.                     }

  1467.                     else if (LV2_IS_PORT_DESIGNATION_SAMPLE_RATE(portDesignation))

  1468.                     {

  1469.                         def = sampleRate;

  1470.                         step = 1.0;

  1471.                         stepSmall = 1.0;

  1472.                         stepLarge = 1.0;

  1473. 

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

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

  1476.                     }

  1477.                     else if (LV2_IS_PORT_DESIGNATION_FREEWHEELING(portDesignation))

  1478.                     {

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

  1480.                     }

  1481.                     else if (LV2_IS_PORT_DESIGNATION_TIME(portDesignation))

  1482.                     {

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

  1484.                     }

  1485.                     else

  1486.                     {

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

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

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

  1490.                         needsCtrlIn = true;

  1491.                     }

  1492. 

  1493.                     // MIDI CC value

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

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

  1496.                     {

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

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

  1499.                     }

  1500.                 }

  1501.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1502.                 {

  1503.                     if (LV2_IS_PORT_DESIGNATION_LATENCY(portDesignation))

  1504.                     {

  1505.                         min = 0.0;

  1506.                         max = sampleRate;

  1507.                         def = 0.0;

  1508.                         step = 1.0;

  1509.                         stepSmall = 1.0;

  1510.                         stepLarge = 1.0;

  1511. 

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

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

  1514.                     }

  1515.                     else if (LV2_IS_PORT_DESIGNATION_SAMPLE_RATE(portDesignation))

  1516.                     {

  1517.                         def = sampleRate;

  1518.                         step = 1.0;

  1519.                         stepSmall = 1.0;

  1520.                         stepLarge = 1.0;

  1521. 

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

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

  1524.                     }

  1525.                     else if (LV2_IS_PORT_DESIGNATION_FREEWHEELING(portDesignation))

  1526.                     {

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

  1528.                     }

  1529.                     else if (LV2_IS_PORT_DESIGNATION_TIME(portDesignation))

  1530.                     {

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

  1532.                     }

  1533.                     else

  1534.                     {

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

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

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

  1538.                         needsCtrlOut = true;

  1539.                     }

  1540.                 }

  1541.                 else

  1542.                 {

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

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

  1545.                 }

  1546. 

  1547.                 // extra parameter hints

  1548.                 if (LV2_IS_PORT_ENUMERATION(portProps))

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

  1550. 

  1551.                 if (LV2_IS_PORT_LOGARITHMIC(portProps))

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

  1553. 

  1554.                 if (LV2_IS_PORT_TRIGGER(portProps))

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

  1556. 

  1557.                 if (LV2_IS_PORT_STRICT_BOUNDS(portProps))

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

  1559. 

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

  1561.                 if (LV2_IS_PORT_NOT_ON_GUI(portProps))

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

  1563. 

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

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

  1566. 

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

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

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

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

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

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

  1573. 

  1574.                 // Start parameters in their default values

  1575.                 paramBuffers[j] = def;

  1576. 

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

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

  1579.             }

  1580.             else

  1581.             {

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

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

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

  1585.             }

  1586.         }

  1587. 

  1588.         if (needsCtrlIn)

  1589.         {

  1590. #ifndef BUILD_BRIDGE

  1591.             if (carlaOptions.processMode != PROCESS_MODE_MULTIPLE_CLIENTS)

  1592.             {

  1593.                 strcpy(portName, m_name);

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

  1595.             }

  1596.             else

  1597. #endif

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

  1599. 

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

  1601.         }

  1602. 

  1603.         if (needsCtrlOut)

  1604.         {

  1605. #ifndef BUILD_BRIDGE

  1606.             if (carlaOptions.processMode != PROCESS_MODE_MULTIPLE_CLIENTS)

  1607.             {

  1608.                 strcpy(portName, m_name);

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

  1610.             }

  1611.             else

  1612. #endif

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

  1614. 

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

  1616.         }

  1617. 

  1618.         aIn.count   = aIns;

  1619.         aOut.count  = aOuts;

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

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

  1622.         param.count = params;

  1623. 

  1624.         // plugin checks

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

  1626. 

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

  1628.             m_hints |= PLUGIN_IS_SYNTH;

  1629. 

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

  1631.             m_hints |= PLUGIN_CAN_DRYWET;

  1632. 

  1633.         if (aOuts > 0)

  1634.             m_hints |= PLUGIN_CAN_VOLUME;

  1635. 

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

  1637.             m_hints |= PLUGIN_CAN_BALANCE;

  1638. 

  1639.         // check extensions

  1640.         ext.state      = nullptr;

  1641.         ext.worker     = nullptr;

  1642.         ext.programs   = nullptr;

  1643. 

  1644.         if (descriptor->extension_data)

  1645.         {

  1646.             if (m_hints & PLUGIN_HAS_EXTENSION_PROGRAMS)

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

  1648. 

  1649.             if (m_hints & PLUGIN_HAS_EXTENSION_STATE)

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

  1651. 

  1652.             if (m_hints & PLUGIN_HAS_EXTENSION_WORKER)

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

  1654.         }

  1655. 

  1656.         reloadPrograms(true);

  1657. 

  1658.         x_client->activate();

  1659. 

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

  1661.     }

  1662. 

  1663.     void reloadPrograms(const bool init)

  1664.     {

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

  1666.         uint32_t i, oldCount = midiprog.count;

  1667. 

  1668.         // Delete old programs

  1669.         if (midiprog.count > 0)

  1670.         {

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

  1672.             {

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

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

  1675.             }

  1676. 

  1677.             delete[] midiprog.data;

  1678.         }

  1679. 

  1680.         midiprog.count = 0;

  1681.         midiprog.data  = nullptr;

  1682. 

  1683.         // Query new programs

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

  1685.         {

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

  1687.                 midiprog.count += 1;

  1688.         }

  1689. 

  1690.         if (midiprog.count > 0)

  1691.             midiprog.data = new midi_program_t[midiprog.count];

  1692. 

  1693.         // Update data

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

  1695.         {

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

  1697.             Q_ASSERT(pdesc);

  1698.             Q_ASSERT(pdesc->program < 128);

  1699.             Q_ASSERT(pdesc->name);

  1700. 

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

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

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

  1704.         }

  1705. 

  1706. #ifndef BUILD_BRIDGE

  1707.         // Update OSC Names

  1708.         if (x_engine->isOscControllerRegisted())

  1709.         {

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

  1711. 

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

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

  1714.         }

  1715. #endif

  1716. 

  1717.         if (init)

  1718.         {

  1719.             if (midiprog.count > 0)

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

  1721.         }

  1722.         else

  1723.         {

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

  1725. 

  1726.             // Check if current program is invalid

  1727.             bool programChanged = false;

  1728. 

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

  1730.             {

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

  1732.                 midiprog.current = oldCount;

  1733.                 programChanged   = true;

  1734.             }

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

  1736.             {

  1737.                 // current midi program > count

  1738.                 midiprog.current = 0;

  1739.                 programChanged   = true;

  1740.             }

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

  1742.             {

  1743.                 // programs exist now, but not before

  1744.                 midiprog.current = 0;

  1745.                 programChanged   = true;

  1746.             }

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

  1748.             {

  1749.                 // programs existed before, but not anymore

  1750.                 midiprog.current = -1;

  1751.                 programChanged   = true;

  1752.             }

  1753. 

  1754.             if (programChanged)

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

  1756.         }

  1757.     }

  1758. 

  1759.     void prepareForSave()

  1760.     {

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

  1762.         {

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

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

  1765.         }

  1766.     }

  1767. 

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

  1769.     // Plugin processing

  1770. 

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

  1772.     {

  1773.         uint32_t i, k;

  1774.         uint32_t midiEventCount = 0;

  1775. 

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

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

  1778. 

  1779.         // handle events from different APIs

  1780.         uint32_t evInAtomOffsets[evIn.count];

  1781.         LV2_Event_Iterator evInEventIters[evIn.count];

  1782.         LV2_MIDIState evInMidiStates[evIn.count];

  1783. 

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

  1785.         {

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

  1787.             {

  1788.                 evInAtomOffsets[i] = 0;

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

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

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

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

  1793.             }

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

  1795.             {

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

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

  1798.             }

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

  1800.             {

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

  1802.                 evInMidiStates[i].frame_count = frames;

  1803.                 evInMidiStates[i].position = 0;

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

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

  1806.             }

  1807.         }

  1808. 

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

  1810.         {

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

  1812.             {

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

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

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

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

  1817.             }

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

  1819.             {

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

  1821.             }

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

  1823.             {

  1824.                 // not needed

  1825.             }

  1826.         }

  1827. 

  1828.         CARLA_PROCESS_CONTINUE_CHECK;

  1829. 

  1830.         // --------------------------------------------------------------------------------------------------------

  1831.         // Input VU

  1832. 

  1833.         if (aIn.count > 0)

  1834.         {

  1835.             if (aIn.count == 1)

  1836.             {

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

  1838.                 {

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

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

  1841.                 }

  1842.             }

  1843.             else if (aIn.count > 1)

  1844.             {

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

  1846.                 {

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

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

  1849. 

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

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

  1852.                 }

  1853.             }

  1854.         }

  1855. 

  1856.         CARLA_PROCESS_CONTINUE_CHECK;

  1857. 

  1858.         // --------------------------------------------------------------------------------------------------------

  1859.         // Parameters Input [Automation]

  1860. 

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

  1862.         {

  1863.             bool allNotesOffSent = false;

  1864. 

  1865.             const CarlaEngineControlEvent* cinEvent;

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

  1867. 

  1868.             uint32_t nextBankId = 0;

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

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

  1871. 

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

  1873.             {

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

  1875. 

  1876.                 if (! cinEvent)

  1877.                     continue;

  1878. 

  1879.                 time = cinEvent->time - framesOffset;

  1880. 

  1881.                 if (time >= frames)

  1882.                     continue;

  1883. 

  1884.                 // Control change

  1885.                 switch (cinEvent->type)

  1886.                 {

  1887.                 case CarlaEngineEventNull:

  1888.                     break;

  1889. 

  1890.                 case CarlaEngineEventControlChange:

  1891.                 {

  1892.                     double value;

  1893. 

  1894.                     // Control backend stuff

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

  1896.                     {

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

  1898.                         {

  1899.                             value = cinEvent->value;

  1900.                             setDryWet(value, false, false);

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

  1902.                             continue;

  1903.                         }

  1904. 

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

  1906.                         {

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

  1908.                             setVolume(value, false, false);

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

  1910.                             continue;

  1911.                         }

  1912. 

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

  1914.                         {

  1915.                             double left, right;

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

  1917. 

  1918.                             if (value < 0.0)

  1919.                             {

  1920.                                 left  = -1.0;

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

  1922.                             }

  1923.                             else if (value > 0.0)

  1924.                             {

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

  1926.                                 right = 1.0;

  1927.                             }

  1928.                             else

  1929.                             {

  1930.                                 left  = -1.0;

  1931.                                 right = 1.0;

  1932.                             }

  1933. 

  1934.                             setBalanceLeft(left, false, false);

  1935.                             setBalanceRight(right, false, false);

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

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

  1938.                             continue;

  1939.                         }

  1940.                     }

  1941. 

  1942.                     // Control plugin parameters

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

  1944.                     {

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

  1946.                             continue;

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

  1948.                             continue;

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

  1950.                             continue;

  1951. 

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

  1953.                         {

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

  1955.                             {

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

  1957.                             }

  1958.                             else

  1959.                             {

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

  1961. 

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

  1963.                                     value = rint(value);

  1964.                             }

  1965. 

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

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

  1968.                         }

  1969.                     }

  1970. 

  1971.                     break;

  1972.                 }

  1973. 

  1974.                 case CarlaEngineEventMidiBankChange:

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

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

  1977.                     break;

  1978. 

  1979.                 case CarlaEngineEventMidiProgramChange:

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

  1981.                     {

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

  1983. 

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

  1985.                         {

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

  1987.                             {

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

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

  1990.                                 break;

  1991.                             }

  1992.                         }

  1993.                     }

  1994.                     break;

  1995. 

  1996.                 case CarlaEngineEventAllSoundOff:

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

  1998.                     {

  1999.                         if (midi.portMin && ! allNotesOffSent)

  2000.                             sendMidiAllNotesOff();

  2001. 

  2002.                         if (descriptor->deactivate)

  2003.                         {

  2004.                             descriptor->deactivate(handle);

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

  2006.                         }

  2007. 

  2008.                         if (descriptor->activate)

  2009.                         {

  2010.                             descriptor->activate(handle);

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

  2012.                         }

  2013. 

  2014.                         allNotesOffSent = true;

  2015.                     }

  2016.                     break;

  2017. 

  2018.                 case CarlaEngineEventAllNotesOff:

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

  2020.                     {

  2021.                         if (midi.portMin && ! allNotesOffSent)

  2022.                             sendMidiAllNotesOff();

  2023. 

  2024.                         allNotesOffSent = true;

  2025.                     }

  2026.                     break;

  2027.                 }

  2028.             }

  2029.         } // End of Parameters Input

  2030. 

  2031.         CARLA_PROCESS_CONTINUE_CHECK;

  2032. 

  2033.         // --------------------------------------------------------------------------------------------------------

  2034.         // Event Input

  2035. 

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

  2037.         {

  2038.             // ----------------------------------------------------------------------------------------------------

  2039.             // MIDI Input (External)

  2040. 

  2041.             {

  2042.                 engineMidiLock();

  2043. 

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

  2045.                 {

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

  2047.                         break;

  2048. 

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

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

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

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

  2053. 

  2054.                     // send to all midi inputs

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

  2056.                     {

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

  2058.                         {

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

  2060.                             {

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

  2062.                                 aev->time.frames = 0;

  2063.                                 aev->body.type   = CARLA_URI_MAP_ID_MIDI_EVENT;

  2064.                                 aev->body.size   = 3;

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

  2066. 

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

  2068.                                 evInAtomOffsets[k]           += evInPadSize;

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

  2070.                             }

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

  2072.                             {

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

  2074.                             }

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

  2076.                             {

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

  2078.                             }

  2079.                         }

  2080.                     }

  2081. 

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

  2083.                     midiEventCount += 1;

  2084.                 }

  2085. 

  2086.                 engineMidiUnlock();

  2087. 

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

  2089. 

  2090.             CARLA_PROCESS_CONTINUE_CHECK;

  2091. 

  2092.             // ----------------------------------------------------------------------------------------------------

  2093.             // MIDI Input (System)

  2094. 

  2095.             {

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

  2097.                 {

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

  2099.                         continue;

  2100. 

  2101.                     const CarlaEngineMidiEvent* minEvent;

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

  2103. 

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

  2105.                     {

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

  2107. 

  2108.                         if (! minEvent)

  2109.                             continue;

  2110. 

  2111.                         time = minEvent->time - framesOffset;

  2112. 

  2113.                         if (time >= frames)

  2114.                             continue;

  2115. 

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

  2117.                         uint8_t channel = status & 0x0F;

  2118. 

  2119.                         // Fix bad note-off

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

  2121.                             status -= 0x10;

  2122. 

  2123.                         // only write supported status types

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

  2125.                         {

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

  2127.                             {

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

  2129.                                 aev->time.frames = time;

  2130.                                 aev->body.type   = CARLA_URI_MAP_ID_MIDI_EVENT;

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

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

  2133. 

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

  2135.                                 evInAtomOffsets[i]           += evInPadSize;

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

  2137.                             }

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

  2139.                             {

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

  2141.                             }

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

  2143.                             {

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

  2145.                             }

  2146. 

  2147.                             if (MIDI_IS_STATUS_NOTE_OFF(status))

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

  2149.                             else if (MIDI_IS_STATUS_NOTE_ON(status))

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

  2151.                         }

  2152. 

  2153.                         midiEventCount += 1;

  2154.                     }

  2155.                 }

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

  2157. 

  2158.             // ----------------------------------------------------------------------------------------------------

  2159.             // Message Input

  2160. 

  2161.             {

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

  2163.                 {

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

  2165.                         continue;

  2166. 

  2167.                     // messages only supported in Atom type ports

  2168.                     Q_ASSERT(evIn.data[i].type & CARLA_EVENT_DATA_ATOM);

  2169. 

  2170. #if 0

  2171.                      // send transport info if changed

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

  2173. 

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

  2175.                     {

  2176.                         uint8_t posBuf[256];

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

  2178. 

  2179.                         LV2_Atom_Forge tempForge;

  2180.                         LV2_Atom_Forge* const forge = &tempForge;

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

  2182. 

  2183.                         //LV2_Atom_Forge_Frame frame;

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

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

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

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

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

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

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

  2191. 

  2192.                         if (timeInfo->valid & CarlaEngineTimeBBT)

  2193.                         {

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

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

  2196. 

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

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

  2199. 

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

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

  2202. 

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

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

  2205. 

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

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

  2208. 

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

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

  2211.                         }

  2212. 

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

  2214.                         aev->time.frames = framesOffset;

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

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

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

  2218. 

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

  2220.                         evInAtomOffsets[i]           += evInPadSize;

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

  2222. 

  2223.                         lastTimePosPlaying = timeInfo->playing;

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

  2225.                     }

  2226. #endif

  2227. 

  2228.                     // TODO - get messages from ringbuffer

  2229. 

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

  2231.                     //aev->time.frames = framesOffset;

  2232.                     //aev->body.type   = CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT;

  2233.                     //aev->body.size   = 0; // message size

  2234.                     //memcpy(LV2_ATOM_BODY(&aev->body), nullptr /* message data body */, 0 /* message size */);

  2235.                 }

  2236.             }

  2237. 

  2238.         } // End of Event Input

  2239. 

  2240.         CARLA_PROCESS_CONTINUE_CHECK;

  2241. 

  2242.         // --------------------------------------------------------------------------------------------------------

  2243.         // Special Parameters

  2244. 

  2245.         {

  2246.             int32_t rindex;

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

  2248. 

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

  2250.             {

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

  2252.                 {

  2253.                     // TODO

  2254.                 }

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

  2256.                 {

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

  2258.                 }

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

  2260.                 {

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

  2262.                     Q_ASSERT(rindex >= 0 && rindex < (int32_t)rdf_descriptor->PortCount);

  2263. 

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

  2265.                     {

  2266.                     // Non-BBT

  2267.                     case LV2_PORT_DESIGNATION_TIME_FRAME:

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

  2269.                         break;

  2270.                     case LV2_PORT_DESIGNATION_TIME_FRAMES_PER_SECOND:

  2271.                         break;

  2272.                     case LV2_PORT_DESIGNATION_TIME_POSITION:

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

  2274.                         break;

  2275.                     case LV2_PORT_DESIGNATION_TIME_SPEED:

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

  2277.                         break;

  2278.                     // BBT

  2279.                     case LV2_PORT_DESIGNATION_TIME_BAR:

  2280.                         if (timeInfo->valid & CarlaEngineTimeBBT)

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

  2282.                         break;

  2283.                     case LV2_PORT_DESIGNATION_TIME_BAR_BEAT:

  2284.                         if (timeInfo->valid & CarlaEngineTimeBBT)

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

  2286.                         break;

  2287.                     case LV2_PORT_DESIGNATION_TIME_BEAT:

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

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

  2290.                         break;

  2291.                     case LV2_PORT_DESIGNATION_TIME_BEAT_UNIT:

  2292.                         if (timeInfo->valid & CarlaEngineTimeBBT)

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

  2294.                         break;

  2295.                     case LV2_PORT_DESIGNATION_TIME_BEATS_PER_BAR:

  2296.                         if (timeInfo->valid & CarlaEngineTimeBBT)

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

  2298.                         break;

  2299.                     case LV2_PORT_DESIGNATION_TIME_BEATS_PER_MINUTE:

  2300.                         if (timeInfo->valid & CarlaEngineTimeBBT)

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

  2302.                         break;

  2303.                     }

  2304.                 }

  2305.             }

  2306.         }

  2307. 

  2308.         CARLA_PROCESS_CONTINUE_CHECK;

  2309. 

  2310.         // --------------------------------------------------------------------------------------------------------

  2311.         // Plugin processing

  2312. 

  2313.         if (m_active)

  2314.         {

  2315.             if (! m_activeBefore)

  2316.             {

  2317.                 if (evIn.count > 0 && m_ctrlInChannel >= 0 && m_ctrlInChannel < 16)

  2318.                 {

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

  2320.                     midiEvent1[0] = MIDI_STATUS_CONTROL_CHANGE + m_ctrlInChannel;

  2321.                     midiEvent1[1] = MIDI_CONTROL_ALL_SOUND_OFF;

  2322. 

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

  2324.                     midiEvent2[0] = MIDI_STATUS_CONTROL_CHANGE + m_ctrlInChannel;

  2325.                     midiEvent2[1] = MIDI_CONTROL_ALL_SOUND_OFF;

  2326. 

  2327.                     // send to all midi inputs

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

  2329.                     {

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

  2331.                         {

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

  2333.                             {

  2334.                                 // all sound off

  2335.                                 LV2_Atom_Event* const aev1 = (LV2_Atom_Event*)((char*)LV2_ATOM_CONTENTS(LV2_Atom_Sequence, evIn.data[k].atom) + evInAtomOffsets[k]);

  2336.                                 aev1->time.frames = 0;

  2337.                                 aev1->body.type   = CARLA_URI_MAP_ID_MIDI_EVENT;

  2338.                                 aev1->body.size   = 2;

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

  2340. 

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

  2342.                                 evInAtomOffsets[k]           += padSize;

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

  2344. 

  2345.                                 // all notes off

  2346.                                 LV2_Atom_Event* const aev2 = (LV2_Atom_Event*)((char*)LV2_ATOM_CONTENTS(LV2_Atom_Sequence, evIn.data[k].atom) + evInAtomOffsets[k]);

  2347.                                 aev2->time.frames = 0;

  2348.                                 aev2->body.type   = CARLA_URI_MAP_ID_MIDI_EVENT;

  2349.                                 aev2->body.size   = 2;

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

  2351. 

  2352.                                 evInAtomOffsets[k]           += padSize;

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

  2354.                             }

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

  2356.                             {

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

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

  2359.                             }

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

  2361.                             {

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

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

  2364.                             }

  2365.                         }

  2366.                     }

  2367. 

  2368.                     midiEventCount = 2;

  2369.                 }

  2370. 

  2371.                 if (descriptor->activate)

  2372.                 {

  2373.                     descriptor->activate(handle);

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

  2375.                 }

  2376.             }

  2377. 

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

  2379.             {

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

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

  2382.             }

  2383. 

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

  2385.             {

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

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

  2388.             }

  2389. 

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

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

  2392. 

  2393.             if (ext.worker)

  2394.             {

  2395.                 // TODO

  2396.                 //ext.worker->work_response();

  2397. 

  2398.                 if (ext.worker->end_run)

  2399.                 {

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

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

  2402.                 }

  2403.             }

  2404.         }

  2405.         else

  2406.         {

  2407.             if (m_activeBefore)

  2408.             {

  2409.                 if (descriptor->deactivate)

  2410.                 {

  2411.                     descriptor->deactivate(handle);

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

  2413.                 }

  2414.             }

  2415.         }

  2416. 

  2417.         CARLA_PROCESS_CONTINUE_CHECK;

  2418. 

  2419.         // --------------------------------------------------------------------------------------------------------

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

  2421. 

  2422.         if (m_active)

  2423.         {

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

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

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

  2427. 

  2428.             double bal_rangeL, bal_rangeR;

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

  2430. 

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

  2432.             {

  2433.                 // Dry/Wet

  2434.                 if (do_drywet)

  2435.                 {

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

  2437.                     {

  2438.                         if (aOut.count == 1)

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

  2440.                         else

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

  2442.                     }

  2443.                 }

  2444. 

  2445.                 // Balance

  2446.                 if (do_balance)

  2447.                 {

  2448.                     if (i%2 == 0)

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

  2450. 

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

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

  2453. 

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

  2455.                     {

  2456.                         if (i%2 == 0)

  2457.                         {

  2458.                             // left output

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

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

  2461.                         }

  2462.                         else

  2463.                         {

  2464.                             // right

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

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

  2467.                         }

  2468.                     }

  2469.                 }

  2470. 

  2471.                 // Volume

  2472.                 if (do_volume)

  2473.                 {

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

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

  2476.                 }

  2477. 

  2478.                 // Output VU

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

  2480.                 {

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

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

  2483.                 }

  2484.             }

  2485.         }

  2486.         else

  2487.         {

  2488.             // disable any output sound if not active

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

  2490.                 memset(outBuffer[i], 0.0f, sizeof(float)*frames);

  2491. 

  2492.             aOutsPeak[0] = 0.0;

  2493.             aOutsPeak[1] = 0.0;

  2494. 

  2495.         } // End of Post-processing

  2496. 

  2497.         CARLA_PROCESS_CONTINUE_CHECK;

  2498. 

  2499.         // --------------------------------------------------------------------------------------------------------

  2500.         // Control Output

  2501. 

  2502.         if (param.portCout && m_active)

  2503.         {

  2504.             double value;

  2505. 

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

  2507.             {

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

  2509.                 {

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

  2511. 

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

  2513.                     {

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

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

  2516.                     }

  2517.                 }

  2518.             }

  2519.         } // End of Control Output

  2520. 

  2521.         CARLA_PROCESS_CONTINUE_CHECK;

  2522. 

  2523.         // --------------------------------------------------------------------------------------------------------

  2524.         // Event Output

  2525. 

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

  2527.         {

  2528.             // ----------------------------------------------------------------------------------------------------

  2529.             // MIDI Output

  2530. 

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

  2532.             {

  2533.                 if (! evOut.data[i].port)

  2534.                     continue;

  2535. 

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

  2537.                 {

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

  2539.                     uint32_t offset = 0;

  2540. 

  2541.                     while (offset < size)

  2542.                     {

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

  2544. 

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

  2546.                             break;

  2547. 

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

  2549.                         {

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

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

  2552.                         }

  2553. 

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

  2555.                     }

  2556.                 }

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

  2558.                 {

  2559.                     const LV2_Event* ev;

  2560.                     LV2_Event_Iterator iter;

  2561. 

  2562.                     uint8_t* data;

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

  2564. 

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

  2566.                     {

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

  2568. 

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

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

  2571. 

  2572.                         lv2_event_increment(&iter);

  2573.                     }

  2574.                 }

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

  2576.                 {

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

  2578. 

  2579.                     uint32_t eventSize;

  2580.                     double   eventTime;

  2581.                     unsigned char* eventData;

  2582. 

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

  2584.                     {

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

  2586.                         lv2midi_step(&state);

  2587.                     }

  2588.                 }

  2589.             }

  2590. 

  2591.             // ----------------------------------------------------------------------------------------------------

  2592.             // Message Output

  2593. 

  2594.             // TODO

  2595. 

  2596.         } // End of Event Output

  2597. 

  2598.         CARLA_PROCESS_CONTINUE_CHECK;

  2599. 

  2600.         // --------------------------------------------------------------------------------------------------------

  2601.         // Peak Values

  2602. 

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

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

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

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

  2607. 

  2608.         m_activeBefore = m_active;

  2609.     }

  2610. 

  2611.     void bufferSizeChanged(const uint32_t newBufferSize)

  2612.     {

  2613.         lv2Options.bufferSize = newBufferSize;

  2614.     }

  2615. 

  2616.     // -------------------------------------------------------------------

  2617.     // Post-poned events

  2618. 

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

  2620.     {

  2621.         Q_ASSERT(index < param.count);

  2622. 

  2623.         if (index >= param.count)

  2624.             return;

  2625. 

  2626. #ifndef BUILD_BRIDGE

  2627.         if (gui.type == GUI_EXTERNAL_OSC)

  2628.         {

  2629.             if (osc.data.target)

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

  2631.         }

  2632.         else

  2633. #endif

  2634.         {

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

  2636.             {

  2637.                 float valueF = value;

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

  2639.             }

  2640.         }

  2641.     }

  2642. 

  2643.     void uiMidiProgramChange(const uint32_t index)

  2644.     {

  2645.         Q_ASSERT(index < midiprog.count);

  2646. 

  2647.         if (index >= midiprog.count)

  2648.             return;

  2649. 

  2650. #ifndef BUILD_BRIDGE

  2651.         if (gui.type == GUI_EXTERNAL_OSC)

  2652.         {

  2653.             if (osc.data.target)

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

  2655.         }

  2656.         else

  2657. #endif

  2658.         {

  2659.             if (ext.uiprograms)

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

  2661.         }

  2662.     }

  2663. 

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

  2665.     {

  2666.         Q_ASSERT(channel < 16);

  2667.         Q_ASSERT(note < 128);

  2668.         Q_ASSERT(velo > 0 && velo < 128);

  2669. 

  2670. #ifndef BUILD_BRIDGE

  2671.         if (gui.type == GUI_EXTERNAL_OSC)

  2672.         {

  2673.             if (osc.data.target)

  2674.             {

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

  2676.                 midiData[1] = MIDI_STATUS_NOTE_ON + channel;

  2677.                 midiData[2] = note;

  2678.                 midiData[3] = velo;

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

  2680.             }

  2681.         }

  2682.         else

  2683. #endif

  2684.         {

  2685.             uiTransferAtom(); // TODO

  2686.         }

  2687.     }

  2688. 

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

  2690.     {

  2691.         Q_ASSERT(channel < 16);

  2692.         Q_ASSERT(note < 128);

  2693. 

  2694. #ifndef BUILD_BRIDGE

  2695.         if (gui.type == GUI_EXTERNAL_OSC)

  2696.         {

  2697.             if (osc.data.target)

  2698.             {

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

  2700.                 midiData[1] = MIDI_STATUS_NOTE_OFF + channel;

  2701.                 midiData[2] = note;

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

  2703.             }

  2704.         }

  2705.         else

  2706. #endif

  2707.         {

  2708.             uiTransferAtom(); // TODO

  2709.         }

  2710.     }

  2711. 

  2712.     // -------------------------------------------------------------------

  2713.     // Cleanup

  2714. 

  2715.     void removeClientPorts()

  2716.     {

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

  2718. 

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

  2720.         {

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

  2722.             {

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

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

  2725.             }

  2726.         }

  2727. 

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

  2729.         {

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

  2731.             {

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

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

  2734.             }

  2735.         }

  2736. 

  2737.         CarlaPlugin::removeClientPorts();

  2738. 

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

  2740.     }

  2741. 

  2742.     void initBuffers()

  2743.     {

  2744.         uint32_t i;

  2745. 

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

  2747.         {

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

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

  2750.         }

  2751. 

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

  2753.         {

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

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

  2756.         }

  2757. 

  2758.         CarlaPlugin::initBuffers();

  2759.     }

  2760. 

  2761.     void deleteBuffers()

  2762.     {

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

  2764. 

  2765.         if (evIn.count > 0)

  2766.         {

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

  2768.             {

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

  2770.                 {

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

  2772.                 }

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

  2774.                 {

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

  2776.                 }

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

  2778.                 {

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

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

  2781.                 }

  2782.             }

  2783. 

  2784.             delete[] evIn.data;

  2785.         }

  2786. 

  2787.         if (evOut.count > 0)

  2788.         {

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

  2790.             {

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

  2792.                 {

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

  2794.                 }

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

  2796.                 {

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

  2798.                 }

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

  2800.                 {

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

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

  2803.                 }

  2804.             }

  2805. 

  2806.             delete[] evOut.data;

  2807.         }

  2808. 

  2809.         if (param.count > 0)

  2810.             delete[] paramBuffers;

  2811. 

  2812.         evIn.count = 0;

  2813.         evIn.data  = nullptr;

  2814. 

  2815.         evOut.count = 0;

  2816.         evOut.data  = nullptr;

  2817. 

  2818.         paramBuffers = nullptr;

  2819. 

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

  2821.     }

  2822. 

  2823.     // -------------------------------------------------------------------

  2824. 

  2825.     uint32_t getCustomURID(const char* const uri)

  2826.     {

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

  2828.         Q_ASSERT(uri);

  2829. 

  2830.         if (! uri)

  2831.             return CARLA_URI_MAP_ID_NULL;

  2832. 

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

  2834.         {

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

  2836.                 return i;

  2837.         }

  2838. 

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

  2840. 

  2841.         return customURIDs.size()-1;

  2842.     }

  2843. 

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

  2845.     {

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

  2847.         Q_ASSERT(urid > CARLA_URI_MAP_ID_NULL);

  2848. 

  2849.         if (urid == CARLA_URI_MAP_ID_NULL)

  2850.             return nullptr;

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

  2852.             return customURIDs[urid];

  2853. 

  2854.         return nullptr;

  2855.     }

  2856. 

  2857.     // -------------------------------------------------------------------

  2858. 

  2859.     void handleTransferAtom(const LV2_Atom* const atom, const char* const stype)

  2860.     {

  2861.         qDebug("Lv2Plugin::handleAtomTransfer(%p, \"%s\")", atom, stype);

  2862.         Q_ASSERT(atom);

  2863.         Q_ASSERT(stype);

  2864. 

  2865.         // TODO

  2866.     }

  2867. 

  2868.     void handleTransferEvent(const LV2_Atom* const atom, const char* const stype)

  2869.     {

  2870.         qDebug("Lv2Plugin::handleEventTransfer(%p, \"%s\")", atom, stype);

  2871.         Q_ASSERT(atom);

  2872.         Q_ASSERT(stype);

  2873. 

  2874.         const LV2_URID uridAtomBlank = getCustomURID(LV2_ATOM__Blank);

  2875.         const LV2_URID uridPatchBody = getCustomURID(LV2_PATCH__body);

  2876.         const LV2_URID uridPatchSet  = getCustomURID(LV2_PATCH__Set);

  2877. 

  2878.         if (atom->type != uridAtomBlank)

  2879.         {

  2880.             qWarning("Lv2Plugin::handleEventTransfer() - Not blank");

  2881.             return;

  2882.         }

  2883. 

  2884.         const LV2_Atom_Object* const obj = (LV2_Atom_Object*)atom;

  2885. 

  2886.         if (obj->body.otype != uridPatchSet)

  2887.         {

  2888.             qWarning("Lv2Plugin::handleEventTransfer() - Not Patch Set");

  2889.             return;

  2890.         }

  2891. 

  2892.         const LV2_Atom_Object* body = nullptr;

  2893.         lv2_atom_object_get(obj, uridPatchBody, &body, 0);

  2894. 

  2895.         if (! body)

  2896.         {

  2897.             qWarning("Lv2Plugin::handleEventTransfer() - Has no body");

  2898.             return;

  2899.         }

  2900. 

  2901.         LV2_ATOM_OBJECT_FOREACH(body, iter)

  2902.         {

  2903.             CustomDataType dtype  = CUSTOM_DATA_INVALID;

  2904.             const char* const key = getCustomURIString(iter->key);

  2905.             const char* value     = nullptr;

  2906. 

  2907.             if (iter->value.type == CARLA_URI_MAP_ID_ATOM_STRING || iter->value.type == CARLA_URI_MAP_ID_ATOM_PATH)

  2908.             {

  2909.                 value = strdup((const char*)LV2_ATOM_BODY(&iter->value));

  2910.                 dtype = (iter->value.type == CARLA_URI_MAP_ID_ATOM_STRING) ? CUSTOM_DATA_STRING : CUSTOM_DATA_PATH;

  2911.             }

  2912.             else if (iter->value.type == CARLA_URI_MAP_ID_ATOM_CHUNK || iter->value.type >= CARLA_URI_MAP_ID_COUNT)

  2913.             {

  2914.                 QByteArray chunk((const char*)LV2_ATOM_BODY(&iter->value), iter->value.size);

  2915.                 value = strdup(chunk.toBase64().constData());

  2916.                 dtype = (iter->value.type == CARLA_URI_MAP_ID_ATOM_CHUNK) ? CUSTOM_DATA_CHUNK : CUSTOM_DATA_BINARY; // FIXME - binary should be custom stype

  2917.             }

  2918.             else

  2919.                 value = strdup("");

  2920. 

  2921.             setCustomData(dtype, key, value, false);

  2922. 

  2923.             free((void*)value);

  2924.         }

  2925.     }

  2926. 

  2927.     // -------------------------------------------------------------------

  2928. 

  2929.     void handleProgramChanged(const int32_t index)

  2930.     {

  2931.         if (index == -1)

  2932.         {

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

  2934.             reloadPrograms(false);

  2935.         }

  2936.         else

  2937.         {

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

  2939.             {

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

  2941.                 Q_ASSERT(progName);

  2942. 

  2943.                 if (prog.names[index])

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

  2945. 

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

  2947.             }

  2948.         }

  2949. 

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

  2951.     }

  2952. 

  2953.     LV2_State_Status handleStateStore(const uint32_t key, const void* const value, const size_t size, const uint32_t type, const uint32_t flags)

  2954.     {

  2955.         Q_ASSERT(key > 0);

  2956.         Q_ASSERT(value);

  2957. 

  2958.         CustomDataType dtype;

  2959.         const char* const uriKey = getCustomURIString(key);

  2960. 

  2961.         if (type == CARLA_URI_MAP_ID_ATOM_CHUNK)

  2962.             dtype = CUSTOM_DATA_CHUNK;

  2963.         else if (type == CARLA_URI_MAP_ID_ATOM_PATH)

  2964.             dtype = CUSTOM_DATA_PATH;

  2965.         else if (type == CARLA_URI_MAP_ID_ATOM_STRING)

  2966.             dtype = CUSTOM_DATA_STRING;

  2967.         else if (type >= CARLA_URI_MAP_ID_COUNT)

  2968.             dtype = CUSTOM_DATA_BINARY;

  2969.         else

  2970.             dtype = CUSTOM_DATA_INVALID;

  2971. 

  2972.         // do basic checks

  2973.         if (! uriKey)

  2974.         {

  2975.             qWarning("Lv2Plugin::handleStateStore(%i, %p, " P_SIZE ", %i, %i) - invalid key", key, value, size, type, flags);

  2976.             return LV2_STATE_ERR_NO_PROPERTY;

  2977.         }

  2978. 

  2979.         if (! flags & LV2_STATE_IS_POD)

  2980.         {

  2981.             qWarning("Lv2Plugin::handleStateStore(%i, %p, " P_SIZE ", %i, %i) - invalid flags", key, value, size, type, flags);

  2982.             return LV2_STATE_ERR_BAD_FLAGS;

  2983.         }

  2984. 

  2985.         if (dtype == CUSTOM_DATA_INVALID)

  2986.         {

  2987.             qCritical("Lv2Plugin::handleStateStore(%i, %p, " P_SIZE ", %i, %i) - invalid type '%s'", key, value, size, type, flags, CustomDataType2str(dtype));

  2988.             return LV2_STATE_ERR_BAD_TYPE;

  2989.         }

  2990. 

  2991.         // Check if we already have this key

  2992.         for (size_t i=0; i < custom.size(); i++)

  2993.         {

  2994.             if (strcmp(custom[i].key, uriKey) == 0)

  2995.             {

  2996.                 free((void*)custom[i].value);

  2997. 

  2998.                 if (dtype == CUSTOM_DATA_STRING || dtype == CUSTOM_DATA_PATH)

  2999.                     custom[i].value = strdup((const char*)value);

  3000.                 else

  3001.                     custom[i].value = strdup(QByteArray((const char*)value, size).toBase64().constData());

  3002. 

  3003.                 return LV2_STATE_SUCCESS;

  3004.             }

  3005.         }

  3006. 

  3007.         // Otherwise store it

  3008.         CustomData newData;

  3009.         newData.type = dtype;

  3010.         newData.key  = strdup(uriKey);

  3011. 

  3012.         if (dtype == CUSTOM_DATA_STRING || dtype == CUSTOM_DATA_PATH)

  3013.             newData.value = strdup((const char*)value);

  3014.         else

  3015.             newData.value = strdup(QByteArray((const char*)value, size).toBase64().constData());

  3016. 

  3017.         custom.push_back(newData);

  3018. 

  3019.         return LV2_STATE_SUCCESS;

  3020.     }

  3021. 

  3022.     const void* handleStateRetrieve(const uint32_t key, size_t* const size, uint32_t* const type, uint32_t* const flags)

  3023.     {

  3024.         Q_ASSERT(key > CARLA_URI_MAP_ID_NULL);

  3025. 

  3026.         const char* const uriKey = getCustomURIString(key);

  3027. 

  3028.         if (! uriKey)

  3029.         {

  3030.             qCritical("Lv2Plugin::handleStateRetrieve(%i, %p, %p, %p) - failed to find key", key, size, type, flags);

  3031.             return nullptr;

  3032.         }

  3033. 

  3034.         const char* stringData = nullptr;

  3035.         CustomDataType dtype = CUSTOM_DATA_INVALID;

  3036. 

  3037.         for (size_t i=0; i < custom.size(); i++)

  3038.         {

  3039.             if (strcmp(custom[i].key, uriKey) == 0)

  3040.             {

  3041.                 dtype      = custom[i].type;

  3042.                 stringData = custom[i].value;

  3043.                 break;

  3044.             }

  3045.         }

  3046. 

  3047.         if (! stringData)

  3048.         {

  3049.             qCritical("Lv2Plugin::handleStateRetrieve(%i, %p, %p, %p) - invalid key '%s'", key, size, type, flags, uriKey);

  3050.             return nullptr;

  3051.         }

  3052. 

  3053.         *size  = 0;

  3054.         *type  = 0;

  3055.         *flags = LV2_STATE_IS_POD;

  3056. 

  3057.         if (dtype == CUSTOM_DATA_STRING)

  3058.         {

  3059.             *size = strlen(stringData);

  3060.             *type = CARLA_URI_MAP_ID_ATOM_STRING;

  3061.             return stringData;

  3062.         }

  3063.         if (dtype == CUSTOM_DATA_PATH)

  3064.         {

  3065.             *size = strlen(stringData);

  3066.             *type = CARLA_URI_MAP_ID_ATOM_PATH;

  3067.             return stringData;

  3068.         }

  3069.         if (dtype == CUSTOM_DATA_CHUNK || dtype == CUSTOM_DATA_BINARY)

  3070.         {

  3071.             static QByteArray chunk;

  3072.             chunk = QByteArray::fromBase64(stringData);

  3073. 

  3074.             *size = chunk.size();

  3075.             *type = (dtype == CUSTOM_DATA_CHUNK) ? CARLA_URI_MAP_ID_ATOM_CHUNK : key;

  3076.             return chunk.constData();

  3077.         }

  3078. 

  3079.         qCritical("Lv2Plugin::handleStateRetrieve(%i, %p, %p, %p) - invalid key type '%s'", key, size, type, flags, CustomDataType2str(dtype));

  3080.         return nullptr;

  3081.     }

  3082. 

  3083.     LV2_Worker_Status handleWorkerSchedule(const uint32_t /*size*/, const void* const /*data*/)

  3084.     {

  3085.         // TODO

  3086.         return LV2_WORKER_SUCCESS;

  3087.     }

  3088. 

  3089.     LV2_Worker_Status handleWorkerRespond(const uint32_t /*size*/, const void* const /*data*/)

  3090.     {

  3091.         // TODO

  3092.         if (ext.worker)

  3093.             return LV2_WORKER_SUCCESS;

  3094. 

  3095.         return LV2_WORKER_ERR_UNKNOWN;

  3096.     }

  3097. 

  3098.     void handleExternalUiClosed()

  3099.     {

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

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

  3102. 

  3103.         ui.handle = nullptr;

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

  3105.     }

  3106. 

  3107.     uint32_t handleUiPortMap(const char* const symbol)

  3108.     {

  3109.         Q_ASSERT(symbol);

  3110. 

  3111.         if (! symbol)

  3112.             return LV2UI_INVALID_PORT_INDEX;

  3113. 

  3114.         for (uint32_t i=0; i < rdf_descriptor->PortCount; i++)

  3115.         {

  3116.             if (strcmp(rdf_descriptor->Ports[i].Symbol, symbol) == 0)

  3117.                 return i;

  3118.         }

  3119. 

  3120.         return LV2UI_INVALID_PORT_INDEX;

  3121.     }

  3122. 

  3123.     int handleUiResize(const int width, const int height)

  3124.     {

  3125.         Q_ASSERT(width > 0);

  3126.         Q_ASSERT(height > 0);

  3127. 

  3128.         if (width <= 0 || height <= 0)

  3129.             return 1;

  3130. 

  3131.         gui.width  = width;

  3132.         gui.height = height;

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

  3134. 

  3135.         return 0;

  3136.     }

  3137. 

  3138.     void handleUiWrite(const uint32_t rindex, const uint32_t bufferSize, const uint32_t format, const void* const buffer)

  3139.     {

  3140.         if (format == 0)

  3141.         {

  3142.             Q_ASSERT(buffer);

  3143.             Q_ASSERT(bufferSize == sizeof(float));

  3144. 

  3145.             float value = *(float*)buffer;

  3146. 

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

  3148.             {

  3149.                 if (param.data[i].rindex == (int32_t)rindex)

  3150.                     return setParameterValue(i, value, false, true, true);

  3151.             }

  3152.         }

  3153.         else if (format == CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM)

  3154.         {

  3155.             Q_ASSERT(buffer);

  3156. 

  3157.             const LV2_Atom* const atom = (const LV2_Atom*)buffer;

  3158.             handleTransferAtom(atom, getCustomURIString(atom->type));

  3159. 

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

  3161.                 ui.descriptor->port_event(ui.handle, 0, atom->size, CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM, atom);

  3162.         }

  3163.         else if (format == CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT)

  3164.         {

  3165.             Q_ASSERT(buffer);

  3166. 

  3167.             const LV2_Atom* const atom = (const LV2_Atom*)buffer;

  3168.             handleTransferEvent(atom, getCustomURIString(atom->type));

  3169. 

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

  3171.                 ui.descriptor->port_event(ui.handle, 0, atom->size, CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT, atom);

  3172.         }

  3173.     }

  3174. 

  3175.     // -------------------------------------------------------------------

  3176. 

  3177. #ifndef BUILD_BRIDGE

  3178.     bool isUiBridgeable(const uint32_t uiId)

  3179.     {

  3180.         Q_ASSERT(rdf_descriptor);

  3181.         Q_ASSERT(uiId < rdf_descriptor->UICount);

  3182. 

  3183.         if (uiId >= rdf_descriptor->UICount)

  3184.             return false;

  3185. 

  3186.         const LV2_RDF_UI* const rdf_ui = &rdf_descriptor->UIs[uiId];

  3187. 

  3188.         for (uint32_t i=0; i < rdf_ui->FeatureCount; i++)

  3189.         {

  3190.             if (strcmp(rdf_ui->Features[i].URI, LV2_INSTANCE_ACCESS_URI) == 0 || strcmp(rdf_ui->Features[i].URI, LV2_DATA_ACCESS_URI) == 0)

  3191.                 return false;

  3192.         }

  3193. 

  3194.         return true;

  3195.     }

  3196. #endif

  3197. 

  3198.     bool isUiResizable()

  3199.     {

  3200.         Q_ASSERT(ui.rdf_descriptor);

  3201. 

  3202.         if (! ui.rdf_descriptor)

  3203.             return false;

  3204. 

  3205.         for (uint32_t i=0; i < ui.rdf_descriptor->FeatureCount; i++)

  3206.         {

  3207.             if (strcmp(ui.rdf_descriptor->Features[i].URI, LV2_UI__fixedSize) == 0 || strcmp(ui.rdf_descriptor->Features[i].URI, LV2_UI__noUserResize) == 0)

  3208.                 return false;

  3209.         }

  3210. 

  3211.         return true;

  3212.     }

  3213. 

  3214.     void initExternalUi()

  3215.     {

  3216.         qDebug("Lv2Plugin::initExternalUi()");

  3217. 

  3218.         ui.widget = nullptr;

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

  3220. 

  3221.         if (ui.handle && ui.widget)

  3222.         {

  3223.             updateUi();

  3224.         }

  3225.         else

  3226.         {

  3227.             qWarning("Lv2Plugin::initExternalUi() - failed to instantiate UI");

  3228.             ui.handle = nullptr;

  3229.             ui.widget = nullptr;

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

  3231.         }

  3232.     }

  3233. 

  3234.     void uiTransferAtom()

  3235.     {

  3236.         // TODO

  3237.     }

  3238. 

  3239.     void uiTransferEvent(const CustomData* const cdata)

  3240.     {

  3241.         if (cdata->type == CUSTOM_DATA_INVALID || ! ui.descriptor->port_event)

  3242.             return;

  3243. 

  3244.         LV2_URID_Map* const URID_Map = (LV2_URID_Map*)features[lv2_feature_id_urid_map]->data;

  3245.         const LV2_URID uridPatchSet  = getCustomURID(LV2_PATCH__Set);

  3246.         const LV2_URID uridPatchBody = getCustomURID(LV2_PATCH__body);

  3247. 

  3248.         Sratom* const sratom = sratom_new(URID_Map);

  3249.         SerdChunk     chunk  = { nullptr, 0 };

  3250. 

  3251.         LV2_Atom_Forge forge;

  3252.         lv2_atom_forge_init(&forge, URID_Map);

  3253.         lv2_atom_forge_set_sink(&forge, sratom_forge_sink, sratom_forge_deref, &chunk);

  3254. 

  3255.         LV2_Atom_Forge_Frame refFrame, bodyFrame;

  3256.         LV2_Atom_Forge_Ref   ref = lv2_atom_forge_blank(&forge, &refFrame, 1, uridPatchSet);

  3257. 

  3258.         lv2_atom_forge_property_head(&forge, uridPatchBody, CARLA_URI_MAP_ID_NULL);

  3259.         lv2_atom_forge_blank(&forge, &bodyFrame, 2, CARLA_URI_MAP_ID_NULL);

  3260. 

  3261.         lv2_atom_forge_property_head(&forge, getCustomURID(cdata->key), CARLA_URI_MAP_ID_NULL);

  3262. 

  3263.         if (cdata->type == CUSTOM_DATA_STRING)

  3264.             lv2_atom_forge_string(&forge, cdata->value, strlen(cdata->value));

  3265.         else if (cdata->type == CUSTOM_DATA_PATH)

  3266.             lv2_atom_forge_path(&forge, cdata->value, strlen(cdata->value));

  3267.         else if (cdata->type == CUSTOM_DATA_CHUNK)

  3268.             lv2_atom_forge_literal(&forge, cdata->value, strlen(cdata->value), CARLA_URI_MAP_ID_ATOM_CHUNK, CARLA_URI_MAP_ID_NULL);

  3269.         else

  3270.             lv2_atom_forge_literal(&forge, cdata->value, strlen(cdata->value), getCustomURID(cdata->key), CARLA_URI_MAP_ID_NULL);

  3271. 

  3272.         lv2_atom_forge_pop(&forge, &bodyFrame);

  3273.         lv2_atom_forge_pop(&forge, &refFrame);

  3274. 

  3275.         const LV2_Atom* const atom = lv2_atom_forge_deref(&forge, ref);

  3276.         ui.descriptor->port_event(ui.handle, 0, atom->size, CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT, atom);

  3277. 

  3278.         free((void*)chunk.buf);

  3279.         sratom_free(sratom);

  3280.     }

  3281. 

  3282.     void updateUi()

  3283.     {

  3284.         qDebug("Lv2Plugin::updateUi()");

  3285. 

  3286.         ext.uiprograms = nullptr;

  3287. 

  3288.         if (ui.handle && ui.descriptor)

  3289.         {

  3290.             if (ui.descriptor->extension_data)

  3291.             {

  3292.                 ext.uiprograms = (const LV2_Programs_UI_Interface*)ui.descriptor->extension_data(LV2_PROGRAMS__UIInterface);

  3293. 

  3294.                 if (ext.uiprograms && ! ext.uiprograms->select_program)

  3295.                     // invalid

  3296.                     ext.uiprograms = nullptr;

  3297. 

  3298.                 if (ext.uiprograms && midiprog.count > 0 && midiprog.current >= 0)

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

  3300.             }

  3301. 

  3302.             if (ui.descriptor->port_event)

  3303.             {

  3304.                 // get&store custom data to be sent to the UI

  3305.                 prepareForSave();

  3306. 

  3307.                 // update state (custom data)

  3308.                 for (size_t i=0; i < custom.size(); i++)

  3309.                     uiTransferEvent(&custom[i]);

  3310. 

  3311.                 // update control ports

  3312.                 float valueF;

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

  3314.                 {

  3315.                     valueF = getParameterValue(i);

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

  3317.                 }

  3318.             }

  3319.         }

  3320.     }

  3321. 

  3322.     // ----------------- Event Feature ---------------------------------------------------

  3323. 

  3324.     static uint32_t carla_lv2_event_ref(const LV2_Event_Callback_Data callback_data, LV2_Event* const event)

  3325.     {

  3326.         qDebug("Lv2Plugin::carla_lv2_event_ref(%p, %p)", callback_data, event);

  3327.         Q_ASSERT(callback_data);

  3328.         Q_ASSERT(event);

  3329. 

  3330.         return 0;

  3331.     }

  3332. 

  3333.     static uint32_t carla_lv2_event_unref(const LV2_Event_Callback_Data callback_data, LV2_Event* const event)

  3334.     {

  3335.         qDebug("Lv2Plugin::carla_lv2_event_unref(%p, %p)", callback_data, event);

  3336.         Q_ASSERT(callback_data);

  3337.         Q_ASSERT(event);

  3338. 

  3339.         return 0;

  3340.     }

  3341. 

  3342.     // ----------------- Logs Feature ----------------------------------------------------

  3343. 

  3344.     static int carla_lv2_log_printf(const LV2_Log_Handle handle, const LV2_URID type, const char* const fmt, ...)

  3345.     {

  3346.         qDebug("Lv2Plugin::carla_lv2_log_printf(%p, %i, \"%s\", ...)", handle, type, fmt);

  3347.         Q_ASSERT(handle);

  3348.         Q_ASSERT(type > 0);

  3349. 

  3350. #ifndef DEBUG

  3351.         if (type == CARLA_URI_MAP_ID_LOG_TRACE)

  3352.             return 0;

  3353. #endif

  3354. 

  3355.         va_list args;

  3356.         va_start(args, fmt);

  3357.         const int ret = carla_lv2_log_vprintf(handle, type, fmt, args);

  3358.         va_end(args);

  3359. 

  3360.         return ret;

  3361.     }

  3362. 

  3363.     static int carla_lv2_log_vprintf(const LV2_Log_Handle handle, const LV2_URID type, const char* const fmt, va_list ap)

  3364.     {

  3365.         qDebug("Lv2Plugin::carla_lv2_log_vprintf(%p, %i, \"%s\", ...)", handle, type, fmt);

  3366.         Q_ASSERT(handle);

  3367.         Q_ASSERT(type > 0);

  3368. 

  3369. #ifndef DEBUG

  3370.         if (type == CARLA_URI_MAP_ID_LOG_TRACE)

  3371.             return 0;

  3372. #endif

  3373. 

  3374.         char buf[8196];

  3375.         vsprintf(buf, fmt, ap);

  3376. 

  3377.         if (*buf == 0)

  3378.             return 0;

  3379. 

  3380.         switch (type)

  3381.         {

  3382.         case CARLA_URI_MAP_ID_LOG_ERROR:

  3383.             qCritical("%s", buf);

  3384.             break;

  3385.         case CARLA_URI_MAP_ID_LOG_NOTE:

  3386.             printf("%s\n", buf);

  3387.             break;

  3388.         case CARLA_URI_MAP_ID_LOG_TRACE:

  3389.             qDebug("%s", buf);

  3390.             break;

  3391.         case CARLA_URI_MAP_ID_LOG_WARNING:

  3392.             qWarning("%s", buf);

  3393.             break;

  3394.         default:

  3395.             break;

  3396.         }

  3397. 

  3398.         return strlen(buf);

  3399.     }

  3400. 

  3401.     // ----------------- Programs Feature ------------------------------------------------

  3402. 

  3403.     static void carla_lv2_program_changed(const LV2_Programs_Handle handle, const int32_t index)

  3404.     {

  3405.         qDebug("Lv2Plugin::carla_lv2_program_changed(%p, %i)", handle, index);

  3406.         Q_ASSERT(handle);

  3407. 

  3408.         if (! handle)

  3409.             return;

  3410. 

  3411.         Lv2Plugin* const plugin = (Lv2Plugin*)handle;

  3412.         plugin->handleProgramChanged(index);

  3413.     }

  3414. 

  3415.     // ----------------- State Feature ---------------------------------------------------

  3416. 

  3417.     static char* carla_lv2_state_make_path(const LV2_State_Make_Path_Handle handle, const char* const path)

  3418.     {

  3419.         qDebug("Lv2Plugin::carla_lv2_state_make_path(%p, \"%s\")", handle, path);

  3420.         Q_ASSERT(handle);

  3421.         Q_ASSERT(path);

  3422. 

  3423.         if (! path)

  3424.             return nullptr;

  3425. 

  3426.         QDir dir;

  3427.         dir.mkpath(path);

  3428.         return strdup(path);

  3429.     }

  3430. 

  3431.     static char* carla_lv2_state_map_abstract_path(const LV2_State_Map_Path_Handle handle, const char* const absolute_path)

  3432.     {

  3433.         qDebug("Lv2Plugin::carla_lv2_state_map_abstract_path(%p, \"%s\")", handle, absolute_path);

  3434.         Q_ASSERT(handle);

  3435.         Q_ASSERT(absolute_path);

  3436. 

  3437.         if (! absolute_path)

  3438.             return nullptr;

  3439. 

  3440.         QDir dir(absolute_path);

  3441.         return strdup(dir.canonicalPath().toUtf8().constData());

  3442.     }

  3443. 

  3444.     static char* carla_lv2_state_map_absolute_path(const LV2_State_Map_Path_Handle handle, const char* const abstract_path)

  3445.     {

  3446.         qDebug("Lv2Plugin::carla_lv2_state_map_absolute_path(%p, \"%s\")", handle, abstract_path);

  3447.         Q_ASSERT(handle);

  3448.         Q_ASSERT(abstract_path);

  3449. 

  3450.         if (! abstract_path)

  3451.             return nullptr;

  3452. 

  3453.         QDir dir(abstract_path);

  3454.         return strdup(dir.absolutePath().toUtf8().constData());

  3455.     }

  3456. 

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

  3458.     {

  3459.         qDebug("Lv2Plugin::carla_lv2_state_store(%p, %i, %p, " P_SIZE ", %i, %i)", handle, key, value, size, type, flags);

  3460.         Q_ASSERT(handle);

  3461. 

  3462.         if (! handle)

  3463.             return LV2_STATE_ERR_UNKNOWN;

  3464. 

  3465.         Lv2Plugin* const plugin = (Lv2Plugin*)handle;

  3466.         return plugin->handleStateStore(key, value, size, type, flags);

  3467.     }

  3468. 

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

  3470.     {

  3471.         qDebug("Lv2Plugin::carla_lv2_state_retrieve(%p, %i, %p, %p, %p)", handle, key, size, type, flags);

  3472.         Q_ASSERT(handle);

  3473. 

  3474.         if (! handle)

  3475.             return nullptr;

  3476. 

  3477.         Lv2Plugin* const plugin = (Lv2Plugin*)handle;

  3478.         return plugin->handleStateRetrieve(key, size, type, flags);

  3479.     }

  3480. 

  3481.     // ----------------- URI-Map Feature -------------------------------------------------

  3482. 

  3483.     static uint32_t carla_lv2_uri_to_id(const LV2_URI_Map_Callback_Data data, const char* const map, const char* const uri)

  3484.     {

  3485.         qDebug("Lv2Plugin::carla_lv2_uri_to_id(%p, \"%s\", \"%s\")", data, map, uri);

  3486.         return carla_lv2_urid_map((LV2_URID_Map_Handle*)data, uri);

  3487.     }

  3488. 

  3489.     // ----------------- URID Feature ----------------------------------------------------

  3490. 

  3491.     static LV2_URID carla_lv2_urid_map(const LV2_URID_Map_Handle handle, const char* const uri)

  3492.     {

  3493.         qDebug("Lv2Plugin::carla_lv2_urid_map(%p, \"%s\")", handle, uri);

  3494.         Q_ASSERT(handle);

  3495.         Q_ASSERT(uri);

  3496. 

  3497.         if (! uri)

  3498.             return CARLA_URI_MAP_ID_NULL;

  3499. 

  3500.         // Atom types

  3501.         if (strcmp(uri, LV2_ATOM__Chunk) == 0)

  3502.             return CARLA_URI_MAP_ID_ATOM_CHUNK;

  3503.         if (strcmp(uri, LV2_ATOM__Double) == 0)

  3504.             return CARLA_URI_MAP_ID_ATOM_DOUBLE;

  3505.         if (strcmp(uri, LV2_ATOM__Int) == 0)

  3506.             return CARLA_URI_MAP_ID_ATOM_INT;

  3507.         if (strcmp(uri, LV2_ATOM__Path) == 0)

  3508.             return CARLA_URI_MAP_ID_ATOM_PATH;

  3509.         if (strcmp(uri, LV2_ATOM__Sequence) == 0)

  3510.             return CARLA_URI_MAP_ID_ATOM_SEQUENCE;

  3511.         if (strcmp(uri, LV2_ATOM__String) == 0)

  3512.             return CARLA_URI_MAP_ID_ATOM_STRING;

  3513.         if (strcmp(uri, LV2_ATOM__atomTransfer) == 0)

  3514.             return CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM;

  3515.         if (strcmp(uri, LV2_ATOM__eventTransfer) == 0)

  3516.             return CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT;

  3517. 

  3518.         // BufSize types

  3519.         if (strcmp(uri, LV2_BUF_SIZE__maxBlockLength) == 0)

  3520.             return CARLA_URI_MAP_ID_BUF_MAX_LENGTH;

  3521.         if (strcmp(uri, LV2_BUF_SIZE__minBlockLength) == 0)

  3522.             return CARLA_URI_MAP_ID_BUF_MIN_LENGTH;

  3523.         if (strcmp(uri, LV2_BUF_SIZE__sequenceSize) == 0)

  3524.             return CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE;

  3525. 

  3526.         // Log types

  3527.         if (strcmp(uri, LV2_LOG__Error) == 0)

  3528.             return CARLA_URI_MAP_ID_LOG_ERROR;

  3529.         if (strcmp(uri, LV2_LOG__Note) == 0)

  3530.             return CARLA_URI_MAP_ID_LOG_NOTE;

  3531.         if (strcmp(uri, LV2_LOG__Trace) == 0)

  3532.             return CARLA_URI_MAP_ID_LOG_TRACE;

  3533.         if (strcmp(uri, LV2_LOG__Warning) == 0)

  3534.             return CARLA_URI_MAP_ID_LOG_WARNING;

  3535. 

  3536.         // Others

  3537.         if (strcmp(uri, LV2_MIDI__MidiEvent) == 0)

  3538.             return CARLA_URI_MAP_ID_MIDI_EVENT;

  3539.         if (strcmp(uri, LV2_PARAMETERS__sampleRate) == 0)

  3540.             return CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE;

  3541. 

  3542.         if (! handle)

  3543.             return CARLA_URI_MAP_ID_NULL;

  3544. 

  3545.         // Custom types

  3546.         Lv2Plugin* const plugin = (Lv2Plugin*)handle;

  3547.         return plugin->getCustomURID(uri);

  3548.     }

  3549. 

  3550.     static const char* carla_lv2_urid_unmap(const LV2_URID_Map_Handle handle, const LV2_URID urid)

  3551.     {

  3552.         qDebug("Lv2Plugin::carla_lv2_urid_unmap(%p, %i)", handle, urid);

  3553.         Q_ASSERT(handle);

  3554.         Q_ASSERT(urid > CARLA_URI_MAP_ID_NULL);

  3555. 

  3556.         if (urid == CARLA_URI_MAP_ID_NULL)

  3557.             return nullptr;

  3558. 

  3559.         // Atom types

  3560.         if (urid == CARLA_URI_MAP_ID_ATOM_CHUNK)

  3561.             return LV2_ATOM__Chunk;

  3562.         if (urid == CARLA_URI_MAP_ID_ATOM_DOUBLE)

  3563.             return LV2_ATOM__Double;

  3564.         if (urid == CARLA_URI_MAP_ID_ATOM_INT)

  3565.             return LV2_ATOM__Int;

  3566.         if (urid == CARLA_URI_MAP_ID_ATOM_PATH)

  3567.             return LV2_ATOM__Path;

  3568.         if (urid == CARLA_URI_MAP_ID_ATOM_SEQUENCE)

  3569.             return LV2_ATOM__Sequence;

  3570.         if (urid == CARLA_URI_MAP_ID_ATOM_STRING)

  3571.             return LV2_ATOM__String;

  3572.         if (urid == CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM)

  3573.             return LV2_ATOM__atomTransfer;

  3574.         if (urid == CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT)

  3575.             return LV2_ATOM__eventTransfer;

  3576. 

  3577.         // BufSize types

  3578.         if (urid == CARLA_URI_MAP_ID_BUF_MAX_LENGTH)

  3579.             return LV2_BUF_SIZE__maxBlockLength;

  3580.         if (urid == CARLA_URI_MAP_ID_BUF_MIN_LENGTH)

  3581.             return LV2_BUF_SIZE__minBlockLength;

  3582.         if (urid == CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE)

  3583.             return LV2_BUF_SIZE__sequenceSize;

  3584. 

  3585.         // Log types

  3586.         if (urid == CARLA_URI_MAP_ID_LOG_ERROR)

  3587.             return LV2_LOG__Error;

  3588.         if (urid == CARLA_URI_MAP_ID_LOG_NOTE)

  3589.             return LV2_LOG__Note;

  3590.         if (urid == CARLA_URI_MAP_ID_LOG_TRACE)

  3591.             return LV2_LOG__Trace;

  3592.         if (urid == CARLA_URI_MAP_ID_LOG_WARNING)

  3593.             return LV2_LOG__Warning;

  3594. 

  3595.         // Others

  3596.         if (urid == CARLA_URI_MAP_ID_MIDI_EVENT)

  3597.             return LV2_MIDI__MidiEvent;

  3598.         if (urid == CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE)

  3599.             return LV2_PARAMETERS__sampleRate;

  3600. 

  3601.         if (! handle)

  3602.             return nullptr;

  3603. 

  3604.         // Custom types

  3605.         Lv2Plugin* const plugin = (Lv2Plugin*)handle;

  3606.         return plugin->getCustomURIString(urid);

  3607.     }

  3608. 

  3609.     // ----------------- Worker Feature --------------------------------------------------

  3610. 

  3611.     static LV2_Worker_Status carla_lv2_worker_schedule(const LV2_Worker_Schedule_Handle handle, const uint32_t size, const void* const data)

  3612.     {

  3613.         qDebug("Lv2Plugin::carla_lv2_worker_schedule(%p, %i, %p)", handle, size, data);

  3614.         Q_ASSERT(handle);

  3615. 

  3616.         if (! handle)

  3617.             return LV2_WORKER_ERR_UNKNOWN;

  3618. 

  3619.         Lv2Plugin* const plugin = (Lv2Plugin*)handle;

  3620.         return plugin->handleWorkerSchedule(size, data);

  3621.     }

  3622. 

  3623.     static LV2_Worker_Status carla_lv2_worker_respond(const LV2_Worker_Respond_Handle handle, const uint32_t size, const void* const data)

  3624.     {

  3625.         qDebug("Lv2Plugin::carla_lv2_worker_respond(%p, %i, %p)", handle, size, data);

  3626.         Q_ASSERT(handle);

  3627. 

  3628.         if (! handle)

  3629.             return LV2_WORKER_ERR_UNKNOWN;

  3630. 

  3631.         Lv2Plugin* const plugin = (Lv2Plugin*)handle;

  3632.         return plugin->handleWorkerRespond(size, data);

  3633.     }

  3634. 

  3635.     // ----------------- UI Port-Map Feature ---------------------------------------------

  3636. 

  3637.     static uint32_t carla_lv2_ui_port_map(const LV2UI_Feature_Handle handle, const char* const symbol)

  3638.     {

  3639.         qDebug("Lv2Plugin::carla_lv2_ui_port_map(%p, \"%s\")", handle, symbol);

  3640.         Q_ASSERT(handle);

  3641. 

  3642.         if (! handle)

  3643.             return LV2UI_INVALID_PORT_INDEX;

  3644. 

  3645.         Lv2Plugin* const plugin = (Lv2Plugin*)handle;

  3646.         return plugin->handleUiPortMap(symbol);

  3647.     }

  3648. 

  3649.     // ----------------- UI Resize Feature -----------------------------------------------

  3650. 

  3651.     static int carla_lv2_ui_resize(const LV2UI_Feature_Handle handle, const int width, const int height)

  3652.     {

  3653.         qDebug("Lv2Plugin::carla_lv2_ui_resize(%p, %i, %i)", handle, width, height);

  3654.         Q_ASSERT(handle);

  3655. 

  3656.         if (! handle)

  3657.             return 1;

  3658. 

  3659.         Lv2Plugin* const plugin  = (Lv2Plugin*)handle;

  3660.         return plugin->handleUiResize(width, height);

  3661.     }

  3662. 

  3663.     // ----------------- External UI Feature ---------------------------------------------

  3664. 

  3665.     static void carla_lv2_external_ui_closed(const LV2UI_Controller controller)

  3666.     {

  3667.         qDebug("Lv2Plugin::carla_lv2_external_ui_closed(%p)", controller);

  3668.         Q_ASSERT(controller);

  3669. 

  3670.         if (! controller)

  3671.             return;

  3672. 

  3673.         Lv2Plugin* const plugin = (Lv2Plugin*)controller;

  3674.         plugin->handleExternalUiClosed();

  3675.     }

  3676. 

  3677.     // ----------------- UI Extension ----------------------------------------------------

  3678. 

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

  3680.     {

  3681.         qDebug("Lv2Plugin::carla_lv2_ui_write_function(%p, %i, %i, %i, %p)", controller, port_index, buffer_size, format, buffer);

  3682.         Q_ASSERT(controller);

  3683. 

  3684.         if (! controller)

  3685.             return;

  3686. 

  3687.         Lv2Plugin* const plugin = (Lv2Plugin*)controller;

  3688.         plugin->handleUiWrite(port_index, buffer_size, format, buffer);

  3689.     }

  3690. 

  3691.     // -------------------------------------------------------------------

  3692. 

  3693.     bool uiLibOpen(const char* const filename)

  3694.     {

  3695.         ui.lib = lib_open(filename);

  3696.         return bool(ui.lib);

  3697.     }

  3698. 

  3699.     bool uiLibClose()

  3700.     {

  3701.         if (ui.lib)

  3702.             return lib_close(ui.lib);

  3703.         return false;

  3704.     }

  3705. 

  3706.     void* uiLibSymbol(const char* const symbol)

  3707.     {

  3708.         if (ui.lib)

  3709.             return lib_symbol(ui.lib, symbol);

  3710.         return nullptr;

  3711.     }

  3712. 

  3713.     // -------------------------------------------------------------------

  3714. 

  3715.     bool init(const char* const bundle, const char* const name, const char* const URI)

  3716.     {

  3717.         // ---------------------------------------------------------------

  3718.         // get plugin from lv2_rdf (lilv)

  3719. 

  3720.         rdf_descriptor = lv2_rdf_new(URI);

  3721. 

  3722.         if (! rdf_descriptor)

  3723.         {

  3724.             setLastError("Failed to find the requested plugin in the LV2 Bundle");

  3725.             return false;

  3726.         }

  3727. 

  3728.         // ---------------------------------------------------------------

  3729.         // open DLL

  3730. 

  3731.         if (! libOpen(rdf_descriptor->Binary))

  3732.         {

  3733.             setLastError(libError(rdf_descriptor->Binary));

  3734.             return false;

  3735.         }

  3736. 

  3737.         // ---------------------------------------------------------------

  3738.         // get DLL main entry

  3739. 

  3740.         const LV2_Descriptor_Function descFn = (LV2_Descriptor_Function)libSymbol("lv2_descriptor");

  3741. 

  3742.         if (! descFn)

  3743.         {

  3744.             setLastError("Could not find the LV2 Descriptor in the plugin library");

  3745.             return false;

  3746.         }

  3747. 

  3748.         // ---------------------------------------------------------------

  3749.         // get descriptor that matches URI

  3750. 

  3751.         uint32_t i = 0;

  3752.         while ((descriptor = descFn(i++)))

  3753.         {

  3754.             if (strcmp(descriptor->URI, URI) == 0)

  3755.                 break;

  3756.         }

  3757. 

  3758.         if (! descriptor)

  3759.         {

  3760.             setLastError("Could not find the requested plugin URI in the plugin library");

  3761.             return false;

  3762.         }

  3763. 

  3764.         // ---------------------------------------------------------------

  3765.         // check supported port-types and features

  3766. 

  3767.         bool canContinue = true;

  3768. 

  3769.         // Check supported ports

  3770.         for (i=0; i < rdf_descriptor->PortCount; i++)

  3771.         {

  3772.             LV2_Property PortType = rdf_descriptor->Ports[i].Type;

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

  3774.             {

  3775.                 if (! LV2_IS_PORT_OPTIONAL(rdf_descriptor->Ports[i].Properties))

  3776.                 {

  3777.                     setLastError("Plugin requires a port that is not currently supported");

  3778.                     canContinue = false;

  3779.                     break;

  3780.                 }

  3781.             }

  3782.         }

  3783. 

  3784.         // Check supported features

  3785.         for (i=0; i < rdf_descriptor->FeatureCount && canContinue; i++)

  3786.         {

  3787.             if (LV2_IS_FEATURE_REQUIRED(rdf_descriptor->Features[i].Type) && ! is_lv2_feature_supported(rdf_descriptor->Features[i].URI))

  3788.             {

  3789.                 QString msg = QString("Plugin requires a feature that is not supported:\n%1").arg(rdf_descriptor->Features[i].URI);

  3790.                 setLastError(msg.toUtf8().constData());

  3791.                 canContinue = false;

  3792.                 break;

  3793.             }

  3794.         }

  3795. 

  3796.         // Check extensions

  3797.         for (i=0; i < rdf_descriptor->ExtensionCount; i++)

  3798.         {

  3799.             if (strcmp(rdf_descriptor->Extensions[i], LV2_PROGRAMS__Interface) == 0)

  3800.                 m_hints |= PLUGIN_HAS_EXTENSION_PROGRAMS;

  3801.             else if (strcmp(rdf_descriptor->Extensions[i], LV2_STATE__interface) == 0)

  3802.                 m_hints |= PLUGIN_HAS_EXTENSION_STATE;

  3803.             else if (strcmp(rdf_descriptor->Extensions[i], LV2_WORKER__interface) == 0)

  3804.                 m_hints |= PLUGIN_HAS_EXTENSION_WORKER;

  3805.             else

  3806.                 qDebug("Plugin has non-supported extension: '%s'", rdf_descriptor->Extensions[i]);

  3807.         }

  3808. 

  3809.         if (! canContinue)

  3810.         {

  3811.             // error already set

  3812.             return false;

  3813.         }

  3814. 

  3815.         // ---------------------------------------------------------------

  3816.         // initialize features

  3817. 

  3818.         LV2_Event_Feature* const eventFt = new LV2_Event_Feature;

  3819.         eventFt->callback_data           = this;

  3820.         eventFt->lv2_event_ref           = carla_lv2_event_ref;

  3821.         eventFt->lv2_event_unref         = carla_lv2_event_unref;

  3822. 

  3823.         LV2_Log_Log* const logFt         = new LV2_Log_Log;

  3824.         logFt->handle                    = this;

  3825.         logFt->printf                    = carla_lv2_log_printf;

  3826.         logFt->vprintf                   = carla_lv2_log_vprintf;

  3827. 

  3828.         LV2_RtMemPool_Pool* const rtMemPoolFt      = new LV2_RtMemPool_Pool;

  3829.         rtmempool_allocator_init(rtMemPoolFt);

  3830. 

  3831.         LV2_Programs_Host* const programsFt        = new LV2_Programs_Host;

  3832.         programsFt->handle                         = this;

  3833.         programsFt->program_changed                = carla_lv2_program_changed;

  3834. 

  3835.         LV2_State_Make_Path* const stateMakePathFt = new LV2_State_Make_Path;

  3836.         stateMakePathFt->handle                    = this;

  3837.         stateMakePathFt->path                      = carla_lv2_state_make_path;

  3838. 

  3839.         LV2_State_Map_Path* const stateMapPathFt   = new LV2_State_Map_Path;

  3840.         stateMapPathFt->handle                     = this;

  3841.         stateMapPathFt->abstract_path              = carla_lv2_state_map_abstract_path;

  3842.         stateMapPathFt->absolute_path              = carla_lv2_state_map_absolute_path;

  3843. 

  3844.         LV2_URI_Map_Feature* const uriMapFt = new LV2_URI_Map_Feature;

  3845.         uriMapFt->callback_data             = this;

  3846.         uriMapFt->uri_to_id                 = carla_lv2_uri_to_id;

  3847. 

  3848.         LV2_URID_Map* const uridMapFt       = new LV2_URID_Map;

  3849.         uridMapFt->handle                   = this;

  3850.         uridMapFt->map                      = carla_lv2_urid_map;

  3851. 

  3852.         LV2_URID_Unmap* const uridUnmapFt   = new LV2_URID_Unmap;

  3853.         uridUnmapFt->handle                 = this;

  3854.         uridUnmapFt->unmap                  = carla_lv2_urid_unmap;

  3855. 

  3856.         LV2_Worker_Schedule* const workerFt = new LV2_Worker_Schedule;

  3857.         workerFt->handle                    = this;

  3858.         workerFt->schedule_work             = carla_lv2_worker_schedule;

  3859. 

  3860.         LV2_Options_Option* const optionsFt = new LV2_Options_Option [5];

  3861.         optionsFt[0] = lv2Options.oMaxBlockLenth;

  3862.         optionsFt[1] = lv2Options.oMinBlockLenth;

  3863.         optionsFt[2] = lv2Options.oSequenceSize;

  3864.         optionsFt[3] = lv2Options.oSampleRate;

  3865.         optionsFt[4] = lv2Options.oNull;

  3866. 

  3867.         features[lv2_feature_id_bufsize_bounded]       = new LV2_Feature;

  3868.         features[lv2_feature_id_bufsize_bounded]->URI  = LV2_BUF_SIZE__boundedBlockLength;

  3869.         features[lv2_feature_id_bufsize_bounded]->data = nullptr;

  3870. 

  3871. #ifndef BUILD_BRIDGE

  3872.         if (carlaOptions.processHighPrecision)

  3873.         {

  3874.             features[lv2_feature_id_bufsize_fixed]          = new LV2_Feature;

  3875.             features[lv2_feature_id_bufsize_fixed]->URI     = LV2_BUF_SIZE__fixedBlockLength;

  3876.             features[lv2_feature_id_bufsize_fixed]->data    = nullptr;

  3877. 

  3878.             features[lv2_feature_id_bufsize_powerof2]       = new LV2_Feature;

  3879.             features[lv2_feature_id_bufsize_powerof2]->URI  = LV2_BUF_SIZE__powerOf2BlockLength;

  3880.             features[lv2_feature_id_bufsize_powerof2]->data = nullptr;

  3881.         }

  3882.         else

  3883. #endif

  3884.         {

  3885.             // fake, used to keep a valid array

  3886.             features[lv2_feature_id_bufsize_fixed]    = features[lv2_feature_id_bufsize_bounded];

  3887.             features[lv2_feature_id_bufsize_powerof2] = features[lv2_feature_id_bufsize_bounded];

  3888.         }

  3889. 

  3890.         features[lv2_feature_id_event]          = new LV2_Feature;

  3891.         features[lv2_feature_id_event]->URI     = LV2_EVENT_URI;

  3892.         features[lv2_feature_id_event]->data    = eventFt;

  3893. 

  3894.         features[lv2_feature_id_logs]           = new LV2_Feature;

  3895.         features[lv2_feature_id_logs]->URI      = LV2_LOG__log;

  3896.         features[lv2_feature_id_logs]->data     = logFt;

  3897. 

  3898.         features[lv2_feature_id_options]        = new LV2_Feature;

  3899.         features[lv2_feature_id_options]->URI   = LV2_OPTIONS__options;

  3900.         features[lv2_feature_id_options]->data  = optionsFt;

  3901. 

  3902.         features[lv2_feature_id_programs]       = new LV2_Feature;

  3903.         features[lv2_feature_id_programs]->URI  = LV2_PROGRAMS__Host;

  3904.         features[lv2_feature_id_programs]->data = programsFt;

  3905. 

  3906.         features[lv2_feature_id_rtmempool]       = new LV2_Feature;

  3907.         features[lv2_feature_id_rtmempool]->URI  = LV2_RTSAFE_MEMORY_POOL__Pool;

  3908.         features[lv2_feature_id_rtmempool]->data = rtMemPoolFt;

  3909. 

  3910.         features[lv2_feature_id_state_make_path]       = new LV2_Feature;

  3911.         features[lv2_feature_id_state_make_path]->URI  = LV2_STATE__makePath;

  3912.         features[lv2_feature_id_state_make_path]->data = stateMakePathFt;

  3913. 

  3914.         features[lv2_feature_id_state_map_path]        = new LV2_Feature;

  3915.         features[lv2_feature_id_state_map_path]->URI   = LV2_STATE__mapPath;

  3916.         features[lv2_feature_id_state_map_path]->data  = stateMapPathFt;

  3917. 

  3918.         features[lv2_feature_id_strict_bounds]         = new LV2_Feature;

  3919.         features[lv2_feature_id_strict_bounds]->URI    = LV2_PORT_PROPS__supportsStrictBounds;

  3920.         features[lv2_feature_id_strict_bounds]->data   = nullptr;

  3921. 

  3922.         features[lv2_feature_id_uri_map]          = new LV2_Feature;

  3923.         features[lv2_feature_id_uri_map]->URI     = LV2_URI_MAP_URI;

  3924.         features[lv2_feature_id_uri_map]->data    = uriMapFt;

  3925. 

  3926.         features[lv2_feature_id_urid_map]         = new LV2_Feature;

  3927.         features[lv2_feature_id_urid_map]->URI    = LV2_URID__map;

  3928.         features[lv2_feature_id_urid_map]->data   = uridMapFt;

  3929. 

  3930.         features[lv2_feature_id_urid_unmap]       = new LV2_Feature;

  3931.         features[lv2_feature_id_urid_unmap]->URI  = LV2_URID__unmap;

  3932.         features[lv2_feature_id_urid_unmap]->data = uridUnmapFt;

  3933. 

  3934.         features[lv2_feature_id_worker]           = new LV2_Feature;

  3935.         features[lv2_feature_id_worker]->URI      = LV2_WORKER__schedule;

  3936.         features[lv2_feature_id_worker]->data     = workerFt;

  3937. 

  3938.         // ---------------------------------------------------------------

  3939.         // initialize plugin

  3940. 

  3941.         handle = descriptor->instantiate(descriptor, x_engine->getSampleRate(), rdf_descriptor->Bundle, features);

  3942. 

  3943.         if (! handle)

  3944.         {

  3945.             setLastError("Plugin failed to initialize");

  3946.             return false;

  3947.         }

  3948. 

  3949.         // ---------------------------------------------------------------

  3950.         // get info

  3951. 

  3952.         m_filename = strdup(bundle);

  3953. 

  3954.         if (name)

  3955.             m_name = x_engine->getUniqueName(name);

  3956.         else

  3957.             m_name = x_engine->getUniqueName(rdf_descriptor->Name);

  3958. 

  3959.         // ---------------------------------------------------------------

  3960.         // register client

  3961. 

  3962.         x_client = x_engine->addClient(this);

  3963. 

  3964.         if (! x_client->isOk())

  3965.         {

  3966.             setLastError("Failed to register plugin client");

  3967.             return false;

  3968.         }

  3969. 

  3970.         // ---------------------------------------------------------------

  3971.         // gui stuff

  3972. 

  3973.         if (rdf_descriptor->UICount == 0)

  3974.             return true;

  3975. 

  3976.         // -----------------------------------------------------------

  3977.         // find more appropriate ui

  3978. 

  3979.         int eQt4, eCocoa, eHWND, eX11, eGtk2, eGtk3, iCocoa, iHWND, iX11, iQt4, iExt, iSuil, iFinal;

  3980.         eQt4 = eCocoa = eHWND = eX11 = eGtk2 = eGtk3 = iQt4 = iCocoa = iHWND = iX11 = iExt = iSuil = iFinal = -1;

  3981. 

  3982.         for (i=0; i < rdf_descriptor->UICount; i++)

  3983.         {

  3984.             switch (rdf_descriptor->UIs[i].Type)

  3985.             {

  3986.             case LV2_UI_QT4:

  3987. #ifndef BUILD_BRIDGE

  3988.                 if (isUiBridgeable(i) && carlaOptions.preferUiBridges)

  3989.                     eQt4 = i;

  3990. #endif

  3991.                 iQt4 = i;

  3992.                 break;

  3993. 

  3994.             case LV2_UI_COCOA:

  3995. #ifndef BUILD_BRIDGE

  3996.                 if (isUiBridgeable(i) && carlaOptions.preferUiBridges)

  3997.                     eCocoa = i;

  3998. #endif

  3999.                 iCocoa = i;

  4000.                 break;

  4001. 

  4002.             case LV2_UI_WINDOWS:

  4003. #ifndef BUILD_BRIDGE

  4004.                 if (isUiBridgeable(i) && carlaOptions.preferUiBridges)

  4005.                     eHWND = i;

  4006. #endif

  4007.                 iHWND = i;

  4008.                 break;

  4009. 

  4010.             case LV2_UI_X11:

  4011. #ifndef BUILD_BRIDGE

  4012.                 if (isUiBridgeable(i) && carlaOptions.preferUiBridges)

  4013.                     eX11 = i;

  4014. #endif

  4015.                 iX11 = i;

  4016.                 break;

  4017. 

  4018.             case LV2_UI_GTK2:

  4019. #ifdef BUILD_BRIDGE

  4020.                 if (false)

  4021. #else

  4022. #  ifdef HAVE_SUIL

  4023.                 if (isUiBridgeable(i) && carlaOptions.preferUiBridges)

  4024. #  else

  4025.                 if (isUiBridgeable(i))

  4026. #  endif

  4027. #endif

  4028.                     eGtk2 = i;

  4029. #ifdef HAVE_SUIL

  4030.                 iSuil = i;

  4031. #endif

  4032.                 break;

  4033. 

  4034. #ifndef BUILD_BRIDGE

  4035.             case LV2_UI_GTK3:

  4036.                 if (isUiBridgeable(i))

  4037.                     eGtk3 = i;

  4038.                 break;

  4039. #endif

  4040. 

  4041.             case LV2_UI_EXTERNAL:

  4042.             case LV2_UI_OLD_EXTERNAL:

  4043.                 iExt = i;

  4044.                 break;

  4045. 

  4046.             default:

  4047.                 break;

  4048.             }

  4049.         }

  4050. 

  4051.         if (eQt4 >= 0)

  4052.             iFinal = eQt4;

  4053.         else if (eCocoa >= 0)

  4054.             iFinal = eCocoa;

  4055.         else if (eHWND >= 0)

  4056.             iFinal = eHWND;

  4057.         else if (eX11 >= 0)

  4058.             iFinal = eX11;

  4059.         else if (eGtk2 >= 0)

  4060.             iFinal = eGtk2;

  4061.         else if (eGtk3 >= 0)

  4062.             iFinal = eGtk3;

  4063.         else if (iQt4 >= 0)

  4064.             iFinal = iQt4;

  4065.         else if (iCocoa >= 0)

  4066.             iFinal = iCocoa;

  4067.         else if (iHWND >= 0)

  4068.             iFinal = iHWND;

  4069.         else if (iX11 >= 0)

  4070.             iFinal = iX11;

  4071.         else if (iExt >= 0)

  4072.             iFinal = iExt;

  4073.         else if (iSuil >= 0)

  4074.             iFinal = iSuil;

  4075. 

  4076. #ifndef BUILD_BRIDGE

  4077.         const bool isBridged = (iFinal == eQt4 || iFinal == eCocoa || iFinal == eHWND || iFinal == eX11 || iFinal == eGtk2 || iFinal == eGtk3);

  4078. #endif

  4079. #ifdef HAVE_SUIL

  4080.         const bool isSuil = (iFinal == iSuil && !isBridged);

  4081. #endif

  4082. 

  4083.         if (iFinal < 0)

  4084.         {

  4085.             qWarning("Failed to find an appropriate LV2 UI for this plugin");

  4086.             return true;

  4087.         }

  4088. 

  4089.         ui.rdf_descriptor = &rdf_descriptor->UIs[iFinal];

  4090. 

  4091.         // -----------------------------------------------------------

  4092.         // check supported ui features

  4093. 

  4094.         canContinue = true;

  4095. 

  4096.         for (i=0; i < ui.rdf_descriptor->FeatureCount; i++)

  4097.         {

  4098.             if (LV2_IS_FEATURE_REQUIRED(ui.rdf_descriptor->Features[i].Type) && is_lv2_ui_feature_supported(ui.rdf_descriptor->Features[i].URI) == false)

  4099.             {

  4100.                 qCritical("Plugin UI requires a feature that is not supported:\n%s", ui.rdf_descriptor->Features[i].URI);

  4101.                 canContinue = false;

  4102.                 break;

  4103.             }

  4104.         }

  4105. 

  4106.         if (! canContinue)

  4107.         {

  4108.             ui.rdf_descriptor = nullptr;

  4109.             return true;

  4110.         }

  4111. 

  4112. #ifdef HAVE_SUIL

  4113.         if (isSuil)

  4114.         {

  4115.             // -------------------------------------------------------

  4116.             // init suil host

  4117. 

  4118.             suil.host = suil_host_new(carla_lv2_ui_write_function, carla_lv2_ui_port_map, nullptr, nullptr);

  4119.         }

  4120.         else

  4121. #endif

  4122.         {

  4123.             // -------------------------------------------------------

  4124.             // open DLL

  4125. 

  4126.             if (! uiLibOpen(ui.rdf_descriptor->Binary))

  4127.             {

  4128.                 qCritical("Could not load UI library, error was:\n%s", libError(ui.rdf_descriptor->Binary));

  4129.                 ui.rdf_descriptor = nullptr;

  4130.                 return true;

  4131.             }

  4132. 

  4133.             // -------------------------------------------------------

  4134.             // get DLL main entry

  4135. 

  4136.             LV2UI_DescriptorFunction ui_descFn = (LV2UI_DescriptorFunction)uiLibSymbol("lv2ui_descriptor");

  4137. 

  4138.             if (! ui_descFn)

  4139.             {

  4140.                 qCritical("Could not find the LV2UI Descriptor in the UI library");

  4141.                 uiLibClose();

  4142.                 ui.lib = nullptr;

  4143.                 ui.rdf_descriptor = nullptr;

  4144.                 return true;

  4145.             }

  4146. 

  4147.             // -------------------------------------------------------

  4148.             // get descriptor that matches URI

  4149. 

  4150.             i = 0;

  4151.             while ((ui.descriptor = ui_descFn(i++)))

  4152.             {

  4153.                 if (strcmp(ui.descriptor->URI, ui.rdf_descriptor->URI) == 0)

  4154.                     break;

  4155.             }

  4156. 

  4157.             if (! ui.descriptor)

  4158.             {

  4159.                 qCritical("Could not find the requested GUI in the plugin UI library");

  4160.                 uiLibClose();

  4161.                 ui.lib = nullptr;

  4162.                 ui.rdf_descriptor = nullptr;

  4163.                 return true;

  4164.             }

  4165.         }

  4166. 

  4167.         // -----------------------------------------------------------

  4168.         // initialize ui according to type

  4169. 

  4170.         const LV2_Property uiType = ui.rdf_descriptor->Type;

  4171. 

  4172. #ifndef BUILD_BRIDGE

  4173.         if (isBridged)

  4174.         {

  4175.             // -------------------------------------------------------

  4176.             // initialize ui bridge

  4177. 

  4178.             if (const char* const oscBinary = lv2bridge2str(uiType))

  4179.             {

  4180.                 gui.type = GUI_EXTERNAL_OSC;

  4181.                 osc.thread = new CarlaPluginThread(x_engine, this, CarlaPluginThread::PLUGIN_THREAD_LV2_GUI);

  4182.                 osc.thread->setOscData(oscBinary, descriptor->URI, ui.descriptor->URI);

  4183.             }

  4184.         }

  4185.         else

  4186. #endif

  4187.         {

  4188.             // -------------------------------------------------------

  4189.             // initialize ui features

  4190. 

  4191.             QString guiTitle = QString("%1 (GUI)").arg(m_name);

  4192. 

  4193.             LV2_Extension_Data_Feature* const uiDataFt = new LV2_Extension_Data_Feature;

  4194.             uiDataFt->data_access                      = descriptor->extension_data;

  4195. 

  4196.             LV2UI_Port_Map* const uiPortMapFt = new LV2UI_Port_Map;

  4197.             uiPortMapFt->handle               = this;

  4198.             uiPortMapFt->port_index           = carla_lv2_ui_port_map;

  4199. 

  4200.             LV2UI_Resize* const uiResizeFt    = new LV2UI_Resize;

  4201.             uiResizeFt->handle                = this;

  4202.             uiResizeFt->ui_resize             = carla_lv2_ui_resize;

  4203. 

  4204.             LV2_External_UI_Host* const uiExternalHostFt = new LV2_External_UI_Host;

  4205.             uiExternalHostFt->ui_closed                  = carla_lv2_external_ui_closed;

  4206.             uiExternalHostFt->plugin_human_id            = strdup(guiTitle.toUtf8().constData());

  4207. 

  4208.             features[lv2_feature_id_data_access]           = new LV2_Feature;

  4209.             features[lv2_feature_id_data_access]->URI      = LV2_DATA_ACCESS_URI;

  4210.             features[lv2_feature_id_data_access]->data     = uiDataFt;

  4211. 

  4212.             features[lv2_feature_id_instance_access]       = new LV2_Feature;

  4213.             features[lv2_feature_id_instance_access]->URI  = LV2_INSTANCE_ACCESS_URI;

  4214.             features[lv2_feature_id_instance_access]->data = handle;

  4215. 

  4216.             features[lv2_feature_id_ui_parent]             = new LV2_Feature;

  4217.             features[lv2_feature_id_ui_parent]->URI        = LV2_UI__parent;

  4218.             features[lv2_feature_id_ui_parent]->data       = nullptr;

  4219. 

  4220.             features[lv2_feature_id_ui_port_map]           = new LV2_Feature;

  4221.             features[lv2_feature_id_ui_port_map]->URI      = LV2_UI__portMap;

  4222.             features[lv2_feature_id_ui_port_map]->data     = uiPortMapFt;

  4223. 

  4224.             features[lv2_feature_id_ui_resize]             = new LV2_Feature;

  4225.             features[lv2_feature_id_ui_resize]->URI        = LV2_UI__resize;

  4226.             features[lv2_feature_id_ui_resize]->data       = uiResizeFt;

  4227. 

  4228.             features[lv2_feature_id_external_ui]           = new LV2_Feature;

  4229.             features[lv2_feature_id_external_ui]->URI      = LV2_EXTERNAL_UI__Host;

  4230.             features[lv2_feature_id_external_ui]->data     = uiExternalHostFt;

  4231. 

  4232.             features[lv2_feature_id_external_ui_old]       = new LV2_Feature;

  4233.             features[lv2_feature_id_external_ui_old]->URI  = LV2_EXTERNAL_UI_DEPRECATED_URI;

  4234.             features[lv2_feature_id_external_ui_old]->data = uiExternalHostFt;

  4235. 

  4236.             // -------------------------------------------------------

  4237.             // initialize ui

  4238. 

  4239.             switch (uiType)

  4240.             {

  4241.             case LV2_UI_QT4:

  4242.                 qDebug("Will use LV2 Qt4 UI");

  4243.                 gui.type      = GUI_INTERNAL_QT4;

  4244.                 gui.resizable = isUiResizable();

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

  4246.                 m_hints      |= PLUGIN_USES_SINGLE_THREAD;

  4247.                 break;

  4248. 

  4249.             case LV2_UI_COCOA:

  4250.                 qDebug("Will use LV2 Cocoa UI");

  4251.                 gui.type      = GUI_INTERNAL_COCOA;

  4252.                 gui.resizable = isUiResizable();

  4253.                 break;

  4254. 

  4255.             case LV2_UI_WINDOWS:

  4256.                 qDebug("Will use LV2 Windows UI");

  4257.                 gui.type      = GUI_INTERNAL_HWND;

  4258.                 gui.resizable = isUiResizable();

  4259.                 break;

  4260. 

  4261.             case LV2_UI_X11:

  4262.                 qDebug("Will use LV2 X11 UI");

  4263.                 gui.type      = GUI_INTERNAL_X11;

  4264.                 gui.resizable = isUiResizable();

  4265.                 break;

  4266. 

  4267.             case LV2_UI_GTK2:

  4268. #ifdef HAVE_SUIL

  4269.                 qDebug("Will use LV2 Gtk2 UI (suil)");

  4270.                 gui.type      = GUI_EXTERNAL_SUIL;

  4271.                 gui.resizable = isUiResizable();

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

  4273.                 m_hints      |= PLUGIN_USES_SINGLE_THREAD;

  4274. 

  4275.                 if (suil.handle)

  4276.                 {

  4277.                     ui.handle     = ((SuilInstanceImpl*)suil.handle)->handle;

  4278.                     ui.descriptor = ((SuilInstanceImpl*)suil.handle)->descriptor;

  4279.                     ui.widget     = suil_instance_get_widget(suil.handle);

  4280. 

  4281.                     if (ui.widget)

  4282.                     {

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

  4284.                         widget->setWindowTitle(guiTitle);

  4285.                     }

  4286.                 }

  4287. #else

  4288.                 qDebug("Will use LV2 Gtk2 UI, NOT!");

  4289. #endif

  4290.                 break;

  4291. 

  4292.             case LV2_UI_GTK3:

  4293.                 qDebug("Will use LV2 Gtk3 UI, NOT!");

  4294.                 break;

  4295. 

  4296.             case LV2_UI_EXTERNAL:

  4297.             case LV2_UI_OLD_EXTERNAL:

  4298.                 qDebug("Will use LV2 External UI");

  4299.                 gui.type = GUI_EXTERNAL_LV2;

  4300.                 break;

  4301.             }

  4302.         }

  4303. 

  4304.         if (gui.type != GUI_NONE)

  4305.             m_hints |= PLUGIN_HAS_GUI;

  4306. 

  4307.         return true;

  4308.     }

  4309. 

  4310. private:

  4311.     LV2_Handle handle, h2;

  4312.     const LV2_Descriptor* descriptor;

  4313.     const LV2_RDF_Descriptor* rdf_descriptor;

  4314.     LV2_Feature* features[lv2_feature_count+1];

  4315. 

  4316.     struct {

  4317.         const LV2_State_Interface* state;

  4318.         const LV2_Worker_Interface* worker;

  4319.         const LV2_Programs_Interface* programs;

  4320.         const LV2_Programs_UI_Interface* uiprograms;

  4321.     } ext;

  4322. 

  4323.     struct {

  4324.         void* lib;

  4325.         LV2UI_Handle handle;

  4326.         LV2UI_Widget widget;

  4327.         const LV2UI_Descriptor* descriptor;

  4328.         const LV2_RDF_UI* rdf_descriptor;

  4329.     } ui;

  4330. 

  4331.     struct {

  4332.         GuiType type;

  4333.         bool resizable;

  4334.         int width;

  4335.         int height;

  4336.     } gui;

  4337. 

  4338. #ifdef HAVE_SUIL

  4339.     struct {

  4340.         SuilHost* host;

  4341.         SuilInstance* handle;

  4342.         QByteArray pos;

  4343.     } suil;

  4344. #endif

  4345. 

  4346.     Lv2PluginEventData evIn;

  4347.     Lv2PluginEventData evOut;

  4348.     float* paramBuffers;

  4349.     std::vector<const char*> customURIDs;

  4350. 

  4351.     bool     lastTimePosPlaying;

  4352.     uint32_t lastTimePosFrame;

  4353. };

  4354. 

  4355. CarlaPlugin* CarlaPlugin::newLV2(const initializer& init)

  4356. {

  4357.     qDebug("CarlaPlugin::newLV2(%p, \"%s\", \"%s\", \"%s\")", init.engine, init.filename, init.name, init.label);

  4358. 

  4359.     short id = init.engine->getNewPluginId();

  4360. 

  4361.     if (id < 0 || id > CarlaEngine::maxPluginNumber())

  4362.     {

  4363.         setLastError("Maximum number of plugins reached");

  4364.         return nullptr;

  4365.     }

  4366. 

  4367.     Lv2Plugin* const plugin = new Lv2Plugin(init.engine, id);

  4368. 

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

  4370.     {

  4371.         delete plugin;

  4372.         return nullptr;

  4373.     }

  4374. 

  4375.     plugin->reload();

  4376. 

  4377. #ifndef BUILD_BRIDGE

  4378.     if (carlaOptions.processMode == PROCESS_MODE_CONTINUOUS_RACK)

  4379.     {

  4380.         const uint32_t ins  = plugin->audioInCount();

  4381.         const uint32_t outs = plugin->audioOutCount();

  4382. 

  4383.         if (ins > 2 || outs > 2 || (ins != outs && ins != 0 && outs != 0))

  4384.         {

  4385.             setLastError("Carla's rack mode can only work with Mono or Stereo LV2 plugins, sorry!");

  4386.             delete plugin;

  4387.             return nullptr;

  4388.         }

  4389.     }

  4390. #endif

  4391. 

  4392.     plugin->registerToOsc();

  4393.     plugin->updateUi();

  4394. 

  4395.     return plugin;

  4396. }

  4397. 

  4398. /**@}*/

  4399. 

  4400. // -------------------------------------------------------------------------------------------------------------------

  4401. 

  4402. int CarlaOsc::handle_lv2_atom_transfer(CARLA_OSC_HANDLE_ARGS2)

  4403. {

  4404.     qDebug("CarlaOsc::handle_lv2_atom_transfer()");

  4405.     CARLA_OSC_CHECK_OSC_TYPES(2, "ss");

  4406. 

  4407.     const char* const type  = (const char*)&argv[0]->s;

  4408.     const char* const value = (const char*)&argv[1]->s;

  4409. 

  4410.     QByteArray chunk;

  4411.     chunk = QByteArray::fromBase64(value);

  4412. 

  4413.     const LV2_Atom* const atom = (LV2_Atom*)chunk.constData();

  4414. 

  4415.     CarlaBackend::Lv2Plugin* const lv2plugin = (CarlaBackend::Lv2Plugin*)plugin;

  4416.     lv2plugin->handleTransferAtom(atom, type);

  4417. 

  4418.     return 0;

  4419. }

  4420. 

  4421. int CarlaOsc::handle_lv2_event_transfer(CARLA_OSC_HANDLE_ARGS2)

  4422. {

  4423.     qDebug("CarlaOsc::handle_lv2_event_transfer()");

  4424.     CARLA_OSC_CHECK_OSC_TYPES(2, "ss");

  4425. 

  4426.     const char* const type  = (const char*)&argv[0]->s;

  4427.     const char* const value = (const char*)&argv[1]->s;

  4428. 

  4429.     QByteArray chunk;

  4430.     chunk = QByteArray::fromBase64(value);

  4431. 

  4432.     const LV2_Atom* const atom = (LV2_Atom*)chunk.constData();

  4433. 

  4434.     CarlaBackend::Lv2Plugin* const lv2plugin = (CarlaBackend::Lv2Plugin*)plugin;

  4435.     lv2plugin->handleTransferEvent(atom, type);

  4436. 

  4437.     return 0;

  4438. }

  4439. 

  4440. CARLA_BACKEND_END_NAMESPACE