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

4354 lines
151KB
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. 

  24. #ifndef __WINE__

  25. #include <QtGui/QLayout>

  26. #endif

  27. 

  28. #ifdef HAVE_SUIL

  29. #include <suil/suil.h>

  30. struct SuilInstanceImpl {

  31.     void*                   lib_handle;

  32.     const LV2UI_Descriptor* descriptor;

  33.     LV2UI_Handle            handle;

  34.     // ...

  35. };

  36. #endif

  37. 

  38. CARLA_BACKEND_START_NAMESPACE

  39. 

  40. /*!

  41.  * @defgroup CarlaBackendLv2Plugin Carla Backend LV2 Plugin

  42.  *

  43.  * The Carla Backend LV2 Plugin.\n

  44.  * http://lv2plug.in/

  45.  * @{

  46.  */

  47. 

  48. // static max values

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

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

  51. 

  52. /*!

  53.  * @defgroup PluginHints Plugin Hints

  54.  * @{

  55.  */

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

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

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

  59. /**@}*/

  60. 

  61. /*!

  62.  * @defgroup ParameterHints Parameter Hints

  63.  * @{

  64.  */

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

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

  67. /**@}*/

  68. 

  69. /*!

  70.  * @defgroup Lv2FeatureIds LV2 Feature Ids

  71.  *

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

  73.  * \see CarlaPlugin::hints

  74.  * @{

  75.  */

  76. const uint32_t lv2_feature_id_bufsize_bounded  =  0;

  77. const uint32_t lv2_feature_id_bufsize_fixed    =  1;

  78. const uint32_t lv2_feature_id_bufsize_powerof2 =  2;

  79. const uint32_t lv2_feature_id_event            =  3;

  80. const uint32_t lv2_feature_id_logs             =  4;

  81. const uint32_t lv2_feature_id_options          =  5;

  82. const uint32_t lv2_feature_id_programs         =  6;

  83. const uint32_t lv2_feature_id_rtmempool        =  7;

  84. const uint32_t lv2_feature_id_state_make_path  =  8;

  85. const uint32_t lv2_feature_id_state_map_path   =  9;

  86. const uint32_t lv2_feature_id_strict_bounds    = 10;

  87. const uint32_t lv2_feature_id_uri_map          = 11;

  88. const uint32_t lv2_feature_id_urid_map         = 12;

  89. const uint32_t lv2_feature_id_urid_unmap       = 13;

  90. const uint32_t lv2_feature_id_worker           = 14;

  91. const uint32_t lv2_feature_id_data_access      = 15;

  92. const uint32_t lv2_feature_id_instance_access  = 16;

  93. const uint32_t lv2_feature_id_ui_parent        = 17;

  94. const uint32_t lv2_feature_id_ui_port_map      = 18;

  95. const uint32_t lv2_feature_id_ui_resize        = 19;

  96. const uint32_t lv2_feature_id_external_ui      = 20;

  97. const uint32_t lv2_feature_id_external_ui_old  = 21;

  98. const uint32_t lv2_feature_count               = 22;

  99. /**@}*/

  100. 

  101. /*!

  102.  * @defgroup Lv2EventTypes LV2 Event Data/Types

  103.  *

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

  105.  * \see CarlaPlugin::hints

  106.  * @{

  107.  */

  108. const unsigned int CARLA_EVENT_DATA_ATOM      = 0x01;

  109. const unsigned int CARLA_EVENT_DATA_EVENT     = 0x02;

  110. const unsigned int CARLA_EVENT_DATA_MIDI_LL   = 0x04;

  111. const unsigned int CARLA_EVENT_TYPE_MESSAGE   = 0x10;

  112. const unsigned int CARLA_EVENT_TYPE_MIDI      = 0x20;

  113. /**@}*/

  114. 

  115. /*!

  116.  * @defgroup Lv2UriMapIds LV2 URI Map Ids

  117.  *

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

  119.  * \see CarlaPlugin::hints

  120.  * @{

  121.  */

  122. const uint32_t CARLA_URI_MAP_ID_NULL                = 0;

  123. const uint32_t CARLA_URI_MAP_ID_ATOM_CHUNK          = 1;

  124. const uint32_t CARLA_URI_MAP_ID_ATOM_DOUBLE         = 2;

  125. const uint32_t CARLA_URI_MAP_ID_ATOM_INT            = 3;

  126. const uint32_t CARLA_URI_MAP_ID_ATOM_PATH           = 4;

  127. const uint32_t CARLA_URI_MAP_ID_ATOM_SEQUENCE       = 5;

  128. const uint32_t CARLA_URI_MAP_ID_ATOM_STRING         = 6;

  129. const uint32_t CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM  = 7;

  130. const uint32_t CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT = 8;

  131. const uint32_t CARLA_URI_MAP_ID_BUF_MAX_LENGTH      = 9;

  132. const uint32_t CARLA_URI_MAP_ID_BUF_MIN_LENGTH      = 10;

  133. const uint32_t CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE   = 11;

  134. const uint32_t CARLA_URI_MAP_ID_LOG_ERROR           = 12;

  135. const uint32_t CARLA_URI_MAP_ID_LOG_NOTE            = 13;

  136. const uint32_t CARLA_URI_MAP_ID_LOG_TRACE           = 14;

  137. const uint32_t CARLA_URI_MAP_ID_LOG_WARNING         = 15;

  138. const uint32_t CARLA_URI_MAP_ID_MIDI_EVENT          = 16;

  139. const uint32_t CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE   = 17;

  140. const uint32_t CARLA_URI_MAP_ID_COUNT               = 18;

  141. /**@}*/

  142. 

  143. struct Lv2EventData {

  144.     uint32_t type;

  145.     CarlaEngineMidiPort* port;

  146.     union {

  147.         LV2_Atom_Sequence* atom;

  148.         LV2_Event_Buffer* event;

  149.         LV2_MIDI* midi;

  150.     };

  151. 

  152.     Lv2EventData()

  153.         : type(0),

  154.           port(nullptr) {}

  155. };

  156. 

  157. struct Lv2PluginEventData {

  158.     uint32_t count;

  159.     Lv2EventData* data;

  160. 

  161.     Lv2PluginEventData()

  162.         : count(0),

  163.           data(nullptr) {}

  164. };

  165. 

  166. struct Lv2PluginOptions {

  167.     bool init;

  168.     uint32_t eventSize;

  169.     uint32_t bufferSize;

  170.     double   sampleRate;

  171.     LV2_Options_Option oNull;

  172.     LV2_Options_Option oMaxBlockLenth;

  173.     LV2_Options_Option oMinBlockLenth;

  174.     LV2_Options_Option oSequenceSize;

  175.     LV2_Options_Option oSampleRate;

  176. 

  177.     Lv2PluginOptions()

  178.         : init(false),

  179.           eventSize(MAX_EVENT_BUFFER),

  180.           bufferSize(0),

  181.           sampleRate(0.0) {}

  182. };

  183. 

  184. Lv2PluginOptions lv2Options;

  185. 

  186. const char* lv2bridge2str(const LV2_Property type)

  187. {

  188.     switch (type)

  189.     {

  190. #ifndef BUILD_BRIDGE

  191.     case LV2_UI_GTK2:

  192.         return carlaOptions.bridge_lv2gtk2;

  193.     case LV2_UI_QT4:

  194.         return carlaOptions.bridge_lv2qt4;

  195.     case LV2_UI_COCOA:

  196.         return nullptr; //carlaOptions.bridge_lv2cocoa;

  197.     case LV2_UI_WINDOWS:

  198.         return nullptr; //carlaOptions.bridge_lv2hwnd;

  199.     case LV2_UI_X11:

  200.         return carlaOptions.bridge_lv2x11;

  201. #endif

  202.     default:

  203.         return nullptr;

  204.     }

  205. }

  206. 

  207. class Lv2Plugin : public CarlaPlugin

  208. {

  209. public:

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

  211.         : CarlaPlugin(engine, id)

  212.     {

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

  214. 

  215.         m_type = PLUGIN_LV2;

  216. 

  217.         handle = h2 = nullptr;

  218.         descriptor  = nullptr;

  219.         rdf_descriptor = nullptr;

  220. 

  221.         ext.state      = nullptr;

  222.         ext.worker     = nullptr;

  223.         ext.programs   = nullptr;

  224.         ext.uiprograms = nullptr;

  225. 

  226.         ui.lib = nullptr;

  227.         ui.handle = nullptr;

  228.         ui.descriptor = nullptr;

  229.         ui.rdf_descriptor = nullptr;

  230. 

  231.         evIn.count = 0;

  232.         evIn.data  = nullptr;

  233. 

  234.         evOut.count = 0;

  235.         evOut.data  = nullptr;

  236. 

  237.         paramBuffers = nullptr;

  238. 

  239.         gui.type = GUI_NONE;

  240.         gui.resizable = false;

  241.         gui.width  = 0;

  242.         gui.height = 0;

  243. 

  244. #ifdef HAVE_SUIL

  245.         suil.handle = nullptr;

  246.         suil.host   = nullptr;

  247. #endif

  248. 

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

  250.             customURIDs.push_back(nullptr);

  251. 

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

  253.             features[i] = nullptr;

  254. 

  255.         if (! lv2Options.init)

  256.         {

  257.             lv2Options.init = true;

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

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

  260. 

  261.             lv2Options.oNull.key   = CARLA_URI_MAP_ID_NULL;

  262.             lv2Options.oNull.size  = 0;

  263.             lv2Options.oNull.type  = CARLA_URI_MAP_ID_NULL;

  264.             lv2Options.oNull.value = nullptr;

  265. 

  266.             lv2Options.oMaxBlockLenth.key   = CARLA_URI_MAP_ID_BUF_MAX_LENGTH;

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

  268.             lv2Options.oMaxBlockLenth.type  = CARLA_URI_MAP_ID_ATOM_INT;

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

  270. 

  271.             lv2Options.oMinBlockLenth.key   = CARLA_URI_MAP_ID_BUF_MIN_LENGTH;

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

  273.             lv2Options.oMinBlockLenth.type  = CARLA_URI_MAP_ID_ATOM_INT;

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

  275. 

  276.             lv2Options.oSequenceSize.key   = CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE;

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

  278.             lv2Options.oSequenceSize.type  = CARLA_URI_MAP_ID_ATOM_INT;

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

  280. 

  281.             lv2Options.oSampleRate.key     = CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE;

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

  283.             lv2Options.oSampleRate.type    = CARLA_URI_MAP_ID_ATOM_DOUBLE;

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

  285.         }

  286.     }

  287. 

  288.     ~Lv2Plugin()

  289.     {

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

  291. 

  292.         // close UI

  293.         if (m_hints & PLUGIN_HAS_GUI)

  294.         {

  295.             showGui(false);

  296. 

  297.             switch (gui.type)

  298.             {

  299.             case GUI_NONE:

  300.             case GUI_INTERNAL_QT4:

  301.             case GUI_INTERNAL_COCOA:

  302.             case GUI_INTERNAL_HWND:

  303.             case GUI_INTERNAL_X11:

  304.             case GUI_EXTERNAL_LV2:

  305.                 break;

  306. 

  307.             case GUI_EXTERNAL_SUIL:

  308. #if defined(HAVE_SUIL) && ! defined(__WINE__)

  309.                 if (ui.widget)

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

  311. #endif

  312.                 break;

  313. 

  314.             case GUI_EXTERNAL_OSC:

  315. #ifndef BUILD_BRIDGE

  316.                 if (osc.thread)

  317.                 {

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

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

  320.                     {

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

  322.                         osc.thread->terminate();

  323.                     }

  324. 

  325.                     delete osc.thread;

  326.                 }

  327. #endif

  328.                 break;

  329.             }

  330. 

  331. #ifdef HAVE_SUIL

  332.             if (suil.handle)

  333.             {

  334.                 suil_instance_free(suil.handle);

  335. 

  336.                 if (suil.host)

  337.                     suil_host_free(suil.host);

  338. 

  339.                 ui.handle = nullptr;

  340.                 ui.descriptor = nullptr;

  341.             }

  342. #endif

  343. 

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

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

  346. 

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

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

  349. 

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

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

  352. 

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

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

  355. 

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

  357.             {

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

  359. 

  360.                 if (uiHost->plugin_human_id)

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

  362. 

  363.                 delete uiHost;

  364.             }

  365. 

  366.             uiLibClose();

  367.         }

  368. 

  369.         if (descriptor)

  370.         {

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

  372.             {

  373.                 if (handle)

  374.                     descriptor->deactivate(handle);

  375.                 if (h2)

  376.                     descriptor->deactivate(h2);

  377.             }

  378. 

  379.             if (descriptor->cleanup)

  380.             {

  381.                 if (handle)

  382.                     descriptor->cleanup(handle);

  383.                 if (h2)

  384.                     descriptor->cleanup(h2);

  385.             }

  386.         }

  387. 

  388.         if (rdf_descriptor)

  389.             lv2_rdf_free(rdf_descriptor);

  390. 

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

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

  393. 

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

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

  396. 

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

  398.         {

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

  400.             delete[] options;

  401.         }

  402. 

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

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

  405. 

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

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

  408. 

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

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

  411. 

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

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

  414. 

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

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

  417. 

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

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

  420. 

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

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

  423. 

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

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

  426. 

  427. #ifndef BUILD_BRIDGE

  428.         if (! carlaOptions.processHighPrecision)

  429. #endif

  430.         {

  431.             features[lv2_feature_id_bufsize_fixed]    = nullptr;

  432.             features[lv2_feature_id_bufsize_powerof2] = nullptr;

  433.         }

  434. 

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

  436.         {

  437.             if (features[i])

  438.                 delete features[i];

  439.         }

  440. 

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

  442.         {

  443.             if (customURIDs[i])

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

  445.         }

  446. 

  447.         customURIDs.clear();

  448.     }

  449. 

  450.     // -------------------------------------------------------------------

  451.     // Information (base)

  452. 

  453.     PluginCategory category()

  454.     {

  455.         Q_ASSERT(rdf_descriptor);

  456. 

  457.         LV2_Property category = rdf_descriptor->Type;

  458. 

  459.         if (LV2_IS_DELAY(category))

  460.             return PLUGIN_CATEGORY_DELAY;

  461.         if (LV2_IS_DISTORTION(category))

  462.             return PLUGIN_CATEGORY_OTHER;

  463.         if (LV2_IS_DYNAMICS(category))

  464.             return PLUGIN_CATEGORY_DYNAMICS;

  465.         if (LV2_IS_EQ(category))

  466.             return PLUGIN_CATEGORY_EQ;

  467.         if (LV2_IS_FILTER(category))

  468.             return PLUGIN_CATEGORY_FILTER;

  469.         if (LV2_IS_GENERATOR(category))

  470.             return PLUGIN_CATEGORY_SYNTH;

  471.         if (LV2_IS_MODULATOR(category))

  472.             return PLUGIN_CATEGORY_MODULATOR;

  473.         if (LV2_IS_REVERB(category))

  474.             return PLUGIN_CATEGORY_DELAY;

  475.         if (LV2_IS_SIMULATOR(category))

  476.             return PLUGIN_CATEGORY_OTHER;

  477.         if (LV2_IS_SPATIAL(category))

  478.             return PLUGIN_CATEGORY_OTHER;

  479.         if (LV2_IS_SPECTRAL(category))

  480.             return PLUGIN_CATEGORY_UTILITY;

  481.         if (LV2_IS_UTILITY(category))

  482.             return PLUGIN_CATEGORY_UTILITY;

  483. 

  484.         return getPluginCategoryFromName(m_name);

  485.     }

  486. 

  487.     long uniqueId()

  488.     {

  489.         Q_ASSERT(rdf_descriptor);

  490. 

  491.         return rdf_descriptor->UniqueID;

  492.     }

  493. 

  494.     // -------------------------------------------------------------------

  495.     // Information (count)

  496. 

  497.     uint32_t midiInCount()

  498.     {

  499.         uint32_t i, count = 0;

  500. 

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

  502.         {

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

  504.                 count += 1;

  505.         }

  506. 

  507.         return count;

  508.     }

  509. 

  510.     uint32_t midiOutCount()

  511.     {

  512.         uint32_t i, count = 0;

  513. 

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

  515.         {

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

  517.                 count += 1;

  518.         }

  519. 

  520.         return count;

  521.     }

  522. 

  523.     uint32_t parameterScalePointCount(const uint32_t parameterId)

  524.     {

  525.         Q_ASSERT(parameterId < param.count);

  526.         Q_ASSERT(rdf_descriptor);

  527. 

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

  529. 

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

  531.         {

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

  533. 

  534.             if (port)

  535.                 return port->ScalePointCount;

  536.         }

  537. 

  538.         return 0;

  539.     }

  540. 

  541.     // -------------------------------------------------------------------

  542.     // Information (per-plugin data)

  543. 

  544.     double getParameterValue(const uint32_t parameterId)

  545.     {

  546.         Q_ASSERT(parameterId < param.count);

  547. 

  548.         return paramBuffers[parameterId];

  549.     }

  550. 

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

  552.     {

  553.         Q_ASSERT(parameterId < param.count);

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

  555. 

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

  557. 

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

  559.         {

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

  561. 

  562.             if (port && scalePointId < port->ScalePointCount)

  563.             {

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

  565. 

  566.                 if (portScalePoint)

  567.                     return portScalePoint->Value;

  568.             }

  569.         }

  570. 

  571.         return 0.0;

  572.     }

  573. 

  574.     void getLabel(char* const strBuf)

  575.     {

  576.         Q_ASSERT(rdf_descriptor);

  577. 

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

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

  580.         else

  581.             CarlaPlugin::getLabel(strBuf);

  582.     }

  583. 

  584.     void getMaker(char* const strBuf)

  585.     {

  586.         Q_ASSERT(rdf_descriptor);

  587. 

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

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

  590.         else

  591.             CarlaPlugin::getMaker(strBuf);

  592.     }

  593. 

  594.     void getCopyright(char* const strBuf)

  595.     {

  596.         Q_ASSERT(rdf_descriptor);

  597. 

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

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

  600.         else

  601.             CarlaPlugin::getCopyright(strBuf);

  602.     }

  603. 

  604.     void getRealName(char* const strBuf)

  605.     {

  606.         Q_ASSERT(rdf_descriptor);

  607. 

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

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

  610.         else

  611.             CarlaPlugin::getRealName(strBuf);

  612.     }

  613. 

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

  615.     {

  616.         Q_ASSERT(rdf_descriptor);

  617.         Q_ASSERT(parameterId < param.count);

  618. 

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

  620. 

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

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

  623.         else

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

  625.     }

  626. 

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

  628.     {

  629.         Q_ASSERT(rdf_descriptor);

  630.         Q_ASSERT(parameterId < param.count);

  631. 

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

  633. 

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

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

  636.         else

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

  638.     }

  639. 

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

  641.     {

  642.         Q_ASSERT(rdf_descriptor);

  643.         Q_ASSERT(parameterId < param.count);

  644. 

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

  646. 

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

  648.         {

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

  650. 

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

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

  653. 

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

  655.             {

  656.                 switch (port->Unit.Type)

  657.                 {

  658.                 case LV2_UNIT_BAR:

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

  660.                     return;

  661.                 case LV2_UNIT_BEAT:

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

  663.                     return;

  664.                 case LV2_UNIT_BPM:

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

  666.                     return;

  667.                 case LV2_UNIT_CENT:

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

  669.                     return;

  670.                 case LV2_UNIT_CM:

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

  672.                     return;

  673.                 case LV2_UNIT_COEF:

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

  675.                     return;

  676.                 case LV2_UNIT_DB:

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

  678.                     return;

  679.                 case LV2_UNIT_DEGREE:

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

  681.                     return;

  682.                 case LV2_UNIT_FRAME:

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

  684.                     return;

  685.                 case LV2_UNIT_HZ:

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

  687.                     return;

  688.                 case LV2_UNIT_INCH:

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

  690.                     return;

  691.                 case LV2_UNIT_KHZ:

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

  693.                     return;

  694.                 case LV2_UNIT_KM:

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

  696.                     return;

  697.                 case LV2_UNIT_M:

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

  699.                     return;

  700.                 case LV2_UNIT_MHZ:

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

  702.                     return;

  703.                 case LV2_UNIT_MIDINOTE:

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

  705.                     return;

  706.                 case LV2_UNIT_MILE:

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

  708.                     return;

  709.                 case LV2_UNIT_MIN:

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

  711.                     return;

  712.                 case LV2_UNIT_MM:

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

  714.                     return;

  715.                 case LV2_UNIT_MS:

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

  717.                     return;

  718.                 case LV2_UNIT_OCT:

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

  720.                     return;

  721.                 case LV2_UNIT_PC:

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

  723.                     return;

  724.                 case LV2_UNIT_S:

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

  726.                     return;

  727.                 case LV2_UNIT_SEMITONE:

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

  729.                     return;

  730.                 }

  731.             }

  732.         }

  733. 

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

  735.     }

  736. 

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

  738.     {

  739.         Q_ASSERT(rdf_descriptor);

  740.         Q_ASSERT(parameterId < param.count);

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

  742. 

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

  744. 

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

  746.         {

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

  748. 

  749.             if (port && scalePointId < port->ScalePointCount)

  750.             {

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

  752. 

  753.                 if (portScalePoint && portScalePoint->Label)

  754.                 {

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

  756.                     return;

  757.                 }

  758.             }

  759.         }

  760. 

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

  762.     }

  763. 

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

  765.     {

  766.         Q_ASSERT(type);

  767.         Q_ASSERT(resizable);

  768. 

  769.         *type      = gui.type;

  770.         *resizable = gui.resizable;

  771.     }

  772. 

  773.     // -------------------------------------------------------------------

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

  775. 

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

  777.     {

  778.         Q_ASSERT(parameterId < param.count);

  779. 

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

  781. 

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

  783.     }

  784. 

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

  786.     {

  787.         Q_ASSERT(type != CUSTOM_DATA_INVALID);

  788.         Q_ASSERT(key);

  789.         Q_ASSERT(value);

  790. 

  791.         if (type == CUSTOM_DATA_INVALID)

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

  793. 

  794.         if (! key)

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

  796. 

  797.         if (! value)

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

  799. 

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

  801. 

  802.         if (ext.state)

  803.         {

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

  805.             LV2_State_Status status;

  806. 

  807.             if (x_engine->isOffline())

  808.             {

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

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

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

  812.             }

  813.             else

  814.             {

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

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

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

  818.             }

  819. 

  820.             switch (status)

  821.             {

  822.             case LV2_STATE_SUCCESS:

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

  824.                 break;

  825.             case LV2_STATE_ERR_UNKNOWN:

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

  827.                 break;

  828.             case LV2_STATE_ERR_BAD_TYPE:

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

  830.                 break;

  831.             case LV2_STATE_ERR_BAD_FLAGS:

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

  833.                 break;

  834.             case LV2_STATE_ERR_NO_FEATURE:

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

  836.                 break;

  837.             case LV2_STATE_ERR_NO_PROPERTY:

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

  839.                 break;

  840.             }

  841.         }

  842. 

  843.         if (sendGui)

  844.         {

  845.             CustomData cdata;

  846.             cdata.type  = type;

  847.             cdata.key   = key;

  848.             cdata.value = value;

  849.             uiTransferEvent(&cdata);

  850.         }

  851.     }

  852. 

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

  854.     {

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

  856. 

  857.         if (index < -1)

  858.             index = -1;

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

  860.             return;

  861. 

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

  863.         {

  864.             if (x_engine->isOffline())

  865.             {

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

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

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

  869.             }

  870.             else

  871.             {

  872.                 const ScopedDisabler m(this, block);

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

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

  875.             }

  876.         }

  877. 

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

  879.     }

  880. 

  881.     // -------------------------------------------------------------------

  882.     // Set gui stuff

  883. 

  884.     void setGuiData(const GuiDataHandle handle)

  885.     {

  886.         switch(gui.type)

  887.         {

  888.         case GUI_NONE:

  889.             break;

  890. 

  891. #ifndef __WINE__

  892.         case GUI_INTERNAL_QT4:

  893.             if (ui.widget)

  894.             {

  895.                 QDialog* const dialog = handle;

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

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

  898.                 widget->adjustSize();

  899.                 widget->setParent(dialog);

  900.                 widget->show();

  901.             }

  902.             break;

  903. #endif

  904. 

  905.         case GUI_INTERNAL_COCOA:

  906.         case GUI_INTERNAL_HWND:

  907.         case GUI_INTERNAL_X11:

  908.             if (ui.descriptor)

  909.             {

  910. #ifdef __WINE__

  911.                 features[lv2_feature_id_ui_parent]->data = (void*)handle;

  912. #else

  913.                 features[lv2_feature_id_ui_parent]->data = (void*)handle->winId();

  914. #endif

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

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

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

  918.                 updateUi();

  919.             }

  920.             break;

  921. 

  922.         case GUI_EXTERNAL_LV2:

  923.         case GUI_EXTERNAL_SUIL:

  924.         case GUI_EXTERNAL_OSC:

  925.             break;

  926.         }

  927.     }

  928. 

  929.     void showGui(const bool yesNo)

  930.     {

  931.         switch(gui.type)

  932.         {

  933.         case GUI_NONE:

  934.         case GUI_INTERNAL_QT4:

  935.             break;

  936. 

  937.         case GUI_INTERNAL_COCOA:

  938.         case GUI_INTERNAL_HWND:

  939.         case GUI_INTERNAL_X11:

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

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

  942.             break;

  943. 

  944.         case GUI_EXTERNAL_LV2:

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

  946.                 initExternalUi();

  947. 

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

  949.             {

  950.                 if (yesNo)

  951.                 {

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

  953.                 }

  954.                 else

  955.                 {

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

  957. 

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

  959.                     {

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

  961. 

  962.                         if (ui.descriptor->cleanup)

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

  964. 

  965.                         ui.handle = nullptr;

  966.                     }

  967.                 }

  968.             }

  969.             else

  970.                 // failed to init UI

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

  972. 

  973.             break;

  974. 

  975.         case GUI_EXTERNAL_SUIL:

  976. #if defined(HAVE_SUIL) && ! defined(__WINE__)

  977.             if (ui.widget)

  978.             {

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

  980. 

  981.                 if (yesNo)

  982.                 {

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

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

  985.                 }

  986.                 else

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

  988. 

  989.                 widget->setVisible(yesNo);

  990.             }

  991. #endif

  992.             break;

  993. 

  994.         case GUI_EXTERNAL_OSC:

  995. #ifndef BUILD_BRIDGE

  996.             Q_ASSERT(osc.thread);

  997. 

  998.             if (! osc.thread)

  999.             {

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

  1001.                 return;

  1002.             }

  1003. 

  1004.             if (yesNo)

  1005.             {

  1006.                 osc.thread->start();

  1007.             }

  1008.             else

  1009.             {

  1010.                 if (osc.data.target)

  1011.                 {

  1012.                     osc_send_hide(&osc.data);

  1013.                     osc_send_quit(&osc.data);

  1014.                     osc_clear_data(&osc.data);

  1015.                 }

  1016. 

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

  1018.                     osc.thread->quit();

  1019.             }

  1020. #endif

  1021.             break;

  1022.         }

  1023.     }

  1024. 

  1025.     void idleGui()

  1026.     {

  1027.         // Update external UI

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

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

  1030. 

  1031.         CarlaPlugin::idleGui();

  1032.     }

  1033. 

  1034.     // -------------------------------------------------------------------

  1035.     // Plugin state

  1036. 

  1037.     void reload()

  1038.     {

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

  1040.         Q_ASSERT(descriptor && rdf_descriptor);

  1041. 

  1042.         // Safely disable plugin for reload

  1043.         const ScopedDisabler m(this);

  1044. 

  1045.         if (x_client->isActive())

  1046.             x_client->deactivate();

  1047. 

  1048.         // Remove client ports

  1049.         removeClientPorts();

  1050. 

  1051.         // Delete old data

  1052.         deleteBuffers();

  1053. 

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

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

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

  1057. 

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

  1059.         const uint32_t portCount = rdf_descriptor->PortCount;

  1060. 

  1061.         bool forcedStereoIn, forcedStereoOut;

  1062.         forcedStereoIn = forcedStereoOut = false;

  1063. 

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

  1065.         {

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

  1067. 

  1068.             if (LV2_IS_PORT_AUDIO(portType))

  1069.             {

  1070.                 if (LV2_IS_PORT_INPUT(portType))

  1071.                     aIns += 1;

  1072.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1073.                     aOuts += 1;

  1074.             }

  1075.             else if (LV2_IS_PORT_CV(portType))

  1076.             {

  1077.                 if (LV2_IS_PORT_INPUT(portType))

  1078.                     cvIns += 1;

  1079.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1080.                     cvOuts += 1;

  1081.             }

  1082.             else if (LV2_IS_PORT_ATOM_SEQUENCE(portType))

  1083.             {

  1084.                 if (LV2_IS_PORT_INPUT(portType))

  1085.                     evIns.push_back(CARLA_EVENT_DATA_ATOM);

  1086.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1087.                     evOuts.push_back(CARLA_EVENT_DATA_ATOM);

  1088.             }

  1089.             else if (LV2_IS_PORT_EVENT(portType))

  1090.             {

  1091.                 if (LV2_IS_PORT_INPUT(portType))

  1092.                     evIns.push_back(CARLA_EVENT_DATA_EVENT);

  1093.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1094.                     evOuts.push_back(CARLA_EVENT_DATA_EVENT);

  1095.             }

  1096.             else if (LV2_IS_PORT_MIDI_LL(portType))

  1097.             {

  1098.                 if (LV2_IS_PORT_INPUT(portType))

  1099.                     evIns.push_back(CARLA_EVENT_DATA_MIDI_LL);

  1100.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1101.                     evOuts.push_back(CARLA_EVENT_DATA_MIDI_LL);

  1102.             }

  1103.             else if (LV2_IS_PORT_CONTROL(portType))

  1104.                 params += 1;

  1105.         }

  1106. 

  1107. #ifndef BUILD_BRIDGE

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

  1109.         {

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

  1111. 

  1112.             if (aIns == 1)

  1113.             {

  1114.                 aIns = 2;

  1115.                 forcedStereoIn = true;

  1116.             }

  1117. 

  1118.             if (aOuts == 1)

  1119.             {

  1120.                 aOuts = 2;

  1121.                 forcedStereoOut = true;

  1122.             }

  1123.         }

  1124. #endif

  1125. 

  1126.         if (aIns > 0)

  1127.         {

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

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

  1130.         }

  1131. 

  1132.         if (aOuts > 0)

  1133.         {

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

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

  1136.         }

  1137. 

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

  1139.         {

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

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

  1142. 

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

  1144.             {

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

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

  1147. 

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

  1149.                 {

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

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

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

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

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

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

  1156.                 }

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

  1158.                 {

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

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

  1161.                 }

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

  1163.                 {

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

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

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

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

  1168.                 }

  1169.             }

  1170.         }

  1171. 

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

  1173.         {

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

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

  1176. 

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

  1178.             {

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

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

  1181. 

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

  1183.                 {

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

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

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

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

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

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

  1190.                 }

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

  1192.                 {

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

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

  1195.                 }

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

  1197.                 {

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

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

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

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

  1202.                 }

  1203.             }

  1204.         }

  1205. 

  1206.         if (params > 0)

  1207.         {

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

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

  1210.             paramBuffers = new float[params];

  1211.         }

  1212. 

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

  1214.         char portName[portNameSize];

  1215.         bool needsCtrlIn  = false;

  1216.         bool needsCtrlOut = false;

  1217. 

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

  1219.         {

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

  1221. 

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

  1223.             {

  1224. #ifndef BUILD_BRIDGE

  1225.                 if (carlaOptions.processMode != PROCESS_MODE_MULTIPLE_CLIENTS)

  1226.                 {

  1227.                     strcpy(portName, m_name);

  1228.                     strcat(portName, ":");

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

  1230.                 }

  1231.                 else

  1232. #endif

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

  1234.             }

  1235. 

  1236.             if (LV2_IS_PORT_AUDIO(portType))

  1237.             {

  1238.                 if (LV2_IS_PORT_INPUT(portType))

  1239.                 {

  1240.                     j = aIn.count++;

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

  1242.                     aIn.rindexes[j] = i;

  1243. 

  1244.                     if (forcedStereoIn)

  1245.                     {

  1246.                         strcat(portName, "_");

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

  1248.                         aIn.rindexes[1] = i;

  1249.                     }

  1250.                 }

  1251.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1252.                 {

  1253.                     j = aOut.count++;

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

  1255.                     aOut.rindexes[j] = i;

  1256.                     needsCtrlIn = true;

  1257. 

  1258.                     if (forcedStereoOut)

  1259.                     {

  1260.                         strcat(portName, "_");

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

  1262.                         aOut.rindexes[1] = i;

  1263.                     }

  1264.                 }

  1265.                 else

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

  1267.             }

  1268.             else if (LV2_IS_PORT_CV(portType))

  1269.             {

  1270.                 if (LV2_IS_PORT_INPUT(portType))

  1271.                 {

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

  1273.                 }

  1274.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1275.                 {

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

  1277.                 }

  1278.                 else

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

  1280. 

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

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

  1283.             }

  1284.             else if (LV2_IS_PORT_ATOM_SEQUENCE(portType))

  1285.             {

  1286.                 if (LV2_IS_PORT_INPUT(portType))

  1287.                 {

  1288.                     j = evIn.count++;

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

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

  1291. 

  1292.                     if (portType & LV2_PORT_SUPPORTS_MIDI_EVENT)

  1293.                     {

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

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

  1296.                     }

  1297.                     if (portType & LV2_PORT_SUPPORTS_PATCH_MESSAGE)

  1298.                     {

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

  1300.                     }

  1301.                 }

  1302.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1303.                 {

  1304.                     j = evOut.count++;

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

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

  1307. 

  1308.                     if (portType & LV2_PORT_SUPPORTS_MIDI_EVENT)

  1309.                     {

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

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

  1312.                     }

  1313.                     if (portType & LV2_PORT_SUPPORTS_PATCH_MESSAGE)

  1314.                     {

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

  1316.                     }

  1317.                 }

  1318.                 else

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

  1320.             }

  1321.             else if (LV2_IS_PORT_EVENT(portType))

  1322.             {

  1323.                 if (LV2_IS_PORT_INPUT(portType))

  1324.                 {

  1325.                     j = evIn.count++;

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

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

  1328. 

  1329.                     if (portType & LV2_PORT_SUPPORTS_MIDI_EVENT)

  1330.                     {

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

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

  1333.                     }

  1334.                 }

  1335.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1336.                 {

  1337.                     j = evOut.count++;

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

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

  1340. 

  1341.                     if (portType & LV2_PORT_SUPPORTS_MIDI_EVENT)

  1342.                     {

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

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

  1345.                     }

  1346.                 }

  1347.                 else

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

  1349.             }

  1350.             else if (LV2_IS_PORT_MIDI_LL(portType))

  1351.             {

  1352.                 if (LV2_IS_PORT_INPUT(portType))

  1353.                 {

  1354.                     j = evIn.count++;

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

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

  1357. 

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

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

  1360.                 }

  1361.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1362.                 {

  1363.                     j = evOut.count++;

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

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

  1366. 

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

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

  1369.                 }

  1370.                 else

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

  1372.             }

  1373.             else if (LV2_IS_PORT_CONTROL(portType))

  1374.             {

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

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

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

  1378. 

  1379.                 j = param.count++;

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

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

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

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

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

  1385. 

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

  1387. 

  1388.                 // min value

  1389.                 if (LV2_HAVE_MINIMUM_PORT_POINT(portPoints.Hints))

  1390.                     min = portPoints.Minimum;

  1391.                 else

  1392.                     min = 0.0;

  1393. 

  1394.                 // max value

  1395.                 if (LV2_HAVE_MAXIMUM_PORT_POINT(portPoints.Hints))

  1396.                     max = portPoints.Maximum;

  1397.                 else

  1398.                     max = 1.0;

  1399. 

  1400.                 if (min > max)

  1401.                     max = min;

  1402.                 else if (max < min)

  1403.                     min = max;

  1404. 

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

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

  1407.                 {

  1408.                     min = 0.0;

  1409.                     max = 16777215.0; // 0xffffff

  1410.                 }

  1411. 

  1412.                 if (max - min == 0.0)

  1413.                 {

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

  1415.                     max = min + 0.1;

  1416.                 }

  1417. 

  1418.                 // default value

  1419.                 if (LV2_HAVE_DEFAULT_PORT_POINT(portPoints.Hints))

  1420.                 {

  1421.                     def = portPoints.Default;

  1422.                 }

  1423.                 else

  1424.                 {

  1425.                     // no default value

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

  1427.                         def = 0.0;

  1428.                     else

  1429.                         def = min;

  1430.                 }

  1431. 

  1432.                 if (def < min)

  1433.                     def = min;

  1434.                 else if (def > max)

  1435.                     def = max;

  1436. 

  1437.                 if (LV2_IS_PORT_SAMPLE_RATE(portProps))

  1438.                 {

  1439.                     min *= sampleRate;

  1440.                     max *= sampleRate;

  1441.                     def *= sampleRate;

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

  1443.                 }

  1444. 

  1445.                 if (LV2_IS_PORT_TOGGLED(portProps))

  1446.                 {

  1447.                     step = max - min;

  1448.                     stepSmall = step;

  1449.                     stepLarge = step;

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

  1451.                 }

  1452.                 else if (LV2_IS_PORT_INTEGER(portProps))

  1453.                 {

  1454.                     step = 1.0;

  1455.                     stepSmall = 1.0;

  1456.                     stepLarge = 10.0;

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

  1458.                 }

  1459.                 else

  1460.                 {

  1461.                     double range = max - min;

  1462.                     step = range/100.0;

  1463.                     stepSmall = range/1000.0;

  1464.                     stepLarge = range/10.0;

  1465.                 }

  1466. 

  1467.                 if (LV2_IS_PORT_INPUT(portType))

  1468.                 {

  1469.                     if (LV2_IS_PORT_DESIGNATION_LATENCY(portDesignation))

  1470.                     {

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

  1472.                     }

  1473.                     else if (LV2_IS_PORT_DESIGNATION_SAMPLE_RATE(portDesignation))

  1474.                     {

  1475.                         def = sampleRate;

  1476.                         step = 1.0;

  1477.                         stepSmall = 1.0;

  1478.                         stepLarge = 1.0;

  1479. 

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

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

  1482.                     }

  1483.                     else if (LV2_IS_PORT_DESIGNATION_FREEWHEELING(portDesignation))

  1484.                     {

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

  1486.                     }

  1487.                     else if (LV2_IS_PORT_DESIGNATION_TIME(portDesignation))

  1488.                     {

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

  1490.                     }

  1491.                     else

  1492.                     {

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

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

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

  1496.                         needsCtrlIn = true;

  1497.                     }

  1498. 

  1499.                     // MIDI CC value

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

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

  1502.                     {

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

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

  1505.                     }

  1506.                 }

  1507.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1508.                 {

  1509.                     if (LV2_IS_PORT_DESIGNATION_LATENCY(portDesignation))

  1510.                     {

  1511.                         min = 0.0;

  1512.                         max = sampleRate;

  1513.                         def = 0.0;

  1514.                         step = 1.0;

  1515.                         stepSmall = 1.0;

  1516.                         stepLarge = 1.0;

  1517. 

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

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

  1520.                     }

  1521.                     else if (LV2_IS_PORT_DESIGNATION_SAMPLE_RATE(portDesignation))

  1522.                     {

  1523.                         def = sampleRate;

  1524.                         step = 1.0;

  1525.                         stepSmall = 1.0;

  1526.                         stepLarge = 1.0;

  1527. 

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

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

  1530.                     }

  1531.                     else if (LV2_IS_PORT_DESIGNATION_FREEWHEELING(portDesignation))

  1532.                     {

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

  1534.                     }

  1535.                     else if (LV2_IS_PORT_DESIGNATION_TIME(portDesignation))

  1536.                     {

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

  1538.                     }

  1539.                     else

  1540.                     {

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

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

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

  1544.                         needsCtrlOut = true;

  1545.                     }

  1546.                 }

  1547.                 else

  1548.                 {

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

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

  1551.                 }

  1552. 

  1553.                 // extra parameter hints

  1554.                 if (LV2_IS_PORT_ENUMERATION(portProps))

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

  1556. 

  1557.                 if (LV2_IS_PORT_LOGARITHMIC(portProps))

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

  1559. 

  1560.                 if (LV2_IS_PORT_TRIGGER(portProps))

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

  1562. 

  1563.                 if (LV2_IS_PORT_STRICT_BOUNDS(portProps))

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

  1565. 

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

  1567.                 if (LV2_IS_PORT_NOT_ON_GUI(portProps))

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

  1569. 

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

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

  1572. 

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

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

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

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

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

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

  1579. 

  1580.                 // Start parameters in their default values

  1581.                 paramBuffers[j] = def;

  1582. 

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

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

  1585.             }

  1586.             else

  1587.             {

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

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

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

  1591.             }

  1592.         }

  1593. 

  1594.         if (needsCtrlIn)

  1595.         {

  1596. #ifndef BUILD_BRIDGE

  1597.             if (carlaOptions.processMode != PROCESS_MODE_MULTIPLE_CLIENTS)

  1598.             {

  1599.                 strcpy(portName, m_name);

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

  1601.             }

  1602.             else

  1603. #endif

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

  1605. 

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

  1607.         }

  1608. 

  1609.         if (needsCtrlOut)

  1610.         {

  1611. #ifndef BUILD_BRIDGE

  1612.             if (carlaOptions.processMode != PROCESS_MODE_MULTIPLE_CLIENTS)

  1613.             {

  1614.                 strcpy(portName, m_name);

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

  1616.             }

  1617.             else

  1618. #endif

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

  1620. 

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

  1622.         }

  1623. 

  1624.         aIn.count   = aIns;

  1625.         aOut.count  = aOuts;

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

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

  1628.         param.count = params;

  1629. 

  1630.         // plugin checks

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

  1632. 

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

  1634.             m_hints |= PLUGIN_IS_SYNTH;

  1635. 

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

  1637.             m_hints |= PLUGIN_CAN_DRYWET;

  1638. 

  1639.         if (aOuts > 0)

  1640.             m_hints |= PLUGIN_CAN_VOLUME;

  1641. 

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

  1643.             m_hints |= PLUGIN_CAN_BALANCE;

  1644. 

  1645.         // check extensions

  1646.         ext.state      = nullptr;

  1647.         ext.worker     = nullptr;

  1648.         ext.programs   = nullptr;

  1649. 

  1650.         if (descriptor->extension_data)

  1651.         {

  1652.             if (m_hints & PLUGIN_HAS_EXTENSION_PROGRAMS)

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

  1654. 

  1655.             if (m_hints & PLUGIN_HAS_EXTENSION_STATE)

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

  1657. 

  1658.             if (m_hints & PLUGIN_HAS_EXTENSION_WORKER)

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

  1660.         }

  1661. 

  1662.         reloadPrograms(true);

  1663. 

  1664.         x_client->activate();

  1665. 

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

  1667.     }

  1668. 

  1669.     void reloadPrograms(const bool init)

  1670.     {

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

  1672.         uint32_t i, oldCount = midiprog.count;

  1673. 

  1674.         // Delete old programs

  1675.         if (midiprog.count > 0)

  1676.         {

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

  1678.             {

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

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

  1681.             }

  1682. 

  1683.             delete[] midiprog.data;

  1684.         }

  1685. 

  1686.         midiprog.count = 0;

  1687.         midiprog.data  = nullptr;

  1688. 

  1689.         // Query new programs

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

  1691.         {

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

  1693.                 midiprog.count += 1;

  1694.         }

  1695. 

  1696.         if (midiprog.count > 0)

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

  1698. 

  1699.         // Update data

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

  1701.         {

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

  1703.             Q_ASSERT(pdesc);

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

  1705.             Q_ASSERT(pdesc->name);

  1706. 

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

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

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

  1710.         }

  1711. 

  1712. #ifndef BUILD_BRIDGE

  1713.         // Update OSC Names

  1714.         if (x_engine->isOscControllerRegisted())

  1715.         {

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

  1717. 

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

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

  1720.         }

  1721. #endif

  1722. 

  1723.         if (init)

  1724.         {

  1725.             if (midiprog.count > 0)

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

  1727.         }

  1728.         else

  1729.         {

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

  1731. 

  1732.             // Check if current program is invalid

  1733.             bool programChanged = false;

  1734. 

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

  1736.             {

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

  1738.                 midiprog.current = oldCount;

  1739.                 programChanged   = true;

  1740.             }

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

  1742.             {

  1743.                 // current midi program > count

  1744.                 midiprog.current = 0;

  1745.                 programChanged   = true;

  1746.             }

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

  1748.             {

  1749.                 // programs exist now, but not before

  1750.                 midiprog.current = 0;

  1751.                 programChanged   = true;

  1752.             }

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

  1754.             {

  1755.                 // programs existed before, but not anymore

  1756.                 midiprog.current = -1;

  1757.                 programChanged   = true;

  1758.             }

  1759. 

  1760.             if (programChanged)

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

  1762.         }

  1763.     }

  1764. 

  1765.     void prepareForSave()

  1766.     {

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

  1768.         {

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

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

  1771.         }

  1772.     }

  1773. 

  1774.     // -------------------------------------------------------------------

  1775.     // Plugin processing

  1776. 

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

  1778.     {

  1779.         uint32_t i, k;

  1780.         uint32_t midiEventCount = 0;

  1781. 

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

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

  1784. 

  1785.         // handle midi from different APIs

  1786.         uint32_t evInAtomOffsets[evIn.count];

  1787.         LV2_Event_Iterator evInEventIters[evIn.count];

  1788.         LV2_MIDIState evInMidiStates[evIn.count];

  1789. 

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

  1791.         {

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

  1793.             {

  1794.                 evInAtomOffsets[i] = 0;

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

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

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

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

  1799.             }

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

  1801.             {

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

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

  1804.             }

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

  1806.             {

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

  1808.                 evInMidiStates[i].frame_count = frames;

  1809.                 evInMidiStates[i].position = 0;

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

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

  1812.             }

  1813.         }

  1814. 

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

  1816.         {

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

  1818.             {

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

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

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

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

  1823.             }

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

  1825.             {

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

  1827.             }

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

  1829.             {

  1830.                 // not needed

  1831.             }

  1832.         }

  1833. 

  1834.         CARLA_PROCESS_CONTINUE_CHECK;

  1835. 

  1836.         // --------------------------------------------------------------------------------------------------------

  1837.         // Input VU

  1838. 

  1839.         if (aIn.count > 0)

  1840.         {

  1841.             if (aIn.count == 1)

  1842.             {

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

  1844.                 {

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

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

  1847.                 }

  1848.             }

  1849.             else if (aIn.count > 1)

  1850.             {

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

  1852.                 {

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

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

  1855. 

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

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

  1858.                 }

  1859.             }

  1860.         }

  1861. 

  1862.         CARLA_PROCESS_CONTINUE_CHECK;

  1863. 

  1864.         // --------------------------------------------------------------------------------------------------------

  1865.         // Parameters Input [Automation]

  1866. 

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

  1868.         {

  1869.             bool allNotesOffSent = false;

  1870. 

  1871.             const CarlaEngineControlEvent* cinEvent;

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

  1873. 

  1874.             uint32_t nextBankId = 0;

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

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

  1877. 

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

  1879.             {

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

  1881. 

  1882.                 if (! cinEvent)

  1883.                     continue;

  1884. 

  1885.                 time = cinEvent->time - framesOffset;

  1886. 

  1887.                 if (time >= frames)

  1888.                     continue;

  1889. 

  1890.                 // Control change

  1891.                 switch (cinEvent->type)

  1892.                 {

  1893.                 case CarlaEngineEventNull:

  1894.                     break;

  1895. 

  1896.                 case CarlaEngineEventControlChange:

  1897.                 {

  1898.                     double value;

  1899. 

  1900.                     // Control backend stuff

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

  1902.                     {

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

  1904.                         {

  1905.                             value = cinEvent->value;

  1906.                             setDryWet(value, false, false);

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

  1908.                             continue;

  1909.                         }

  1910. 

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

  1912.                         {

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

  1914.                             setVolume(value, false, false);

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

  1916.                             continue;

  1917.                         }

  1918. 

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

  1920.                         {

  1921.                             double left, right;

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

  1923. 

  1924.                             if (value < 0.0)

  1925.                             {

  1926.                                 left  = -1.0;

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

  1928.                             }

  1929.                             else if (value > 0.0)

  1930.                             {

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

  1932.                                 right = 1.0;

  1933.                             }

  1934.                             else

  1935.                             {

  1936.                                 left  = -1.0;

  1937.                                 right = 1.0;

  1938.                             }

  1939. 

  1940.                             setBalanceLeft(left, false, false);

  1941.                             setBalanceRight(right, false, false);

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

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

  1944.                             continue;

  1945.                         }

  1946.                     }

  1947. 

  1948.                     // Control plugin parameters

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

  1950.                     {

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

  1952.                             continue;

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

  1954.                             continue;

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

  1956.                             continue;

  1957. 

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

  1959.                         {

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

  1961.                             {

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

  1963.                             }

  1964.                             else

  1965.                             {

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

  1967. 

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

  1969.                                     value = rint(value);

  1970.                             }

  1971. 

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

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

  1974.                         }

  1975.                     }

  1976. 

  1977.                     break;

  1978.                 }

  1979. 

  1980.                 case CarlaEngineEventMidiBankChange:

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

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

  1983.                     break;

  1984. 

  1985.                 case CarlaEngineEventMidiProgramChange:

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

  1987.                     {

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

  1989. 

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

  1991.                         {

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

  1993.                             {

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

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

  1996.                                 break;

  1997.                             }

  1998.                         }

  1999.                     }

  2000.                     break;

  2001. 

  2002.                 case CarlaEngineEventAllSoundOff:

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

  2004.                     {

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

  2006.                             sendMidiAllNotesOff();

  2007. 

  2008.                         if (descriptor->deactivate)

  2009.                         {

  2010.                             descriptor->deactivate(handle);

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

  2012.                         }

  2013. 

  2014.                         if (descriptor->activate)

  2015.                         {

  2016.                             descriptor->activate(handle);

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

  2018.                         }

  2019. 

  2020.                         allNotesOffSent = true;

  2021.                     }

  2022.                     break;

  2023. 

  2024.                 case CarlaEngineEventAllNotesOff:

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

  2026.                     {

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

  2028.                             sendMidiAllNotesOff();

  2029. 

  2030.                         allNotesOffSent = true;

  2031.                     }

  2032.                     break;

  2033.                 }

  2034.             }

  2035.         } // End of Parameters Input

  2036. 

  2037.         CARLA_PROCESS_CONTINUE_CHECK;

  2038. 

  2039.         // --------------------------------------------------------------------------------------------------------

  2040.         // MIDI Input

  2041. 

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

  2043.         {

  2044.             // ----------------------------------------------------------------------------------------------------

  2045.             // MIDI Input (External)

  2046. 

  2047.             {

  2048.                 engineMidiLock();

  2049. 

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

  2051.                 {

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

  2053.                         break;

  2054. 

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

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

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

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

  2059. 

  2060.                     // send to all midi inputs

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

  2062.                     {

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

  2064.                         {

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

  2066.                             {

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

  2068.                                 aev->time.frames = 0;

  2069.                                 aev->body.type   = CARLA_URI_MAP_ID_MIDI_EVENT;

  2070.                                 aev->body.size   = 3;

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

  2072. 

  2073.                                 const uint32_t padSize = lv2_atom_pad_size(sizeof(LV2_Atom_Event) + 3);

  2074.                                 evInAtomOffsets[k]           += padSize;

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

  2076.                             }

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

  2078.                             {

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

  2080.                             }

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

  2082.                             {

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

  2084.                             }

  2085.                         }

  2086.                     }

  2087. 

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

  2089.                     midiEventCount += 1;

  2090.                 }

  2091. 

  2092.                 engineMidiUnlock();

  2093. 

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

  2095. 

  2096.             CARLA_PROCESS_CONTINUE_CHECK;

  2097. 

  2098.             // ----------------------------------------------------------------------------------------------------

  2099.             // MIDI Input (System)

  2100. 

  2101.             {

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

  2103.                 {

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

  2105.                         continue;

  2106. 

  2107.                     const CarlaEngineMidiEvent* minEvent;

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

  2109. 

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

  2111.                     {

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

  2113. 

  2114.                         if (! minEvent)

  2115.                             continue;

  2116. 

  2117.                         time = minEvent->time - framesOffset;

  2118. 

  2119.                         if (time >= frames)

  2120.                             continue;

  2121. 

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

  2123.                         uint8_t channel = status & 0x0F;

  2124. 

  2125.                         // Fix bad note-off

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

  2127.                             status -= 0x10;

  2128. 

  2129.                         // only write supported status types

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

  2131.                         {

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

  2133.                             {

  2134.                                 LV2_Atom_Event* const aev = (LV2_Atom_Event*)((char*)LV2_ATOM_CONTENTS(LV2_Atom_Sequence, evIn.data[i].atom) + evInAtomOffsets[i]);

  2135.                                 aev->time.frames = time;

  2136.                                 aev->body.type   = CARLA_URI_MAP_ID_MIDI_EVENT;

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

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

  2139. 

  2140.                                 const uint32_t padSize = lv2_atom_pad_size(sizeof(LV2_Atom_Event) + minEvent->size);

  2141.                                 evInAtomOffsets[i]           += padSize;

  2142.                                 evIn.data[i].atom->atom.size += padSize;

  2143.                             }

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

  2145.                             {

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

  2147.                             }

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

  2149.                             {

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

  2151.                             }

  2152. 

  2153.                             if (MIDI_IS_STATUS_NOTE_OFF(status))

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

  2155.                             else if (MIDI_IS_STATUS_NOTE_ON(status))

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

  2157.                         }

  2158. 

  2159.                         midiEventCount += 1;

  2160.                     }

  2161.                 }

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

  2163. 

  2164.         } // End of MIDI Input

  2165. 

  2166.         CARLA_PROCESS_CONTINUE_CHECK;

  2167. 

  2168.         // --------------------------------------------------------------------------------------------------------

  2169.         // Special Parameters

  2170. 

  2171.         {

  2172.             int32_t rindex;

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

  2174. 

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

  2176.             {

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

  2178.                 {

  2179.                     // TODO

  2180.                 }

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

  2182.                 {

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

  2184.                 }

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

  2186.                 {

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

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

  2189. 

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

  2191.                     {

  2192.                     case LV2_PORT_DESIGNATION_TIME_BAR:

  2193.                         if (timeInfo->valid & CarlaEngineTimeBBT)

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

  2195.                         break;

  2196.                     case LV2_PORT_DESIGNATION_TIME_BAR_BEAT:

  2197.                         if (timeInfo->valid & CarlaEngineTimeBBT)

  2198.                             setParameterValue(k, timeInfo->bbt.tick, false, false, false);

  2199.                         break;

  2200.                     case LV2_PORT_DESIGNATION_TIME_BEAT:

  2201.                         if (timeInfo->valid & CarlaEngineTimeBBT)

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

  2203.                         break;

  2204.                     case LV2_PORT_DESIGNATION_TIME_BEAT_UNIT:

  2205.                         if (timeInfo->valid & CarlaEngineTimeBBT)

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

  2207.                         break;

  2208.                     case LV2_PORT_DESIGNATION_TIME_BEATS_PER_BAR:

  2209.                         if (timeInfo->valid & CarlaEngineTimeBBT)

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

  2211.                         break;

  2212.                     case LV2_PORT_DESIGNATION_TIME_BEATS_PER_MINUTE:

  2213.                         if (timeInfo->valid & CarlaEngineTimeBBT)

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

  2215.                         break;

  2216. 

  2217.                     case LV2_PORT_DESIGNATION_TIME_FRAME:

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

  2219.                         break;

  2220.                     case LV2_PORT_DESIGNATION_TIME_FRAMES_PER_SECOND:

  2221.                         break;

  2222.                     case LV2_PORT_DESIGNATION_TIME_POSITION:

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

  2224.                         break;

  2225.                     case LV2_PORT_DESIGNATION_TIME_SPEED:

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

  2227.                         break;

  2228.                     }

  2229.                 }

  2230.             }

  2231.         }

  2232. 

  2233.         CARLA_PROCESS_CONTINUE_CHECK;

  2234. 

  2235.         // --------------------------------------------------------------------------------------------------------

  2236.         // Plugin processing

  2237. 

  2238.         if (m_active)

  2239.         {

  2240.             if (! m_activeBefore)

  2241.             {

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

  2243.                 {

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

  2245.                     midiEvent1[0] = MIDI_STATUS_CONTROL_CHANGE + m_ctrlInChannel;

  2246.                     midiEvent1[1] = MIDI_CONTROL_ALL_SOUND_OFF;

  2247. 

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

  2249.                     midiEvent2[0] = MIDI_STATUS_CONTROL_CHANGE + m_ctrlInChannel;

  2250.                     midiEvent2[1] = MIDI_CONTROL_ALL_SOUND_OFF;

  2251. 

  2252.                     // send to all midi inputs

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

  2254.                     {

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

  2256.                         {

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

  2258.                             {

  2259.                                 // all sound off

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

  2261.                                 aev1->time.frames = 0;

  2262.                                 aev1->body.type   = CARLA_URI_MAP_ID_MIDI_EVENT;

  2263.                                 aev1->body.size   = 2;

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

  2265. 

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

  2267.                                 evInAtomOffsets[k]           += padSize;

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

  2269. 

  2270.                                 // all notes off

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

  2272.                                 aev2->time.frames = 0;

  2273.                                 aev2->body.type   = CARLA_URI_MAP_ID_MIDI_EVENT;

  2274.                                 aev2->body.size   = 2;

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

  2276. 

  2277.                                 evInAtomOffsets[k]           += padSize;

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

  2279.                             }

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

  2281.                             {

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

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

  2284.                             }

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

  2286.                             {

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

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

  2289.                             }

  2290.                         }

  2291.                     }

  2292. 

  2293.                     midiEventCount = 2;

  2294.                 }

  2295. 

  2296.                 if (descriptor->activate)

  2297.                 {

  2298.                     descriptor->activate(handle);

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

  2300.                 }

  2301.             }

  2302. 

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

  2304.             {

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

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

  2307.             }

  2308. 

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

  2310.             {

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

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

  2313.             }

  2314. 

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

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

  2317. 

  2318.             if (ext.worker)

  2319.             {

  2320.                 // TODO

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

  2322. 

  2323.                 if (ext.worker->end_run)

  2324.                 {

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

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

  2327.                 }

  2328.             }

  2329.         }

  2330.         else

  2331.         {

  2332.             if (m_activeBefore)

  2333.             {

  2334.                 if (descriptor->deactivate)

  2335.                 {

  2336.                     descriptor->deactivate(handle);

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

  2338.                 }

  2339.             }

  2340.         }

  2341. 

  2342.         CARLA_PROCESS_CONTINUE_CHECK;

  2343. 

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

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

  2346. 

  2347.         if (m_active)

  2348.         {

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

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

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

  2352. 

  2353.             double bal_rangeL, bal_rangeR;

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

  2355. 

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

  2357.             {

  2358.                 // Dry/Wet

  2359.                 if (do_drywet)

  2360.                 {

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

  2362.                     {

  2363.                         if (aOut.count == 1)

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

  2365.                         else

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

  2367.                     }

  2368.                 }

  2369. 

  2370.                 // Balance

  2371.                 if (do_balance)

  2372.                 {

  2373.                     if (i%2 == 0)

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

  2375. 

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

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

  2378. 

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

  2380.                     {

  2381.                         if (i%2 == 0)

  2382.                         {

  2383.                             // left output

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

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

  2386.                         }

  2387.                         else

  2388.                         {

  2389.                             // right

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

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

  2392.                         }

  2393.                     }

  2394.                 }

  2395. 

  2396.                 // Volume

  2397.                 if (do_volume)

  2398.                 {

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

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

  2401.                 }

  2402. 

  2403.                 // Output VU

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

  2405.                 {

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

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

  2408.                 }

  2409.             }

  2410.         }

  2411.         else

  2412.         {

  2413.             // disable any output sound if not active

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

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

  2416. 

  2417.             aOutsPeak[0] = 0.0;

  2418.             aOutsPeak[1] = 0.0;

  2419. 

  2420.         } // End of Post-processing

  2421. 

  2422.         CARLA_PROCESS_CONTINUE_CHECK;

  2423. 

  2424.         // --------------------------------------------------------------------------------------------------------

  2425.         // Control Output

  2426. 

  2427.         if (param.portCout && m_active)

  2428.         {

  2429.             double value;

  2430. 

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

  2432.             {

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

  2434.                 {

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

  2436. 

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

  2438.                     {

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

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

  2441.                     }

  2442.                 }

  2443.             }

  2444.         } // End of Control Output

  2445. 

  2446.         CARLA_PROCESS_CONTINUE_CHECK;

  2447. 

  2448.         // --------------------------------------------------------------------------------------------------------

  2449.         // MIDI Output

  2450. 

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

  2452.         {

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

  2454.             {

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

  2456.                     continue;

  2457. 

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

  2459.                 {

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

  2461.                     uint32_t offset = 0;

  2462. 

  2463.                     while (offset < size)

  2464.                     {

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

  2466. 

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

  2468.                             break;

  2469. 

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

  2471.                         {

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

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

  2474.                         }

  2475. 

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

  2477.                     }

  2478.                 }

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

  2480.                 {

  2481.                     const LV2_Event* ev;

  2482.                     LV2_Event_Iterator iter;

  2483. 

  2484.                     uint8_t* data;

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

  2486. 

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

  2488.                     {

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

  2490. 

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

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

  2493. 

  2494.                         lv2_event_increment(&iter);

  2495.                     }

  2496.                 }

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

  2498.                 {

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

  2500. 

  2501.                     uint32_t eventSize;

  2502.                     double   eventTime;

  2503.                     unsigned char* eventData;

  2504. 

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

  2506.                     {

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

  2508.                         lv2midi_step(&state);

  2509.                     }

  2510.                 }

  2511.             }

  2512.         } // End of MIDI Output

  2513. 

  2514.         CARLA_PROCESS_CONTINUE_CHECK;

  2515. 

  2516.         // --------------------------------------------------------------------------------------------------------

  2517.         // Peak Values

  2518. 

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

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

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

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

  2523. 

  2524.         m_activeBefore = m_active;

  2525.     }

  2526. 

  2527.     void bufferSizeChanged(const uint32_t newBufferSize)

  2528.     {

  2529.         lv2Options.bufferSize = newBufferSize;

  2530.     }

  2531. 

  2532.     // -------------------------------------------------------------------

  2533.     // Post-poned events

  2534. 

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

  2536.     {

  2537.         Q_ASSERT(index < param.count);

  2538. 

  2539.         if (index >= param.count)

  2540.             return;

  2541. 

  2542. #ifndef BUILD_BRIDGE

  2543.         if (gui.type == GUI_EXTERNAL_OSC)

  2544.         {

  2545.             if (osc.data.target)

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

  2547.         }

  2548.         else

  2549. #endif

  2550.         {

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

  2552.             {

  2553.                 float valueF = value;

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

  2555.             }

  2556.         }

  2557.     }

  2558. 

  2559.     void uiMidiProgramChange(const uint32_t index)

  2560.     {

  2561.         Q_ASSERT(index < midiprog.count);

  2562. 

  2563.         if (index >= midiprog.count)

  2564.             return;

  2565. 

  2566. #ifndef BUILD_BRIDGE

  2567.         if (gui.type == GUI_EXTERNAL_OSC)

  2568.         {

  2569.             if (osc.data.target)

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

  2571.         }

  2572.         else

  2573. #endif

  2574.         {

  2575.             if (ext.uiprograms)

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

  2577.         }

  2578.     }

  2579. 

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

  2581.     {

  2582.         Q_ASSERT(channel < 16);

  2583.         Q_ASSERT(note < 128);

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

  2585. 

  2586. #ifndef BUILD_BRIDGE

  2587.         if (gui.type == GUI_EXTERNAL_OSC)

  2588.         {

  2589.             if (osc.data.target)

  2590.             {

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

  2592.                 midiData[1] = MIDI_STATUS_NOTE_ON + channel;

  2593.                 midiData[2] = note;

  2594.                 midiData[3] = velo;

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

  2596.             }

  2597.         }

  2598.         else

  2599. #endif

  2600.         {

  2601.             uiTransferAtom(); // TODO

  2602.         }

  2603.     }

  2604. 

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

  2606.     {

  2607.         Q_ASSERT(channel < 16);

  2608.         Q_ASSERT(note < 128);

  2609. 

  2610. #ifndef BUILD_BRIDGE

  2611.         if (gui.type == GUI_EXTERNAL_OSC)

  2612.         {

  2613.             if (osc.data.target)

  2614.             {

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

  2616.                 midiData[1] = MIDI_STATUS_NOTE_OFF + channel;

  2617.                 midiData[2] = note;

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

  2619.             }

  2620.         }

  2621.         else

  2622. #endif

  2623.         {

  2624.             uiTransferAtom(); // TODO

  2625.         }

  2626.     }

  2627. 

  2628.     // -------------------------------------------------------------------

  2629.     // Cleanup

  2630. 

  2631.     void removeClientPorts()

  2632.     {

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

  2634. 

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

  2636.         {

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

  2638.             {

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

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

  2641.             }

  2642.         }

  2643. 

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

  2645.         {

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

  2647.             {

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

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

  2650.             }

  2651.         }

  2652. 

  2653.         CarlaPlugin::removeClientPorts();

  2654. 

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

  2656.     }

  2657. 

  2658.     void initBuffers()

  2659.     {

  2660.         uint32_t i;

  2661. 

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

  2663.         {

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

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

  2666.         }

  2667. 

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

  2669.         {

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

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

  2672.         }

  2673. 

  2674.         CarlaPlugin::initBuffers();

  2675.     }

  2676. 

  2677.     void deleteBuffers()

  2678.     {

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

  2680. 

  2681.         if (evIn.count > 0)

  2682.         {

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

  2684.             {

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

  2686.                 {

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

  2688.                 }

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

  2690.                 {

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

  2692.                 }

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

  2694.                 {

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

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

  2697.                 }

  2698.             }

  2699. 

  2700.             delete[] evIn.data;

  2701.         }

  2702. 

  2703.         if (evOut.count > 0)

  2704.         {

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

  2706.             {

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

  2708.                 {

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

  2710.                 }

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

  2712.                 {

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

  2714.                 }

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

  2716.                 {

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

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

  2719.                 }

  2720.             }

  2721. 

  2722.             delete[] evOut.data;

  2723.         }

  2724. 

  2725.         if (param.count > 0)

  2726.             delete[] paramBuffers;

  2727. 

  2728.         evIn.count = 0;

  2729.         evIn.data  = nullptr;

  2730. 

  2731.         evOut.count = 0;

  2732.         evOut.data  = nullptr;

  2733. 

  2734.         paramBuffers = nullptr;

  2735. 

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

  2737.     }

  2738. 

  2739.     // -------------------------------------------------------------------

  2740. 

  2741.     uint32_t getCustomURID(const char* const uri)

  2742.     {

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

  2744.         Q_ASSERT(uri);

  2745. 

  2746.         if (! uri)

  2747.             return CARLA_URI_MAP_ID_NULL;

  2748. 

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

  2750.         {

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

  2752.                 return i;

  2753.         }

  2754. 

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

  2756. 

  2757.         return customURIDs.size()-1;

  2758.     }

  2759. 

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

  2761.     {

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

  2763.         Q_ASSERT(urid > CARLA_URI_MAP_ID_NULL);

  2764. 

  2765.         if (urid == CARLA_URI_MAP_ID_NULL)

  2766.             return nullptr;

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

  2768.             return customURIDs[urid];

  2769. 

  2770.         return nullptr;

  2771.     }

  2772. 

  2773.     // -------------------------------------------------------------------

  2774. 

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

  2776.     {

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

  2778.         Q_ASSERT(atom);

  2779.         Q_ASSERT(stype);

  2780. 

  2781.         // TODO

  2782.     }

  2783. 

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

  2785.     {

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

  2787.         Q_ASSERT(atom);

  2788.         Q_ASSERT(stype);

  2789. 

  2790.         const LV2_URID uridAtomBlank = getCustomURID(LV2_ATOM__Blank);

  2791.         const LV2_URID uridPatchBody = getCustomURID(LV2_PATCH__body);

  2792.         const LV2_URID uridPatchSet  = getCustomURID(LV2_PATCH__Set);

  2793. 

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

  2795.         {

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

  2797.             return;

  2798.         }

  2799. 

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

  2801. 

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

  2803.         {

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

  2805.             return;

  2806.         }

  2807. 

  2808.         const LV2_Atom_Object* body = nullptr;

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

  2810. 

  2811.         if (! body)

  2812.         {

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

  2814.             return;

  2815.         }

  2816. 

  2817.         LV2_ATOM_OBJECT_FOREACH(body, iter)

  2818.         {

  2819.             CustomDataType dtype  = CUSTOM_DATA_INVALID;

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

  2821.             const char* value     = nullptr;

  2822. 

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

  2824.             {

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

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

  2827.             }

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

  2829.             {

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

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

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

  2833.             }

  2834.             else

  2835.                 value = strdup("");

  2836. 

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

  2838. 

  2839.             free((void*)value);

  2840.         }

  2841.     }

  2842. 

  2843.     // -------------------------------------------------------------------

  2844. 

  2845.     void handleProgramChanged(const int32_t index)

  2846.     {

  2847.         if (index == -1)

  2848.         {

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

  2850.             reloadPrograms(false);

  2851.         }

  2852.         else

  2853.         {

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

  2855.             {

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

  2857.                 Q_ASSERT(progName);

  2858. 

  2859.                 if (prog.names[index])

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

  2861. 

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

  2863.             }

  2864.         }

  2865. 

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

  2867.     }

  2868. 

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

  2870.     {

  2871.         Q_ASSERT(key > 0);

  2872.         Q_ASSERT(value);

  2873. 

  2874.         CustomDataType dtype;

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

  2876. 

  2877.         if (type == CARLA_URI_MAP_ID_ATOM_CHUNK)

  2878.             dtype = CUSTOM_DATA_CHUNK;

  2879.         else if (type == CARLA_URI_MAP_ID_ATOM_PATH)

  2880.             dtype = CUSTOM_DATA_PATH;

  2881.         else if (type == CARLA_URI_MAP_ID_ATOM_STRING)

  2882.             dtype = CUSTOM_DATA_STRING;

  2883.         else if (type >= CARLA_URI_MAP_ID_COUNT)

  2884.             dtype = CUSTOM_DATA_BINARY;

  2885.         else

  2886.             dtype = CUSTOM_DATA_INVALID;

  2887. 

  2888.         // do basic checks

  2889.         if (! uriKey)

  2890.         {

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

  2892.             return LV2_STATE_ERR_NO_PROPERTY;

  2893.         }

  2894. 

  2895.         if (! flags & LV2_STATE_IS_POD)

  2896.         {

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

  2898.             return LV2_STATE_ERR_BAD_FLAGS;

  2899.         }

  2900. 

  2901.         if (dtype == CUSTOM_DATA_INVALID)

  2902.         {

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

  2904.             return LV2_STATE_ERR_BAD_TYPE;

  2905.         }

  2906. 

  2907.         // Check if we already have this key

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

  2909.         {

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

  2911.             {

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

  2913. 

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

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

  2916.                 else

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

  2918. 

  2919.                 return LV2_STATE_SUCCESS;

  2920.             }

  2921.         }

  2922. 

  2923.         // Otherwise store it

  2924.         CustomData newData;

  2925.         newData.type = dtype;

  2926.         newData.key  = strdup(uriKey);

  2927. 

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

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

  2930.         else

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

  2932. 

  2933.         custom.push_back(newData);

  2934. 

  2935.         return LV2_STATE_SUCCESS;

  2936.     }

  2937. 

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

  2939.     {

  2940.         Q_ASSERT(key > CARLA_URI_MAP_ID_NULL);

  2941. 

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

  2943. 

  2944.         if (! uriKey)

  2945.         {

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

  2947.             return nullptr;

  2948.         }

  2949. 

  2950.         const char* stringData = nullptr;

  2951.         CustomDataType dtype = CUSTOM_DATA_INVALID;

  2952. 

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

  2954.         {

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

  2956.             {

  2957.                 dtype      = custom[i].type;

  2958.                 stringData = custom[i].value;

  2959.                 break;

  2960.             }

  2961.         }

  2962. 

  2963.         if (! stringData)

  2964.         {

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

  2966.             return nullptr;

  2967.         }

  2968. 

  2969.         *size  = 0;

  2970.         *type  = 0;

  2971.         *flags = LV2_STATE_IS_POD;

  2972. 

  2973.         if (dtype == CUSTOM_DATA_STRING)

  2974.         {

  2975.             *size = strlen(stringData);

  2976.             *type = CARLA_URI_MAP_ID_ATOM_STRING;

  2977.             return stringData;

  2978.         }

  2979.         if (dtype == CUSTOM_DATA_PATH)

  2980.         {

  2981.             *size = strlen(stringData);

  2982.             *type = CARLA_URI_MAP_ID_ATOM_PATH;

  2983.             return stringData;

  2984.         }

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

  2986.         {

  2987.             static QByteArray chunk;

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

  2989. 

  2990.             *size = chunk.size();

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

  2992.             return chunk.constData();

  2993.         }

  2994. 

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

  2996.         return nullptr;

  2997.     }

  2998. 

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

  3000.     {

  3001.         // TODO

  3002.         return LV2_WORKER_SUCCESS;

  3003.     }

  3004. 

  3005.     LV2_Worker_Status handleWorkerRespond(const uint32_t /*size*/, const void* const /*data*/)

  3006.     {

  3007.         // TODO

  3008.         if (ext.worker)

  3009.             return LV2_WORKER_SUCCESS;

  3010. 

  3011.         return LV2_WORKER_ERR_UNKNOWN;

  3012.     }

  3013. 

  3014.     void handleExternalUiClosed()

  3015.     {

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

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

  3018. 

  3019.         ui.handle = nullptr;

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

  3021.     }

  3022. 

  3023.     uint32_t handleUiPortMap(const char* const symbol)

  3024.     {

  3025.         Q_ASSERT(symbol);

  3026. 

  3027.         if (! symbol)

  3028.             return LV2UI_INVALID_PORT_INDEX;

  3029. 

  3030.         for (uint32_t i=0; i < rdf_descriptor->PortCount; i++)

  3031.         {

  3032.             if (strcmp(rdf_descriptor->Ports[i].Symbol, symbol) == 0)

  3033.                 return i;

  3034.         }

  3035. 

  3036.         return LV2UI_INVALID_PORT_INDEX;

  3037.     }

  3038. 

  3039.     int handleUiResize(const int width, const int height)

  3040.     {

  3041.         Q_ASSERT(width > 0);

  3042.         Q_ASSERT(height > 0);

  3043. 

  3044.         if (width <= 0 || height <= 0)

  3045.             return 1;

  3046. 

  3047.         gui.width  = width;

  3048.         gui.height = height;

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

  3050. 

  3051.         return 0;

  3052.     }

  3053. 

  3054.     void handleUiWrite(const uint32_t rindex, const uint32_t bufferSize, const uint32_t format, const void* const buffer)

  3055.     {

  3056.         if (format == 0)

  3057.         {

  3058.             Q_ASSERT(buffer);

  3059.             Q_ASSERT(bufferSize == sizeof(float));

  3060. 

  3061.             float value = *(float*)buffer;

  3062. 

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

  3064.             {

  3065.                 if (param.data[i].rindex == (int32_t)rindex)

  3066.                     return setParameterValue(i, value, false, true, true);

  3067.             }

  3068.         }

  3069.         else if (format == CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM)

  3070.         {

  3071.             Q_ASSERT(buffer);

  3072. 

  3073.             const LV2_Atom* const atom = (const LV2_Atom*)buffer;

  3074.             handleTransferAtom(atom, getCustomURIString(atom->type));

  3075. 

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

  3077.                 ui.descriptor->port_event(ui.handle, 0, atom->size, CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM, atom);

  3078.         }

  3079.         else if (format == CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT)

  3080.         {

  3081.             Q_ASSERT(buffer);

  3082. 

  3083.             const LV2_Atom* const atom = (const LV2_Atom*)buffer;

  3084.             handleTransferEvent(atom, getCustomURIString(atom->type));

  3085. 

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

  3087.                 ui.descriptor->port_event(ui.handle, 0, atom->size, CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT, atom);

  3088.         }

  3089.     }

  3090. 

  3091.     // -------------------------------------------------------------------

  3092. 

  3093. #ifndef BUILD_BRIDGE

  3094.     bool isUiBridgeable(const uint32_t uiId)

  3095.     {

  3096.         Q_ASSERT(rdf_descriptor);

  3097.         Q_ASSERT(uiId < rdf_descriptor->UICount);

  3098. 

  3099.         if (uiId >= rdf_descriptor->UICount)

  3100.             return false;

  3101. 

  3102.         const LV2_RDF_UI* const rdf_ui = &rdf_descriptor->UIs[uiId];

  3103. 

  3104.         for (uint32_t i=0; i < rdf_ui->FeatureCount; i++)

  3105.         {

  3106.             if (strcmp(rdf_ui->Features[i].URI, LV2_INSTANCE_ACCESS_URI) == 0 || strcmp(rdf_ui->Features[i].URI, LV2_DATA_ACCESS_URI) == 0)

  3107.                 return false;

  3108.         }

  3109. 

  3110.         return true;

  3111.     }

  3112. #endif

  3113. 

  3114.     bool isUiResizable()

  3115.     {

  3116.         Q_ASSERT(ui.rdf_descriptor);

  3117. 

  3118.         if (! ui.rdf_descriptor)

  3119.             return false;

  3120. 

  3121.         for (uint32_t i=0; i < ui.rdf_descriptor->FeatureCount; i++)

  3122.         {

  3123.             if (strcmp(ui.rdf_descriptor->Features[i].URI, LV2_UI__fixedSize) == 0 || strcmp(ui.rdf_descriptor->Features[i].URI, LV2_UI__noUserResize) == 0)

  3124.                 return false;

  3125.         }

  3126. 

  3127.         return true;

  3128.     }

  3129. 

  3130.     void initExternalUi()

  3131.     {

  3132.         qDebug("Lv2Plugin::initExternalUi()");

  3133. 

  3134.         ui.widget = nullptr;

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

  3136. 

  3137.         if (ui.handle && ui.widget)

  3138.         {

  3139.             updateUi();

  3140.         }

  3141.         else

  3142.         {

  3143.             qWarning("Lv2Plugin::initExternalUi() - failed to instantiate UI");

  3144.             ui.handle = nullptr;

  3145.             ui.widget = nullptr;

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

  3147.         }

  3148.     }

  3149. 

  3150.     void uiTransferAtom()

  3151.     {

  3152.         // TODO

  3153.     }

  3154. 

  3155.     void uiTransferEvent(const CustomData* const cdata)

  3156.     {

  3157.         if (cdata->type == CUSTOM_DATA_INVALID || ! ui.descriptor->port_event)

  3158.             return;

  3159. 

  3160.         LV2_URID_Map* const URID_Map = (LV2_URID_Map*)features[lv2_feature_id_urid_map]->data;

  3161.         const LV2_URID uridPatchSet  = getCustomURID(LV2_PATCH__Set);

  3162.         const LV2_URID uridPatchBody = getCustomURID(LV2_PATCH__body);

  3163. 

  3164.         Sratom* const sratom = sratom_new(URID_Map);

  3165.         SerdChunk     chunk  = { nullptr, 0 };

  3166. 

  3167.         LV2_Atom_Forge forge;

  3168.         lv2_atom_forge_init(&forge, URID_Map);

  3169.         lv2_atom_forge_set_sink(&forge, sratom_forge_sink, sratom_forge_deref, &chunk);

  3170. 

  3171.         LV2_Atom_Forge_Frame refFrame, bodyFrame;

  3172.         LV2_Atom_Forge_Ref   ref = lv2_atom_forge_blank(&forge, &refFrame, 1, uridPatchSet);

  3173. 

  3174.         lv2_atom_forge_property_head(&forge, uridPatchBody, CARLA_URI_MAP_ID_NULL);

  3175.         lv2_atom_forge_blank(&forge, &bodyFrame, 2, CARLA_URI_MAP_ID_NULL);

  3176. 

  3177.         lv2_atom_forge_property_head(&forge, getCustomURID(cdata->key), CARLA_URI_MAP_ID_NULL);

  3178. 

  3179.         if (cdata->type == CUSTOM_DATA_STRING)

  3180.             lv2_atom_forge_string(&forge, cdata->value, strlen(cdata->value));

  3181.         else if (cdata->type == CUSTOM_DATA_PATH)

  3182.             lv2_atom_forge_path(&forge, cdata->value, strlen(cdata->value));

  3183.         else if (cdata->type == CUSTOM_DATA_CHUNK)

  3184.             lv2_atom_forge_literal(&forge, cdata->value, strlen(cdata->value), CARLA_URI_MAP_ID_ATOM_CHUNK, CARLA_URI_MAP_ID_NULL);

  3185.         else

  3186.             lv2_atom_forge_literal(&forge, cdata->value, strlen(cdata->value), getCustomURID(cdata->key), CARLA_URI_MAP_ID_NULL);

  3187. 

  3188.         lv2_atom_forge_pop(&forge, &bodyFrame);

  3189.         lv2_atom_forge_pop(&forge, &refFrame);

  3190. 

  3191.         const LV2_Atom* const atom = lv2_atom_forge_deref(&forge, ref);

  3192.         ui.descriptor->port_event(ui.handle, 0, atom->size, CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT, atom);

  3193. 

  3194.         free((void*)chunk.buf);

  3195.         sratom_free(sratom);

  3196.     }

  3197. 

  3198.     void updateUi()

  3199.     {

  3200.         qDebug("Lv2Plugin::updateUi()");

  3201. 

  3202.         ext.uiprograms = nullptr;

  3203. 

  3204.         if (ui.handle && ui.descriptor)

  3205.         {

  3206.             if (ui.descriptor->extension_data)

  3207.             {

  3208.                 ext.uiprograms = (const LV2_Programs_UI_Interface*)ui.descriptor->extension_data(LV2_PROGRAMS__UIInterface);

  3209. 

  3210.                 if (ext.uiprograms && ! ext.uiprograms->select_program)

  3211.                     // invalid

  3212.                     ext.uiprograms = nullptr;

  3213. 

  3214.                 if (ext.uiprograms && midiprog.count > 0 && midiprog.current >= 0)

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

  3216.             }

  3217. 

  3218.             if (ui.descriptor->port_event)

  3219.             {

  3220.                 // get&store custom data to be sent to the UI

  3221.                 prepareForSave();

  3222. 

  3223.                 // update state (custom data)

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

  3225.                     uiTransferEvent(&custom[i]);

  3226. 

  3227.                 // update control ports

  3228.                 float valueF;

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

  3230.                 {

  3231.                     valueF = getParameterValue(i);

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

  3233.                 }

  3234.             }

  3235.         }

  3236.     }

  3237. 

  3238.     // ----------------- Event Feature ---------------------------------------------------

  3239. 

  3240.     static uint32_t carla_lv2_event_ref(const LV2_Event_Callback_Data callback_data, LV2_Event* const event)

  3241.     {

  3242.         qDebug("Lv2Plugin::carla_lv2_event_ref(%p, %p)", callback_data, event);

  3243.         Q_ASSERT(callback_data);

  3244.         Q_ASSERT(event);

  3245. 

  3246.         return 0;

  3247.     }

  3248. 

  3249.     static uint32_t carla_lv2_event_unref(const LV2_Event_Callback_Data callback_data, LV2_Event* const event)

  3250.     {

  3251.         qDebug("Lv2Plugin::carla_lv2_event_unref(%p, %p)", callback_data, event);

  3252.         Q_ASSERT(callback_data);

  3253.         Q_ASSERT(event);

  3254. 

  3255.         return 0;

  3256.     }

  3257. 

  3258.     // ----------------- Logs Feature ----------------------------------------------------

  3259. 

  3260.     static int carla_lv2_log_printf(const LV2_Log_Handle handle, const LV2_URID type, const char* const fmt, ...)

  3261.     {

  3262.         qDebug("Lv2Plugin::carla_lv2_log_printf(%p, %i, \"%s\", ...)", handle, type, fmt);

  3263.         Q_ASSERT(handle);

  3264.         Q_ASSERT(type > 0);

  3265. 

  3266. #ifndef DEBUG

  3267.         if (type == CARLA_URI_MAP_ID_LOG_TRACE)

  3268.             return 0;

  3269. #endif

  3270. 

  3271.         va_list args;

  3272.         va_start(args, fmt);

  3273.         const int ret = carla_lv2_log_vprintf(handle, type, fmt, args);

  3274.         va_end(args);

  3275. 

  3276.         return ret;

  3277.     }

  3278. 

  3279.     static int carla_lv2_log_vprintf(const LV2_Log_Handle handle, const LV2_URID type, const char* const fmt, va_list ap)

  3280.     {

  3281.         qDebug("Lv2Plugin::carla_lv2_log_vprintf(%p, %i, \"%s\", ...)", handle, type, fmt);

  3282.         Q_ASSERT(handle);

  3283.         Q_ASSERT(type > 0);

  3284. 

  3285. #ifndef DEBUG

  3286.         if (type == CARLA_URI_MAP_ID_LOG_TRACE)

  3287.             return 0;

  3288. #endif

  3289. 

  3290.         char buf[8196];

  3291.         vsprintf(buf, fmt, ap);

  3292. 

  3293.         if (*buf == 0)

  3294.             return 0;

  3295. 

  3296.         switch (type)

  3297.         {

  3298.         case CARLA_URI_MAP_ID_LOG_ERROR:

  3299.             qCritical("%s", buf);

  3300.             break;

  3301.         case CARLA_URI_MAP_ID_LOG_NOTE:

  3302.             printf("%s\n", buf);

  3303.             break;

  3304.         case CARLA_URI_MAP_ID_LOG_TRACE:

  3305.             qDebug("%s", buf);

  3306.             break;

  3307.         case CARLA_URI_MAP_ID_LOG_WARNING:

  3308.             qWarning("%s", buf);

  3309.             break;

  3310.         default:

  3311.             break;

  3312.         }

  3313. 

  3314.         return strlen(buf);

  3315.     }

  3316. 

  3317.     // ----------------- Programs Feature ------------------------------------------------

  3318. 

  3319.     static void carla_lv2_program_changed(const LV2_Programs_Handle handle, const int32_t index)

  3320.     {

  3321.         qDebug("Lv2Plugin::carla_lv2_program_changed(%p, %i)", handle, index);

  3322.         Q_ASSERT(handle);

  3323. 

  3324.         if (! handle)

  3325.             return;

  3326. 

  3327.         Lv2Plugin* const plugin = (Lv2Plugin*)handle;

  3328.         plugin->handleProgramChanged(index);

  3329.     }

  3330. 

  3331.     // ----------------- State Feature ---------------------------------------------------

  3332. 

  3333.     static char* carla_lv2_state_make_path(const LV2_State_Make_Path_Handle handle, const char* const path)

  3334.     {

  3335.         qDebug("Lv2Plugin::carla_lv2_state_make_path(%p, \"%s\")", handle, path);

  3336.         Q_ASSERT(handle);

  3337.         Q_ASSERT(path);

  3338. 

  3339.         if (! path)

  3340.             return nullptr;

  3341. 

  3342.         QDir dir;

  3343.         dir.mkpath(path);

  3344.         return strdup(path);

  3345.     }

  3346. 

  3347.     static char* carla_lv2_state_map_abstract_path(const LV2_State_Map_Path_Handle handle, const char* const absolute_path)

  3348.     {

  3349.         qDebug("Lv2Plugin::carla_lv2_state_map_abstract_path(%p, \"%s\")", handle, absolute_path);

  3350.         Q_ASSERT(handle);

  3351.         Q_ASSERT(absolute_path);

  3352. 

  3353.         if (! absolute_path)

  3354.             return nullptr;

  3355. 

  3356.         QDir dir(absolute_path);

  3357.         return strdup(dir.canonicalPath().toUtf8().constData());

  3358.     }

  3359. 

  3360.     static char* carla_lv2_state_map_absolute_path(const LV2_State_Map_Path_Handle handle, const char* const abstract_path)

  3361.     {

  3362.         qDebug("Lv2Plugin::carla_lv2_state_map_absolute_path(%p, \"%s\")", handle, abstract_path);

  3363.         Q_ASSERT(handle);

  3364.         Q_ASSERT(abstract_path);

  3365. 

  3366.         if (! abstract_path)

  3367.             return nullptr;

  3368. 

  3369.         QDir dir(abstract_path);

  3370.         return strdup(dir.absolutePath().toUtf8().constData());

  3371.     }

  3372. 

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

  3374.     {

  3375.         qDebug("Lv2Plugin::carla_lv2_state_store(%p, %i, %p, " P_SIZE ", %i, %i)", handle, key, value, size, type, flags);

  3376.         Q_ASSERT(handle);

  3377. 

  3378.         if (! handle)

  3379.             return LV2_STATE_ERR_UNKNOWN;

  3380. 

  3381.         Lv2Plugin* const plugin = (Lv2Plugin*)handle;

  3382.         return plugin->handleStateStore(key, value, size, type, flags);

  3383.     }

  3384. 

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

  3386.     {

  3387.         qDebug("Lv2Plugin::carla_lv2_state_retrieve(%p, %i, %p, %p, %p)", handle, key, size, type, flags);

  3388.         Q_ASSERT(handle);

  3389. 

  3390.         if (! handle)

  3391.             return nullptr;

  3392. 

  3393.         Lv2Plugin* const plugin = (Lv2Plugin*)handle;

  3394.         return plugin->handleStateRetrieve(key, size, type, flags);

  3395.     }

  3396. 

  3397.     // ----------------- URI-Map Feature -------------------------------------------------

  3398. 

  3399.     static uint32_t carla_lv2_uri_to_id(const LV2_URI_Map_Callback_Data data, const char* const map, const char* const uri)

  3400.     {

  3401.         qDebug("Lv2Plugin::carla_lv2_uri_to_id(%p, \"%s\", \"%s\")", data, map, uri);

  3402.         return carla_lv2_urid_map((LV2_URID_Map_Handle*)data, uri);

  3403.     }

  3404. 

  3405.     // ----------------- URID Feature ----------------------------------------------------

  3406. 

  3407.     static LV2_URID carla_lv2_urid_map(const LV2_URID_Map_Handle handle, const char* const uri)

  3408.     {

  3409.         qDebug("Lv2Plugin::carla_lv2_urid_map(%p, \"%s\")", handle, uri);

  3410.         Q_ASSERT(handle);

  3411.         Q_ASSERT(uri);

  3412. 

  3413.         if (! uri)

  3414.             return CARLA_URI_MAP_ID_NULL;

  3415. 

  3416.         // Atom types

  3417.         if (strcmp(uri, LV2_ATOM__Chunk) == 0)

  3418.             return CARLA_URI_MAP_ID_ATOM_CHUNK;

  3419.         if (strcmp(uri, LV2_ATOM__Double) == 0)

  3420.             return CARLA_URI_MAP_ID_ATOM_DOUBLE;

  3421.         if (strcmp(uri, LV2_ATOM__Int) == 0)

  3422.             return CARLA_URI_MAP_ID_ATOM_INT;

  3423.         if (strcmp(uri, LV2_ATOM__Path) == 0)

  3424.             return CARLA_URI_MAP_ID_ATOM_PATH;

  3425.         if (strcmp(uri, LV2_ATOM__Sequence) == 0)

  3426.             return CARLA_URI_MAP_ID_ATOM_SEQUENCE;

  3427.         if (strcmp(uri, LV2_ATOM__String) == 0)

  3428.             return CARLA_URI_MAP_ID_ATOM_STRING;

  3429.         if (strcmp(uri, LV2_ATOM__atomTransfer) == 0)

  3430.             return CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM;

  3431.         if (strcmp(uri, LV2_ATOM__eventTransfer) == 0)

  3432.             return CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT;

  3433. 

  3434.         // BufSize types

  3435.         if (strcmp(uri, LV2_BUF_SIZE__maxBlockLength) == 0)

  3436.             return CARLA_URI_MAP_ID_BUF_MAX_LENGTH;

  3437.         if (strcmp(uri, LV2_BUF_SIZE__minBlockLength) == 0)

  3438.             return CARLA_URI_MAP_ID_BUF_MIN_LENGTH;

  3439.         if (strcmp(uri, LV2_BUF_SIZE__sequenceSize) == 0)

  3440.             return CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE;

  3441. 

  3442.         // Log types

  3443.         if (strcmp(uri, LV2_LOG__Error) == 0)

  3444.             return CARLA_URI_MAP_ID_LOG_ERROR;

  3445.         if (strcmp(uri, LV2_LOG__Note) == 0)

  3446.             return CARLA_URI_MAP_ID_LOG_NOTE;

  3447.         if (strcmp(uri, LV2_LOG__Trace) == 0)

  3448.             return CARLA_URI_MAP_ID_LOG_TRACE;

  3449.         if (strcmp(uri, LV2_LOG__Warning) == 0)

  3450.             return CARLA_URI_MAP_ID_LOG_WARNING;

  3451. 

  3452.         // Others

  3453.         if (strcmp(uri, LV2_MIDI__MidiEvent) == 0)

  3454.             return CARLA_URI_MAP_ID_MIDI_EVENT;

  3455.         if (strcmp(uri, LV2_PARAMETERS__sampleRate) == 0)

  3456.             return CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE;

  3457. 

  3458.         if (! handle)

  3459.             return CARLA_URI_MAP_ID_NULL;

  3460. 

  3461.         // Custom types

  3462.         Lv2Plugin* const plugin = (Lv2Plugin*)handle;

  3463.         return plugin->getCustomURID(uri);

  3464.     }

  3465. 

  3466.     static const char* carla_lv2_urid_unmap(const LV2_URID_Map_Handle handle, const LV2_URID urid)

  3467.     {

  3468.         qDebug("Lv2Plugin::carla_lv2_urid_unmap(%p, %i)", handle, urid);

  3469.         Q_ASSERT(handle);

  3470.         Q_ASSERT(urid > CARLA_URI_MAP_ID_NULL);

  3471. 

  3472.         if (urid == CARLA_URI_MAP_ID_NULL)

  3473.             return nullptr;

  3474. 

  3475.         // Atom types

  3476.         if (urid == CARLA_URI_MAP_ID_ATOM_CHUNK)

  3477.             return LV2_ATOM__Chunk;

  3478.         if (urid == CARLA_URI_MAP_ID_ATOM_DOUBLE)

  3479.             return LV2_ATOM__Double;

  3480.         if (urid == CARLA_URI_MAP_ID_ATOM_INT)

  3481.             return LV2_ATOM__Int;

  3482.         if (urid == CARLA_URI_MAP_ID_ATOM_PATH)

  3483.             return LV2_ATOM__Path;

  3484.         if (urid == CARLA_URI_MAP_ID_ATOM_SEQUENCE)

  3485.             return LV2_ATOM__Sequence;

  3486.         if (urid == CARLA_URI_MAP_ID_ATOM_STRING)

  3487.             return LV2_ATOM__String;

  3488.         if (urid == CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM)

  3489.             return LV2_ATOM__atomTransfer;

  3490.         if (urid == CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT)

  3491.             return LV2_ATOM__eventTransfer;

  3492. 

  3493.         // BufSize types

  3494.         if (urid == CARLA_URI_MAP_ID_BUF_MAX_LENGTH)

  3495.             return LV2_BUF_SIZE__maxBlockLength;

  3496.         if (urid == CARLA_URI_MAP_ID_BUF_MIN_LENGTH)

  3497.             return LV2_BUF_SIZE__minBlockLength;

  3498.         if (urid == CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE)

  3499.             return LV2_BUF_SIZE__sequenceSize;

  3500. 

  3501.         // Log types

  3502.         if (urid == CARLA_URI_MAP_ID_LOG_ERROR)

  3503.             return LV2_LOG__Error;

  3504.         if (urid == CARLA_URI_MAP_ID_LOG_NOTE)

  3505.             return LV2_LOG__Note;

  3506.         if (urid == CARLA_URI_MAP_ID_LOG_TRACE)

  3507.             return LV2_LOG__Trace;

  3508.         if (urid == CARLA_URI_MAP_ID_LOG_WARNING)

  3509.             return LV2_LOG__Warning;

  3510. 

  3511.         // Others

  3512.         if (urid == CARLA_URI_MAP_ID_MIDI_EVENT)

  3513.             return LV2_MIDI__MidiEvent;

  3514.         if (urid == CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE)

  3515.             return LV2_PARAMETERS__sampleRate;

  3516. 

  3517.         if (! handle)

  3518.             return nullptr;

  3519. 

  3520.         // Custom types

  3521.         Lv2Plugin* const plugin = (Lv2Plugin*)handle;

  3522.         return plugin->getCustomURIString(urid);

  3523.     }

  3524. 

  3525.     // ----------------- Worker Feature --------------------------------------------------

  3526. 

  3527.     static LV2_Worker_Status carla_lv2_worker_schedule(const LV2_Worker_Schedule_Handle handle, const uint32_t size, const void* const data)

  3528.     {

  3529.         qDebug("Lv2Plugin::carla_lv2_worker_schedule(%p, %i, %p)", handle, size, data);

  3530.         Q_ASSERT(handle);

  3531. 

  3532.         if (! handle)

  3533.             return LV2_WORKER_ERR_UNKNOWN;

  3534. 

  3535.         Lv2Plugin* const plugin = (Lv2Plugin*)handle;

  3536.         return plugin->handleWorkerSchedule(size, data);

  3537.     }

  3538. 

  3539.     static LV2_Worker_Status carla_lv2_worker_respond(const LV2_Worker_Respond_Handle handle, const uint32_t size, const void* const data)

  3540.     {

  3541.         qDebug("Lv2Plugin::carla_lv2_worker_respond(%p, %i, %p)", handle, size, data);

  3542.         Q_ASSERT(handle);

  3543. 

  3544.         if (! handle)

  3545.             return LV2_WORKER_ERR_UNKNOWN;

  3546. 

  3547.         Lv2Plugin* const plugin = (Lv2Plugin*)handle;

  3548.         return plugin->handleWorkerRespond(size, data);

  3549.     }

  3550. 

  3551.     // ----------------- UI Port-Map Feature ---------------------------------------------

  3552. 

  3553.     static uint32_t carla_lv2_ui_port_map(const LV2UI_Feature_Handle handle, const char* const symbol)

  3554.     {

  3555.         qDebug("Lv2Plugin::carla_lv2_ui_port_map(%p, \"%s\")", handle, symbol);

  3556.         Q_ASSERT(handle);

  3557. 

  3558.         if (! handle)

  3559.             return LV2UI_INVALID_PORT_INDEX;

  3560. 

  3561.         Lv2Plugin* const plugin = (Lv2Plugin*)handle;

  3562.         return plugin->handleUiPortMap(symbol);

  3563.     }

  3564. 

  3565.     // ----------------- UI Resize Feature -----------------------------------------------

  3566. 

  3567.     static int carla_lv2_ui_resize(const LV2UI_Feature_Handle handle, const int width, const int height)

  3568.     {

  3569.         qDebug("Lv2Plugin::carla_lv2_ui_resize(%p, %i, %i)", handle, width, height);

  3570.         Q_ASSERT(handle);

  3571. 

  3572.         if (! handle)

  3573.             return 1;

  3574. 

  3575.         Lv2Plugin* const plugin  = (Lv2Plugin*)handle;

  3576.         return plugin->handleUiResize(width, height);

  3577.     }

  3578. 

  3579.     // ----------------- External UI Feature ---------------------------------------------

  3580. 

  3581.     static void carla_lv2_external_ui_closed(const LV2UI_Controller controller)

  3582.     {

  3583.         qDebug("Lv2Plugin::carla_lv2_external_ui_closed(%p)", controller);

  3584.         Q_ASSERT(controller);

  3585. 

  3586.         if (! controller)

  3587.             return;

  3588. 

  3589.         Lv2Plugin* const plugin = (Lv2Plugin*)controller;

  3590.         plugin->handleExternalUiClosed();

  3591.     }

  3592. 

  3593.     // ----------------- UI Extension ----------------------------------------------------

  3594. 

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

  3596.     {

  3597.         qDebug("Lv2Plugin::carla_lv2_ui_write_function(%p, %i, %i, %i, %p)", controller, port_index, buffer_size, format, buffer);

  3598.         Q_ASSERT(controller);

  3599. 

  3600.         if (! controller)

  3601.             return;

  3602. 

  3603.         Lv2Plugin* const plugin = (Lv2Plugin*)controller;

  3604.         plugin->handleUiWrite(port_index, buffer_size, format, buffer);

  3605.     }

  3606. 

  3607.     // -------------------------------------------------------------------

  3608. 

  3609.     bool uiLibOpen(const char* const filename)

  3610.     {

  3611.         ui.lib = lib_open(filename);

  3612.         return bool(ui.lib);

  3613.     }

  3614. 

  3615.     bool uiLibClose()

  3616.     {

  3617.         if (ui.lib)

  3618.             return lib_close(ui.lib);

  3619.         return false;

  3620.     }

  3621. 

  3622.     void* uiLibSymbol(const char* const symbol)

  3623.     {

  3624.         if (ui.lib)

  3625.             return lib_symbol(ui.lib, symbol);

  3626.         return nullptr;

  3627.     }

  3628. 

  3629.     // -------------------------------------------------------------------

  3630. 

  3631.     bool init(const char* const bundle, const char* const name, const char* const URI)

  3632.     {

  3633.         // ---------------------------------------------------------------

  3634.         // get plugin from lv2_rdf (lilv)

  3635. 

  3636.         rdf_descriptor = lv2_rdf_new(URI);

  3637. 

  3638.         if (! rdf_descriptor)

  3639.         {

  3640.             setLastError("Failed to find the requested plugin in the LV2 Bundle");

  3641.             return false;

  3642.         }

  3643. 

  3644.         // ---------------------------------------------------------------

  3645.         // open DLL

  3646. 

  3647.         if (! libOpen(rdf_descriptor->Binary))

  3648.         {

  3649.             setLastError(libError(rdf_descriptor->Binary));

  3650.             return false;

  3651.         }

  3652. 

  3653.         // ---------------------------------------------------------------

  3654.         // get DLL main entry

  3655. 

  3656.         const LV2_Descriptor_Function descFn = (LV2_Descriptor_Function)libSymbol("lv2_descriptor");

  3657. 

  3658.         if (! descFn)

  3659.         {

  3660.             setLastError("Could not find the LV2 Descriptor in the plugin library");

  3661.             return false;

  3662.         }

  3663. 

  3664.         // ---------------------------------------------------------------

  3665.         // get descriptor that matches URI

  3666. 

  3667.         uint32_t i = 0;

  3668.         while ((descriptor = descFn(i++)))

  3669.         {

  3670.             if (strcmp(descriptor->URI, URI) == 0)

  3671.                 break;

  3672.         }

  3673. 

  3674.         if (! descriptor)

  3675.         {

  3676.             setLastError("Could not find the requested plugin URI in the plugin library");

  3677.             return false;

  3678.         }

  3679. 

  3680.         // ---------------------------------------------------------------

  3681.         // check supported port-types and features

  3682. 

  3683.         bool canContinue = true;

  3684. 

  3685.         // Check supported ports

  3686.         for (i=0; i < rdf_descriptor->PortCount; i++)

  3687.         {

  3688.             LV2_Property PortType = rdf_descriptor->Ports[i].Type;

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

  3690.             {

  3691.                 if (! LV2_IS_PORT_OPTIONAL(rdf_descriptor->Ports[i].Properties))

  3692.                 {

  3693.                     setLastError("Plugin requires a port that is not currently supported");

  3694.                     canContinue = false;

  3695.                     break;

  3696.                 }

  3697.             }

  3698.         }

  3699. 

  3700.         // Check supported features

  3701.         for (i=0; i < rdf_descriptor->FeatureCount && canContinue; i++)

  3702.         {

  3703.             if (LV2_IS_FEATURE_REQUIRED(rdf_descriptor->Features[i].Type) && ! is_lv2_feature_supported(rdf_descriptor->Features[i].URI))

  3704.             {

  3705.                 QString msg = QString("Plugin requires a feature that is not supported:\n%1").arg(rdf_descriptor->Features[i].URI);

  3706.                 setLastError(msg.toUtf8().constData());

  3707.                 canContinue = false;

  3708.                 break;

  3709.             }

  3710.         }

  3711. 

  3712.         // Check extensions

  3713.         for (i=0; i < rdf_descriptor->ExtensionCount; i++)

  3714.         {

  3715.             if (strcmp(rdf_descriptor->Extensions[i], LV2_PROGRAMS__Interface) == 0)

  3716.                 m_hints |= PLUGIN_HAS_EXTENSION_PROGRAMS;

  3717.             else if (strcmp(rdf_descriptor->Extensions[i], LV2_STATE__interface) == 0)

  3718.                 m_hints |= PLUGIN_HAS_EXTENSION_STATE;

  3719.             else if (strcmp(rdf_descriptor->Extensions[i], LV2_WORKER__interface) == 0)

  3720.                 m_hints |= PLUGIN_HAS_EXTENSION_WORKER;

  3721.             else

  3722.                 qDebug("Plugin has non-supported extension: '%s'", rdf_descriptor->Extensions[i]);

  3723.         }

  3724. 

  3725.         if (! canContinue)

  3726.         {

  3727.             // error already set

  3728.             return false;

  3729.         }

  3730. 

  3731.         // ---------------------------------------------------------------

  3732.         // initialize features

  3733. 

  3734.         LV2_Event_Feature* const eventFt = new LV2_Event_Feature;

  3735.         eventFt->callback_data           = this;

  3736.         eventFt->lv2_event_ref           = carla_lv2_event_ref;

  3737.         eventFt->lv2_event_unref         = carla_lv2_event_unref;

  3738. 

  3739.         LV2_Log_Log* const logFt         = new LV2_Log_Log;

  3740.         logFt->handle                    = this;

  3741.         logFt->printf                    = carla_lv2_log_printf;

  3742.         logFt->vprintf                   = carla_lv2_log_vprintf;

  3743. 

  3744.         LV2_RtMemPool_Pool* const rtMemPoolFt      = new LV2_RtMemPool_Pool;

  3745.         rtmempool_allocator_init(rtMemPoolFt);

  3746. 

  3747.         LV2_Programs_Host* const programsFt        = new LV2_Programs_Host;

  3748.         programsFt->handle                         = this;

  3749.         programsFt->program_changed                = carla_lv2_program_changed;

  3750. 

  3751.         LV2_State_Make_Path* const stateMakePathFt = new LV2_State_Make_Path;

  3752.         stateMakePathFt->handle                    = this;

  3753.         stateMakePathFt->path                      = carla_lv2_state_make_path;

  3754. 

  3755.         LV2_State_Map_Path* const stateMapPathFt   = new LV2_State_Map_Path;

  3756.         stateMapPathFt->handle                     = this;

  3757.         stateMapPathFt->abstract_path              = carla_lv2_state_map_abstract_path;

  3758.         stateMapPathFt->absolute_path              = carla_lv2_state_map_absolute_path;

  3759. 

  3760.         LV2_URI_Map_Feature* const uriMapFt = new LV2_URI_Map_Feature;

  3761.         uriMapFt->callback_data             = this;

  3762.         uriMapFt->uri_to_id                 = carla_lv2_uri_to_id;

  3763. 

  3764.         LV2_URID_Map* const uridMapFt       = new LV2_URID_Map;

  3765.         uridMapFt->handle                   = this;

  3766.         uridMapFt->map                      = carla_lv2_urid_map;

  3767. 

  3768.         LV2_URID_Unmap* const uridUnmapFt   = new LV2_URID_Unmap;

  3769.         uridUnmapFt->handle                 = this;

  3770.         uridUnmapFt->unmap                  = carla_lv2_urid_unmap;

  3771. 

  3772.         LV2_Worker_Schedule* const workerFt = new LV2_Worker_Schedule;

  3773.         workerFt->handle                    = this;

  3774.         workerFt->schedule_work             = carla_lv2_worker_schedule;

  3775. 

  3776.         LV2_Options_Option* const optionsFt = new LV2_Options_Option [5];

  3777.         optionsFt[0] = lv2Options.oMaxBlockLenth;

  3778.         optionsFt[1] = lv2Options.oMinBlockLenth;

  3779.         optionsFt[2] = lv2Options.oSequenceSize;

  3780.         optionsFt[3] = lv2Options.oSampleRate;

  3781.         optionsFt[4] = lv2Options.oNull;

  3782. 

  3783.         features[lv2_feature_id_bufsize_bounded]       = new LV2_Feature;

  3784.         features[lv2_feature_id_bufsize_bounded]->URI  = LV2_BUF_SIZE__boundedBlockLength;

  3785.         features[lv2_feature_id_bufsize_bounded]->data = nullptr;

  3786. 

  3787. #ifndef BUILD_BRIDGE

  3788.         if (carlaOptions.processHighPrecision)

  3789.         {

  3790.             features[lv2_feature_id_bufsize_fixed]          = new LV2_Feature;

  3791.             features[lv2_feature_id_bufsize_fixed]->URI     = LV2_BUF_SIZE__fixedBlockLength;

  3792.             features[lv2_feature_id_bufsize_fixed]->data    = nullptr;

  3793. 

  3794.             features[lv2_feature_id_bufsize_powerof2]       = new LV2_Feature;

  3795.             features[lv2_feature_id_bufsize_powerof2]->URI  = LV2_BUF_SIZE__powerOf2BlockLength;

  3796.             features[lv2_feature_id_bufsize_powerof2]->data = nullptr;

  3797.         }

  3798.         else

  3799. #endif

  3800.         {

  3801.             // fake, used to keep a valid array

  3802.             features[lv2_feature_id_bufsize_fixed]    = features[lv2_feature_id_bufsize_bounded];

  3803.             features[lv2_feature_id_bufsize_powerof2] = features[lv2_feature_id_bufsize_bounded];

  3804.         }

  3805. 

  3806.         features[lv2_feature_id_event]          = new LV2_Feature;

  3807.         features[lv2_feature_id_event]->URI     = LV2_EVENT_URI;

  3808.         features[lv2_feature_id_event]->data    = eventFt;

  3809. 

  3810.         features[lv2_feature_id_logs]           = new LV2_Feature;

  3811.         features[lv2_feature_id_logs]->URI      = LV2_LOG__log;

  3812.         features[lv2_feature_id_logs]->data     = logFt;

  3813. 

  3814.         features[lv2_feature_id_options]        = new LV2_Feature;

  3815.         features[lv2_feature_id_options]->URI   = LV2_OPTIONS__options;

  3816.         features[lv2_feature_id_options]->data  = optionsFt;

  3817. 

  3818.         features[lv2_feature_id_programs]       = new LV2_Feature;

  3819.         features[lv2_feature_id_programs]->URI  = LV2_PROGRAMS__Host;

  3820.         features[lv2_feature_id_programs]->data = programsFt;

  3821. 

  3822.         features[lv2_feature_id_rtmempool]       = new LV2_Feature;

  3823.         features[lv2_feature_id_rtmempool]->URI  = LV2_RTSAFE_MEMORY_POOL__Pool;

  3824.         features[lv2_feature_id_rtmempool]->data = rtMemPoolFt;

  3825. 

  3826.         features[lv2_feature_id_state_make_path]       = new LV2_Feature;

  3827.         features[lv2_feature_id_state_make_path]->URI  = LV2_STATE__makePath;

  3828.         features[lv2_feature_id_state_make_path]->data = stateMakePathFt;

  3829. 

  3830.         features[lv2_feature_id_state_map_path]        = new LV2_Feature;

  3831.         features[lv2_feature_id_state_map_path]->URI   = LV2_STATE__mapPath;

  3832.         features[lv2_feature_id_state_map_path]->data  = stateMapPathFt;

  3833. 

  3834.         features[lv2_feature_id_strict_bounds]         = new LV2_Feature;

  3835.         features[lv2_feature_id_strict_bounds]->URI    = LV2_PORT_PROPS__supportsStrictBounds;

  3836.         features[lv2_feature_id_strict_bounds]->data   = nullptr;

  3837. 

  3838.         features[lv2_feature_id_uri_map]          = new LV2_Feature;

  3839.         features[lv2_feature_id_uri_map]->URI     = LV2_URI_MAP_URI;

  3840.         features[lv2_feature_id_uri_map]->data    = uriMapFt;

  3841. 

  3842.         features[lv2_feature_id_urid_map]         = new LV2_Feature;

  3843.         features[lv2_feature_id_urid_map]->URI    = LV2_URID__map;

  3844.         features[lv2_feature_id_urid_map]->data   = uridMapFt;

  3845. 

  3846.         features[lv2_feature_id_urid_unmap]       = new LV2_Feature;

  3847.         features[lv2_feature_id_urid_unmap]->URI  = LV2_URID__unmap;

  3848.         features[lv2_feature_id_urid_unmap]->data = uridUnmapFt;

  3849. 

  3850.         features[lv2_feature_id_worker]           = new LV2_Feature;

  3851.         features[lv2_feature_id_worker]->URI      = LV2_WORKER__schedule;

  3852.         features[lv2_feature_id_worker]->data     = workerFt;

  3853. 

  3854.         // ---------------------------------------------------------------

  3855.         // initialize plugin

  3856. 

  3857.         handle = descriptor->instantiate(descriptor, x_engine->getSampleRate(), rdf_descriptor->Bundle, features);

  3858. 

  3859.         if (! handle)

  3860.         {

  3861.             setLastError("Plugin failed to initialize");

  3862.             return false;

  3863.         }

  3864. 

  3865.         // ---------------------------------------------------------------

  3866.         // get info

  3867. 

  3868.         m_filename = strdup(bundle);

  3869. 

  3870.         if (name)

  3871.             m_name = x_engine->getUniqueName(name);

  3872.         else

  3873.             m_name = x_engine->getUniqueName(rdf_descriptor->Name);

  3874. 

  3875.         // ---------------------------------------------------------------

  3876.         // register client

  3877. 

  3878.         x_client = x_engine->addClient(this);

  3879. 

  3880.         if (! x_client->isOk())

  3881.         {

  3882.             setLastError("Failed to register plugin client");

  3883.             return false;

  3884.         }

  3885. 

  3886.         // ---------------------------------------------------------------

  3887.         // gui stuff

  3888. 

  3889.         if (rdf_descriptor->UICount == 0)

  3890.             return true;

  3891. 

  3892.         // -----------------------------------------------------------

  3893.         // find more appropriate ui

  3894. 

  3895.         int eQt4, eCocoa, eHWND, eX11, eGtk2, eGtk3, iCocoa, iHWND, iX11, iQt4, iExt, iSuil, iFinal;

  3896.         eQt4 = eCocoa = eHWND = eX11 = eGtk2 = eGtk3 = iQt4 = iCocoa = iHWND = iX11 = iExt = iSuil = iFinal = -1;

  3897. 

  3898.         for (i=0; i < rdf_descriptor->UICount; i++)

  3899.         {

  3900.             switch (rdf_descriptor->UIs[i].Type)

  3901.             {

  3902.             case LV2_UI_QT4:

  3903. #ifndef BUILD_BRIDGE

  3904.                 if (isUiBridgeable(i) && carlaOptions.preferUiBridges)

  3905.                     eQt4 = i;

  3906. #endif

  3907.                 iQt4 = i;

  3908.                 break;

  3909. 

  3910.             case LV2_UI_COCOA:

  3911. #ifndef BUILD_BRIDGE

  3912.                 if (isUiBridgeable(i) && carlaOptions.preferUiBridges)

  3913.                     eCocoa = i;

  3914. #endif

  3915.                 iCocoa = i;

  3916.                 break;

  3917. 

  3918.             case LV2_UI_WINDOWS:

  3919. #ifndef BUILD_BRIDGE

  3920.                 if (isUiBridgeable(i) && carlaOptions.preferUiBridges)

  3921.                     eHWND = i;

  3922. #endif

  3923.                 iHWND = i;

  3924.                 break;

  3925. 

  3926.             case LV2_UI_X11:

  3927. #ifndef BUILD_BRIDGE

  3928.                 if (isUiBridgeable(i) && carlaOptions.preferUiBridges)

  3929.                     eX11 = i;

  3930. #endif

  3931.                 iX11 = i;

  3932.                 break;

  3933. 

  3934.             case LV2_UI_GTK2:

  3935. #ifdef BUILD_BRIDGE

  3936.                 if (false)

  3937. #else

  3938. #  ifdef HAVE_SUIL

  3939.                 if (isUiBridgeable(i) && carlaOptions.preferUiBridges)

  3940. #  else

  3941.                 if (isUiBridgeable(i))

  3942. #  endif

  3943. #endif

  3944.                     eGtk2 = i;

  3945. #ifdef HAVE_SUIL

  3946.                 iSuil = i;

  3947. #endif

  3948.                 break;

  3949. 

  3950. #ifndef BUILD_BRIDGE

  3951.             case LV2_UI_GTK3:

  3952.                 if (isUiBridgeable(i))

  3953.                     eGtk3 = i;

  3954.                 break;

  3955. #endif

  3956. 

  3957.             case LV2_UI_EXTERNAL:

  3958.             case LV2_UI_OLD_EXTERNAL:

  3959.                 iExt = i;

  3960.                 break;

  3961. 

  3962.             default:

  3963.                 break;

  3964.             }

  3965.         }

  3966. 

  3967.         if (eQt4 >= 0)

  3968.             iFinal = eQt4;

  3969.         else if (eCocoa >= 0)

  3970.             iFinal = eCocoa;

  3971.         else if (eHWND >= 0)

  3972.             iFinal = eHWND;

  3973.         else if (eX11 >= 0)

  3974.             iFinal = eX11;

  3975.         else if (eGtk2 >= 0)

  3976.             iFinal = eGtk2;

  3977.         else if (eGtk3 >= 0)

  3978.             iFinal = eGtk3;

  3979.         else if (iQt4 >= 0)

  3980.             iFinal = iQt4;

  3981.         else if (iCocoa >= 0)

  3982.             iFinal = iCocoa;

  3983.         else if (iHWND >= 0)

  3984.             iFinal = iHWND;

  3985.         else if (iX11 >= 0)

  3986.             iFinal = iX11;

  3987.         else if (iExt >= 0)

  3988.             iFinal = iExt;

  3989.         else if (iSuil >= 0)

  3990.             iFinal = iSuil;

  3991. 

  3992. #ifndef BUILD_BRIDGE

  3993.         const bool isBridged = (iFinal == eQt4 || iFinal == eCocoa || iFinal == eHWND || iFinal == eX11 || iFinal == eGtk2 || iFinal == eGtk3);

  3994. #endif

  3995. #ifdef HAVE_SUIL

  3996.         const bool isSuil = (iFinal == iSuil && !isBridged);

  3997. #endif

  3998. 

  3999.         if (iFinal < 0)

  4000.         {

  4001.             qWarning("Failed to find an appropriate LV2 UI for this plugin");

  4002.             return true;

  4003.         }

  4004. 

  4005.         ui.rdf_descriptor = &rdf_descriptor->UIs[iFinal];

  4006. 

  4007.         // -----------------------------------------------------------

  4008.         // check supported ui features

  4009. 

  4010.         canContinue = true;

  4011. 

  4012.         for (i=0; i < ui.rdf_descriptor->FeatureCount; i++)

  4013.         {

  4014.             if (LV2_IS_FEATURE_REQUIRED(ui.rdf_descriptor->Features[i].Type) && is_lv2_ui_feature_supported(ui.rdf_descriptor->Features[i].URI) == false)

  4015.             {

  4016.                 qCritical("Plugin UI requires a feature that is not supported:\n%s", ui.rdf_descriptor->Features[i].URI);

  4017.                 canContinue = false;

  4018.                 break;

  4019.             }

  4020.         }

  4021. 

  4022.         if (! canContinue)

  4023.         {

  4024.             ui.rdf_descriptor = nullptr;

  4025.             return true;

  4026.         }

  4027. 

  4028. #ifdef HAVE_SUIL

  4029.         if (isSuil)

  4030.         {

  4031.             // -------------------------------------------------------

  4032.             // init suil host

  4033. 

  4034.             suil.host = suil_host_new(carla_lv2_ui_write_function, carla_lv2_ui_port_map, nullptr, nullptr);

  4035.         }

  4036.         else

  4037. #endif

  4038.         {

  4039.             // -------------------------------------------------------

  4040.             // open DLL

  4041. 

  4042.             if (! uiLibOpen(ui.rdf_descriptor->Binary))

  4043.             {

  4044.                 qCritical("Could not load UI library, error was:\n%s", libError(ui.rdf_descriptor->Binary));

  4045.                 ui.rdf_descriptor = nullptr;

  4046.                 return true;

  4047.             }

  4048. 

  4049.             // -------------------------------------------------------

  4050.             // get DLL main entry

  4051. 

  4052.             LV2UI_DescriptorFunction ui_descFn = (LV2UI_DescriptorFunction)uiLibSymbol("lv2ui_descriptor");

  4053. 

  4054.             if (! ui_descFn)

  4055.             {

  4056.                 qCritical("Could not find the LV2UI Descriptor in the UI library");

  4057.                 uiLibClose();

  4058.                 ui.lib = nullptr;

  4059.                 ui.rdf_descriptor = nullptr;

  4060.                 return true;

  4061.             }

  4062. 

  4063.             // -------------------------------------------------------

  4064.             // get descriptor that matches URI

  4065. 

  4066.             i = 0;

  4067.             while ((ui.descriptor = ui_descFn(i++)))

  4068.             {

  4069.                 if (strcmp(ui.descriptor->URI, ui.rdf_descriptor->URI) == 0)

  4070.                     break;

  4071.             }

  4072. 

  4073.             if (! ui.descriptor)

  4074.             {

  4075.                 qCritical("Could not find the requested GUI in the plugin UI library");

  4076.                 uiLibClose();

  4077.                 ui.lib = nullptr;

  4078.                 ui.rdf_descriptor = nullptr;

  4079.                 return true;

  4080.             }

  4081.         }

  4082. 

  4083.         // -----------------------------------------------------------

  4084.         // initialize ui according to type

  4085. 

  4086.         const LV2_Property uiType = ui.rdf_descriptor->Type;

  4087. 

  4088. #ifndef BUILD_BRIDGE

  4089.         if (isBridged)

  4090.         {

  4091.             // -------------------------------------------------------

  4092.             // initialize ui bridge

  4093. 

  4094.             if (const char* const oscBinary = lv2bridge2str(uiType))

  4095.             {

  4096.                 gui.type = GUI_EXTERNAL_OSC;

  4097.                 osc.thread = new CarlaPluginThread(x_engine, this, CarlaPluginThread::PLUGIN_THREAD_LV2_GUI);

  4098.                 osc.thread->setOscData(oscBinary, descriptor->URI, ui.descriptor->URI);

  4099.             }

  4100.         }

  4101.         else

  4102. #endif

  4103.         {

  4104.             // -------------------------------------------------------

  4105.             // initialize ui features

  4106. 

  4107.             QString guiTitle = QString("%1 (GUI)").arg(m_name);

  4108. 

  4109.             LV2_Extension_Data_Feature* const uiDataFt = new LV2_Extension_Data_Feature;

  4110.             uiDataFt->data_access                      = descriptor->extension_data;

  4111. 

  4112.             LV2UI_Port_Map* const uiPortMapFt = new LV2UI_Port_Map;

  4113.             uiPortMapFt->handle               = this;

  4114.             uiPortMapFt->port_index           = carla_lv2_ui_port_map;

  4115. 

  4116.             LV2UI_Resize* const uiResizeFt    = new LV2UI_Resize;

  4117.             uiResizeFt->handle                = this;

  4118.             uiResizeFt->ui_resize             = carla_lv2_ui_resize;

  4119. 

  4120.             LV2_External_UI_Host* const uiExternalHostFt = new LV2_External_UI_Host;

  4121.             uiExternalHostFt->ui_closed                  = carla_lv2_external_ui_closed;

  4122.             uiExternalHostFt->plugin_human_id            = strdup(guiTitle.toUtf8().constData());

  4123. 

  4124.             features[lv2_feature_id_data_access]           = new LV2_Feature;

  4125.             features[lv2_feature_id_data_access]->URI      = LV2_DATA_ACCESS_URI;

  4126.             features[lv2_feature_id_data_access]->data     = uiDataFt;

  4127. 

  4128.             features[lv2_feature_id_instance_access]       = new LV2_Feature;

  4129.             features[lv2_feature_id_instance_access]->URI  = LV2_INSTANCE_ACCESS_URI;

  4130.             features[lv2_feature_id_instance_access]->data = handle;

  4131. 

  4132.             features[lv2_feature_id_ui_parent]             = new LV2_Feature;

  4133.             features[lv2_feature_id_ui_parent]->URI        = LV2_UI__parent;

  4134.             features[lv2_feature_id_ui_parent]->data       = nullptr;

  4135. 

  4136.             features[lv2_feature_id_ui_port_map]           = new LV2_Feature;

  4137.             features[lv2_feature_id_ui_port_map]->URI      = LV2_UI__portMap;

  4138.             features[lv2_feature_id_ui_port_map]->data     = uiPortMapFt;

  4139. 

  4140.             features[lv2_feature_id_ui_resize]             = new LV2_Feature;

  4141.             features[lv2_feature_id_ui_resize]->URI        = LV2_UI__resize;

  4142.             features[lv2_feature_id_ui_resize]->data       = uiResizeFt;

  4143. 

  4144.             features[lv2_feature_id_external_ui]           = new LV2_Feature;

  4145.             features[lv2_feature_id_external_ui]->URI      = LV2_EXTERNAL_UI__Host;

  4146.             features[lv2_feature_id_external_ui]->data     = uiExternalHostFt;

  4147. 

  4148.             features[lv2_feature_id_external_ui_old]       = new LV2_Feature;

  4149.             features[lv2_feature_id_external_ui_old]->URI  = LV2_EXTERNAL_UI_DEPRECATED_URI;

  4150.             features[lv2_feature_id_external_ui_old]->data = uiExternalHostFt;

  4151. 

  4152.             // -------------------------------------------------------

  4153.             // initialize ui

  4154. 

  4155.             switch (uiType)

  4156.             {

  4157.             case LV2_UI_QT4:

  4158.                 qDebug("Will use LV2 Qt4 UI");

  4159.                 gui.type      = GUI_INTERNAL_QT4;

  4160.                 gui.resizable = isUiResizable();

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

  4162.                 m_hints      |= PLUGIN_USES_SINGLE_THREAD;

  4163.                 break;

  4164. 

  4165.             case LV2_UI_COCOA:

  4166.                 qDebug("Will use LV2 Cocoa UI");

  4167.                 gui.type      = GUI_INTERNAL_COCOA;

  4168.                 gui.resizable = isUiResizable();

  4169.                 break;

  4170. 

  4171.             case LV2_UI_WINDOWS:

  4172.                 qDebug("Will use LV2 Windows UI");

  4173.                 gui.type      = GUI_INTERNAL_HWND;

  4174.                 gui.resizable = isUiResizable();

  4175.                 break;

  4176. 

  4177.             case LV2_UI_X11:

  4178.                 qDebug("Will use LV2 X11 UI");

  4179.                 gui.type      = GUI_INTERNAL_X11;

  4180.                 gui.resizable = isUiResizable();

  4181.                 break;

  4182. 

  4183.             case LV2_UI_GTK2:

  4184. #ifdef HAVE_SUIL

  4185.                 qDebug("Will use LV2 Gtk2 UI (suil)");

  4186.                 gui.type      = GUI_EXTERNAL_SUIL;

  4187.                 gui.resizable = isUiResizable();

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

  4189.                 m_hints      |= PLUGIN_USES_SINGLE_THREAD;

  4190. 

  4191.                 if (suil.handle)

  4192.                 {

  4193.                     ui.handle     = ((SuilInstanceImpl*)suil.handle)->handle;

  4194.                     ui.descriptor = ((SuilInstanceImpl*)suil.handle)->descriptor;

  4195.                     ui.widget     = suil_instance_get_widget(suil.handle);

  4196. 

  4197.                     if (ui.widget)

  4198.                     {

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

  4200.                         widget->setWindowTitle(guiTitle);

  4201.                     }

  4202.                 }

  4203. #else

  4204.                 qDebug("Will use LV2 Gtk2 UI, NOT!");

  4205. #endif

  4206.                 break;

  4207. 

  4208.             case LV2_UI_GTK3:

  4209.                 qDebug("Will use LV2 Gtk3 UI, NOT!");

  4210.                 break;

  4211. 

  4212.             case LV2_UI_EXTERNAL:

  4213.             case LV2_UI_OLD_EXTERNAL:

  4214.                 qDebug("Will use LV2 External UI");

  4215.                 gui.type = GUI_EXTERNAL_LV2;

  4216.                 break;

  4217.             }

  4218.         }

  4219. 

  4220.         if (gui.type != GUI_NONE)

  4221.             m_hints |= PLUGIN_HAS_GUI;

  4222. 

  4223.         return true;

  4224.     }

  4225. 

  4226. private:

  4227.     LV2_Handle handle, h2;

  4228.     const LV2_Descriptor* descriptor;

  4229.     const LV2_RDF_Descriptor* rdf_descriptor;

  4230.     LV2_Feature* features[lv2_feature_count+1];

  4231. 

  4232.     struct {

  4233.         const LV2_State_Interface* state;

  4234.         const LV2_Worker_Interface* worker;

  4235.         const LV2_Programs_Interface* programs;

  4236.         const LV2_Programs_UI_Interface* uiprograms;

  4237.     } ext;

  4238. 

  4239.     struct {

  4240.         void* lib;

  4241.         LV2UI_Handle handle;

  4242.         LV2UI_Widget widget;

  4243.         const LV2UI_Descriptor* descriptor;

  4244.         const LV2_RDF_UI* rdf_descriptor;

  4245.     } ui;

  4246. 

  4247.     struct {

  4248.         GuiType type;

  4249.         bool resizable;

  4250.         int width;

  4251.         int height;

  4252.     } gui;

  4253. 

  4254. #ifdef HAVE_SUIL

  4255.     struct {

  4256.         SuilHost* host;

  4257.         SuilInstance* handle;

  4258.         QByteArray pos;

  4259.     } suil;

  4260. #endif

  4261. 

  4262.     Lv2PluginEventData evIn;

  4263.     Lv2PluginEventData evOut;

  4264.     float* paramBuffers;

  4265.     std::vector<const char*> customURIDs;

  4266. };

  4267. 

  4268. CarlaPlugin* CarlaPlugin::newLV2(const initializer& init)

  4269. {

  4270.     qDebug("CarlaPlugin::newLV2(%p, \"%s\", \"%s\", \"%s\")", init.engine, init.filename, init.name, init.label);

  4271. 

  4272.     short id = init.engine->getNewPluginId();

  4273. 

  4274.     if (id < 0 || id > CarlaEngine::maxPluginNumber())

  4275.     {

  4276.         setLastError("Maximum number of plugins reached");

  4277.         return nullptr;

  4278.     }

  4279. 

  4280.     Lv2Plugin* const plugin = new Lv2Plugin(init.engine, id);

  4281. 

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

  4283.     {

  4284.         delete plugin;

  4285.         return nullptr;

  4286.     }

  4287. 

  4288.     plugin->reload();

  4289. 

  4290. #ifndef BUILD_BRIDGE

  4291.     if (carlaOptions.processMode == PROCESS_MODE_CONTINUOUS_RACK)

  4292.     {

  4293.         const uint32_t ins  = plugin->audioInCount();

  4294.         const uint32_t outs = plugin->audioOutCount();

  4295. 

  4296.         if (ins > 2 || outs > 2 || (ins != outs && ins != 0 && outs != 0))

  4297.         {

  4298.             setLastError("Carla's rack mode can only work with Mono or Stereo LV2 plugins, sorry!");

  4299.             delete plugin;

  4300.             return nullptr;

  4301.         }

  4302.     }

  4303. #endif

  4304. 

  4305.     plugin->registerToOsc();

  4306.     plugin->updateUi();

  4307. 

  4308.     return plugin;

  4309. }

  4310. 

  4311. /**@}*/

  4312. 

  4313. // -------------------------------------------------------------------------------------------------------------------

  4314. 

  4315. int CarlaOsc::handle_lv2_atom_transfer(CARLA_OSC_HANDLE_ARGS2)

  4316. {

  4317.     qDebug("CarlaOsc::handle_lv2_atom_transfer()");

  4318.     CARLA_OSC_CHECK_OSC_TYPES(2, "ss");

  4319. 

  4320.     const char* const type  = (const char*)&argv[0]->s;

  4321.     const char* const value = (const char*)&argv[1]->s;

  4322. 

  4323.     QByteArray chunk;

  4324.     chunk = QByteArray::fromBase64(value);

  4325. 

  4326.     const LV2_Atom* const atom = (LV2_Atom*)chunk.constData();

  4327. 

  4328.     CarlaBackend::Lv2Plugin* const lv2plugin = (CarlaBackend::Lv2Plugin*)plugin;

  4329.     lv2plugin->handleTransferAtom(atom, type);

  4330. 

  4331.     return 0;

  4332. }

  4333. 

  4334. int CarlaOsc::handle_lv2_event_transfer(CARLA_OSC_HANDLE_ARGS2)

  4335. {

  4336.     qDebug("CarlaOsc::handle_lv2_event_transfer()");

  4337.     CARLA_OSC_CHECK_OSC_TYPES(2, "ss");

  4338. 

  4339.     const char* const type  = (const char*)&argv[0]->s;

  4340.     const char* const value = (const char*)&argv[1]->s;

  4341. 

  4342.     QByteArray chunk;

  4343.     chunk = QByteArray::fromBase64(value);

  4344. 

  4345.     const LV2_Atom* const atom = (LV2_Atom*)chunk.constData();

  4346. 

  4347.     CarlaBackend::Lv2Plugin* const lv2plugin = (CarlaBackend::Lv2Plugin*)plugin;

  4348.     lv2plugin->handleTransferEvent(atom, type);

  4349. 

  4350.     return 0;

  4351. }

  4352. 

  4353. CARLA_BACKEND_END_NAMESPACE