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

4294 lines
148KB
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. 

  21. #include <QtCore/QDir>

  22. 

  23. #ifndef __WINE__

  24. #include <QtGui/QLayout>

  25. #endif

  26. 

  27. #ifdef HAVE_SUIL

  28. #include <suil/suil.h>

  29. struct SuilInstanceImpl {

  30.     void*                   lib_handle;

  31.     const LV2UI_Descriptor* descriptor;

  32.     LV2UI_Handle            handle;

  33.     // ...

  34. };

  35. #endif

  36. 

  37. CARLA_BACKEND_START_NAMESPACE

  38. 

  39. /*!

  40.  * @defgroup CarlaBackendLv2Plugin Carla Backend LV2 Plugin

  41.  *

  42.  * The Carla Backend LV2 Plugin.\n

  43.  * http://lv2plug.in/

  44.  * @{

  45.  */

  46. 

  47. // static max values

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

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

  50. 

  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_state_make_path  =  7;

  84. const uint32_t lv2_feature_id_state_map_path   =  8;

  85. const uint32_t lv2_feature_id_strict_bounds    =  9;

  86. const uint32_t lv2_feature_id_uri_map          = 10;

  87. const uint32_t lv2_feature_id_urid_map         = 11;

  88. const uint32_t lv2_feature_id_urid_unmap       = 12;

  89. const uint32_t lv2_feature_id_worker           = 13;

  90. const uint32_t lv2_feature_id_data_access      = 14;

  91. const uint32_t lv2_feature_id_instance_access  = 15;

  92. const uint32_t lv2_feature_id_ui_parent        = 16;

  93. const uint32_t lv2_feature_id_ui_port_map      = 17;

  94. const uint32_t lv2_feature_id_ui_resize        = 18;

  95. const uint32_t lv2_feature_id_external_ui      = 19;

  96. const uint32_t lv2_feature_id_external_ui_old  = 20;

  97. const uint32_t lv2_feature_count               = 21;

  98. /**@}*/

  99. 

  100. /*!

  101.  * @defgroup Lv2EventTypes LV2 Event Data/Types

  102.  *

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

  104.  * \see CarlaPlugin::hints

  105.  * @{

  106.  */

  107. const unsigned int CARLA_EVENT_DATA_ATOM      = 0x01;

  108. const unsigned int CARLA_EVENT_DATA_EVENT     = 0x02;

  109. const unsigned int CARLA_EVENT_DATA_MIDI_LL   = 0x04;

  110. const unsigned int CARLA_EVENT_TYPE_MESSAGE   = 0x10;

  111. const unsigned int CARLA_EVENT_TYPE_MIDI      = 0x20;

  112. /**@}*/

  113. 

  114. /*!

  115.  * @defgroup Lv2UriMapIds LV2 URI Map Ids

  116.  *

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

  118.  * \see CarlaPlugin::hints

  119.  * @{

  120.  */

  121. const uint32_t CARLA_URI_MAP_ID_NULL                = 0;

  122. const uint32_t CARLA_URI_MAP_ID_ATOM_CHUNK          = 1;

  123. const uint32_t CARLA_URI_MAP_ID_ATOM_DOUBLE         = 2;

  124. const uint32_t CARLA_URI_MAP_ID_ATOM_INT            = 3;

  125. const uint32_t CARLA_URI_MAP_ID_ATOM_PATH           = 4;

  126. const uint32_t CARLA_URI_MAP_ID_ATOM_SEQUENCE       = 5;

  127. const uint32_t CARLA_URI_MAP_ID_ATOM_STRING         = 6;

  128. const uint32_t CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM  = 7;

  129. const uint32_t CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT = 8;

  130. const uint32_t CARLA_URI_MAP_ID_BUF_MAX_LENGTH      = 9;

  131. const uint32_t CARLA_URI_MAP_ID_BUF_MIN_LENGTH      = 10;

  132. const uint32_t CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE   = 11;

  133. const uint32_t CARLA_URI_MAP_ID_LOG_ERROR           = 12;

  134. const uint32_t CARLA_URI_MAP_ID_LOG_NOTE            = 13;

  135. const uint32_t CARLA_URI_MAP_ID_LOG_TRACE           = 14;

  136. const uint32_t CARLA_URI_MAP_ID_LOG_WARNING         = 15;

  137. const uint32_t CARLA_URI_MAP_ID_MIDI_EVENT          = 16;

  138. const uint32_t CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE   = 17;

  139. const uint32_t CARLA_URI_MAP_ID_COUNT               = 18;

  140. /**@}*/

  141. 

  142. struct Lv2EventData {

  143.     uint32_t type;

  144.     CarlaEngineMidiPort* port;

  145.     union {

  146.         LV2_Atom_Sequence* atom;

  147.         LV2_Event_Buffer* event;

  148.         LV2_MIDI* midi;

  149.     };

  150. 

  151.     Lv2EventData()

  152.         : type(0),

  153.           port(nullptr) {}

  154. };

  155. 

  156. struct Lv2PluginEventData {

  157.     uint32_t count;

  158.     Lv2EventData* data;

  159. 

  160.     Lv2PluginEventData()

  161.         : count(0),

  162.           data(nullptr) {}

  163. };

  164. 

  165. struct Lv2PluginOptions {

  166.     bool init;

  167.     uint32_t eventSize;

  168.     uint32_t bufferSize;

  169.     double   sampleRate;

  170.     LV2_Options_Option oNull;

  171.     LV2_Options_Option oMaxBlockLenth;

  172.     LV2_Options_Option oMinBlockLenth;

  173.     LV2_Options_Option oSequenceSize;

  174.     LV2_Options_Option oSampleRate;

  175. 

  176.     Lv2PluginOptions()

  177.         : init(false),

  178.           eventSize(MAX_EVENT_BUFFER),

  179.           bufferSize(0),

  180.           sampleRate(0.0) {}

  181. };

  182. 

  183. Lv2PluginOptions lv2Options;

  184. 

  185. const char* lv2bridge2str(const LV2_Property type)

  186. {

  187.     switch (type)

  188.     {

  189. #ifndef BUILD_BRIDGE

  190.     case LV2_UI_GTK2:

  191.         return carlaOptions.bridge_lv2gtk2;

  192.     case LV2_UI_QT4:

  193.         return carlaOptions.bridge_lv2qt4;

  194.     case LV2_UI_COCOA:

  195.         return nullptr; //carlaOptions.bridge_lv2cocoa;

  196.     case LV2_UI_WINDOWS:

  197.         return nullptr; //carlaOptions.bridge_lv2hwnd;

  198.     case LV2_UI_X11:

  199.         return carlaOptions.bridge_lv2x11;

  200. #endif

  201.     default:

  202.         return nullptr;

  203.     }

  204. }

  205. 

  206. class Lv2Plugin : public CarlaPlugin

  207. {

  208. public:

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

  210.         : CarlaPlugin(engine, id)

  211.     {

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

  213. 

  214.         m_type = PLUGIN_LV2;

  215. 

  216.         handle = h2 = nullptr;

  217.         descriptor  = nullptr;

  218.         rdf_descriptor = nullptr;

  219. 

  220.         ext.state      = nullptr;

  221.         ext.worker     = nullptr;

  222.         ext.programs   = nullptr;

  223.         ext.uiprograms = nullptr;

  224. 

  225.         ui.lib = nullptr;

  226.         ui.handle = nullptr;

  227.         ui.descriptor = nullptr;

  228.         ui.rdf_descriptor = nullptr;

  229. 

  230.         evIn.count = 0;

  231.         evIn.data  = nullptr;

  232. 

  233.         evOut.count = 0;

  234.         evOut.data  = nullptr;

  235. 

  236.         paramBuffers = nullptr;

  237. 

  238.         gui.type = GUI_NONE;

  239.         gui.resizable = false;

  240.         gui.width  = 0;

  241.         gui.height = 0;

  242. 

  243. #ifdef HAVE_SUIL

  244.         suil.handle = nullptr;

  245.         suil.host   = nullptr;

  246. #endif

  247. 

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

  249.             customURIDs.push_back(nullptr);

  250. 

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

  252.             features[i] = nullptr;

  253. 

  254.         if (! lv2Options.init)

  255.         {

  256.             lv2Options.init = true;

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

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

  259. 

  260.             lv2Options.oNull.key   = CARLA_URI_MAP_ID_NULL;

  261.             lv2Options.oNull.size  = 0;

  262.             lv2Options.oNull.type  = CARLA_URI_MAP_ID_NULL;

  263.             lv2Options.oNull.value = nullptr;

  264. 

  265.             lv2Options.oMaxBlockLenth.key   = CARLA_URI_MAP_ID_BUF_MAX_LENGTH;

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

  267.             lv2Options.oMaxBlockLenth.type  = CARLA_URI_MAP_ID_ATOM_INT;

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

  269. 

  270.             lv2Options.oMinBlockLenth.key   = CARLA_URI_MAP_ID_BUF_MIN_LENGTH;

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

  272.             lv2Options.oMinBlockLenth.type  = CARLA_URI_MAP_ID_ATOM_INT;

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

  274. 

  275.             lv2Options.oSequenceSize.key   = CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE;

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

  277.             lv2Options.oSequenceSize.type  = CARLA_URI_MAP_ID_ATOM_INT;

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

  279. 

  280.             lv2Options.oSampleRate.key     = CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE;

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

  282.             lv2Options.oSampleRate.type    = CARLA_URI_MAP_ID_ATOM_DOUBLE;

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

  284.         }

  285.     }

  286. 

  287.     ~Lv2Plugin()

  288.     {

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

  290. 

  291.         // close UI

  292.         if (m_hints & PLUGIN_HAS_GUI)

  293.         {

  294.             showGui(false);

  295. 

  296.             switch (gui.type)

  297.             {

  298.             case GUI_NONE:

  299.             case GUI_INTERNAL_QT4:

  300.             case GUI_INTERNAL_COCOA:

  301.             case GUI_INTERNAL_HWND:

  302.             case GUI_INTERNAL_X11:

  303.             case GUI_EXTERNAL_LV2:

  304.                 break;

  305. 

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

  307.             case GUI_EXTERNAL_SUIL:

  308.                 if (ui.widget)

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

  310.                 break;

  311. #endif

  312. 

  313. #ifndef BUILD_BRIDGE

  314.             case GUI_EXTERNAL_OSC:

  315.                 if (osc.data.target)

  316.                 {

  317.                     osc_send_hide(&osc.data);

  318.                     osc_send_quit(&osc.data);

  319.                 }

  320. 

  321.                 if (osc.thread)

  322.                 {

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

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

  325.                     {

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

  327.                         osc.thread->terminate();

  328.                     }

  329. 

  330.                     delete osc.thread;

  331.                 }

  332. 

  333.                 break;

  334. #endif

  335.             }

  336. 

  337. #ifdef HAVE_SUIL

  338.             if (suil.handle)

  339.             {

  340.                 suil_instance_free(suil.handle);

  341. 

  342.                 if (suil.host)

  343.                     suil_host_free(suil.host);

  344. 

  345.                 ui.handle = nullptr;

  346.                 ui.descriptor = nullptr;

  347.             }

  348. #endif

  349. 

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

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

  352. 

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

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

  355. 

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

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

  358. 

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

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

  361. 

  362.             if (features[lv2_feature_id_external_ui])

  363.             {

  364.                 const lv2_external_ui_host* const uiHost = (const lv2_external_ui_host*)features[lv2_feature_id_external_ui]->data;

  365. 

  366.                 if (uiHost)

  367.                 {

  368.                     if (uiHost->plugin_human_id)

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

  370. 

  371.                     delete uiHost;

  372.                 }

  373.             }

  374. 

  375.             uiLibClose();

  376.         }

  377. 

  378.         if (descriptor)

  379.         {

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

  381.             {

  382.                 if (handle)

  383.                     descriptor->deactivate(handle);

  384.                 if (h2)

  385.                     descriptor->deactivate(h2);

  386.             }

  387. 

  388.             if (descriptor->cleanup)

  389.             {

  390.                 if (handle)

  391.                     descriptor->cleanup(handle);

  392.                 if (h2)

  393.                     descriptor->cleanup(h2);

  394.             }

  395.         }

  396. 

  397.         if (rdf_descriptor)

  398.             lv2_rdf_free(rdf_descriptor);

  399. 

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

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

  402. 

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

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

  405. 

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

  407.         {

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

  409.             delete[] options;

  410.         }

  411. 

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

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

  414. 

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

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

  417. 

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

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

  420. 

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

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

  423. 

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

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

  426. 

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

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

  429. 

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

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

  432. 

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

  434.         {

  435.             if (features[i])

  436.                 delete features[i];

  437.         }

  438. 

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

  440.         {

  441.             if (customURIDs[i])

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

  443.         }

  444. 

  445.         customURIDs.clear();

  446.     }

  447. 

  448.     // -------------------------------------------------------------------

  449.     // Information (base)

  450. 

  451.     PluginCategory category()

  452.     {

  453.         Q_ASSERT(rdf_descriptor);

  454. 

  455.         LV2_Property category = rdf_descriptor->Type;

  456. 

  457.         if (LV2_IS_DELAY(category))

  458.             return PLUGIN_CATEGORY_DELAY;

  459.         if (LV2_IS_DISTORTION(category))

  460.             return PLUGIN_CATEGORY_OTHER;

  461.         if (LV2_IS_DYNAMICS(category))

  462.             return PLUGIN_CATEGORY_DYNAMICS;

  463.         if (LV2_IS_EQ(category))

  464.             return PLUGIN_CATEGORY_EQ;

  465.         if (LV2_IS_FILTER(category))

  466.             return PLUGIN_CATEGORY_FILTER;

  467.         if (LV2_IS_GENERATOR(category))

  468.             return PLUGIN_CATEGORY_SYNTH;

  469.         if (LV2_IS_MODULATOR(category))

  470.             return PLUGIN_CATEGORY_MODULATOR;

  471.         if (LV2_IS_REVERB(category))

  472.             return PLUGIN_CATEGORY_DELAY;

  473.         if (LV2_IS_SIMULATOR(category))

  474.             return PLUGIN_CATEGORY_OTHER;

  475.         if (LV2_IS_SPATIAL(category))

  476.             return PLUGIN_CATEGORY_OTHER;

  477.         if (LV2_IS_SPECTRAL(category))

  478.             return PLUGIN_CATEGORY_UTILITY;

  479.         if (LV2_IS_UTILITY(category))

  480.             return PLUGIN_CATEGORY_UTILITY;

  481. 

  482.         return getPluginCategoryFromName(m_name);

  483.     }

  484. 

  485.     long uniqueId()

  486.     {

  487.         Q_ASSERT(rdf_descriptor);

  488. 

  489.         return rdf_descriptor->UniqueID;

  490.     }

  491. 

  492.     // -------------------------------------------------------------------

  493.     // Information (count)

  494. 

  495.     uint32_t midiInCount()

  496.     {

  497.         uint32_t i, count = 0;

  498. 

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

  500.         {

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

  502.                 count += 1;

  503.         }

  504. 

  505.         return count;

  506.     }

  507. 

  508.     uint32_t midiOutCount()

  509.     {

  510.         uint32_t i, count = 0;

  511. 

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

  513.         {

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

  515.                 count += 1;

  516.         }

  517. 

  518.         return count;

  519.     }

  520. 

  521.     uint32_t parameterScalePointCount(const uint32_t parameterId)

  522.     {

  523.         Q_ASSERT(parameterId < param.count);

  524.         Q_ASSERT(rdf_descriptor);

  525. 

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

  527. 

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

  529.         {

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

  531. 

  532.             if (port)

  533.                 return port->ScalePointCount;

  534.         }

  535. 

  536.         return 0;

  537.     }

  538. 

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

  540.     // Information (per-plugin data)

  541. 

  542.     double getParameterValue(const uint32_t parameterId)

  543.     {

  544.         Q_ASSERT(parameterId < param.count);

  545. 

  546.         return paramBuffers[parameterId];

  547.     }

  548. 

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

  550.     {

  551.         Q_ASSERT(parameterId < param.count);

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

  553. 

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

  555. 

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

  557.         {

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

  559. 

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

  561.             {

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

  563. 

  564.                 if (portScalePoint)

  565.                     return portScalePoint->Value;

  566.             }

  567.         }

  568. 

  569.         return 0.0;

  570.     }

  571. 

  572.     void getLabel(char* const strBuf)

  573.     {

  574.         Q_ASSERT(rdf_descriptor);

  575. 

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

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

  578.         else

  579.             CarlaPlugin::getLabel(strBuf);

  580.     }

  581. 

  582.     void getMaker(char* const strBuf)

  583.     {

  584.         Q_ASSERT(rdf_descriptor);

  585. 

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

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

  588.         else

  589.             CarlaPlugin::getMaker(strBuf);

  590.     }

  591. 

  592.     void getCopyright(char* const strBuf)

  593.     {

  594.         Q_ASSERT(rdf_descriptor);

  595. 

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

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

  598.         else

  599.             CarlaPlugin::getCopyright(strBuf);

  600.     }

  601. 

  602.     void getRealName(char* const strBuf)

  603.     {

  604.         Q_ASSERT(rdf_descriptor);

  605. 

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

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

  608.         else

  609.             CarlaPlugin::getRealName(strBuf);

  610.     }

  611. 

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

  613.     {

  614.         Q_ASSERT(rdf_descriptor);

  615.         Q_ASSERT(parameterId < param.count);

  616. 

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

  618. 

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

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

  621.         else

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

  623.     }

  624. 

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

  626.     {

  627.         Q_ASSERT(rdf_descriptor);

  628.         Q_ASSERT(parameterId < param.count);

  629. 

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

  631. 

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

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

  634.         else

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

  636.     }

  637. 

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

  639.     {

  640.         Q_ASSERT(rdf_descriptor);

  641.         Q_ASSERT(parameterId < param.count);

  642. 

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

  644. 

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

  646.         {

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

  648. 

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

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

  651. 

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

  653.             {

  654.                 switch (port->Unit.Type)

  655.                 {

  656.                 case LV2_UNIT_BAR:

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

  658.                     return;

  659.                 case LV2_UNIT_BEAT:

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

  661.                     return;

  662.                 case LV2_UNIT_BPM:

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

  664.                     return;

  665.                 case LV2_UNIT_CENT:

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

  667.                     return;

  668.                 case LV2_UNIT_CM:

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

  670.                     return;

  671.                 case LV2_UNIT_COEF:

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

  673.                     return;

  674.                 case LV2_UNIT_DB:

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

  676.                     return;

  677.                 case LV2_UNIT_DEGREE:

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

  679.                     return;

  680.                 case LV2_UNIT_FRAME:

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

  682.                     return;

  683.                 case LV2_UNIT_HZ:

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

  685.                     return;

  686.                 case LV2_UNIT_INCH:

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

  688.                     return;

  689.                 case LV2_UNIT_KHZ:

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

  691.                     return;

  692.                 case LV2_UNIT_KM:

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

  694.                     return;

  695.                 case LV2_UNIT_M:

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

  697.                     return;

  698.                 case LV2_UNIT_MHZ:

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

  700.                     return;

  701.                 case LV2_UNIT_MIDINOTE:

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

  703.                     return;

  704.                 case LV2_UNIT_MILE:

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

  706.                     return;

  707.                 case LV2_UNIT_MIN:

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

  709.                     return;

  710.                 case LV2_UNIT_MM:

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

  712.                     return;

  713.                 case LV2_UNIT_MS:

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

  715.                     return;

  716.                 case LV2_UNIT_OCT:

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

  718.                     return;

  719.                 case LV2_UNIT_PC:

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

  721.                     return;

  722.                 case LV2_UNIT_S:

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

  724.                     return;

  725.                 case LV2_UNIT_SEMITONE:

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

  727.                     return;

  728.                 }

  729.             }

  730.         }

  731. 

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

  733.     }

  734. 

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

  736.     {

  737.         Q_ASSERT(rdf_descriptor);

  738.         Q_ASSERT(parameterId < param.count);

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

  740. 

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

  742. 

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

  744.         {

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

  746. 

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

  748.             {

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

  750. 

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

  752.                 {

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

  754.                     return;

  755.                 }

  756.             }

  757.         }

  758. 

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

  760.     }

  761. 

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

  763.     {

  764.         Q_ASSERT(type);

  765.         Q_ASSERT(resizable);

  766. 

  767.         *type      = gui.type;

  768.         *resizable = gui.resizable;

  769.     }

  770. 

  771.     // -------------------------------------------------------------------

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

  773. 

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

  775.     {

  776.         Q_ASSERT(parameterId < param.count);

  777. 

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

  779. 

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

  781.     }

  782. 

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

  784.     {

  785.         Q_ASSERT(type != CUSTOM_DATA_INVALID);

  786.         Q_ASSERT(key);

  787.         Q_ASSERT(value);

  788. 

  789.         if (type == CUSTOM_DATA_INVALID)

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

  791. 

  792.         if (! key)

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

  794. 

  795.         if (! value)

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

  797. 

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

  799. 

  800.         if (ext.state)

  801.         {

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

  803.             LV2_State_Status status;

  804. 

  805.             if (x_engine->isOffline())

  806.             {

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

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

  809.             }

  810.             else

  811.             {

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

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

  814.             }

  815. 

  816.             switch (status)

  817.             {

  818.             case LV2_STATE_SUCCESS:

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

  820.                 break;

  821.             case LV2_STATE_ERR_UNKNOWN:

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

  823.                 break;

  824.             case LV2_STATE_ERR_BAD_TYPE:

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

  826.                 break;

  827.             case LV2_STATE_ERR_BAD_FLAGS:

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

  829.                 break;

  830.             case LV2_STATE_ERR_NO_FEATURE:

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

  832.                 break;

  833.             case LV2_STATE_ERR_NO_PROPERTY:

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

  835.                 break;

  836.             }

  837.         }

  838. 

  839.         if (sendGui)

  840.         {

  841.             CustomData cdata;

  842.             cdata.type  = type;

  843.             cdata.key   = key;

  844.             cdata.value = value;

  845.             uiTransferEvent(&cdata);

  846.         }

  847.     }

  848. 

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

  850.     {

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

  852. 

  853.         if (index < -1)

  854.             index = -1;

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

  856.             return;

  857. 

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

  859.         {

  860.             if (x_engine->isOffline())

  861.             {

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

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

  864.             }

  865.             else

  866.             {

  867.                 const ScopedDisabler m(this, block);

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

  869.             }

  870.         }

  871. 

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

  873.     }

  874. 

  875.     // -------------------------------------------------------------------

  876.     // Set gui stuff

  877. 

  878.     void setGuiData(const int, const GuiDataHandle handle)

  879.     {

  880.         switch(gui.type)

  881.         {

  882.         case GUI_NONE:

  883.             break;

  884. 

  885. #ifndef __WINE__

  886.         case GUI_INTERNAL_QT4:

  887.             if (ui.widget)

  888.             {

  889.                 QDialog* const dialog = handle;

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

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

  892.                 widget->adjustSize();

  893.                 widget->setParent(dialog);

  894.                 widget->show();

  895.             }

  896.             break;

  897. #endif

  898. 

  899.         case GUI_INTERNAL_COCOA:

  900.         case GUI_INTERNAL_HWND:

  901.         case GUI_INTERNAL_X11:

  902.             if (ui.descriptor)

  903.             {

  904. #ifdef __WINE__

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

  906. #else

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

  908. #endif

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

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

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

  912.                 updateUi();

  913.             }

  914.             break;

  915. 

  916.         case GUI_EXTERNAL_LV2:

  917.         case GUI_EXTERNAL_SUIL:

  918.         case GUI_EXTERNAL_OSC:

  919.             break;

  920.         }

  921.     }

  922. 

  923.     void showGui(const bool yesNo)

  924.     {

  925.         switch(gui.type)

  926.         {

  927.         case GUI_NONE:

  928.         case GUI_INTERNAL_QT4:

  929.             break;

  930. 

  931.         case GUI_INTERNAL_COCOA:

  932.         case GUI_INTERNAL_HWND:

  933.         case GUI_INTERNAL_X11:

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

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

  936.             break;

  937. 

  938.         case GUI_EXTERNAL_LV2:

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

  940.                 initExternalUi();

  941. 

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

  943.             {

  944.                 if (yesNo)

  945.                 {

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

  947.                 }

  948.                 else

  949.                 {

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

  951. 

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

  953.                     {

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

  955. 

  956.                         if (ui.descriptor->cleanup)

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

  958. 

  959.                         ui.handle = nullptr;

  960.                     }

  961.                 }

  962.             }

  963.             else

  964.                 // failed to init UI

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

  966. 

  967.             break;

  968. 

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

  970.         case GUI_EXTERNAL_SUIL:

  971.             if (ui.widget)

  972.             {

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

  974. 

  975.                 if (yesNo)

  976.                 {

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

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

  979.                 }

  980.                 else

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

  982. 

  983.                 widget->setVisible(yesNo);

  984.             }

  985.             break;

  986. #endif

  987. 

  988. #ifndef BUILD_BRIDGE

  989.         case GUI_EXTERNAL_OSC:

  990.             Q_ASSERT(osc.thread);

  991. 

  992.             if (! osc.thread)

  993.             {

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

  995.                 return;

  996.             }

  997. 

  998.             if (yesNo)

  999.             {

  1000.                 osc.thread->start();

  1001.             }

  1002.             else

  1003.             {

  1004.                 osc_send_hide(&osc.data);

  1005.                 osc_send_quit(&osc.data);

  1006.                 osc_clear_data(&osc.data);

  1007. 

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

  1009.                     osc.thread->quit();

  1010.             }

  1011.             break;

  1012. #endif

  1013.         }

  1014.     }

  1015. 

  1016.     void idleGui()

  1017.     {

  1018.         // Update external UI

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

  1020.             LV2_EXTERNAL_UI_RUN((lv2_external_ui*)ui.widget);

  1021. 

  1022.         CarlaPlugin::idleGui();

  1023.     }

  1024. 

  1025.     // -------------------------------------------------------------------

  1026.     // Plugin state

  1027. 

  1028.     void reload()

  1029.     {

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

  1031. 

  1032.         // Safely disable plugin for reload

  1033.         const ScopedDisabler m(this);

  1034. 

  1035.         if (x_client->isActive())

  1036.             x_client->deactivate();

  1037. 

  1038.         // Remove client ports

  1039.         removeClientPorts();

  1040. 

  1041.         // Delete old data

  1042.         deleteBuffers();

  1043. 

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

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

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

  1047. 

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

  1049.         const uint32_t portCount = rdf_descriptor->PortCount;

  1050. 

  1051.         bool forcedStereoIn, forcedStereoOut;

  1052.         forcedStereoIn = forcedStereoOut = false;

  1053. 

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

  1055.         {

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

  1057. 

  1058.             if (LV2_IS_PORT_AUDIO(portType))

  1059.             {

  1060.                 if (LV2_IS_PORT_INPUT(portType))

  1061.                     aIns += 1;

  1062.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1063.                     aOuts += 1;

  1064.             }

  1065.             else if (LV2_IS_PORT_CV(portType))

  1066.             {

  1067.                 if (LV2_IS_PORT_INPUT(portType))

  1068.                     cvIns += 1;

  1069.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1070.                     cvOuts += 1;

  1071.             }

  1072.             else if (LV2_IS_PORT_ATOM_SEQUENCE(portType))

  1073.             {

  1074.                 if (LV2_IS_PORT_INPUT(portType))

  1075.                     evIns.push_back(CARLA_EVENT_DATA_ATOM);

  1076.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1077.                     evOuts.push_back(CARLA_EVENT_DATA_ATOM);

  1078.             }

  1079.             else if (LV2_IS_PORT_EVENT(portType))

  1080.             {

  1081.                 if (LV2_IS_PORT_INPUT(portType))

  1082.                     evIns.push_back(CARLA_EVENT_DATA_EVENT);

  1083.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1084.                     evOuts.push_back(CARLA_EVENT_DATA_EVENT);

  1085.             }

  1086.             else if (LV2_IS_PORT_MIDI_LL(portType))

  1087.             {

  1088.                 if (LV2_IS_PORT_INPUT(portType))

  1089.                     evIns.push_back(CARLA_EVENT_DATA_MIDI_LL);

  1090.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1091.                     evOuts.push_back(CARLA_EVENT_DATA_MIDI_LL);

  1092.             }

  1093.             else if (LV2_IS_PORT_CONTROL(portType))

  1094.                 params += 1;

  1095.         }

  1096. 

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

  1098.         {

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

  1100. 

  1101.             if (aIns == 1)

  1102.             {

  1103.                 aIns = 2;

  1104.                 forcedStereoIn = true;

  1105.             }

  1106. 

  1107.             if (aOuts == 1)

  1108.             {

  1109.                 aOuts = 2;

  1110.                 forcedStereoOut = true;

  1111.             }

  1112.         }

  1113. 

  1114.         if (aIns > 0)

  1115.         {

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

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

  1118.         }

  1119. 

  1120.         if (aOuts > 0)

  1121.         {

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

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

  1124.         }

  1125. 

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

  1127.         {

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

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

  1130. 

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

  1132.             {

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

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

  1135. 

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

  1137.                 {

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

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

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

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

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

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

  1144.                 }

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

  1146.                 {

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

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

  1149.                 }

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

  1151.                 {

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

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

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

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

  1156.                 }

  1157.             }

  1158.         }

  1159. 

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

  1161.         {

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

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

  1164. 

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

  1166.             {

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

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

  1169. 

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

  1171.                 {

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

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

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

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

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

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

  1178.                 }

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

  1180.                 {

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

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

  1183.                 }

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

  1185.                 {

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

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

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

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

  1190.                 }

  1191.             }

  1192.         }

  1193. 

  1194.         if (params > 0)

  1195.         {

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

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

  1198.             paramBuffers = new float[params];

  1199.         }

  1200. 

  1201.         const int portNameSize = CarlaEngine::maxPortNameSize() - 1;

  1202.         char portName[portNameSize];

  1203.         bool needsCtrlIn  = false;

  1204.         bool needsCtrlOut = false;

  1205. 

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

  1207.         {

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

  1209. 

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

  1211.             {

  1212. #ifndef BUILD_BRIDGE

  1213.                 if (carlaOptions.processMode != PROCESS_MODE_MULTIPLE_CLIENTS)

  1214.                 {

  1215.                     strcpy(portName, m_name);

  1216.                     strcat(portName, ":");

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

  1218.                 }

  1219.                 else

  1220. #endif

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

  1222.             }

  1223. 

  1224.             if (LV2_IS_PORT_AUDIO(portType))

  1225.             {

  1226.                 if (LV2_IS_PORT_INPUT(portType))

  1227.                 {

  1228.                     j = aIn.count++;

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

  1230.                     aIn.rindexes[j] = i;

  1231. 

  1232.                     if (forcedStereoIn)

  1233.                     {

  1234.                         strcat(portName, "_");

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

  1236.                         aIn.rindexes[1] = i;

  1237.                     }

  1238.                 }

  1239.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1240.                 {

  1241.                     j = aOut.count++;

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

  1243.                     aOut.rindexes[j] = i;

  1244.                     needsCtrlIn = true;

  1245. 

  1246.                     if (forcedStereoOut)

  1247.                     {

  1248.                         strcat(portName, "_");

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

  1250.                         aOut.rindexes[1] = i;

  1251.                     }

  1252.                 }

  1253.                 else

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

  1255.             }

  1256.             else if (LV2_IS_PORT_CV(portType))

  1257.             {

  1258.                 if (LV2_IS_PORT_INPUT(portType))

  1259.                 {

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

  1261.                 }

  1262.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1263.                 {

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

  1265.                 }

  1266.                 else

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

  1268. 

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

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

  1271.             }

  1272.             else if (LV2_IS_PORT_ATOM_SEQUENCE(portType))

  1273.             {

  1274.                 if (LV2_IS_PORT_INPUT(portType))

  1275.                 {

  1276.                     j = evIn.count++;

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

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

  1279. 

  1280.                     if (portType & LV2_PORT_SUPPORTS_MIDI_EVENT)

  1281.                     {

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

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

  1284.                     }

  1285.                     if (portType & LV2_PORT_SUPPORTS_PATCH_MESSAGE)

  1286.                     {

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

  1288.                     }

  1289.                 }

  1290.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1291.                 {

  1292.                     j = evOut.count++;

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

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

  1295. 

  1296.                     if (portType & LV2_PORT_SUPPORTS_MIDI_EVENT)

  1297.                     {

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

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

  1300.                     }

  1301.                     if (portType & LV2_PORT_SUPPORTS_PATCH_MESSAGE)

  1302.                     {

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

  1304.                     }

  1305.                 }

  1306.                 else

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

  1308.             }

  1309.             else if (LV2_IS_PORT_EVENT(portType))

  1310.             {

  1311.                 if (LV2_IS_PORT_INPUT(portType))

  1312.                 {

  1313.                     j = evIn.count++;

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

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

  1316. 

  1317.                     if (portType & LV2_PORT_SUPPORTS_MIDI_EVENT)

  1318.                     {

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

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

  1321.                     }

  1322.                 }

  1323.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1324.                 {

  1325.                     j = evOut.count++;

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

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

  1328. 

  1329.                     if (portType & LV2_PORT_SUPPORTS_MIDI_EVENT)

  1330.                     {

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

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

  1333.                     }

  1334.                 }

  1335.                 else

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

  1337.             }

  1338.             else if (LV2_IS_PORT_MIDI_LL(portType))

  1339.             {

  1340.                 if (LV2_IS_PORT_INPUT(portType))

  1341.                 {

  1342.                     j = evIn.count++;

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

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

  1345. 

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

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

  1348.                 }

  1349.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1350.                 {

  1351.                     j = evOut.count++;

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

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

  1354. 

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

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

  1357.                 }

  1358.                 else

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

  1360.             }

  1361.             else if (LV2_IS_PORT_CONTROL(portType))

  1362.             {

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

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

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

  1366. 

  1367.                 j = param.count++;

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

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

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

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

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

  1373. 

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

  1375. 

  1376.                 // min value

  1377.                 if (LV2_HAVE_MINIMUM_PORT_POINT(portPoints.Hints))

  1378.                     min = portPoints.Minimum;

  1379.                 else

  1380.                     min = 0.0;

  1381. 

  1382.                 // max value

  1383.                 if (LV2_HAVE_MAXIMUM_PORT_POINT(portPoints.Hints))

  1384.                     max = portPoints.Maximum;

  1385.                 else

  1386.                     max = 1.0;

  1387. 

  1388.                 if (min > max)

  1389.                     max = min;

  1390.                 else if (max < min)

  1391.                     min = max;

  1392. 

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

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

  1395.                 {

  1396.                     min = 0.0;

  1397.                     max = 16777215.0; // 0xffffff

  1398.                 }

  1399. 

  1400.                 if (max - min == 0.0)

  1401.                 {

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

  1403.                     max = min + 0.1;

  1404.                 }

  1405. 

  1406.                 // default value

  1407.                 if (LV2_HAVE_DEFAULT_PORT_POINT(portPoints.Hints))

  1408.                 {

  1409.                     def = portPoints.Default;

  1410.                 }

  1411.                 else

  1412.                 {

  1413.                     // no default value

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

  1415.                         def = 0.0;

  1416.                     else

  1417.                         def = min;

  1418.                 }

  1419. 

  1420.                 if (def < min)

  1421.                     def = min;

  1422.                 else if (def > max)

  1423.                     def = max;

  1424. 

  1425.                 if (LV2_IS_PORT_SAMPLE_RATE(portProps))

  1426.                 {

  1427.                     min *= sampleRate;

  1428.                     max *= sampleRate;

  1429.                     def *= sampleRate;

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

  1431.                 }

  1432. 

  1433.                 if (LV2_IS_PORT_TOGGLED(portProps))

  1434.                 {

  1435.                     step = max - min;

  1436.                     stepSmall = step;

  1437.                     stepLarge = step;

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

  1439.                 }

  1440.                 else if (LV2_IS_PORT_INTEGER(portProps))

  1441.                 {

  1442.                     step = 1.0;

  1443.                     stepSmall = 1.0;

  1444.                     stepLarge = 10.0;

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

  1446.                 }

  1447.                 else

  1448.                 {

  1449.                     double range = max - min;

  1450.                     step = range/100.0;

  1451.                     stepSmall = range/1000.0;

  1452.                     stepLarge = range/10.0;

  1453.                 }

  1454. 

  1455.                 if (LV2_IS_PORT_INPUT(portType))

  1456.                 {

  1457.                     if (LV2_IS_PORT_DESIGNATION_LATENCY(portDesignation))

  1458.                     {

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

  1460.                     }

  1461.                     else if (LV2_IS_PORT_DESIGNATION_SAMPLE_RATE(portDesignation))

  1462.                     {

  1463.                         def = sampleRate;

  1464.                         step = 1.0;

  1465.                         stepSmall = 1.0;

  1466.                         stepLarge = 1.0;

  1467. 

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

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

  1470.                     }

  1471.                     else if (LV2_IS_PORT_DESIGNATION_FREEWHEELING(portDesignation))

  1472.                     {

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

  1474.                     }

  1475.                     else if (LV2_IS_PORT_DESIGNATION_TIME(portDesignation))

  1476.                     {

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

  1478.                     }

  1479.                     else

  1480.                     {

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

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

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

  1484.                         needsCtrlIn = true;

  1485.                     }

  1486. 

  1487.                     // MIDI CC value

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

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

  1490.                     {

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

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

  1493.                     }

  1494.                 }

  1495.                 else if (LV2_IS_PORT_OUTPUT(portType))

  1496.                 {

  1497.                     if (LV2_IS_PORT_DESIGNATION_LATENCY(portDesignation))

  1498.                     {

  1499.                         min = 0.0;

  1500.                         max = sampleRate;

  1501.                         def = 0.0;

  1502.                         step = 1.0;

  1503.                         stepSmall = 1.0;

  1504.                         stepLarge = 1.0;

  1505. 

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

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

  1508.                     }

  1509.                     else if (LV2_IS_PORT_DESIGNATION_SAMPLE_RATE(portDesignation))

  1510.                     {

  1511.                         def = sampleRate;

  1512.                         step = 1.0;

  1513.                         stepSmall = 1.0;

  1514.                         stepLarge = 1.0;

  1515. 

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

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

  1518.                     }

  1519.                     else if (LV2_IS_PORT_DESIGNATION_FREEWHEELING(portDesignation))

  1520.                     {

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

  1522.                     }

  1523.                     else if (LV2_IS_PORT_DESIGNATION_TIME(portDesignation))

  1524.                     {

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

  1526.                     }

  1527.                     else

  1528.                     {

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

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

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

  1532.                         needsCtrlOut = true;

  1533.                     }

  1534.                 }

  1535.                 else

  1536.                 {

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

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

  1539.                 }

  1540. 

  1541.                 // extra parameter hints

  1542.                 if (LV2_IS_PORT_ENUMERATION(portProps))

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

  1544. 

  1545.                 if (LV2_IS_PORT_LOGARITHMIC(portProps))

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

  1547. 

  1548.                 if (LV2_IS_PORT_TRIGGER(portProps))

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

  1550. 

  1551.                 if (LV2_IS_PORT_STRICT_BOUNDS(portProps))

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

  1553. 

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

  1555.                 if (LV2_IS_PORT_NOT_ON_GUI(portProps))

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

  1557. 

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

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

  1560. 

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

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

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

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

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

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

  1567. 

  1568.                 // Start parameters in their default values

  1569.                 paramBuffers[j] = def;

  1570. 

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

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

  1573.             }

  1574.             else

  1575.             {

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

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

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

  1579.             }

  1580.         }

  1581. 

  1582.         if (needsCtrlIn)

  1583.         {

  1584. #ifndef BUILD_BRIDGE

  1585.             if (carlaOptions.processMode != PROCESS_MODE_MULTIPLE_CLIENTS)

  1586.             {

  1587.                 strcpy(portName, m_name);

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

  1589.             }

  1590.             else

  1591. #endif

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

  1593. 

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

  1595.         }

  1596. 

  1597.         if (needsCtrlOut)

  1598.         {

  1599. #ifndef BUILD_BRIDGE

  1600.             if (carlaOptions.processMode != PROCESS_MODE_MULTIPLE_CLIENTS)

  1601.             {

  1602.                 strcpy(portName, m_name);

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

  1604.             }

  1605.             else

  1606. #endif

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

  1608. 

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

  1610.         }

  1611. 

  1612.         aIn.count   = aIns;

  1613.         aOut.count  = aOuts;

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

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

  1616.         param.count = params;

  1617. 

  1618.         // plugin checks

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

  1620. 

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

  1622.             m_hints |= PLUGIN_IS_SYNTH;

  1623. 

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

  1625.             m_hints |= PLUGIN_CAN_DRYWET;

  1626. 

  1627.         if (aOuts > 0)

  1628.             m_hints |= PLUGIN_CAN_VOLUME;

  1629. 

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

  1631.             m_hints |= PLUGIN_CAN_BALANCE;

  1632. 

  1633.         // check extensions

  1634.         ext.state      = nullptr;

  1635.         ext.worker     = nullptr;

  1636.         ext.programs   = nullptr;

  1637. 

  1638.         if (descriptor->extension_data)

  1639.         {

  1640.             if (m_hints & PLUGIN_HAS_EXTENSION_PROGRAMS)

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

  1642. 

  1643.             if (m_hints & PLUGIN_HAS_EXTENSION_STATE)

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

  1645. 

  1646.             if (m_hints & PLUGIN_HAS_EXTENSION_WORKER)

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

  1648.         }

  1649. 

  1650.         reloadPrograms(true);

  1651. 

  1652.         x_client->activate();

  1653. 

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

  1655.     }

  1656. 

  1657.     void reloadPrograms(const bool init)

  1658.     {

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

  1660.         uint32_t i, oldCount = midiprog.count;

  1661. 

  1662.         // Delete old programs

  1663.         if (midiprog.count > 0)

  1664.         {

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

  1666.             {

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

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

  1669.             }

  1670. 

  1671.             delete[] midiprog.data;

  1672.         }

  1673. 

  1674.         midiprog.count = 0;

  1675.         midiprog.data  = nullptr;

  1676. 

  1677.         // Query new programs

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

  1679.         {

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

  1681.                 midiprog.count += 1;

  1682.         }

  1683. 

  1684.         if (midiprog.count > 0)

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

  1686. 

  1687.         // Update data

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

  1689.         {

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

  1691.             Q_ASSERT(pdesc);

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

  1693.             Q_ASSERT(pdesc->name);

  1694. 

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

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

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

  1698.         }

  1699. 

  1700. #ifndef BUILD_BRIDGE

  1701.         // Update OSC Names

  1702.         x_engine->osc_send_set_midi_program_count(m_id, midiprog.count);

  1703. 

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

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

  1706. #endif

  1707. 

  1708.         if (init)

  1709.         {

  1710.             if (midiprog.count > 0)

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

  1712.         }

  1713.         else

  1714.         {

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

  1716. 

  1717.             // Check if current program is invalid

  1718.             bool programChanged = false;

  1719. 

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

  1721.             {

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

  1723.                 midiprog.current = oldCount;

  1724.                 programChanged   = true;

  1725.             }

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

  1727.             {

  1728.                 // current midi program > count

  1729.                 midiprog.current = 0;

  1730.                 programChanged   = true;

  1731.             }

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

  1733.             {

  1734.                 // programs exist now, but not before

  1735.                 midiprog.current = 0;

  1736.                 programChanged   = true;

  1737.             }

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

  1739.             {

  1740.                 // programs existed before, but not anymore

  1741.                 midiprog.current = -1;

  1742.                 programChanged   = true;

  1743.             }

  1744. 

  1745.             if (programChanged)

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

  1747.         }

  1748.     }

  1749. 

  1750.     void prepareForSave()

  1751.     {

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

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

  1754.     }

  1755. 

  1756.     // -------------------------------------------------------------------

  1757.     // Plugin processing

  1758. 

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

  1760.     {

  1761.         uint32_t i, k;

  1762.         uint32_t midiEventCount = 0;

  1763. 

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

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

  1766. 

  1767.         // handle midi from different APIs

  1768.         uint32_t evinAtomOffsets[evIn.count];

  1769.         LV2_Event_Iterator evinEventIters[evIn.count];

  1770.         LV2_MIDIState evinMidiStates[evIn.count];

  1771. 

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

  1773.         {

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

  1775.             {

  1776.                 evinAtomOffsets[i] = 0;

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

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

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

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

  1781.             }

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

  1783.             {

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

  1785.                 lv2_event_begin(&evinEventIters[i], evIn.data[i].event);

  1786.             }

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

  1788.             {

  1789.                 evinMidiStates[i].midi = evIn.data[i].midi;

  1790.                 evinMidiStates[i].frame_count = frames;

  1791.                 evinMidiStates[i].position = 0;

  1792.                 evinMidiStates[i].midi->event_count = 0;

  1793.                 evinMidiStates[i].midi->size = 0;

  1794.             }

  1795.         }

  1796. 

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

  1798.         {

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

  1800.             {

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

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

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

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

  1805.             }

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

  1807.             {

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

  1809.             }

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

  1811.             {

  1812.                 // not needed

  1813.             }

  1814.         }

  1815. 

  1816.         CARLA_PROCESS_CONTINUE_CHECK;

  1817. 

  1818.         // --------------------------------------------------------------------------------------------------------

  1819.         // Input VU

  1820. 

  1821.         if (aIn.count > 0)

  1822.         {

  1823.             uint32_t count = h2 ? 2 : aIn.count;

  1824. 

  1825.             if (count == 1)

  1826.             {

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

  1828.                 {

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

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

  1831.                 }

  1832.             }

  1833.             else if (count > 1)

  1834.             {

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

  1836.                 {

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

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

  1839. 

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

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

  1842.                 }

  1843.             }

  1844.         }

  1845. 

  1846.         CARLA_PROCESS_CONTINUE_CHECK;

  1847. 

  1848.         // --------------------------------------------------------------------------------------------------------

  1849.         // Parameters Input [Automation]

  1850. 

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

  1852.         {

  1853.             bool allNotesOffSent = false;

  1854. 

  1855.             const CarlaEngineControlEvent* cinEvent;

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

  1857. 

  1858.             uint32_t nextBankId = 0;

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

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

  1861. 

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

  1863.             {

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

  1865. 

  1866.                 if (! cinEvent)

  1867.                     continue;

  1868. 

  1869.                 time = cinEvent->time - framesOffset;

  1870. 

  1871.                 if (time >= frames)

  1872.                     continue;

  1873. 

  1874.                 // Control change

  1875.                 switch (cinEvent->type)

  1876.                 {

  1877.                 case CarlaEngineEventNull:

  1878.                     break;

  1879. 

  1880.                 case CarlaEngineEventControlChange:

  1881.                 {

  1882.                     double value;

  1883. 

  1884.                     // Control backend stuff

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

  1886.                     {

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

  1888.                         {

  1889.                             value = cinEvent->value;

  1890.                             setDryWet(value, false, false);

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

  1892.                             continue;

  1893.                         }

  1894. 

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

  1896.                         {

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

  1898.                             setVolume(value, false, false);

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

  1900.                             continue;

  1901.                         }

  1902. 

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

  1904.                         {

  1905.                             double left, right;

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

  1907. 

  1908.                             if (value < 0.0)

  1909.                             {

  1910.                                 left  = -1.0;

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

  1912.                             }

  1913.                             else if (value > 0.0)

  1914.                             {

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

  1916.                                 right = 1.0;

  1917.                             }

  1918.                             else

  1919.                             {

  1920.                                 left  = -1.0;

  1921.                                 right = 1.0;

  1922.                             }

  1923. 

  1924.                             setBalanceLeft(left, false, false);

  1925.                             setBalanceRight(right, false, false);

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

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

  1928.                             continue;

  1929.                         }

  1930.                     }

  1931. 

  1932.                     // Control plugin parameters

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

  1934.                     {

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

  1936.                             continue;

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

  1938.                             continue;

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

  1940.                             continue;

  1941. 

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

  1943.                         {

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

  1945.                             {

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

  1947.                             }

  1948.                             else

  1949.                             {

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

  1951. 

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

  1953.                                     value = rint(value);

  1954.                             }

  1955. 

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

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

  1958.                         }

  1959.                     }

  1960. 

  1961.                     break;

  1962.                 }

  1963. 

  1964.                 case CarlaEngineEventMidiBankChange:

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

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

  1967.                     break;

  1968. 

  1969.                 case CarlaEngineEventMidiProgramChange:

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

  1971.                     {

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

  1973. 

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

  1975.                         {

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

  1977.                             {

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

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

  1980.                                 break;

  1981.                             }

  1982.                         }

  1983.                     }

  1984.                     break;

  1985. 

  1986.                 case CarlaEngineEventAllSoundOff:

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

  1988.                     {

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

  1990.                             sendMidiAllNotesOff();

  1991. 

  1992.                         if (descriptor->deactivate)

  1993.                         {

  1994.                             descriptor->deactivate(handle);

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

  1996.                         }

  1997. 

  1998.                         if (descriptor->activate)

  1999.                         {

  2000.                             descriptor->activate(handle);

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

  2002.                         }

  2003. 

  2004.                         allNotesOffSent = true;

  2005.                     }

  2006.                     break;

  2007. 

  2008.                 case CarlaEngineEventAllNotesOff:

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

  2010.                     {

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

  2012.                             sendMidiAllNotesOff();

  2013. 

  2014.                         allNotesOffSent = true;

  2015.                     }

  2016.                     break;

  2017.                 }

  2018.             }

  2019.         } // End of Parameters Input

  2020. 

  2021.         CARLA_PROCESS_CONTINUE_CHECK;

  2022. 

  2023.         // --------------------------------------------------------------------------------------------------------

  2024.         // MIDI Input

  2025. 

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

  2027.         {

  2028.             // ----------------------------------------------------------------------------------------------------

  2029.             // MIDI Input (External)

  2030. 

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

  2032.             {

  2033.                 engineMidiLock();

  2034. 

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

  2036.                 {

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

  2038.                         break;

  2039. 

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

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

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

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

  2044. 

  2045.                     // send to all midi inputs

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

  2047.                     {

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

  2049.                         {

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

  2051.                             {

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

  2053.                                 aev->time.frames = 0;

  2054.                                 aev->body.type   = CARLA_URI_MAP_ID_MIDI_EVENT;

  2055.                                 aev->body.size   = 3;

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

  2057. 

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

  2059.                                 evinAtomOffsets[k]           += padSize;

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

  2061.                             }

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

  2063.                             {

  2064.                                 lv2_event_write(&evinEventIters[k], 0, 0, CARLA_URI_MAP_ID_MIDI_EVENT, 3, midiEvent);

  2065.                             }

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

  2067.                             {

  2068.                                 lv2midi_put_event(&evinMidiStates[k], 0, 3, midiEvent);

  2069.                             }

  2070.                         }

  2071.                     }

  2072. 

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

  2074.                     midiEventCount += 1;

  2075.                 }

  2076. 

  2077.                 engineMidiUnlock();

  2078. 

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

  2080. 

  2081.             CARLA_PROCESS_CONTINUE_CHECK;

  2082. 

  2083.             // ----------------------------------------------------------------------------------------------------

  2084.             // MIDI Input (System)

  2085. 

  2086.             {

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

  2088.                 {

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

  2090.                         continue;

  2091. 

  2092.                     const CarlaEngineMidiEvent* minEvent;

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

  2094. 

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

  2096.                     {

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

  2098. 

  2099.                         if (! minEvent)

  2100.                             continue;

  2101. 

  2102.                         time = minEvent->time - framesOffset;

  2103. 

  2104.                         if (time >= frames)

  2105.                             continue;

  2106. 

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

  2108.                         uint8_t channel = status & 0x0F;

  2109. 

  2110.                         // Fix bad note-off

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

  2112.                             status -= 0x10;

  2113. 

  2114.                         // only write supported status types

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

  2116.                         {

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

  2118.                             {

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

  2120.                                 aev->time.frames = time;

  2121.                                 aev->body.type   = CARLA_URI_MAP_ID_MIDI_EVENT;

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

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

  2124. 

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

  2126.                                 evinAtomOffsets[i]           += padSize;

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

  2128.                             }

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

  2130.                             {

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

  2132.                             }

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

  2134.                             {

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

  2136.                             }

  2137. 

  2138.                             if (MIDI_IS_STATUS_NOTE_OFF(status))

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

  2140.                             else if (MIDI_IS_STATUS_NOTE_ON(status))

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

  2142.                         }

  2143. 

  2144.                         midiEventCount += 1;

  2145.                     }

  2146.                 }

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

  2148. 

  2149.         } // End of MIDI Input

  2150. 

  2151.         CARLA_PROCESS_CONTINUE_CHECK;

  2152. 

  2153.         // --------------------------------------------------------------------------------------------------------

  2154.         // Special Parameters

  2155. 

  2156.         {

  2157.             int32_t rindex;

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

  2159. 

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

  2161.             {

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

  2163.                 {

  2164.                     // TODO

  2165.                 }

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

  2167.                 {

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

  2169.                 }

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

  2171.                 {

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

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

  2174. 

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

  2176.                     {

  2177.                     case LV2_PORT_DESIGNATION_TIME_BAR:

  2178.                         if (timeInfo->valid & CarlaEngineTimeBBT)

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

  2180.                         break;

  2181.                     case LV2_PORT_DESIGNATION_TIME_BAR_BEAT:

  2182.                         if (timeInfo->valid & CarlaEngineTimeBBT)

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

  2184.                         break;

  2185.                     case LV2_PORT_DESIGNATION_TIME_BEAT:

  2186.                         if (timeInfo->valid & CarlaEngineTimeBBT)

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

  2188.                         break;

  2189.                     case LV2_PORT_DESIGNATION_TIME_BEAT_UNIT:

  2190.                         if (timeInfo->valid & CarlaEngineTimeBBT)

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

  2192.                         break;

  2193.                     case LV2_PORT_DESIGNATION_TIME_BEATS_PER_BAR:

  2194.                         if (timeInfo->valid & CarlaEngineTimeBBT)

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

  2196.                         break;

  2197.                     case LV2_PORT_DESIGNATION_TIME_BEATS_PER_MINUTE:

  2198.                         if (timeInfo->valid & CarlaEngineTimeBBT)

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

  2200.                         break;

  2201. 

  2202.                     case LV2_PORT_DESIGNATION_TIME_FRAME:

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

  2204.                         break;

  2205.                     case LV2_PORT_DESIGNATION_TIME_FRAMES_PER_SECOND:

  2206.                         break;

  2207.                     case LV2_PORT_DESIGNATION_TIME_POSITION:

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

  2209.                         break;

  2210.                     case LV2_PORT_DESIGNATION_TIME_SPEED:

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

  2212.                         break;

  2213.                     }

  2214.                 }

  2215.             }

  2216.         }

  2217. 

  2218.         CARLA_PROCESS_CONTINUE_CHECK;

  2219. 

  2220.         // --------------------------------------------------------------------------------------------------------

  2221.         // Plugin processing

  2222. 

  2223.         if (m_active)

  2224.         {

  2225.             if (! m_activeBefore)

  2226.             {

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

  2228.                 {

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

  2230.                     midiEvent1[0] = MIDI_STATUS_CONTROL_CHANGE + m_ctrlInChannel;

  2231.                     midiEvent1[1] = MIDI_CONTROL_ALL_SOUND_OFF;

  2232. 

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

  2234.                     midiEvent2[0] = MIDI_STATUS_CONTROL_CHANGE + m_ctrlInChannel;

  2235.                     midiEvent2[1] = MIDI_CONTROL_ALL_SOUND_OFF;

  2236. 

  2237.                     // send to all midi inputs

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

  2239.                     {

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

  2241.                         {

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

  2243.                             {

  2244.                                 // all sound off

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

  2246.                                 aev1->time.frames = 0;

  2247.                                 aev1->body.type   = CARLA_URI_MAP_ID_MIDI_EVENT;

  2248.                                 aev1->body.size   = 2;

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

  2250. 

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

  2252.                                 evinAtomOffsets[k]           += padSize;

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

  2254. 

  2255.                                 // all notes off

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

  2257.                                 aev2->time.frames = 0;

  2258.                                 aev2->body.type   = CARLA_URI_MAP_ID_MIDI_EVENT;

  2259.                                 aev2->body.size   = 2;

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

  2261. 

  2262.                                 evinAtomOffsets[k]           += padSize;

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

  2264.                             }

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

  2266.                             {

  2267.                                 lv2_event_write(&evinEventIters[k], 0, 0, CARLA_URI_MAP_ID_MIDI_EVENT, 2, midiEvent1);

  2268.                                 lv2_event_write(&evinEventIters[k], 0, 0, CARLA_URI_MAP_ID_MIDI_EVENT, 2, midiEvent2);

  2269.                             }

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

  2271.                             {

  2272.                                 lv2midi_put_event(&evinMidiStates[k], 0, 2, midiEvent1);

  2273.                                 lv2midi_put_event(&evinMidiStates[k], 0, 2, midiEvent2);

  2274.                             }

  2275.                         }

  2276.                     }

  2277. 

  2278.                     midiEventCount = 2;

  2279.                 }

  2280. 

  2281.                 if (descriptor->activate)

  2282.                 {

  2283.                     descriptor->activate(handle);

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

  2285.                 }

  2286.             }

  2287. 

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

  2289.             {

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

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

  2292.             }

  2293. 

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

  2295.             {

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

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

  2298.             }

  2299. 

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

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

  2302.         }

  2303.         else

  2304.         {

  2305.             if (m_activeBefore)

  2306.             {

  2307.                 if (descriptor->deactivate)

  2308.                 {

  2309.                     descriptor->deactivate(handle);

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

  2311.                 }

  2312.             }

  2313.         }

  2314. 

  2315.         CARLA_PROCESS_CONTINUE_CHECK;

  2316. 

  2317.         // --------------------------------------------------------------------------------------------------------

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

  2319. 

  2320.         if (m_active)

  2321.         {

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

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

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

  2325. 

  2326.             double bal_rangeL, bal_rangeR;

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

  2328. 

  2329.             uint32_t count = h2 ? 2 : aOut.count;

  2330. 

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

  2332.             {

  2333.                 // Dry/Wet

  2334.                 if (do_drywet)

  2335.                 {

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

  2337.                     {

  2338.                         if (aOut.count == 1 && ! h2)

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

  2340.                         else

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

  2342.                     }

  2343.                 }

  2344. 

  2345.                 // Balance

  2346.                 if (do_balance)

  2347.                 {

  2348.                     if (i%2 == 0)

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

  2350. 

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

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

  2353. 

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

  2355.                     {

  2356.                         if (i%2 == 0)

  2357.                         {

  2358.                             // left output

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

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

  2361.                         }

  2362.                         else

  2363.                         {

  2364.                             // right

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

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

  2367.                         }

  2368.                     }

  2369.                 }

  2370. 

  2371.                 // Volume

  2372.                 if (do_volume)

  2373.                 {

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

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

  2376.                 }

  2377. 

  2378.                 // Output VU

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

  2380.                 {

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

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

  2383.                 }

  2384.             }

  2385.         }

  2386.         else

  2387.         {

  2388.             // disable any output sound if not active

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

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

  2391. 

  2392.             aOutsPeak[0] = 0.0;

  2393.             aOutsPeak[1] = 0.0;

  2394. 

  2395.         } // End of Post-processing

  2396. 

  2397.         CARLA_PROCESS_CONTINUE_CHECK;

  2398. 

  2399.         // --------------------------------------------------------------------------------------------------------

  2400.         // Control Output

  2401. 

  2402.         if (param.portCout && m_active)

  2403.         {

  2404.             double value;

  2405. 

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

  2407.             {

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

  2409.                 {

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

  2411. 

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

  2413.                     {

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

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

  2416.                     }

  2417.                 }

  2418.             }

  2419.         } // End of Control Output

  2420. 

  2421.         CARLA_PROCESS_CONTINUE_CHECK;

  2422. 

  2423.         // --------------------------------------------------------------------------------------------------------

  2424.         // MIDI Output

  2425. 

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

  2427.         {

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

  2429.             {

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

  2431.                     continue;

  2432. 

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

  2434.                 {

  2435.                     // TODO

  2436.                 }

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

  2438.                 {

  2439.                     const LV2_Event* ev;

  2440.                     LV2_Event_Iterator iter;

  2441. 

  2442.                     uint8_t* data;

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

  2444. 

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

  2446.                     {

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

  2448. 

  2449.                         if (ev && data)

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

  2451. 

  2452.                         lv2_event_increment(&iter);

  2453.                     }

  2454.                 }

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

  2456.                 {

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

  2458. 

  2459.                     uint32_t eventSize;

  2460.                     double   eventTime;

  2461.                     unsigned char* eventData;

  2462. 

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

  2464.                     {

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

  2466.                         lv2midi_step(&state);

  2467.                     }

  2468.                 }

  2469.             }

  2470.         } // End of MIDI Output

  2471. 

  2472.         CARLA_PROCESS_CONTINUE_CHECK;

  2473. 

  2474.         // --------------------------------------------------------------------------------------------------------

  2475.         // Peak Values

  2476. 

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

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

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

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

  2481. 

  2482.         m_activeBefore = m_active;

  2483.     }

  2484. 

  2485.     void bufferSizeChanged(const uint32_t newBufferSize)

  2486.     {

  2487.         lv2Options.bufferSize = newBufferSize;

  2488.     }

  2489. 

  2490.     // -------------------------------------------------------------------

  2491.     // Post-poned events

  2492. 

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

  2494.     {

  2495.         Q_ASSERT(index < param.count);

  2496. 

  2497.         if (index >= param.count)

  2498.             return;

  2499. 

  2500. #ifndef BUILD_BRIDGE

  2501.         if (gui.type == GUI_EXTERNAL_OSC)

  2502.         {

  2503.             if (osc.data.target)

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

  2505.         }

  2506.         else

  2507. #endif

  2508.         {

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

  2510.             {

  2511.                 float valueF = value;

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

  2513.             }

  2514.         }

  2515.     }

  2516. 

  2517.     void uiMidiProgramChange(const uint32_t index)

  2518.     {

  2519.         Q_ASSERT(index < midiprog.count);

  2520. 

  2521.         if (index >= midiprog.count)

  2522.             return;

  2523. 

  2524. #ifndef BUILD_BRIDGE

  2525.         if (gui.type == GUI_EXTERNAL_OSC)

  2526.         {

  2527.             if (osc.data.target)

  2528.                 osc_send_program(&osc.data, midiprog.data[index].bank, midiprog.data[index].program);

  2529.         }

  2530.         else

  2531. #endif

  2532.         {

  2533.             if (ext.uiprograms)

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

  2535.         }

  2536.     }

  2537. 

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

  2539.     {

  2540.         Q_ASSERT(channel < 16);

  2541.         Q_ASSERT(note < 128);

  2542.         Q_ASSERT(velo < 128);

  2543. 

  2544. #ifndef BUILD_BRIDGE

  2545.         if (gui.type == GUI_EXTERNAL_OSC)

  2546.         {

  2547.             if (osc.data.target)

  2548.             {

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

  2550.                 midiData[1] = MIDI_STATUS_NOTE_ON + channel;

  2551.                 midiData[2] = note;

  2552.                 midiData[3] = velo;

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

  2554.             }

  2555.         }

  2556.         else

  2557. #endif

  2558.         {

  2559.             uiTransferAtom(); // TODO

  2560.         }

  2561.     }

  2562. 

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

  2564.     {

  2565.         Q_ASSERT(channel < 16);

  2566.         Q_ASSERT(note < 128);

  2567. 

  2568. #ifndef BUILD_BRIDGE

  2569.         if (gui.type == GUI_EXTERNAL_OSC)

  2570.         {

  2571.             if (osc.data.target)

  2572.             {

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

  2574.                 midiData[1] = MIDI_STATUS_NOTE_OFF + channel;

  2575.                 midiData[2] = note;

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

  2577.             }

  2578.         }

  2579.         else

  2580. #endif

  2581.         {

  2582.             uiTransferAtom(); // TODO

  2583.         }

  2584.     }

  2585. 

  2586.     // -------------------------------------------------------------------

  2587.     // Cleanup

  2588. 

  2589.     void removeClientPorts()

  2590.     {

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

  2592. 

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

  2594.         {

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

  2596.             {

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

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

  2599.             }

  2600.         }

  2601. 

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

  2603.         {

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

  2605.             {

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

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

  2608.             }

  2609.         }

  2610. 

  2611.         CarlaPlugin::removeClientPorts();

  2612. 

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

  2614.     }

  2615. 

  2616.     void initBuffers()

  2617.     {

  2618.         uint32_t i;

  2619. 

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

  2621.         {

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

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

  2624.         }

  2625. 

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

  2627.         {

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

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

  2630.         }

  2631. 

  2632.         CarlaPlugin::initBuffers();

  2633.     }

  2634. 

  2635.     void deleteBuffers()

  2636.     {

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

  2638. 

  2639.         if (evIn.count > 0)

  2640.         {

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

  2642.             {

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

  2644.                 {

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

  2646.                 }

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

  2648.                 {

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

  2650.                 }

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

  2652.                 {

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

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

  2655.                 }

  2656.             }

  2657. 

  2658.             delete[] evIn.data;

  2659.         }

  2660. 

  2661.         if (evOut.count > 0)

  2662.         {

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

  2664.             {

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

  2666.                 {

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

  2668.                 }

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

  2670.                 {

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

  2672.                 }

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

  2674.                 {

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

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

  2677.                 }

  2678.             }

  2679. 

  2680.             delete[] evOut.data;

  2681.         }

  2682. 

  2683.         if (param.count > 0)

  2684.             delete[] paramBuffers;

  2685. 

  2686.         evIn.count = 0;

  2687.         evIn.data  = nullptr;

  2688. 

  2689.         evOut.count = 0;

  2690.         evOut.data  = nullptr;

  2691. 

  2692.         paramBuffers = nullptr;

  2693. 

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

  2695.     }

  2696. 

  2697.     // -------------------------------------------------------------------

  2698. 

  2699.     uint32_t getCustomURID(const char* const uri)

  2700.     {

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

  2702.         Q_ASSERT(uri);

  2703. 

  2704.         if (! uri)

  2705.             return CARLA_URI_MAP_ID_NULL;

  2706. 

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

  2708.         {

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

  2710.                 return i;

  2711.         }

  2712. 

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

  2714. 

  2715.         return customURIDs.size()-1;

  2716.     }

  2717. 

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

  2719.     {

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

  2721.         Q_ASSERT(urid > CARLA_URI_MAP_ID_NULL);

  2722. 

  2723.         if (urid == CARLA_URI_MAP_ID_NULL)

  2724.             return nullptr;

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

  2726.             return customURIDs[urid];

  2727. 

  2728.         return nullptr;

  2729.     }

  2730. 

  2731.     // -------------------------------------------------------------------

  2732. 

  2733.     void handleTransferAtom()

  2734.     {

  2735.         // TODO

  2736.     }

  2737. 

  2738.     void handleTransferEvent(const char* const type, const char* const key, const char* const stringData)

  2739.     {

  2740.         qDebug("Lv2Plugin::handleEventTransfer(%s, %s, %s)", type, key, stringData);

  2741.         Q_ASSERT(type);

  2742.         Q_ASSERT(key);

  2743.         Q_ASSERT(stringData);

  2744. 

  2745.         QByteArray chunk;

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

  2747. 

  2748.         const LV2_Atom* const atom = (LV2_Atom*)chunk.constData();

  2749.         const LV2_URID uridAtomBlank = getCustomURID(LV2_ATOM__Blank);

  2750.         const LV2_URID uridPatchBody = getCustomURID(LV2_PATCH__body);

  2751.         const LV2_URID uridPatchSet  = getCustomURID(LV2_PATCH__Set);

  2752. 

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

  2754.         {

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

  2756.             return;

  2757.         }

  2758. 

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

  2760. 

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

  2762.         {

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

  2764.             return;

  2765.         }

  2766. 

  2767.         const LV2_Atom_Object* body = nullptr;

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

  2769. 

  2770.         if (! body)

  2771.         {

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

  2773.             return;

  2774.         }

  2775. 

  2776.         LV2_ATOM_OBJECT_FOREACH(body, iter)

  2777.         {

  2778.             CustomDataType dtype  = CUSTOM_DATA_INVALID;

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

  2780.             const char* value     = nullptr;

  2781. 

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

  2783.             {

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

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

  2786.             }

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

  2788.             {

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

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

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

  2792.             }

  2793.             else

  2794.                 value = strdup("");

  2795. 

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

  2797. 

  2798.             free((void*)value);

  2799.         }

  2800.     }

  2801. 

  2802.     // -------------------------------------------------------------------

  2803. 

  2804.     void handleProgramChanged(const int32_t index)

  2805.     {

  2806.         if (index == -1)

  2807.         {

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

  2809.             reloadPrograms(false);

  2810.         }

  2811.         else

  2812.         {

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

  2814.             {

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

  2816.                 Q_ASSERT(progName);

  2817. 

  2818.                 if (prog.names[index])

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

  2820. 

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

  2822.             }

  2823.         }

  2824. 

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

  2826.     }

  2827. 

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

  2829.     {

  2830.         Q_ASSERT(key > 0);

  2831.         Q_ASSERT(value);

  2832. 

  2833.         CustomDataType dtype;

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

  2835. 

  2836.         if (type == CARLA_URI_MAP_ID_ATOM_CHUNK)

  2837.             dtype = CUSTOM_DATA_CHUNK;

  2838.         else if (type == CARLA_URI_MAP_ID_ATOM_PATH)

  2839.             dtype = CUSTOM_DATA_PATH;

  2840.         else if (type == CARLA_URI_MAP_ID_ATOM_STRING)

  2841.             dtype = CUSTOM_DATA_STRING;

  2842.         else if (type >= CARLA_URI_MAP_ID_COUNT)

  2843.             dtype = CUSTOM_DATA_BINARY;

  2844.         else

  2845.             dtype = CUSTOM_DATA_INVALID;

  2846. 

  2847.         // do basic checks

  2848.         if (! uriKey)

  2849.         {

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

  2851.             return LV2_STATE_ERR_NO_PROPERTY;

  2852.         }

  2853. 

  2854.         if (! flags & LV2_STATE_IS_POD)

  2855.         {

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

  2857.             return LV2_STATE_ERR_BAD_FLAGS;

  2858.         }

  2859. 

  2860.         if (dtype == CUSTOM_DATA_INVALID)

  2861.         {

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

  2863.             return LV2_STATE_ERR_BAD_TYPE;

  2864.         }

  2865. 

  2866.         // Check if we already have this key

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

  2868.         {

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

  2870.             {

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

  2872. 

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

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

  2875.                 else

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

  2877. 

  2878.                 return LV2_STATE_SUCCESS;

  2879.             }

  2880.         }

  2881. 

  2882.         // Otherwise store it

  2883.         CustomData newData;

  2884.         newData.type = dtype;

  2885.         newData.key  = strdup(uriKey);

  2886. 

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

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

  2889.         else

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

  2891. 

  2892.         custom.push_back(newData);

  2893. 

  2894.         return LV2_STATE_SUCCESS;

  2895.     }

  2896. 

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

  2898.     {

  2899.         Q_ASSERT(key > CARLA_URI_MAP_ID_NULL);

  2900. 

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

  2902. 

  2903.         if (! uriKey)

  2904.         {

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

  2906.             return nullptr;

  2907.         }

  2908. 

  2909.         const char* stringData = nullptr;

  2910.         CustomDataType dtype = CUSTOM_DATA_INVALID;

  2911. 

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

  2913.         {

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

  2915.             {

  2916.                 dtype      = custom[i].type;

  2917.                 stringData = custom[i].value;

  2918.                 break;

  2919.             }

  2920.         }

  2921. 

  2922.         if (! stringData)

  2923.         {

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

  2925.             return nullptr;

  2926.         }

  2927. 

  2928.         *size  = 0;

  2929.         *type  = 0;

  2930.         *flags = LV2_STATE_IS_POD;

  2931. 

  2932.         if (dtype == CUSTOM_DATA_STRING)

  2933.         {

  2934.             *size = strlen(stringData);

  2935.             *type = CARLA_URI_MAP_ID_ATOM_STRING;

  2936.             return stringData;

  2937.         }

  2938.         if (dtype == CUSTOM_DATA_PATH)

  2939.         {

  2940.             *size = strlen(stringData);

  2941.             *type = CARLA_URI_MAP_ID_ATOM_PATH;

  2942.             return stringData;

  2943.         }

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

  2945.         {

  2946.             static QByteArray chunk;

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

  2948. 

  2949.             *size = chunk.size();

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

  2951.             return chunk.constData();

  2952.         }

  2953. 

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

  2955.         return nullptr;

  2956.     }

  2957. 

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

  2959.     {

  2960.         // TODO

  2961.         return LV2_WORKER_SUCCESS;

  2962.     }

  2963. 

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

  2965.     {

  2966.         // TODO

  2967.         if (ext.worker)

  2968.             return LV2_WORKER_SUCCESS;

  2969. 

  2970.         return LV2_WORKER_ERR_UNKNOWN;

  2971.     }

  2972. 

  2973.     void handleExternalUiClosed()

  2974.     {

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

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

  2977. 

  2978.         ui.handle = nullptr;

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

  2980.     }

  2981. 

  2982.     uint32_t handleUiPortMap(const char* const symbol)

  2983.     {

  2984.         Q_ASSERT(symbol);

  2985. 

  2986.         if (! symbol)

  2987.             return LV2UI_INVALID_PORT_INDEX;

  2988. 

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

  2990.         {

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

  2992.                 return i;

  2993.         }

  2994. 

  2995.         return LV2UI_INVALID_PORT_INDEX;

  2996.     }

  2997. 

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

  2999.     {

  3000.         Q_ASSERT(width > 0);

  3001.         Q_ASSERT(height > 0);

  3002. 

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

  3004.             return 1;

  3005. 

  3006.         gui.width  = width;

  3007.         gui.height = height;

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

  3009. 

  3010.         return 0;

  3011.     }

  3012. 

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

  3014.     {

  3015.         if (format == 0)

  3016.         {

  3017.             Q_ASSERT(buffer);

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

  3019. 

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

  3021. 

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

  3023.             {

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

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

  3026.             }

  3027.         }

  3028.         else if (format == CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM)

  3029.         {

  3030.             Q_ASSERT(buffer);

  3031. 

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

  3033. 

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

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

  3036.         }

  3037.         else if (format == CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT)

  3038.         {

  3039.             Q_ASSERT(buffer);

  3040. 

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

  3042. 

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

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

  3045.         }

  3046.     }

  3047. 

  3048.     // -------------------------------------------------------------------

  3049. 

  3050. #ifndef BUILD_BRIDGE

  3051.     bool isUiBridgeable(const uint32_t uiId)

  3052.     {

  3053.         Q_ASSERT(rdf_descriptor);

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

  3055. 

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

  3057.             return false;

  3058. 

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

  3060. 

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

  3062.         {

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

  3064.                 return false;

  3065.         }

  3066. 

  3067.         return true;

  3068.     }

  3069. #endif

  3070. 

  3071.     bool isUiResizable()

  3072.     {

  3073.         Q_ASSERT(ui.rdf_descriptor);

  3074. 

  3075.         if (! ui.rdf_descriptor)

  3076.             return false;

  3077. 

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

  3079.         {

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

  3081.                 return false;

  3082.         }

  3083. 

  3084.         return true;

  3085.     }

  3086. 

  3087.     void initExternalUi()

  3088.     {

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

  3090. 

  3091.         ui.widget = nullptr;

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

  3093. 

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

  3095.         {

  3096.             updateUi();

  3097.         }

  3098.         else

  3099.         {

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

  3101.             ui.handle = nullptr;

  3102.             ui.widget = nullptr;

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

  3104.         }

  3105.     }

  3106. 

  3107.     void uiTransferAtom()

  3108.     {

  3109.         // TODO

  3110.     }

  3111. 

  3112.     void uiTransferEvent(const CustomData* const cdata)

  3113.     {

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

  3115.             return;

  3116. 

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

  3118.         const LV2_URID uridPatchSet  = getCustomURID(LV2_PATCH__Set);

  3119.         const LV2_URID uridPatchBody = getCustomURID(LV2_PATCH__body);

  3120. 

  3121.         Sratom*   sratom = sratom_new(URID_Map);

  3122.         SerdChunk chunk  = { nullptr, 0 };

  3123. 

  3124.         LV2_Atom_Forge forge;

  3125.         lv2_atom_forge_init(&forge, URID_Map);

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

  3127. 

  3128.         LV2_Atom_Forge_Frame refFrame, bodyFrame;

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

  3130. 

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

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

  3133. 

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

  3135. 

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

  3137.             lv2_atom_forge_string(&forge, cdata->value, strlen(cdata->value));

  3138.         else if (cdata->type == CUSTOM_DATA_PATH)

  3139.             lv2_atom_forge_path(&forge, cdata->value, strlen(cdata->value));

  3140.         else if (cdata->type == CUSTOM_DATA_CHUNK)

  3141.             lv2_atom_forge_literal(&forge, cdata->value, strlen(cdata->value), CARLA_URI_MAP_ID_ATOM_CHUNK, CARLA_URI_MAP_ID_NULL);

  3142.         else

  3143.             lv2_atom_forge_literal(&forge, cdata->value, strlen(cdata->value), getCustomURID(cdata->key), CARLA_URI_MAP_ID_NULL);

  3144. 

  3145.         lv2_atom_forge_pop(&forge, &bodyFrame);

  3146.         lv2_atom_forge_pop(&forge, &refFrame);

  3147. 

  3148.         const LV2_Atom* const atom = lv2_atom_forge_deref(&forge, ref);

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

  3150. 

  3151.         free((void*)chunk.buf);

  3152.         sratom_free(sratom);

  3153.     }

  3154. 

  3155.     void updateUi()

  3156.     {

  3157.         qDebug("Lv2Plugin::updateUi()");

  3158. 

  3159.         ext.uiprograms = nullptr;

  3160. 

  3161.         if (ui.handle && ui.descriptor)

  3162.         {

  3163.             if (ui.descriptor->extension_data)

  3164.             {

  3165.                 ext.uiprograms = (LV2_Programs_UI_Interface*)ui.descriptor->extension_data(LV2_PROGRAMS__UIInterface);

  3166. 

  3167.                 if (ext.uiprograms && ! ext.uiprograms->select_program)

  3168.                     // invalid

  3169.                     ext.uiprograms = nullptr;

  3170. 

  3171.                 if (ext.uiprograms && midiprog.count > 0 && midiprog.current >= 0)

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

  3173.             }

  3174. 

  3175.             if (ui.descriptor->port_event)

  3176.             {

  3177.                 // get&store custom data to be sent to the UI

  3178.                 prepareForSave();

  3179. 

  3180.                 // update state (custom data)

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

  3182.                     uiTransferEvent(&custom[i]);

  3183. 

  3184.                 // update control ports

  3185.                 float valueF;

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

  3187.                 {

  3188.                     valueF = getParameterValue(i);

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

  3190.                 }

  3191.             }

  3192.         }

  3193.     }

  3194. 

  3195.     // ----------------- Event Feature ---------------------------------------------------

  3196. 

  3197.     static uint32_t carla_lv2_event_ref(const LV2_Event_Callback_Data callback_data, LV2_Event* const event)

  3198.     {

  3199.         qDebug("Lv2Plugin::carla_lv2_event_ref(%p, %p)", callback_data, event);

  3200.         Q_ASSERT(callback_data);

  3201.         Q_ASSERT(event);

  3202. 

  3203.         return 0;

  3204.     }

  3205. 

  3206.     static uint32_t carla_lv2_event_unref(const LV2_Event_Callback_Data callback_data, LV2_Event* const event)

  3207.     {

  3208.         qDebug("Lv2Plugin::carla_lv2_event_unref(%p, %p)", callback_data, event);

  3209.         Q_ASSERT(callback_data);

  3210.         Q_ASSERT(event);

  3211. 

  3212.         return 0;

  3213.     }

  3214. 

  3215.     // ----------------- Logs Feature ----------------------------------------------------

  3216. 

  3217.     static int carla_lv2_log_printf(const LV2_Log_Handle handle, const LV2_URID type, const char* const fmt, ...)

  3218.     {

  3219.         qDebug("Lv2Plugin::carla_lv2_log_printf(%p, %i, \"%s\", ...)", handle, type, fmt);

  3220.         Q_ASSERT(handle);

  3221.         Q_ASSERT(type > 0);

  3222. 

  3223. #ifndef DEBUG

  3224.         if (type == CARLA_URI_MAP_ID_LOG_TRACE)

  3225.             return 0;

  3226. #endif

  3227. 

  3228.         va_list args;

  3229.         va_start(args, fmt);

  3230.         const int ret = carla_lv2_log_vprintf(handle, type, fmt, args);

  3231.         va_end(args);

  3232. 

  3233.         return ret;

  3234.     }

  3235. 

  3236.     static int carla_lv2_log_vprintf(const LV2_Log_Handle handle, const LV2_URID type, const char* const fmt, va_list ap)

  3237.     {

  3238.         qDebug("Lv2Plugin::carla_lv2_log_vprintf(%p, %i, \"%s\", ...)", handle, type, fmt);

  3239.         Q_ASSERT(handle);

  3240.         Q_ASSERT(type > 0);

  3241. 

  3242. #ifndef DEBUG

  3243.         if (type == CARLA_URI_MAP_ID_LOG_TRACE)

  3244.             return 0;

  3245. #endif

  3246. 

  3247.         char buf[8196];

  3248.         vsprintf(buf, fmt, ap);

  3249. 

  3250.         if (*buf == 0)

  3251.             return 0;

  3252. 

  3253.         switch (type)

  3254.         {

  3255.         case CARLA_URI_MAP_ID_LOG_ERROR:

  3256.             qCritical("%s", buf);

  3257.             break;

  3258.         case CARLA_URI_MAP_ID_LOG_NOTE:

  3259.             printf("%s\n", buf);

  3260.             break;

  3261.         case CARLA_URI_MAP_ID_LOG_TRACE:

  3262.             qDebug("%s", buf);

  3263.             break;

  3264.         case CARLA_URI_MAP_ID_LOG_WARNING:

  3265.             qWarning("%s", buf);

  3266.             break;

  3267.         default:

  3268.             break;

  3269.         }

  3270. 

  3271.         return strlen(buf);

  3272.     }

  3273. 

  3274.     // ----------------- Programs Feature ------------------------------------------------

  3275. 

  3276.     static void carla_lv2_program_changed(const LV2_Programs_Handle handle, const int32_t index)

  3277.     {

  3278.         qDebug("Lv2Plugin::carla_lv2_program_changed(%p, %i)", handle, index);

  3279.         Q_ASSERT(handle);

  3280. 

  3281.         if (! handle)

  3282.             return;

  3283. 

  3284.         Lv2Plugin* const plugin = (Lv2Plugin*)handle;

  3285.         plugin->handleProgramChanged(index);

  3286.     }

  3287. 

  3288.     // ----------------- State Feature ---------------------------------------------------

  3289. 

  3290.     static char* carla_lv2_state_make_path(const LV2_State_Make_Path_Handle handle, const char* const path)

  3291.     {

  3292.         qDebug("Lv2Plugin::carla_lv2_state_make_path(%p, \"%s\")", handle, path);

  3293.         Q_ASSERT(handle);

  3294.         Q_ASSERT(path);

  3295. 

  3296.         if (! path)

  3297.             return nullptr;

  3298. 

  3299.         QDir dir;

  3300.         dir.mkpath(path);

  3301.         return strdup(path);

  3302.     }

  3303. 

  3304.     static char* carla_lv2_state_map_abstract_path(const LV2_State_Map_Path_Handle handle, const char* const absolute_path)

  3305.     {

  3306.         qDebug("Lv2Plugin::carla_lv2_state_map_abstract_path(%p, \"%s\")", handle, absolute_path);

  3307.         Q_ASSERT(handle);

  3308.         Q_ASSERT(absolute_path);

  3309. 

  3310.         if (! absolute_path)

  3311.             return nullptr;

  3312. 

  3313.         QDir dir(absolute_path);

  3314.         return strdup(dir.canonicalPath().toUtf8().constData());

  3315.     }

  3316. 

  3317.     static char* carla_lv2_state_map_absolute_path(const LV2_State_Map_Path_Handle handle, const char* const abstract_path)

  3318.     {

  3319.         qDebug("Lv2Plugin::carla_lv2_state_map_absolute_path(%p, \"%s\")", handle, abstract_path);

  3320.         Q_ASSERT(handle);

  3321.         Q_ASSERT(abstract_path);

  3322. 

  3323.         if (! abstract_path)

  3324.             return nullptr;

  3325. 

  3326.         QDir dir(abstract_path);

  3327.         return strdup(dir.absolutePath().toUtf8().constData());

  3328.     }

  3329. 

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

  3331.     {

  3332.         qDebug("Lv2Plugin::carla_lv2_state_store(%p, %i, %p, " P_SIZE ", %i, %i)", handle, key, value, size, type, flags);

  3333.         Q_ASSERT(handle);

  3334. 

  3335.         if (! handle)

  3336.             return LV2_STATE_ERR_UNKNOWN;

  3337. 

  3338.         Lv2Plugin* const plugin = (Lv2Plugin*)handle;

  3339.         return plugin->handleStateStore(key, value, size, type, flags);

  3340.     }

  3341. 

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

  3343.     {

  3344.         qDebug("Lv2Plugin::carla_lv2_state_retrieve(%p, %i, %p, %p, %p)", handle, key, size, type, flags);

  3345.         Q_ASSERT(handle);

  3346. 

  3347.         if (! handle)

  3348.             return nullptr;

  3349. 

  3350.         Lv2Plugin* const plugin = (Lv2Plugin*)handle;

  3351.         return plugin->handleStateRetrieve(key, size, type, flags);

  3352.     }

  3353. 

  3354.     // ----------------- URI-Map Feature -------------------------------------------------

  3355. 

  3356.     static uint32_t carla_lv2_uri_to_id(const LV2_URI_Map_Callback_Data data, const char* const map, const char* const uri)

  3357.     {

  3358.         qDebug("Lv2Plugin::carla_lv2_uri_to_id(%p, \"%s\", \"%s\")", data, map, uri);

  3359.         return carla_lv2_urid_map((LV2_URID_Map_Handle*)data, uri);

  3360.     }

  3361. 

  3362.     // ----------------- URID Feature ----------------------------------------------------

  3363. 

  3364.     static LV2_URID carla_lv2_urid_map(const LV2_URID_Map_Handle handle, const char* const uri)

  3365.     {

  3366.         qDebug("Lv2Plugin::carla_lv2_urid_map(%p, \"%s\")", handle, uri);

  3367.         Q_ASSERT(handle);

  3368.         Q_ASSERT(uri);

  3369. 

  3370.         if (! uri)

  3371.             return CARLA_URI_MAP_ID_NULL;

  3372. 

  3373.         // Atom types

  3374.         if (strcmp(uri, LV2_ATOM__Chunk) == 0)

  3375.             return CARLA_URI_MAP_ID_ATOM_CHUNK;

  3376.         if (strcmp(uri, LV2_ATOM__Double) == 0)

  3377.             return CARLA_URI_MAP_ID_ATOM_DOUBLE;

  3378.         if (strcmp(uri, LV2_ATOM__Int) == 0)

  3379.             return CARLA_URI_MAP_ID_ATOM_INT;

  3380.         if (strcmp(uri, LV2_ATOM__Path) == 0)

  3381.             return CARLA_URI_MAP_ID_ATOM_PATH;

  3382.         if (strcmp(uri, LV2_ATOM__Sequence) == 0)

  3383.             return CARLA_URI_MAP_ID_ATOM_SEQUENCE;

  3384.         if (strcmp(uri, LV2_ATOM__String) == 0)

  3385.             return CARLA_URI_MAP_ID_ATOM_STRING;

  3386.         if (strcmp(uri, LV2_ATOM__atomTransfer) == 0)

  3387.             return CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM;

  3388.         if (strcmp(uri, LV2_ATOM__eventTransfer) == 0)

  3389.             return CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT;

  3390. 

  3391.         // BufSize types

  3392.         if (strcmp(uri, LV2_BUF_SIZE__maxBlockLength) == 0)

  3393.             return CARLA_URI_MAP_ID_BUF_MAX_LENGTH;

  3394.         if (strcmp(uri, LV2_BUF_SIZE__minBlockLength) == 0)

  3395.             return CARLA_URI_MAP_ID_BUF_MIN_LENGTH;

  3396.         if (strcmp(uri, LV2_BUF_SIZE__sequenceSize) == 0)

  3397.             return CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE;

  3398. 

  3399.         // Log types

  3400.         if (strcmp(uri, LV2_LOG__Error) == 0)

  3401.             return CARLA_URI_MAP_ID_LOG_ERROR;

  3402.         if (strcmp(uri, LV2_LOG__Note) == 0)

  3403.             return CARLA_URI_MAP_ID_LOG_NOTE;

  3404.         if (strcmp(uri, LV2_LOG__Trace) == 0)

  3405.             return CARLA_URI_MAP_ID_LOG_TRACE;

  3406.         if (strcmp(uri, LV2_LOG__Warning) == 0)

  3407.             return CARLA_URI_MAP_ID_LOG_WARNING;

  3408. 

  3409.         // Others

  3410.         if (strcmp(uri, LV2_MIDI__MidiEvent) == 0)

  3411.             return CARLA_URI_MAP_ID_MIDI_EVENT;

  3412.         if (strcmp(uri, LV2_PARAMETERS__sampleRate) == 0)

  3413.             return CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE;

  3414. 

  3415.         if (! handle)

  3416.             return CARLA_URI_MAP_ID_NULL;

  3417. 

  3418.         // Custom types

  3419.         Lv2Plugin* const plugin = (Lv2Plugin*)handle;

  3420.         return plugin->getCustomURID(uri);

  3421.     }

  3422. 

  3423.     static const char* carla_lv2_urid_unmap(const LV2_URID_Map_Handle handle, const LV2_URID urid)

  3424.     {

  3425.         qDebug("Lv2Plugin::carla_lv2_urid_unmap(%p, %i)", handle, urid);

  3426.         Q_ASSERT(handle);

  3427.         Q_ASSERT(urid > CARLA_URI_MAP_ID_NULL);

  3428. 

  3429.         if (urid == CARLA_URI_MAP_ID_NULL)

  3430.             return nullptr;

  3431. 

  3432.         // Atom types

  3433.         if (urid == CARLA_URI_MAP_ID_ATOM_CHUNK)

  3434.             return LV2_ATOM__Chunk;

  3435.         if (urid == CARLA_URI_MAP_ID_ATOM_DOUBLE)

  3436.             return LV2_ATOM__Double;

  3437.         if (urid == CARLA_URI_MAP_ID_ATOM_INT)

  3438.             return LV2_ATOM__Int;

  3439.         if (urid == CARLA_URI_MAP_ID_ATOM_PATH)

  3440.             return LV2_ATOM__Path;

  3441.         if (urid == CARLA_URI_MAP_ID_ATOM_SEQUENCE)

  3442.             return LV2_ATOM__Sequence;

  3443.         if (urid == CARLA_URI_MAP_ID_ATOM_STRING)

  3444.             return LV2_ATOM__String;

  3445.         if (urid == CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM)

  3446.             return LV2_ATOM__atomTransfer;

  3447.         if (urid == CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT)

  3448.             return LV2_ATOM__eventTransfer;

  3449. 

  3450.         // BufSize types

  3451.         if (urid == CARLA_URI_MAP_ID_BUF_MAX_LENGTH)

  3452.             return LV2_BUF_SIZE__maxBlockLength;

  3453.         if (urid == CARLA_URI_MAP_ID_BUF_MIN_LENGTH)

  3454.             return LV2_BUF_SIZE__minBlockLength;

  3455.         if (urid == CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE)

  3456.             return LV2_BUF_SIZE__sequenceSize;

  3457. 

  3458.         // Log types

  3459.         if (urid == CARLA_URI_MAP_ID_LOG_ERROR)

  3460.             return LV2_LOG__Error;

  3461.         if (urid == CARLA_URI_MAP_ID_LOG_NOTE)

  3462.             return LV2_LOG__Note;

  3463.         if (urid == CARLA_URI_MAP_ID_LOG_TRACE)

  3464.             return LV2_LOG__Trace;

  3465.         if (urid == CARLA_URI_MAP_ID_LOG_WARNING)

  3466.             return LV2_LOG__Warning;

  3467. 

  3468.         // Others

  3469.         if (urid == CARLA_URI_MAP_ID_MIDI_EVENT)

  3470.             return LV2_MIDI__MidiEvent;

  3471.         if (urid == CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE)

  3472.             return LV2_PARAMETERS__sampleRate;

  3473. 

  3474.         if (! handle)

  3475.             return nullptr;

  3476. 

  3477.         // Custom types

  3478.         Lv2Plugin* const plugin = (Lv2Plugin*)handle;

  3479.         return plugin->getCustomURIString(urid);

  3480.     }

  3481. 

  3482.     // ----------------- Worker Feature --------------------------------------------------

  3483. 

  3484.     static LV2_Worker_Status carla_lv2_worker_schedule(const LV2_Worker_Schedule_Handle handle, const uint32_t size, const void* const data)

  3485.     {

  3486.         qDebug("Lv2Plugin::carla_lv2_worker_schedule(%p, %i, %p)", handle, size, data);

  3487.         Q_ASSERT(handle);

  3488. 

  3489.         if (! handle)

  3490.             return LV2_WORKER_ERR_UNKNOWN;

  3491. 

  3492.         Lv2Plugin* const plugin = (Lv2Plugin*)handle;

  3493.         return plugin->handleWorkerSchedule(size, data);

  3494.     }

  3495. 

  3496.     static LV2_Worker_Status carla_lv2_worker_respond(const LV2_Worker_Respond_Handle handle, const uint32_t size, const void* const data)

  3497.     {

  3498.         qDebug("Lv2Plugin::carla_lv2_worker_respond(%p, %i, %p)", handle, size, data);

  3499.         Q_ASSERT(handle);

  3500. 

  3501.         if (! handle)

  3502.             return LV2_WORKER_ERR_UNKNOWN;

  3503. 

  3504.         Lv2Plugin* const plugin = (Lv2Plugin*)handle;

  3505.         return plugin->handleWorkerRespond(size, data);

  3506.     }

  3507. 

  3508.     // ----------------- UI Port-Map Feature ---------------------------------------------

  3509. 

  3510.     static uint32_t carla_lv2_ui_port_map(const LV2UI_Feature_Handle handle, const char* const symbol)

  3511.     {

  3512.         qDebug("Lv2Plugin::carla_lv2_ui_port_map(%p, \"%s\")", handle, symbol);

  3513.         Q_ASSERT(handle);

  3514. 

  3515.         if (! handle)

  3516.             return LV2UI_INVALID_PORT_INDEX;

  3517. 

  3518.         Lv2Plugin* const plugin = (Lv2Plugin*)handle;

  3519.         return plugin->handleUiPortMap(symbol);

  3520.     }

  3521. 

  3522.     // ----------------- UI Resize Feature -----------------------------------------------

  3523. 

  3524.     static int carla_lv2_ui_resize(const LV2UI_Feature_Handle handle, const int width, const int height)

  3525.     {

  3526.         qDebug("Lv2Plugin::carla_lv2_ui_resize(%p, %i, %i)", handle, width, height);

  3527.         Q_ASSERT(handle);

  3528. 

  3529.         if (! handle)

  3530.             return 1;

  3531. 

  3532.         Lv2Plugin* const plugin  = (Lv2Plugin*)handle;

  3533.         return plugin->handleUiResize(width, height);

  3534.     }

  3535. 

  3536.     // ----------------- External UI Feature ---------------------------------------------

  3537. 

  3538.     static void carla_lv2_external_ui_closed(const LV2UI_Controller controller)

  3539.     {

  3540.         qDebug("Lv2Plugin::carla_lv2_external_ui_closed(%p)", controller);

  3541.         Q_ASSERT(controller);

  3542. 

  3543.         if (! controller)

  3544.             return;

  3545. 

  3546.         Lv2Plugin* const plugin = (Lv2Plugin*)controller;

  3547.         plugin->handleExternalUiClosed();

  3548.     }

  3549. 

  3550.     // ----------------- UI Extension ----------------------------------------------------

  3551. 

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

  3553.     {

  3554.         qDebug("Lv2Plugin::carla_lv2_ui_write_function(%p, %i, %i, %i, %p)", controller, port_index, buffer_size, format, buffer);

  3555.         Q_ASSERT(controller);

  3556. 

  3557.         if (! controller)

  3558.             return;

  3559. 

  3560.         Lv2Plugin* const plugin = (Lv2Plugin*)controller;

  3561.         plugin->handleUiWrite(port_index, buffer_size, format, buffer);

  3562.     }

  3563. 

  3564.     // -------------------------------------------------------------------

  3565. 

  3566.     bool uiLibOpen(const char* const filename)

  3567.     {

  3568.         ui.lib = lib_open(filename);

  3569.         return bool(ui.lib);

  3570.     }

  3571. 

  3572.     bool uiLibClose()

  3573.     {

  3574.         if (ui.lib)

  3575.             return lib_close(ui.lib);

  3576.         return false;

  3577.     }

  3578. 

  3579.     void* uiLibSymbol(const char* const symbol)

  3580.     {

  3581.         if (ui.lib)

  3582.             return lib_symbol(ui.lib, symbol);

  3583.         return nullptr;

  3584.     }

  3585. 

  3586.     // -------------------------------------------------------------------

  3587. 

  3588.     bool init(const char* const bundle, const char* const name, const char* const URI)

  3589.     {

  3590.         // ---------------------------------------------------------------

  3591.         // get plugin from lv2_rdf (lilv)

  3592. 

  3593.         rdf_descriptor = lv2_rdf_new(URI);

  3594. 

  3595.         if (! rdf_descriptor)

  3596.         {

  3597.             setLastError("Failed to find the requested plugin in the LV2 Bundle");

  3598.             return false;

  3599.         }

  3600. 

  3601.         // ---------------------------------------------------------------

  3602.         // open DLL

  3603. 

  3604.         if (! libOpen(rdf_descriptor->Binary))

  3605.         {

  3606.             setLastError(libError(rdf_descriptor->Binary));

  3607.             return false;

  3608.         }

  3609. 

  3610.         // ---------------------------------------------------------------

  3611.         // get DLL main entry

  3612. 

  3613.         const LV2_Descriptor_Function descFn = (LV2_Descriptor_Function)libSymbol("lv2_descriptor");

  3614. 

  3615.         if (! descFn)

  3616.         {

  3617.             setLastError("Could not find the LV2 Descriptor in the plugin library");

  3618.             return false;

  3619.         }

  3620. 

  3621.         // ---------------------------------------------------------------

  3622.         // get descriptor that matches URI

  3623. 

  3624.         uint32_t i = 0;

  3625.         while ((descriptor = descFn(i++)))

  3626.         {

  3627.             if (strcmp(descriptor->URI, URI) == 0)

  3628.                 break;

  3629.         }

  3630. 

  3631.         if (! descriptor)

  3632.         {

  3633.             setLastError("Could not find the requested plugin URI in the plugin library");

  3634.             return false;

  3635.         }

  3636. 

  3637.         // ---------------------------------------------------------------

  3638.         // check supported port-types and features

  3639. 

  3640.         bool canContinue = true;

  3641. 

  3642.         // Check supported ports

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

  3644.         {

  3645.             LV2_Property PortType = rdf_descriptor->Ports[i].Type;

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

  3647.             {

  3648.                 if (! LV2_IS_PORT_OPTIONAL(rdf_descriptor->Ports[i].Properties))

  3649.                 {

  3650.                     setLastError("Plugin requires a port that is not currently supported");

  3651.                     canContinue = false;

  3652.                     break;

  3653.                 }

  3654.             }

  3655.         }

  3656. 

  3657.         // Check supported features

  3658.         for (i=0; i < rdf_descriptor->FeatureCount && canContinue; i++)

  3659.         {

  3660.             if (LV2_IS_FEATURE_REQUIRED(rdf_descriptor->Features[i].Type) && ! is_lv2_feature_supported(rdf_descriptor->Features[i].URI))

  3661.             {

  3662.                 QString msg = QString("Plugin requires a feature that is not supported:\n%1").arg(rdf_descriptor->Features[i].URI);

  3663.                 setLastError(msg.toUtf8().constData());

  3664.                 canContinue = false;

  3665.                 break;

  3666.             }

  3667.         }

  3668. 

  3669.         // Check extensions

  3670.         for (i=0; i < rdf_descriptor->ExtensionCount; i++)

  3671.         {

  3672.             if (strcmp(rdf_descriptor->Extensions[i], LV2_PROGRAMS__Interface) == 0)

  3673.                 m_hints |= PLUGIN_HAS_EXTENSION_PROGRAMS;

  3674.             else if (strcmp(rdf_descriptor->Extensions[i], LV2_STATE__interface) == 0)

  3675.                 m_hints |= PLUGIN_HAS_EXTENSION_STATE;

  3676.             else if (strcmp(rdf_descriptor->Extensions[i], LV2_WORKER__interface) == 0)

  3677.                 m_hints |= PLUGIN_HAS_EXTENSION_WORKER;

  3678.             else

  3679.                 qDebug("Plugin has non-supported extension: '%s'", rdf_descriptor->Extensions[i]);

  3680.         }

  3681. 

  3682.         if (! canContinue)

  3683.         {

  3684.             // error already set

  3685.             return false;

  3686.         }

  3687. 

  3688.         // ---------------------------------------------------------------

  3689.         // initialize features

  3690. 

  3691.         LV2_Event_Feature* const eventFt = new LV2_Event_Feature;

  3692.         eventFt->callback_data           = this;

  3693.         eventFt->lv2_event_ref           = carla_lv2_event_ref;

  3694.         eventFt->lv2_event_unref         = carla_lv2_event_unref;

  3695. 

  3696.         LV2_Log_Log* const logFt         = new LV2_Log_Log;

  3697.         logFt->handle                    = this;

  3698.         logFt->printf                    = carla_lv2_log_printf;

  3699.         logFt->vprintf                   = carla_lv2_log_vprintf;

  3700. 

  3701.         LV2_Programs_Host* const programsFt        = new LV2_Programs_Host;

  3702.         programsFt->handle                         = this;

  3703.         programsFt->program_changed                = carla_lv2_program_changed;

  3704. 

  3705.         LV2_State_Make_Path* const stateMakePathFt = new LV2_State_Make_Path;

  3706.         stateMakePathFt->handle                    = this;

  3707.         stateMakePathFt->path                      = carla_lv2_state_make_path;

  3708. 

  3709.         LV2_State_Map_Path* const stateMapPathFt   = new LV2_State_Map_Path;

  3710.         stateMapPathFt->handle                     = this;

  3711.         stateMapPathFt->abstract_path              = carla_lv2_state_map_abstract_path;

  3712.         stateMapPathFt->absolute_path              = carla_lv2_state_map_absolute_path;

  3713. 

  3714.         LV2_URI_Map_Feature* const uriMapFt = new LV2_URI_Map_Feature;

  3715.         uriMapFt->callback_data             = this;

  3716.         uriMapFt->uri_to_id                 = carla_lv2_uri_to_id;

  3717. 

  3718.         LV2_URID_Map* const uridMapFt       = new LV2_URID_Map;

  3719.         uridMapFt->handle                   = this;

  3720.         uridMapFt->map                      = carla_lv2_urid_map;

  3721. 

  3722.         LV2_URID_Unmap* const uridUnmapFt   = new LV2_URID_Unmap;

  3723.         uridUnmapFt->handle                 = this;

  3724.         uridUnmapFt->unmap                  = carla_lv2_urid_unmap;

  3725. 

  3726.         LV2_Worker_Schedule* const workerFt = new LV2_Worker_Schedule;

  3727.         workerFt->handle                    = this;

  3728.         workerFt->schedule_work             = carla_lv2_worker_schedule;

  3729. 

  3730.         LV2_Options_Option* const optionsFt = new LV2_Options_Option [5];

  3731.         optionsFt[0] = lv2Options.oMaxBlockLenth;

  3732.         optionsFt[1] = lv2Options.oMinBlockLenth;

  3733.         optionsFt[2] = lv2Options.oSequenceSize;

  3734.         optionsFt[3] = lv2Options.oSampleRate;

  3735.         optionsFt[4] = lv2Options.oNull;

  3736. 

  3737.         features[lv2_feature_id_bufsize_bounded]       = new LV2_Feature;

  3738.         features[lv2_feature_id_bufsize_bounded]->URI  = LV2_BUF_SIZE__boundedBlockLength;

  3739.         features[lv2_feature_id_bufsize_bounded]->data = nullptr;

  3740. 

  3741.         if (carlaOptions.processHighPrecision)

  3742.         {

  3743.             features[lv2_feature_id_bufsize_fixed]          = new LV2_Feature;

  3744.             features[lv2_feature_id_bufsize_fixed]->URI     = LV2_BUF_SIZE__fixedBlockLength;

  3745.             features[lv2_feature_id_bufsize_fixed]->data    = nullptr;

  3746. 

  3747.             features[lv2_feature_id_bufsize_powerof2]       = new LV2_Feature;

  3748.             features[lv2_feature_id_bufsize_powerof2]->URI  = LV2_BUF_SIZE__powerOf2BlockLength;

  3749.             features[lv2_feature_id_bufsize_powerof2]->data = nullptr;

  3750.         }

  3751.         else

  3752.         {

  3753.             // fake, used to keep a valid array

  3754.             features[lv2_feature_id_bufsize_fixed]    = features[lv2_feature_id_bufsize_bounded];

  3755.             features[lv2_feature_id_bufsize_powerof2] = features[lv2_feature_id_bufsize_bounded];

  3756.         }

  3757. 

  3758.         features[lv2_feature_id_event]          = new LV2_Feature;

  3759.         features[lv2_feature_id_event]->URI     = LV2_EVENT_URI;

  3760.         features[lv2_feature_id_event]->data    = eventFt;

  3761. 

  3762.         features[lv2_feature_id_logs]           = new LV2_Feature;

  3763.         features[lv2_feature_id_logs]->URI      = LV2_LOG__log;

  3764.         features[lv2_feature_id_logs]->data     = logFt;

  3765. 

  3766.         features[lv2_feature_id_options]        = new LV2_Feature;

  3767.         features[lv2_feature_id_options]->URI   = LV2_OPTIONS__options;

  3768.         features[lv2_feature_id_options]->data  = optionsFt;

  3769. 

  3770.         features[lv2_feature_id_programs]       = new LV2_Feature;

  3771.         features[lv2_feature_id_programs]->URI  = LV2_PROGRAMS__Host;

  3772.         features[lv2_feature_id_programs]->data = programsFt;

  3773. 

  3774.         features[lv2_feature_id_state_make_path]       = new LV2_Feature;

  3775.         features[lv2_feature_id_state_make_path]->URI  = LV2_STATE__makePath;

  3776.         features[lv2_feature_id_state_make_path]->data = stateMakePathFt;

  3777. 

  3778.         features[lv2_feature_id_state_map_path]        = new LV2_Feature;

  3779.         features[lv2_feature_id_state_map_path]->URI   = LV2_STATE__mapPath;

  3780.         features[lv2_feature_id_state_map_path]->data  = stateMapPathFt;

  3781. 

  3782.         features[lv2_feature_id_strict_bounds]         = new LV2_Feature;

  3783.         features[lv2_feature_id_strict_bounds]->URI    = LV2_PORT_PROPS__supportsStrictBounds;

  3784.         features[lv2_feature_id_strict_bounds]->data   = nullptr;

  3785. 

  3786.         features[lv2_feature_id_uri_map]          = new LV2_Feature;

  3787.         features[lv2_feature_id_uri_map]->URI     = LV2_URI_MAP_URI;

  3788.         features[lv2_feature_id_uri_map]->data    = uriMapFt;

  3789. 

  3790.         features[lv2_feature_id_urid_map]         = new LV2_Feature;

  3791.         features[lv2_feature_id_urid_map]->URI    = LV2_URID__map;

  3792.         features[lv2_feature_id_urid_map]->data   = uridMapFt;

  3793. 

  3794.         features[lv2_feature_id_urid_unmap]       = new LV2_Feature;

  3795.         features[lv2_feature_id_urid_unmap]->URI  = LV2_URID__unmap;

  3796.         features[lv2_feature_id_urid_unmap]->data = uridUnmapFt;

  3797. 

  3798.         features[lv2_feature_id_worker]           = new LV2_Feature;

  3799.         features[lv2_feature_id_worker]->URI      = LV2_WORKER__schedule;

  3800.         features[lv2_feature_id_worker]->data     = workerFt;

  3801. 

  3802.         // ---------------------------------------------------------------

  3803.         // initialize plugin

  3804. 

  3805.         handle = descriptor->instantiate(descriptor, x_engine->getSampleRate(), rdf_descriptor->Bundle, features);

  3806. 

  3807.         if (! handle)

  3808.         {

  3809.             setLastError("Plugin failed to initialize");

  3810.             return false;

  3811.         }

  3812. 

  3813.         // ---------------------------------------------------------------

  3814.         // get info

  3815. 

  3816.         m_filename = strdup(bundle);

  3817. 

  3818.         if (name)

  3819.             m_name = x_engine->getUniqueName(name);

  3820.         else

  3821.             m_name = x_engine->getUniqueName(rdf_descriptor->Name);

  3822. 

  3823.         // ---------------------------------------------------------------

  3824.         // register client

  3825. 

  3826.         x_client = x_engine->addClient(this);

  3827. 

  3828.         if (! x_client->isOk())

  3829.         {

  3830.             setLastError("Failed to register plugin client");

  3831.             return false;

  3832.         }

  3833. 

  3834.         // ---------------------------------------------------------------

  3835.         // gui stuff

  3836. 

  3837.         if (rdf_descriptor->UICount == 0)

  3838.             return true;

  3839. 

  3840.         // -----------------------------------------------------------

  3841.         // find more appropriate ui

  3842. 

  3843.         int eQt4, eCocoa, eHWND, eX11, eGtk2, eGtk3, iCocoa, iHWND, iX11, iQt4, iExt, iSuil, iFinal;

  3844.         eQt4 = eCocoa = eHWND = eX11 = eGtk2 = eGtk3 = iQt4 = iCocoa = iHWND = iX11 = iExt = iSuil = iFinal = -1;

  3845. 

  3846.         for (i=0; i < rdf_descriptor->UICount; i++)

  3847.         {

  3848.             switch (rdf_descriptor->UIs[i].Type)

  3849.             {

  3850.             case LV2_UI_QT4:

  3851. #ifndef BUILD_BRIDGE

  3852.                 if (isUiBridgeable(i) && carlaOptions.preferUiBridges)

  3853.                     eQt4 = i;

  3854. #endif

  3855.                 iQt4 = i;

  3856.                 break;

  3857. 

  3858.             case LV2_UI_COCOA:

  3859. #ifndef BUILD_BRIDGE

  3860.                 if (isUiBridgeable(i) && carlaOptions.preferUiBridges)

  3861.                     eCocoa = i;

  3862. #endif

  3863.                 iCocoa = i;

  3864.                 break;

  3865. 

  3866.             case LV2_UI_WINDOWS:

  3867. #ifndef BUILD_BRIDGE

  3868.                 if (isUiBridgeable(i) && carlaOptions.preferUiBridges)

  3869.                     eHWND = i;

  3870. #endif

  3871.                 iHWND = i;

  3872.                 break;

  3873. 

  3874.             case LV2_UI_X11:

  3875. #ifndef BUILD_BRIDGE

  3876.                 if (isUiBridgeable(i) && carlaOptions.preferUiBridges)

  3877.                     eX11 = i;

  3878. #endif

  3879.                 iX11 = i;

  3880.                 break;

  3881. 

  3882.             case LV2_UI_GTK2:

  3883. #ifdef BUILD_BRIDGE

  3884.                 if (false)

  3885. #else

  3886. #  ifdef HAVE_SUIL

  3887.                 if (isUiBridgeable(i) && carlaOptions.preferUiBridges)

  3888. #  else

  3889.                 if (isUiBridgeable(i))

  3890. #  endif

  3891. #endif

  3892.                     eGtk2 = i;

  3893. #ifdef HAVE_SUIL

  3894.                 iSuil = i;

  3895. #endif

  3896.                 break;

  3897. 

  3898. #ifndef BUILD_BRIDGE

  3899.             case LV2_UI_GTK3:

  3900.                 if (isUiBridgeable(i))

  3901.                     eGtk3 = i;

  3902.                 break;

  3903. #endif

  3904. 

  3905.             case LV2_UI_EXTERNAL:

  3906.             case LV2_UI_OLD_EXTERNAL:

  3907.                 iExt = i;

  3908.                 break;

  3909. 

  3910.             default:

  3911.                 break;

  3912.             }

  3913.         }

  3914. 

  3915.         if (eQt4 >= 0)

  3916.             iFinal = eQt4;

  3917.         else if (eCocoa >= 0)

  3918.             iFinal = eCocoa;

  3919.         else if (eHWND >= 0)

  3920.             iFinal = eHWND;

  3921.         else if (eX11 >= 0)

  3922.             iFinal = eX11;

  3923.         else if (eGtk2 >= 0)

  3924.             iFinal = eGtk2;

  3925.         else if (eGtk3 >= 0)

  3926.             iFinal = eGtk3;

  3927.         else if (iQt4 >= 0)

  3928.             iFinal = iQt4;

  3929.         else if (iCocoa >= 0)

  3930.             iFinal = iCocoa;

  3931.         else if (iHWND >= 0)

  3932.             iFinal = iHWND;

  3933.         else if (iX11 >= 0)

  3934.             iFinal = iX11;

  3935.         else if (iExt >= 0)

  3936.             iFinal = iExt;

  3937.         else if (iSuil >= 0)

  3938.             iFinal = iSuil;

  3939. 

  3940. #ifndef BUILD_BRIDGE

  3941.         const bool isBridged = (iFinal == eQt4 || iFinal == eCocoa || iFinal == eHWND || iFinal == eX11 || iFinal == eGtk2 || iFinal == eGtk3);

  3942. #endif

  3943. #ifdef HAVE_SUIL

  3944.         const bool isSuil = (iFinal == iSuil && !isBridged);

  3945. #endif

  3946. 

  3947.         if (iFinal < 0)

  3948.         {

  3949.             qWarning("Failed to find an appropriate LV2 UI for this plugin");

  3950.             return true;

  3951.         }

  3952. 

  3953.         ui.rdf_descriptor = &rdf_descriptor->UIs[iFinal];

  3954. 

  3955.         // -----------------------------------------------------------

  3956.         // check supported ui features

  3957. 

  3958.         canContinue = true;

  3959. 

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

  3961.         {

  3962.             if (LV2_IS_FEATURE_REQUIRED(ui.rdf_descriptor->Features[i].Type) && is_lv2_ui_feature_supported(ui.rdf_descriptor->Features[i].URI) == false)

  3963.             {

  3964.                 qCritical("Plugin UI requires a feature that is not supported:\n%s", ui.rdf_descriptor->Features[i].URI);

  3965.                 canContinue = false;

  3966.                 break;

  3967.             }

  3968.         }

  3969. 

  3970.         if (! canContinue)

  3971.         {

  3972.             ui.rdf_descriptor = nullptr;

  3973.             return true;

  3974.         }

  3975. 

  3976. #ifdef HAVE_SUIL

  3977.         if (isSuil)

  3978.         {

  3979.             // -------------------------------------------------------

  3980.             // init suil host

  3981. 

  3982.             suil.host = suil_host_new(carla_lv2_ui_write_function, carla_lv2_ui_port_map, nullptr, nullptr);

  3983.         }

  3984.         else

  3985. #endif

  3986.         {

  3987.             // -------------------------------------------------------

  3988.             // open DLL

  3989. 

  3990.             if (! uiLibOpen(ui.rdf_descriptor->Binary))

  3991.             {

  3992.                 qCritical("Could not load UI library, error was:\n%s", libError(ui.rdf_descriptor->Binary));

  3993.                 ui.rdf_descriptor = nullptr;

  3994.                 return true;

  3995.             }

  3996. 

  3997.             // -------------------------------------------------------

  3998.             // get DLL main entry

  3999. 

  4000.             LV2UI_DescriptorFunction ui_descFn = (LV2UI_DescriptorFunction)uiLibSymbol("lv2ui_descriptor");

  4001. 

  4002.             if (! ui_descFn)

  4003.             {

  4004.                 qCritical("Could not find the LV2UI Descriptor in the UI library");

  4005.                 uiLibClose();

  4006.                 ui.lib = nullptr;

  4007.                 ui.rdf_descriptor = nullptr;

  4008.                 return true;

  4009.             }

  4010. 

  4011.             // -------------------------------------------------------

  4012.             // get descriptor that matches URI

  4013. 

  4014.             i = 0;

  4015.             while ((ui.descriptor = ui_descFn(i++)))

  4016.             {

  4017.                 if (strcmp(ui.descriptor->URI, ui.rdf_descriptor->URI) == 0)

  4018.                     break;

  4019.             }

  4020. 

  4021.             if (! ui.descriptor)

  4022.             {

  4023.                 qCritical("Could not find the requested GUI in the plugin UI library");

  4024.                 uiLibClose();

  4025.                 ui.lib = nullptr;

  4026.                 ui.rdf_descriptor = nullptr;

  4027.                 return true;

  4028.             }

  4029.         }

  4030. 

  4031.         // -----------------------------------------------------------

  4032.         // initialize ui according to type

  4033. 

  4034.         const LV2_Property uiType = ui.rdf_descriptor->Type;

  4035. 

  4036. #ifndef BUILD_BRIDGE

  4037.         if (isBridged)

  4038.         {

  4039.             // -------------------------------------------------------

  4040.             // initialize ui bridge

  4041. 

  4042.             if (const char* const oscBinary = lv2bridge2str(uiType))

  4043.             {

  4044.                 gui.type = GUI_EXTERNAL_OSC;

  4045.                 osc.thread = new CarlaPluginThread(x_engine, this, CarlaPluginThread::PLUGIN_THREAD_LV2_GUI);

  4046.                 osc.thread->setOscData(oscBinary, descriptor->URI, ui.descriptor->URI);

  4047.             }

  4048.         }

  4049.         else

  4050. #endif

  4051.         {

  4052.             // -------------------------------------------------------

  4053.             // initialize ui features

  4054. 

  4055.             QString guiTitle = QString("%1 (GUI)").arg(m_name);

  4056. 

  4057.             LV2_Extension_Data_Feature* const uiDataFt = new LV2_Extension_Data_Feature;

  4058.             uiDataFt->data_access                      = descriptor->extension_data;

  4059. 

  4060.             LV2UI_Port_Map* const uiPortMapFt = new LV2UI_Port_Map;

  4061.             uiPortMapFt->handle               = this;

  4062.             uiPortMapFt->port_index           = carla_lv2_ui_port_map;

  4063. 

  4064.             LV2UI_Resize* const uiResizeFt    = new LV2UI_Resize;

  4065.             uiResizeFt->handle                = this;

  4066.             uiResizeFt->ui_resize             = carla_lv2_ui_resize;

  4067. 

  4068.             lv2_external_ui_host* const uiExternalHostFt = new lv2_external_ui_host;

  4069.             uiExternalHostFt->ui_closed                  = carla_lv2_external_ui_closed;

  4070.             uiExternalHostFt->plugin_human_id            = strdup(guiTitle.toUtf8().constData());

  4071. 

  4072.             features[lv2_feature_id_data_access]           = new LV2_Feature;

  4073.             features[lv2_feature_id_data_access]->URI      = LV2_DATA_ACCESS_URI;

  4074.             features[lv2_feature_id_data_access]->data     = uiDataFt;

  4075. 

  4076.             features[lv2_feature_id_instance_access]       = new LV2_Feature;

  4077.             features[lv2_feature_id_instance_access]->URI  = LV2_INSTANCE_ACCESS_URI;

  4078.             features[lv2_feature_id_instance_access]->data = handle;

  4079. 

  4080.             features[lv2_feature_id_ui_parent]             = new LV2_Feature;

  4081.             features[lv2_feature_id_ui_parent]->URI        = LV2_UI__parent;

  4082.             features[lv2_feature_id_ui_parent]->data       = nullptr;

  4083. 

  4084.             features[lv2_feature_id_ui_port_map]           = new LV2_Feature;

  4085.             features[lv2_feature_id_ui_port_map]->URI      = LV2_UI__portMap;

  4086.             features[lv2_feature_id_ui_port_map]->data     = uiPortMapFt;

  4087. 

  4088.             features[lv2_feature_id_ui_resize]             = new LV2_Feature;

  4089.             features[lv2_feature_id_ui_resize]->URI        = LV2_UI__resize;

  4090.             features[lv2_feature_id_ui_resize]->data       = uiResizeFt;

  4091. 

  4092.             features[lv2_feature_id_external_ui]           = new LV2_Feature;

  4093.             features[lv2_feature_id_external_ui]->URI      = LV2_EXTERNAL_UI_URI;

  4094.             features[lv2_feature_id_external_ui]->data     = uiExternalHostFt;

  4095. 

  4096.             features[lv2_feature_id_external_ui_old]       = new LV2_Feature;

  4097.             features[lv2_feature_id_external_ui_old]->URI  = LV2_EXTERNAL_UI_DEPRECATED_URI;

  4098.             features[lv2_feature_id_external_ui_old]->data = uiExternalHostFt;

  4099. 

  4100.             // -------------------------------------------------------

  4101.             // initialize ui

  4102. 

  4103.             switch (uiType)

  4104.             {

  4105.             case LV2_UI_QT4:

  4106.                 qDebug("Will use LV2 Qt4 UI");

  4107.                 gui.type      = GUI_INTERNAL_QT4;

  4108.                 gui.resizable = isUiResizable();

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

  4110.                 m_hints      |= PLUGIN_USES_SINGLE_THREAD;

  4111.                 break;

  4112. 

  4113.             case LV2_UI_COCOA:

  4114.                 qDebug("Will use LV2 Cocoa UI");

  4115.                 gui.type      = GUI_INTERNAL_COCOA;

  4116.                 gui.resizable = isUiResizable();

  4117.                 break;

  4118. 

  4119.             case LV2_UI_WINDOWS:

  4120.                 qDebug("Will use LV2 Windows UI");

  4121.                 gui.type      = GUI_INTERNAL_HWND;

  4122.                 gui.resizable = isUiResizable();

  4123.                 break;

  4124. 

  4125.             case LV2_UI_X11:

  4126.                 qDebug("Will use LV2 X11 UI");

  4127.                 gui.type      = GUI_INTERNAL_X11;

  4128.                 gui.resizable = isUiResizable();

  4129.                 break;

  4130. 

  4131.             case LV2_UI_GTK2:

  4132. #ifdef HAVE_SUIL

  4133.                 qDebug("Will use LV2 Gtk2 UI (suil)");

  4134.                 gui.type      = GUI_EXTERNAL_SUIL;

  4135.                 gui.resizable = isUiResizable();

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

  4137.                 m_hints      |= PLUGIN_USES_SINGLE_THREAD;

  4138. 

  4139.                 if (suil.handle)

  4140.                 {

  4141.                     ui.handle     = ((SuilInstanceImpl*)suil.handle)->handle;

  4142.                     ui.descriptor = ((SuilInstanceImpl*)suil.handle)->descriptor;

  4143.                     ui.widget     = suil_instance_get_widget(suil.handle);

  4144. 

  4145.                     if (ui.widget)

  4146.                     {

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

  4148.                         widget->setWindowTitle(guiTitle);

  4149.                     }

  4150.                 }

  4151. #else

  4152.                 qDebug("Will use LV2 Gtk2 UI, NOT!");

  4153. #endif

  4154.                 break;

  4155. 

  4156.             case LV2_UI_GTK3:

  4157.                 qDebug("Will use LV2 Gtk3 UI, NOT!");

  4158.                 break;

  4159. 

  4160.             case LV2_UI_EXTERNAL:

  4161.             case LV2_UI_OLD_EXTERNAL:

  4162.                 qDebug("Will use LV2 External UI");

  4163.                 gui.type = GUI_EXTERNAL_LV2;

  4164.                 break;

  4165.             }

  4166.         }

  4167. 

  4168.         if (gui.type != GUI_NONE)

  4169.             m_hints |= PLUGIN_HAS_GUI;

  4170. 

  4171.         return true;

  4172.     }

  4173. 

  4174. private:

  4175.     LV2_Handle handle, h2;

  4176.     const LV2_Descriptor* descriptor;

  4177.     const LV2_RDF_Descriptor* rdf_descriptor;

  4178.     LV2_Feature* features[lv2_feature_count+1];

  4179. 

  4180.     struct {

  4181.         LV2_State_Interface* state;

  4182.         LV2_Worker_Interface* worker;

  4183.         LV2_Programs_Interface* programs;

  4184.         LV2_Programs_UI_Interface* uiprograms;

  4185.     } ext;

  4186. 

  4187.     struct {

  4188. 

  4189.         void* lib;

  4190.         LV2UI_Handle handle;

  4191.         LV2UI_Widget widget;

  4192.         const LV2UI_Descriptor* descriptor;

  4193.         const LV2_RDF_UI* rdf_descriptor;

  4194.     } ui;

  4195. 

  4196.     struct {

  4197.         GuiType type;

  4198.         bool resizable;

  4199.         int width;

  4200.         int height;

  4201.     } gui;

  4202. 

  4203. #ifdef HAVE_SUIL

  4204.     struct {

  4205.         SuilHost* host;

  4206.         SuilInstance* handle;

  4207.         QByteArray pos;

  4208.     } suil;

  4209. #endif

  4210. 

  4211.     Lv2PluginEventData evIn;

  4212.     Lv2PluginEventData evOut;

  4213.     float* paramBuffers;

  4214.     std::vector<const char*> customURIDs;

  4215. };

  4216. 

  4217. CarlaPlugin* CarlaPlugin::newLV2(const initializer& init)

  4218. {

  4219.     qDebug("CarlaPlugin::newLV2(%p, \"%s\", \"%s\", \"%s\")", init.engine, init.filename, init.name, init.label);

  4220. 

  4221.     short id = init.engine->getNewPluginId();

  4222. 

  4223.     if (id < 0)

  4224.     {

  4225.         setLastError("Maximum number of plugins reached");

  4226.         return nullptr;

  4227.     }

  4228. 

  4229.     Lv2Plugin* const plugin = new Lv2Plugin(init.engine, id);

  4230. 

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

  4232.     {

  4233.         delete plugin;

  4234.         return nullptr;

  4235.     }

  4236. 

  4237.     plugin->reload();

  4238. 

  4239. #ifndef BUILD_BRIDGE

  4240.     if (carlaOptions.processMode == PROCESS_MODE_CONTINUOUS_RACK)

  4241.     {

  4242.         const uint32_t ins  = plugin->audioInCount();

  4243.         const uint32_t outs = plugin->audioOutCount();

  4244. 

  4245.         if (ins > 2 || outs > 2 || (ins != outs && ins != 0 && outs != 0))

  4246.         {

  4247.             setLastError("Carla's rack mode can only work with Mono or Stereo LV2 plugins, sorry!");

  4248.             delete plugin;

  4249.             return nullptr;

  4250.         }

  4251.     }

  4252. #endif

  4253. 

  4254.     plugin->registerToOsc();

  4255.     plugin->updateUi();

  4256. 

  4257.     return plugin;

  4258. }

  4259. 

  4260. /**@}*/

  4261. 

  4262. // -------------------------------------------------------------------------------------------------------------------

  4263. 

  4264. int CarlaOsc::handle_lv2_atom_transfer(CARLA_OSC_HANDLE_ARGS2)

  4265. {

  4266.     qDebug("CarlaOsc::handle_lv2_atom_transfer()");

  4267.     //CARLA_OSC_CHECK_OSC_TYPES(2, "ii");

  4268. 

  4269.     CarlaBackend::Lv2Plugin* const lv2plugin = (CarlaBackend::Lv2Plugin*)plugin;

  4270.     lv2plugin->handleTransferAtom();

  4271. 

  4272.     return 0;

  4273.     Q_UNUSED(argc);

  4274.     Q_UNUSED(argv);

  4275.     Q_UNUSED(types);

  4276. }

  4277. 

  4278. int CarlaOsc::handle_lv2_event_transfer(CARLA_OSC_HANDLE_ARGS2)

  4279. {

  4280.     qDebug("CarlaOsc::handle_lv2_event_transfer()");

  4281.     CARLA_OSC_CHECK_OSC_TYPES(3, "sss");

  4282. 

  4283.     const char* const type  = (const char*)&argv[0]->s;

  4284.     const char* const key   = (const char*)&argv[1]->s;

  4285.     const char* const value = (const char*)&argv[2]->s;

  4286. 

  4287.     CarlaBackend::Lv2Plugin* const lv2plugin = (CarlaBackend::Lv2Plugin*)plugin;

  4288.     lv2plugin->handleTransferEvent(type, key, value);

  4289. 

  4290.     return 0;

  4291. }

  4292. 

  4293. CARLA_BACKEND_END_NAMESPACE