falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 43 Activity
Audio plugin host https://kx.studio/carla
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.
450 Commits
17 Branches
166MB
Tree: 4a33625dc8
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '4a33625dc8'
${ noResults }
Carla/source/backend/plugin/Lv2Plugin.cpp

4705 lines
166KB
Raw Blame History 

  1. /*

  2.  * Carla LV2 Plugin

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

  4.  *

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

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

  7.  * published by the Free Software Foundation; either version 2 of

  8.  * the License, or 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 GPL.txt file

  16.  */

  17. 

  18. #include "CarlaPluginInternal.hpp"

  19. 

  20. #ifdef WANT_LV2

  21. 

  22. #include "CarlaPluginGui.hpp"

  23. #include "CarlaLv2Utils.hpp"

  24. 

  25. #include <QtCore/QDir>

  26. 

  27. extern "C" {

  28. #include "rtmempool/rtmempool-lv2.h"

  29. }

  30. 

  31. // -----------------------------------------------------

  32. // Our LV2 World class object

  33. 

  34. Lv2WorldClass gLv2World;

  35. 

  36. // -----------------------------------------------------

  37. 

  38. CARLA_BACKEND_START_NAMESPACE

  39. 

  40. #if 0

  41. }

  42. #endif

  43. 

  44. /*!

  45.  * @defgroup PluginHints Plugin Hints

  46.  * @{

  47.  */

  48. const unsigned int PLUGIN_HAS_EXTENSION_OPTIONS  = 0x100; //!< LV2 Plugin has Options extension

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

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

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

  52. /**@}*/

  53. 

  54. /*!

  55.  * @defgroup ParameterHints Parameter Hints

  56.  * @{

  57.  */

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

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

  60. /**@}*/

  61. 

  62. /*!

  63.  * @defgroup Lv2EventTypes LV2 Event Data/Types

  64.  *

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

  66.  * @{

  67.  */

  68. const unsigned int CARLA_EVENT_DATA_ATOM    = 0x01;

  69. const unsigned int CARLA_EVENT_DATA_EVENT   = 0x02;

  70. const unsigned int CARLA_EVENT_DATA_MIDI_LL = 0x04;

  71. const unsigned int CARLA_EVENT_TYPE_MESSAGE = 0x10;

  72. const unsigned int CARLA_EVENT_TYPE_MIDI    = 0x20;

  73. const unsigned int CARLA_EVENT_TYPE_TIME    = 0x40;

  74. /**@}*/

  75. 

  76. /*!

  77.  * @defgroup Lv2UriMapIds LV2 URI Map Ids

  78.  *

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

  80.  * @{

  81.  */

  82. const uint32_t CARLA_URI_MAP_ID_NULL                = 0;

  83. const uint32_t CARLA_URI_MAP_ID_ATOM_CHUNK          = 1;

  84. const uint32_t CARLA_URI_MAP_ID_ATOM_DOUBLE         = 2;

  85. const uint32_t CARLA_URI_MAP_ID_ATOM_INT            = 3;

  86. const uint32_t CARLA_URI_MAP_ID_ATOM_PATH           = 4;

  87. const uint32_t CARLA_URI_MAP_ID_ATOM_SEQUENCE       = 5;

  88. const uint32_t CARLA_URI_MAP_ID_ATOM_STRING         = 6;

  89. const uint32_t CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM  = 7;

  90. const uint32_t CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT = 8;

  91. const uint32_t CARLA_URI_MAP_ID_BUF_MAX_LENGTH      = 9;

  92. const uint32_t CARLA_URI_MAP_ID_BUF_MIN_LENGTH      = 10;

  93. const uint32_t CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE   = 11;

  94. const uint32_t CARLA_URI_MAP_ID_LOG_ERROR           = 12;

  95. const uint32_t CARLA_URI_MAP_ID_LOG_NOTE            = 13;

  96. const uint32_t CARLA_URI_MAP_ID_LOG_TRACE           = 14;

  97. const uint32_t CARLA_URI_MAP_ID_LOG_WARNING         = 15;

  98. const uint32_t CARLA_URI_MAP_ID_MIDI_EVENT          = 16;

  99. const uint32_t CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE   = 17;

  100. const uint32_t CARLA_URI_MAP_ID_TIME_POSITION       = 18;

  101. const uint32_t CARLA_URI_MAP_ID_COUNT               = 19;

  102. /**@}*/

  103. 

  104. /*!

  105.  * @defgroup Lv2FeatureIds LV2 Feature Ids

  106.  *

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

  108.  * @{

  109.  */

  110. const uint32_t kFeatureIdBufSizeBounded   =  0;

  111. const uint32_t kFeatureIdBufSizeFixed     =  1;

  112. const uint32_t kFeatureIdBufSizePowerOf2  =  2;

  113. const uint32_t kFeatureIdEvent            =  3;

  114. const uint32_t kFeatureIdLogs             =  4;

  115. const uint32_t kFeatureIdOptions          =  5;

  116. const uint32_t kFeatureIdPrograms         =  6;

  117. const uint32_t kFeatureIdRtMemPool        =  7;

  118. const uint32_t kFeatureIdStateMakePath    =  8;

  119. const uint32_t kFeatureIdStateMapPath     =  9;

  120. const uint32_t kFeatureIdStrictBounds     = 10;

  121. const uint32_t kFeatureIdUriMap           = 11;

  122. const uint32_t kFeatureIdUridMap          = 12;

  123. const uint32_t kFeatureIdUridUnmap        = 13;

  124. const uint32_t kFeatureIdWorker           = 14;

  125. const uint32_t kFeatureIdUiDataAccess     = 15;

  126. const uint32_t kFeatureIdUiInstanceAccess = 16;

  127. const uint32_t kFeatureIdUiParent         = 17;

  128. const uint32_t kFeatureIdUiPortMap        = 18;

  129. const uint32_t kFeatureIdUiResize         = 19;

  130. const uint32_t kFeatureIdExternalUi       = 20;

  131. const uint32_t kFeatureIdExternalUiOld    = 21;

  132. const uint32_t kFeatureCount              = 22;

  133. /**@}*/

  134. 

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

  136. 

  137. enum Lv2PluginGuiType {

  138.     PLUGIN_UI_NULL,

  139.     PLUGIN_UI_OSC,

  140.     PLUGIN_UI_QT,

  141.     PLUGIN_UI_PARENT,

  142.     PLUGIN_UI_EXTERNAL

  143. };

  144. 

  145. struct Lv2EventData {

  146.     uint32_t type;

  147.     uint32_t rindex;

  148.     CarlaEngineEventPort* port;

  149.     union {

  150.         LV2_Atom_Sequence* atom;

  151.         LV2_Event_Buffer* event;

  152.         LV2_MIDI* midi;

  153.     };

  154. 

  155.     Lv2EventData()

  156.         : type(0x0),

  157.           rindex(0),

  158.           port(nullptr) {}

  159. 

  160.     ~Lv2EventData()

  161.     {

  162.         if (port != nullptr)

  163.         {

  164.             delete port;

  165.             port = nullptr;

  166.         }

  167. 

  168.         if (type & CARLA_EVENT_DATA_ATOM)

  169.         {

  170.             CARLA_ASSERT(atom != nullptr);

  171. 

  172.             if (atom != nullptr)

  173.             {

  174.                 std::free(atom);

  175.                 atom = nullptr;

  176.             }

  177.         }

  178.         else if (type & CARLA_EVENT_DATA_EVENT)

  179.         {

  180.             CARLA_ASSERT(event != nullptr);

  181. 

  182.             if (event != nullptr)

  183.             {

  184.                 std::free(event);

  185.                 event = nullptr;

  186.             }

  187.         }

  188.         else if (type & CARLA_EVENT_DATA_MIDI_LL)

  189.         {

  190.             CARLA_ASSERT(midi != nullptr && midi->data != nullptr);

  191. 

  192.             if (midi != nullptr)

  193.             {

  194.                 if (midi->data != nullptr)

  195.                     delete[] midi->data;

  196.                 delete midi;

  197. 

  198.                 midi->data = nullptr;

  199.                 midi = nullptr;

  200.             }

  201.         }

  202.     }

  203. 

  204.     CARLA_DECLARE_NON_COPY_STRUCT_WITH_LEAK_DETECTOR(Lv2EventData)

  205. };

  206. 

  207. struct Lv2PluginEventData {

  208.     uint32_t count;

  209.     Lv2EventData* data;

  210.     Lv2EventData* ctrl; // default port

  211.     uint32_t ctrlIndex;

  212. 

  213.     Lv2PluginEventData()

  214.         : count(0),

  215.           data(nullptr),

  216.           ctrl(nullptr),

  217.           ctrlIndex(0) {}

  218. 

  219.     ~Lv2PluginEventData()

  220.     {

  221.         CARLA_ASSERT_INT(count == 0, count);

  222.         CARLA_ASSERT(data == nullptr);

  223.         CARLA_ASSERT(ctrl == nullptr);

  224.         CARLA_ASSERT(ctrlIndex == 0);

  225.     }

  226. 

  227.     void createNew(const uint32_t newCount)

  228.     {

  229.         CARLA_ASSERT_INT(count == 0, count);

  230.         CARLA_ASSERT(data == nullptr);

  231.         CARLA_ASSERT(ctrl == nullptr);

  232.         CARLA_ASSERT(ctrlIndex == 0);

  233.         CARLA_ASSERT_INT(newCount > 0, newCount);

  234. 

  235.         if (data != nullptr || newCount == 0)

  236.             return;

  237. 

  238.         data  = new Lv2EventData[newCount];

  239.         count = newCount;

  240. 

  241.         ctrl      = nullptr;

  242.         ctrlIndex = 0;

  243.     }

  244. 

  245.     void clear()

  246.     {

  247.         if (data != nullptr)

  248.         {

  249.             delete[] data;

  250.             data = nullptr;

  251.         }

  252. 

  253.         count = 0;

  254. 

  255.         ctrl      = nullptr;

  256.         ctrlIndex = 0;

  257.     }

  258. 

  259.     void initBuffers(CarlaEngine* const engine)

  260.     {

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

  262.         {

  263.             if (data[i].port != nullptr)

  264.                 data[i].port->initBuffer(engine);

  265.         }

  266.     }

  267. 

  268.     CARLA_DECLARE_NON_COPY_STRUCT_WITH_LEAK_DETECTOR(Lv2PluginEventData)

  269. };

  270. 

  271. struct Lv2PluginOptions {

  272.     int minBufferSize;

  273.     int maxBufferSize;

  274.     int sequenceSize;

  275.     double sampleRate;

  276.     LV2_Options_Option optMinBlockLenth;

  277.     LV2_Options_Option optMaxBlockLenth;

  278.     LV2_Options_Option optSequenceSize;

  279.     LV2_Options_Option optSampleRate;

  280.     LV2_Options_Option optNull;

  281.     LV2_Options_Option* opts[5];

  282. 

  283.     Lv2PluginOptions()

  284.         : minBufferSize(0),

  285.           maxBufferSize(0),

  286.           sequenceSize(MAX_EVENT_BUFFER),

  287.           sampleRate(0.0)

  288.     {

  289.         optMinBlockLenth.context = LV2_OPTIONS_INSTANCE;

  290.         optMinBlockLenth.subject = 0;

  291.         optMinBlockLenth.key     = CARLA_URI_MAP_ID_BUF_MIN_LENGTH;

  292.         optMinBlockLenth.size    = sizeof(int);

  293.         optMinBlockLenth.type    = CARLA_URI_MAP_ID_ATOM_INT;

  294.         optMinBlockLenth.value   = &minBufferSize;

  295. 

  296.         optMaxBlockLenth.context = LV2_OPTIONS_INSTANCE;

  297.         optMaxBlockLenth.subject = 0;

  298.         optMaxBlockLenth.key     = CARLA_URI_MAP_ID_BUF_MAX_LENGTH;

  299.         optMaxBlockLenth.size    = sizeof(int);

  300.         optMaxBlockLenth.type    = CARLA_URI_MAP_ID_ATOM_INT;

  301.         optMaxBlockLenth.value   = &maxBufferSize;

  302. 

  303.         optSequenceSize.context = LV2_OPTIONS_INSTANCE;

  304.         optSequenceSize.subject = 0;

  305.         optSequenceSize.key     = CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE;

  306.         optSequenceSize.size    = sizeof(int);

  307.         optSequenceSize.type    = CARLA_URI_MAP_ID_ATOM_INT;

  308.         optSequenceSize.value   = &sequenceSize;

  309. 

  310.         optSampleRate.context = LV2_OPTIONS_INSTANCE;

  311.         optSampleRate.subject = 0;

  312.         optSampleRate.key     = CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE;

  313.         optSampleRate.size    = sizeof(double);

  314.         optSampleRate.type    = CARLA_URI_MAP_ID_ATOM_DOUBLE;

  315.         optSampleRate.value   = &sampleRate;

  316. 

  317.         optNull.context = LV2_OPTIONS_INSTANCE;

  318.         optNull.subject = 0;

  319.         optNull.key     = CARLA_URI_MAP_ID_NULL;

  320.         optNull.size    = 0;

  321.         optNull.type    = CARLA_URI_MAP_ID_NULL;

  322.         optNull.value   = nullptr;

  323. 

  324.         opts[0] = &optMinBlockLenth;

  325.         opts[1] = &optMaxBlockLenth;

  326.         opts[2] = &optSequenceSize;

  327.         opts[3] = &optSampleRate;

  328.         opts[4] = &optNull;

  329.     }

  330. 

  331.     CARLA_DECLARE_NON_COPY_STRUCT_WITH_LEAK_DETECTOR(Lv2PluginOptions)

  332. };

  333. 

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

  335. {

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

  337. }

  338. 

  339. // -----------------------------------------------------

  340. 

  341. class Lv2Plugin : public CarlaPlugin,

  342.                   public CarlaPluginGui::Callback

  343. {

  344. public:

  345.     Lv2Plugin(CarlaEngine* const engine, const unsigned int id)

  346.         : CarlaPlugin(engine, id),

  347.           fHandle(nullptr),

  348.           fHandle2(nullptr),

  349.           fFeatures{nullptr},

  350.           fDescriptor(nullptr),

  351.           fRdfDescriptor(nullptr),

  352.           fAudioInBuffers(nullptr),

  353.           fAudioOutBuffers(nullptr),

  354.           fParamBuffers(nullptr)

  355.     {

  356.         carla_debug("Lv2Plugin::Lv2Plugin(%p, %i)", engine, id);

  357. 

  358.         kData->osc.thread.setMode(CarlaPluginThread::PLUGIN_THREAD_LV2_GUI);

  359. 

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

  361.             fCustomURIDs.append(nullptr);

  362.     }

  363. 

  364.     ~Lv2Plugin() override

  365.     {

  366.         carla_debug("Lv2Plugin::~Lv2Plugin()");

  367. 

  368.         // close UI

  369.         if (fUi.type != PLUGIN_UI_NULL)

  370.         {

  371.             showGui(false);

  372. 

  373.             if (fUi.type == PLUGIN_UI_OSC)

  374.             {

  375.                 // Wait a bit first, then force kill

  376.                 if (kData->osc.thread.isRunning() && ! kData->osc.thread.wait(kData->engine->getOptions().oscUiTimeout))

  377.                 {

  378.                     carla_stderr("LV2 OSC-GUI thread still running, forcing termination now");

  379.                     kData->osc.thread.terminate();

  380.                 }

  381.             }

  382.             else

  383.             {

  384.                 if (fFeatures[kFeatureIdUiDataAccess] != nullptr && fFeatures[kFeatureIdUiDataAccess]->data != nullptr)

  385.                     delete (LV2_Extension_Data_Feature*)fFeatures[kFeatureIdUiDataAccess]->data;

  386. 

  387.                 if (fFeatures[kFeatureIdUiPortMap] != nullptr && fFeatures[kFeatureIdUiPortMap]->data != nullptr)

  388.                     delete (LV2UI_Port_Map*)fFeatures[kFeatureIdUiPortMap]->data;

  389. 

  390.                 if (fFeatures[kFeatureIdUiResize] != nullptr && fFeatures[kFeatureIdUiResize]->data != nullptr)

  391.                     delete (LV2UI_Resize*)fFeatures[kFeatureIdUiResize]->data;

  392. 

  393.                 if (fFeatures[kFeatureIdExternalUi] != nullptr && fFeatures[kFeatureIdExternalUi]->data != nullptr)

  394.                 {

  395.                     const LV2_External_UI_Host* const uiHost((const LV2_External_UI_Host*)fFeatures[kFeatureIdExternalUi]->data);

  396. 

  397.                     if (uiHost->plugin_human_id != nullptr)

  398.                         delete[] uiHost->plugin_human_id;

  399. 

  400.                     delete uiHost;

  401.                 }

  402. 

  403.                 fUi.descriptor = nullptr;

  404.                 kData->uiLibClose();

  405.             }

  406. 

  407.             fUi.rdfDescriptor = nullptr;

  408.         }

  409. 

  410.         kData->singleMutex.lock();

  411.         kData->masterMutex.lock();

  412. 

  413.         if (kData->active)

  414.         {

  415.             deactivate();

  416.             kData->active = false;

  417.         }

  418. 

  419.         if (fDescriptor != nullptr)

  420.         {

  421.             if (fDescriptor->cleanup != nullptr)

  422.             {

  423.                 if (fHandle != nullptr)

  424.                     fDescriptor->cleanup(fHandle);

  425.                 if (fHandle2 != nullptr)

  426.                     fDescriptor->cleanup(fHandle2);

  427.             }

  428. 

  429.             fHandle  = nullptr;

  430.             fHandle2 = nullptr;

  431.             fDescriptor = nullptr;

  432.         }

  433. 

  434.         if (fRdfDescriptor != nullptr)

  435.         {

  436.             delete fRdfDescriptor;

  437.             fRdfDescriptor = nullptr;

  438.         }

  439. 

  440.         if (fFeatures[kFeatureIdEvent] != nullptr && fFeatures[kFeatureIdEvent]->data != nullptr)

  441.             delete (LV2_Event_Feature*)fFeatures[kFeatureIdEvent]->data;

  442. 

  443.         if (fFeatures[kFeatureIdLogs] != nullptr && fFeatures[kFeatureIdLogs]->data != nullptr)

  444.             delete (LV2_Log_Log*)fFeatures[kFeatureIdLogs]->data;

  445. 

  446.         if (fFeatures[kFeatureIdStateMakePath] != nullptr && fFeatures[kFeatureIdStateMakePath]->data != nullptr)

  447.             delete (LV2_State_Make_Path*)fFeatures[kFeatureIdStateMakePath]->data;

  448. 

  449.         if (fFeatures[kFeatureIdStateMapPath] != nullptr && fFeatures[kFeatureIdStateMapPath]->data != nullptr)

  450.             delete (LV2_State_Map_Path*)fFeatures[kFeatureIdStateMapPath]->data;

  451. 

  452.         if (fFeatures[kFeatureIdPrograms] != nullptr && fFeatures[kFeatureIdPrograms]->data != nullptr)

  453.             delete (LV2_Programs_Host*)fFeatures[kFeatureIdPrograms]->data;

  454. 

  455.         if (fFeatures[kFeatureIdRtMemPool] != nullptr && fFeatures[kFeatureIdRtMemPool]->data != nullptr)

  456.             delete (LV2_RtMemPool_Pool*)fFeatures[kFeatureIdRtMemPool]->data;

  457. 

  458.         if (fFeatures[kFeatureIdUriMap] != nullptr && fFeatures[kFeatureIdUriMap]->data != nullptr)

  459.             delete (LV2_URI_Map_Feature*)fFeatures[kFeatureIdUriMap]->data;

  460. 

  461.         if (fFeatures[kFeatureIdUridMap] != nullptr && fFeatures[kFeatureIdUridMap]->data != nullptr)

  462.             delete (LV2_URID_Map*)fFeatures[kFeatureIdUridMap]->data;

  463. 

  464.         if (fFeatures[kFeatureIdUridUnmap] != nullptr && fFeatures[kFeatureIdUridUnmap]->data != nullptr)

  465.             delete (LV2_URID_Unmap*)fFeatures[kFeatureIdUridUnmap]->data;

  466. 

  467.         if (fFeatures[kFeatureIdWorker] != nullptr && fFeatures[kFeatureIdWorker]->data != nullptr)

  468.             delete (LV2_Worker_Schedule*)fFeatures[kFeatureIdWorker]->data;

  469. 

  470.         for (uint32_t i=0; i < kFeatureCount; ++i)

  471.         {

  472.             if (fFeatures[i] != nullptr)

  473.                 delete fFeatures[i];

  474.         }

  475. 

  476.         for (auto it = fCustomURIDs.begin(); it.valid(); it.next())

  477.         {

  478.             const char*& uri(*it);

  479. 

  480.             if (uri != nullptr)

  481.             {

  482.                 delete[] uri;

  483.                 uri = nullptr;

  484.             }

  485.         }

  486. 

  487.         fCustomURIDs.clear();

  488. 

  489.         clearBuffers();

  490.     }

  491. 

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

  493.     // Information (base)

  494. 

  495.     PluginType type() const override

  496.     {

  497.         return PLUGIN_LV2;

  498.     }

  499. 

  500.     PluginCategory category() override

  501.     {

  502.         CARLA_ASSERT(fRdfDescriptor != nullptr);

  503. 

  504.         const LV2_Property cat1(fRdfDescriptor->Type[0]);

  505.         const LV2_Property cat2(fRdfDescriptor->Type[1]);

  506. 

  507.         if (LV2_IS_DELAY(cat1, cat2))

  508.             return PLUGIN_CATEGORY_DELAY;

  509.         if (LV2_IS_DISTORTION(cat1, cat2))

  510.             return PLUGIN_CATEGORY_OTHER;

  511.         if (LV2_IS_DYNAMICS(cat1, cat2))

  512.             return PLUGIN_CATEGORY_DYNAMICS;

  513.         if (LV2_IS_EQ(cat1, cat2))

  514.             return PLUGIN_CATEGORY_EQ;

  515.         if (LV2_IS_FILTER(cat1, cat2))

  516.             return PLUGIN_CATEGORY_FILTER;

  517.         if (LV2_IS_GENERATOR(cat1, cat2))

  518.             return PLUGIN_CATEGORY_SYNTH;

  519.         if (LV2_IS_MODULATOR(cat1, cat2))

  520.             return PLUGIN_CATEGORY_MODULATOR;

  521.         if (LV2_IS_REVERB(cat1, cat2))

  522.             return PLUGIN_CATEGORY_DELAY;

  523.         if (LV2_IS_SIMULATOR(cat1, cat2))

  524.             return PLUGIN_CATEGORY_OTHER;

  525.         if (LV2_IS_SPATIAL(cat1, cat2))

  526.             return PLUGIN_CATEGORY_OTHER;

  527.         if (LV2_IS_SPECTRAL(cat1, cat2))

  528.             return PLUGIN_CATEGORY_UTILITY;

  529.         if (LV2_IS_UTILITY(cat1, cat2))

  530.             return PLUGIN_CATEGORY_UTILITY;

  531. 

  532.         return getPluginCategoryFromName(fName);

  533.     }

  534. 

  535.     long uniqueId() const override

  536.     {

  537.         CARLA_ASSERT(fRdfDescriptor != nullptr);

  538. 

  539.         return fRdfDescriptor->UniqueID;

  540.     }

  541. 

  542.     // -------------------------------------------------------------------

  543.     // Information (count)

  544. 

  545.     uint32_t midiInCount() const override

  546.     {

  547.         CARLA_ASSERT(fRdfDescriptor != nullptr);

  548. 

  549.         uint32_t i, count = 0;

  550. 

  551.         for (i=0; i < fRdfDescriptor->PortCount; ++i)

  552.         {

  553.             const LV2_Property portTypes(fRdfDescriptor->Ports[i].Types);

  554. 

  555.             if (LV2_IS_PORT_INPUT(portTypes) && LV2_PORT_SUPPORTS_MIDI_EVENT(portTypes))

  556.                 count += 1;

  557.         }

  558. 

  559.         return count;

  560.     }

  561. 

  562.     uint32_t midiOutCount() const override

  563.     {

  564.         CARLA_ASSERT(fRdfDescriptor != nullptr);

  565. 

  566.         uint32_t i, count = 0;

  567. 

  568.         for (i=0; i < fRdfDescriptor->PortCount; ++i)

  569.         {

  570.             const LV2_Property portTypes(fRdfDescriptor->Ports[i].Types);

  571. 

  572.             if (LV2_IS_PORT_OUTPUT(portTypes) && LV2_PORT_SUPPORTS_MIDI_EVENT(portTypes))

  573.                 count += 1;

  574.         }

  575. 

  576.         return count;

  577.     }

  578. 

  579.     uint32_t parameterScalePointCount(const uint32_t parameterId) const override

  580.     {

  581.         CARLA_ASSERT(fRdfDescriptor != nullptr);

  582.         CARLA_ASSERT(parameterId < kData->param.count);

  583. 

  584.         const int32_t rindex(kData->param.data[parameterId].rindex);

  585. 

  586.         if (rindex < static_cast<int32_t>(fRdfDescriptor->PortCount))

  587.         {

  588.             const LV2_RDF_Port& port(fRdfDescriptor->Ports[rindex]);

  589.             return port.ScalePointCount;

  590.         }

  591. 

  592.         return 0;

  593.     }

  594. 

  595.     // -------------------------------------------------------------------

  596.     // Information (current data)

  597. 

  598.     // nothing

  599. 

  600.     // -------------------------------------------------------------------

  601.     // Information (per-plugin data)

  602. 

  603.     unsigned int availableOptions() override

  604.     {

  605.         unsigned int options = 0x0;

  606. 

  607.         options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  608. 

  609.         if (! needsFixedBuffer())

  610.             options |= PLUGIN_OPTION_FIXED_BUFFER;

  611. 

  612.         if (kData->engine->getProccessMode() != PROCESS_MODE_CONTINUOUS_RACK)

  613.         {

  614.             if (fOptions & PLUGIN_OPTION_FORCE_STEREO)

  615.                 options |= PLUGIN_OPTION_FORCE_STEREO;

  616.             else if (kData->audioIn.count <= 1 && kData->audioOut.count <= 1 && (kData->audioIn.count != 0 || kData->audioOut.count != 0))

  617.                 options |= PLUGIN_OPTION_FORCE_STEREO;

  618.         }

  619. 

  620.         if (midiInCount() > 0)

  621.         {

  622.             options |= PLUGIN_OPTION_SEND_CONTROL_CHANGES;

  623.             options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  624.             options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

  625.             options |= PLUGIN_OPTION_SEND_PITCHBEND;

  626.             options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  627.         }

  628. 

  629.         return options;

  630.     }

  631. 

  632.     float getParameterValue(const uint32_t parameterId) override

  633.     {

  634.         CARLA_ASSERT(fParamBuffers != nullptr);

  635.         CARLA_ASSERT(parameterId < kData->param.count);

  636. 

  637.         return fParamBuffers[parameterId];

  638.     }

  639. 

  640.     float getParameterScalePointValue(const uint32_t parameterId, const uint32_t scalePointId) override

  641.     {

  642.         CARLA_ASSERT(fRdfDescriptor != nullptr);

  643.         CARLA_ASSERT(parameterId < kData->param.count);

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

  645. 

  646.         const int32_t rindex(kData->param.data[parameterId].rindex);

  647. 

  648.         if (rindex < static_cast<int32_t>(fRdfDescriptor->PortCount))

  649.         {

  650.             const LV2_RDF_Port& port(fRdfDescriptor->Ports[rindex]);

  651. 

  652.             if (scalePointId < port.ScalePointCount)

  653.             {

  654.                 const LV2_RDF_PortScalePoint& portScalePoint(port.ScalePoints[scalePointId]);

  655.                 return portScalePoint.Value;

  656.             }

  657.         }

  658. 

  659.         return 0.0f;

  660.     }

  661. 

  662.     void getLabel(char* const strBuf) override

  663.     {

  664.         CARLA_ASSERT(fRdfDescriptor != nullptr);

  665.         CARLA_ASSERT(fRdfDescriptor->URI != nullptr);

  666. 

  667.         if (fRdfDescriptor->URI != nullptr)

  668.             std::strncpy(strBuf, fRdfDescriptor->URI, STR_MAX);

  669.         else

  670.             CarlaPlugin::getLabel(strBuf);

  671.     }

  672. 

  673.     void getMaker(char* const strBuf) override

  674.     {

  675.         CARLA_ASSERT(fRdfDescriptor != nullptr);

  676. 

  677.         if (fRdfDescriptor->Author != nullptr)

  678.             std::strncpy(strBuf, fRdfDescriptor->Author, STR_MAX);

  679.         else

  680.             CarlaPlugin::getMaker(strBuf);

  681.     }

  682. 

  683.     void getCopyright(char* const strBuf) override

  684.     {

  685.         CARLA_ASSERT(fRdfDescriptor != nullptr);

  686. 

  687.         if (fRdfDescriptor->License != nullptr)

  688.             std::strncpy(strBuf, fRdfDescriptor->License, STR_MAX);

  689.         else

  690.             CarlaPlugin::getCopyright(strBuf);

  691.     }

  692. 

  693.     void getRealName(char* const strBuf) override

  694.     {

  695.         CARLA_ASSERT(fRdfDescriptor != nullptr);

  696. 

  697.         if (fRdfDescriptor->Name != nullptr)

  698.             std::strncpy(strBuf, fRdfDescriptor->Name, STR_MAX);

  699.         else

  700.             CarlaPlugin::getRealName(strBuf);

  701.     }

  702. 

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

  704.     {

  705.         CARLA_ASSERT(fRdfDescriptor != nullptr);

  706.         CARLA_ASSERT(parameterId < kData->param.count);

  707. 

  708.         const int32_t rindex(kData->param.data[parameterId].rindex);

  709. 

  710.         if (rindex < static_cast<int32_t>(fRdfDescriptor->PortCount))

  711.             std::strncpy(strBuf, fRdfDescriptor->Ports[rindex].Name, STR_MAX);

  712.         else

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

  714.     }

  715. 

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

  717.     {

  718.         CARLA_ASSERT(fRdfDescriptor != nullptr);

  719.         CARLA_ASSERT(parameterId < kData->param.count);

  720. 

  721.         const int32_t rindex(kData->param.data[parameterId].rindex);

  722. 

  723.         if (rindex < static_cast<int32_t>(fRdfDescriptor->PortCount))

  724.             strncpy(strBuf, fRdfDescriptor->Ports[rindex].Symbol, STR_MAX);

  725.         else

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

  727.     }

  728. 

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

  730.     {

  731.         CARLA_ASSERT(fRdfDescriptor != nullptr);

  732.         CARLA_ASSERT(parameterId < kData->param.count);

  733. 

  734.         const int32_t rindex(kData->param.data[parameterId].rindex);

  735. 

  736.         if (rindex < static_cast<int32_t>(fRdfDescriptor->PortCount))

  737.         {

  738.             const LV2_RDF_Port& port(fRdfDescriptor->Ports[rindex]);

  739. 

  740.             if (LV2_HAVE_PORT_UNIT_SYMBOL(port.Unit.Hints) && port.Unit.Symbol)

  741.                 std::strncpy(strBuf, port.Unit.Symbol, STR_MAX);

  742. 

  743.             else if (LV2_HAVE_PORT_UNIT_UNIT(port.Unit.Hints))

  744.             {

  745.                 switch (port.Unit.Unit)

  746.                 {

  747.                 case LV2_PORT_UNIT_BAR:

  748.                     std::strncpy(strBuf, "bars", STR_MAX);

  749.                     return;

  750.                 case LV2_PORT_UNIT_BEAT:

  751.                     std::strncpy(strBuf, "beats", STR_MAX);

  752.                     return;

  753.                 case LV2_PORT_UNIT_BPM:

  754.                     std::strncpy(strBuf, "BPM", STR_MAX);

  755.                     return;

  756.                 case LV2_PORT_UNIT_CENT:

  757.                     std::strncpy(strBuf, "ct", STR_MAX);

  758.                     return;

  759.                 case LV2_PORT_UNIT_CM:

  760.                     std::strncpy(strBuf, "cm", STR_MAX);

  761.                     return;

  762.                 case LV2_PORT_UNIT_COEF:

  763.                     std::strncpy(strBuf, "(coef)", STR_MAX);

  764.                     return;

  765.                 case LV2_PORT_UNIT_DB:

  766.                     std::strncpy(strBuf, "dB", STR_MAX);

  767.                     return;

  768.                 case LV2_PORT_UNIT_DEGREE:

  769.                     std::strncpy(strBuf, "deg", STR_MAX);

  770.                     return;

  771.                 case LV2_PORT_UNIT_FRAME:

  772.                     std::strncpy(strBuf, "frames", STR_MAX);

  773.                     return;

  774.                 case LV2_PORT_UNIT_HZ:

  775.                     std::strncpy(strBuf, "Hz", STR_MAX);

  776.                     return;

  777.                 case LV2_PORT_UNIT_INCH:

  778.                     std::strncpy(strBuf, "in", STR_MAX);

  779.                     return;

  780.                 case LV2_PORT_UNIT_KHZ:

  781.                     std::strncpy(strBuf, "kHz", STR_MAX);

  782.                     return;

  783.                 case LV2_PORT_UNIT_KM:

  784.                     std::strncpy(strBuf, "km", STR_MAX);

  785.                     return;

  786.                 case LV2_PORT_UNIT_M:

  787.                     std::strncpy(strBuf, "m", STR_MAX);

  788.                     return;

  789.                 case LV2_PORT_UNIT_MHZ:

  790.                     std::strncpy(strBuf, "MHz", STR_MAX);

  791.                     return;

  792.                 case LV2_PORT_UNIT_MIDINOTE:

  793.                     std::strncpy(strBuf, "note", STR_MAX);

  794.                     return;

  795.                 case LV2_PORT_UNIT_MILE:

  796.                     std::strncpy(strBuf, "mi", STR_MAX);

  797.                     return;

  798.                 case LV2_PORT_UNIT_MIN:

  799.                     std::strncpy(strBuf, "min", STR_MAX);

  800.                     return;

  801.                 case LV2_PORT_UNIT_MM:

  802.                     std::strncpy(strBuf, "mm", STR_MAX);

  803.                     return;

  804.                 case LV2_PORT_UNIT_MS:

  805.                     std::strncpy(strBuf, "ms", STR_MAX);

  806.                     return;

  807.                 case LV2_PORT_UNIT_OCT:

  808.                     std::strncpy(strBuf, "oct", STR_MAX);

  809.                     return;

  810.                 case LV2_PORT_UNIT_PC:

  811.                     std::strncpy(strBuf, "%", STR_MAX);

  812.                     return;

  813.                 case LV2_PORT_UNIT_S:

  814.                     std::strncpy(strBuf, "s", STR_MAX);

  815.                     return;

  816.                 case LV2_PORT_UNIT_SEMITONE:

  817.                     std::strncpy(strBuf, "semi", STR_MAX);

  818.                     return;

  819.                 }

  820.             }

  821.         }

  822. 

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

  824.     }

  825. 

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

  827.     {

  828.         CARLA_ASSERT(fRdfDescriptor != nullptr);

  829.         CARLA_ASSERT(parameterId < kData->param.count);

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

  831. 

  832.         const int32_t rindex(kData->param.data[parameterId].rindex);

  833. 

  834.         if (rindex < static_cast<int32_t>(fRdfDescriptor->PortCount))

  835.         {

  836.             const LV2_RDF_Port& port(fRdfDescriptor->Ports[rindex]);

  837. 

  838.             if (scalePointId < port.ScalePointCount)

  839.             {

  840.                 const LV2_RDF_PortScalePoint& portScalePoint(port.ScalePoints[scalePointId]);

  841. 

  842.                 if (portScalePoint.Label != nullptr)

  843.                 {

  844.                     std::strncpy(strBuf, portScalePoint.Label, STR_MAX);

  845.                     return;

  846.                 }

  847.             }

  848.         }

  849. 

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

  851.     }

  852. 

  853.     // -------------------------------------------------------------------

  854.     // Set data (state)

  855. 

  856.     void prepareForSave() override

  857.     {

  858.         CARLA_ASSERT(fHandle != nullptr);

  859. 

  860.         if (fExt.state != nullptr && fExt.state->save != nullptr)

  861.         {

  862.             fExt.state->save(fHandle, carla_lv2_state_store, this, LV2_STATE_IS_POD, fFeatures);

  863. 

  864.             if (fHandle2 != nullptr)

  865.                 fExt.state->save(fHandle2, carla_lv2_state_store, this, LV2_STATE_IS_POD, fFeatures);

  866.         }

  867.     }

  868. 

  869.     // -------------------------------------------------------------------

  870.     // Set data (internal stuff)

  871. 

  872.     // nothing

  873. 

  874.     // -------------------------------------------------------------------

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

  876. 

  877.     void setParameterValue(const uint32_t parameterId, const float value, const bool sendGui, const bool sendOsc, const bool sendCallback) override

  878.     {

  879.         CARLA_ASSERT(parameterId < kData->param.count);

  880. 

  881.         const float fixedValue(kData->param.fixValue(parameterId, value));

  882.         fParamBuffers[parameterId] = fixedValue;

  883. 

  884.         CarlaPlugin::setParameterValue(parameterId, fixedValue, sendGui, sendOsc, sendCallback);

  885.     }

  886. 

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

  888.     {

  889.         CARLA_ASSERT(fDescriptor != nullptr);

  890.         CARLA_ASSERT(fHandle != nullptr);

  891.         CARLA_ASSERT(type != nullptr);

  892.         CARLA_ASSERT(key != nullptr);

  893.         CARLA_ASSERT(value != nullptr);

  894.         carla_debug("Lv2Plugin::setCustomData(%s, %s, %s, %s)", type, key, value, bool2str(sendGui));

  895. 

  896.         if (type == nullptr)

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

  898. 

  899.         if (key == nullptr)

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

  901. 

  902.         if (value == nullptr)

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

  904. 

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

  906. 

  907.         if (fExt.state != nullptr)

  908.         {

  909.             LV2_State_Status status;

  910. 

  911.             {

  912.                 const ScopedSingleProcessLocker spl(this, true);

  913. 

  914.                 status = fExt.state->restore(fHandle, carla_lv2_state_retrieve, this, 0, fFeatures);

  915. 

  916.                 if (fHandle2 != nullptr)

  917.                     fExt.state->restore(fHandle, carla_lv2_state_retrieve, this, 0, fFeatures);

  918.             }

  919. 

  920.             switch (status)

  921.             {

  922.             case LV2_STATE_SUCCESS:

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

  924.                 break;

  925.             case LV2_STATE_ERR_UNKNOWN:

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

  927.                 break;

  928.             case LV2_STATE_ERR_BAD_TYPE:

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

  930.                 break;

  931.             case LV2_STATE_ERR_BAD_FLAGS:

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

  933.                 break;

  934.             case LV2_STATE_ERR_NO_FEATURE:

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

  936.                 break;

  937.             case LV2_STATE_ERR_NO_PROPERTY:

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

  939.                 break;

  940.             }

  941.         }

  942. 

  943.         if (sendGui)

  944.         {

  945.             //CustomData cdata;

  946.             //cdata.type  = type;

  947.             //cdata.key   = key;

  948.             //cdata.value = value;

  949.             //uiTransferCustomData(&cdata);

  950.         }

  951.     }

  952. 

  953.     void setMidiProgram(int32_t index, const bool sendGui, const bool sendOsc, const bool sendCallback) override

  954.     {

  955.         CARLA_ASSERT(fDescriptor != nullptr);

  956.         CARLA_ASSERT(fHandle != nullptr);

  957.         CARLA_ASSERT(index >= -1 && index < static_cast<int32_t>(kData->midiprog.count));

  958. 

  959.         if (index < -1)

  960.             index = -1;

  961.         else if (index > static_cast<int32_t>(kData->midiprog.count))

  962.             return;

  963. 

  964.         if (index >= 0 && fExt.programs != nullptr && fExt.programs->select_program != nullptr)

  965.         {

  966.             const uint32_t bank    = kData->midiprog.data[index].bank;

  967.             const uint32_t program = kData->midiprog.data[index].program;

  968. 

  969.             const ScopedSingleProcessLocker spl(this, (sendGui || sendOsc || sendCallback));

  970. 

  971.             fExt.programs->select_program(fHandle, bank, program);

  972. 

  973.             if (fHandle2 != nullptr)

  974.                 fExt.programs->select_program(fHandle2, bank, program);

  975.         }

  976. 

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

  978.     }

  979. 

  980.     // -------------------------------------------------------------------

  981.     // Set gui stuff

  982. 

  983.     void showGui(const bool yesNo) override

  984.     {

  985.         if (fUi.type == PLUGIN_UI_NULL)

  986.             return;

  987. 

  988.         if (fUi.type == PLUGIN_UI_OSC)

  989.         {

  990.             if (yesNo)

  991.             {

  992.                 kData->osc.thread.start();

  993.             }

  994.             else

  995.             {

  996.                 if (kData->osc.data.target != nullptr)

  997.                 {

  998.                     osc_send_hide(&kData->osc.data);

  999.                     osc_send_quit(&kData->osc.data);

  1000.                     kData->osc.data.free();

  1001.                 }

  1002. 

  1003.                 if (kData->osc.thread.isRunning() && ! kData->osc.thread.wait(kData->engine->getOptions().oscUiTimeout))

  1004.                     kData->osc.thread.terminate();

  1005.             }

  1006. 

  1007.             return;

  1008.         }

  1009. 

  1010.         // take some precautions

  1011.         CARLA_ASSERT(fUi.descriptor != nullptr);

  1012.         CARLA_ASSERT(fUi.rdfDescriptor != nullptr);

  1013. 

  1014.         if (fUi.descriptor == nullptr)

  1015.             return;

  1016.         if (fUi.rdfDescriptor == nullptr)

  1017.             return;

  1018. 

  1019.         if (yesNo)

  1020.         {

  1021.             CARLA_ASSERT(fUi.descriptor->instantiate != nullptr);

  1022. 

  1023.             if (fUi.descriptor->instantiate == nullptr)

  1024.                 return;

  1025.         }

  1026.         else

  1027.         {

  1028.             CARLA_ASSERT(fUi.descriptor->cleanup != nullptr);

  1029. 

  1030.             if (fUi.handle == nullptr)

  1031.                 return;

  1032.             if (fUi.descriptor->cleanup == nullptr)

  1033.                 return;

  1034.         }

  1035. 

  1036.         if (fUi.type == PLUGIN_UI_EXTERNAL)

  1037.         {

  1038.             if (yesNo)

  1039.             {

  1040.                 fUi.widget = nullptr;

  1041. 

  1042.                 if (fUi.handle == nullptr)

  1043.                     fUi.handle = fUi.descriptor->instantiate(fUi.descriptor, fRdfDescriptor->URI, fUi.rdfDescriptor->Bundle,

  1044.                                                              carla_lv2_ui_write_function, this, &fUi.widget, fFeatures);

  1045. 

  1046.                 CARLA_ASSERT(fUi.handle != nullptr);

  1047.                 CARLA_ASSERT(fUi.widget != nullptr);

  1048. 

  1049.                 if (fUi.handle == nullptr || fUi.widget == nullptr)

  1050.                 {

  1051.                     fUi.handle = nullptr;

  1052.                     fUi.widget = nullptr;

  1053.                     kData->engine->callback(CALLBACK_ERROR, fId, 0, 0, 0.0f, "Plugin refused to open its own UI");

  1054.                     kData->engine->callback(CALLBACK_SHOW_GUI, fId, 0, 0, 0.0f, nullptr);

  1055.                     return;

  1056.                 }

  1057. 

  1058.                 updateUi();

  1059. 

  1060.                 LV2_EXTERNAL_UI_SHOW((LV2_External_UI_Widget*)fUi.widget);

  1061.             }

  1062.             else

  1063.             {

  1064.                 CARLA_ASSERT(fUi.widget != nullptr);

  1065. 

  1066.                 if (fUi.widget != nullptr)

  1067.                     LV2_EXTERNAL_UI_HIDE((LV2_External_UI_Widget*)fUi.widget);

  1068. 

  1069.                 fUi.descriptor->cleanup(fUi.handle);

  1070.                 fUi.handle = nullptr;

  1071.                 fUi.widget = nullptr;

  1072.             }

  1073.         }

  1074.         else // means PLUGIN_UI_PARENT || PLUGIN_UI_QT

  1075.         {

  1076.             if (yesNo)

  1077.             {

  1078.                 if (kData->gui == nullptr)

  1079.                 {

  1080.                     // TODO

  1081.                     CarlaPluginGui::Options guiOptions;

  1082.                     guiOptions.parented  = (fUi.type == PLUGIN_UI_PARENT);

  1083.                     guiOptions.resizable = isUiResizable();

  1084. 

  1085.                     kData->gui = new CarlaPluginGui(kData->engine, this, guiOptions);

  1086.                 }

  1087. 

  1088.                 if (fUi.type == PLUGIN_UI_PARENT)

  1089.                 {

  1090.                     fFeatures[kFeatureIdUiParent]->data = kData->gui->getContainerWinId();

  1091.                     fFeatures[kFeatureIdUiParent]->URI  = LV2_UI__parent;

  1092.                 }

  1093. 

  1094.                 fUi.widget = nullptr;

  1095. 

  1096.                 if (fUi.handle == nullptr)

  1097.                     fUi.handle = fUi.descriptor->instantiate(fUi.descriptor, fRdfDescriptor->URI, fUi.rdfDescriptor->Bundle,

  1098.                                                              carla_lv2_ui_write_function, this, &fUi.widget, fFeatures);

  1099. 

  1100.                 CARLA_ASSERT(fUi.handle != nullptr);

  1101.                 CARLA_ASSERT(fUi.widget != nullptr);

  1102. 

  1103.                 if (fUi.handle == nullptr || fUi.widget == nullptr)

  1104.                 {

  1105.                     fUi.handle = nullptr;

  1106.                     fUi.widget = nullptr;

  1107. 

  1108.                     kData->gui->close();

  1109.                     delete kData->gui;

  1110.                     kData->gui = nullptr;

  1111. 

  1112.                     kData->engine->callback(CALLBACK_ERROR, fId, 0, 0, 0.0f, "Plugin refused to open its own UI");

  1113.                     kData->engine->callback(CALLBACK_SHOW_GUI, fId, -1, 0, 0.0f, nullptr);

  1114.                     return;

  1115.                 }

  1116. 

  1117.                 if (fUi.type == PLUGIN_UI_QT)

  1118.                     kData->gui->setWidget((QWidget*)fUi.widget);

  1119. 

  1120.                 updateUi();

  1121. 

  1122.                 kData->gui->setWindowTitle(QString("%1 (GUI)").arg((const char*)fName));

  1123.                 kData->gui->show();

  1124.             }

  1125.             else

  1126.             {

  1127.                 fUi.descriptor->cleanup(fUi.handle);

  1128.                 fUi.handle = nullptr;

  1129.                 fUi.widget = nullptr;

  1130. 

  1131.                 if (kData->gui != nullptr)

  1132.                 {

  1133.                     kData->gui->close();

  1134.                     delete kData->gui;

  1135.                     kData->gui = nullptr;

  1136.                 }

  1137.             }

  1138.         }

  1139.     }

  1140. 

  1141.     void idleGui() override

  1142.     {

  1143.         if (fUi.handle != nullptr && fUi.descriptor != nullptr)

  1144.         {

  1145.             if (fUi.type == PLUGIN_UI_EXTERNAL && fUi.widget != nullptr)

  1146.                 LV2_EXTERNAL_UI_RUN((LV2_External_UI_Widget*)fUi.widget);

  1147. 

  1148.             if (fExt.uiidle != nullptr)

  1149.             {

  1150.                 if (fExt.uiidle->idle(fUi.handle) != 0)

  1151.                 {

  1152.                     showGui(false);

  1153.                     kData->engine->callback(CALLBACK_SHOW_GUI, fId, 0, 0, 0.0f, nullptr);

  1154.                 }

  1155.             }

  1156.         }

  1157. 

  1158.         CarlaPlugin::idleGui();

  1159.     }

  1160. 

  1161.     // -------------------------------------------------------------------

  1162.     // Plugin state

  1163. 

  1164.     void reload() override

  1165.     {

  1166.         carla_debug("Lv2Plugin::reload() - start");

  1167.         CARLA_ASSERT(kData->engine != nullptr);

  1168.         CARLA_ASSERT(fHandle != nullptr);

  1169.         CARLA_ASSERT(fDescriptor != nullptr);

  1170.         CARLA_ASSERT(fRdfDescriptor != nullptr);

  1171. 

  1172.         if (kData->engine == nullptr)

  1173.             return;

  1174.         if (fHandle == nullptr)

  1175.             return;

  1176.         if (fDescriptor == nullptr)

  1177.             return;

  1178.         if (fRdfDescriptor == nullptr)

  1179.             return;

  1180. 

  1181.         const ProcessMode processMode(kData->engine->getProccessMode());

  1182. 

  1183.         // Safely disable plugin for reload

  1184.         const ScopedDisabler sd(this);

  1185. 

  1186.         if (kData->active)

  1187.             deactivate();

  1188. 

  1189.         clearBuffers();

  1190. 

  1191.         const float   sampleRate = (float)kData->engine->getSampleRate();

  1192.         const uint32_t portCount = fRdfDescriptor->PortCount;

  1193. 

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

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

  1196.         NonRtList<uint32_t> evIns, evOuts;

  1197. 

  1198.         bool forcedStereoIn, forcedStereoOut;

  1199.         forcedStereoIn = forcedStereoOut = false;

  1200. 

  1201.         bool needsCtrlIn, needsCtrlOut;

  1202.         needsCtrlIn = needsCtrlOut = false;

  1203. 

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

  1205.         {

  1206.             const LV2_Property portTypes(fRdfDescriptor->Ports[i].Types);

  1207. 

  1208.             if (LV2_IS_PORT_AUDIO(portTypes))

  1209.             {

  1210.                 if (LV2_IS_PORT_INPUT(portTypes))

  1211.                     aIns += 1;

  1212.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  1213.                     aOuts += 1;

  1214.             }

  1215.             else if (LV2_IS_PORT_CV(portTypes))

  1216.             {

  1217.                 if (LV2_IS_PORT_INPUT(portTypes))

  1218.                     cvIns += 1;

  1219.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  1220.                     cvOuts += 1;

  1221.             }

  1222.             else if (LV2_IS_PORT_ATOM_SEQUENCE(portTypes))

  1223.             {

  1224.                 if (LV2_IS_PORT_INPUT(portTypes))

  1225.                     evIns.append(CARLA_EVENT_DATA_ATOM);

  1226.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  1227.                     evOuts.append(CARLA_EVENT_DATA_ATOM);

  1228.             }

  1229.             else if (LV2_IS_PORT_EVENT(portTypes))

  1230.             {

  1231.                 if (LV2_IS_PORT_INPUT(portTypes))

  1232.                     evIns.append(CARLA_EVENT_DATA_EVENT);

  1233.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  1234.                     evOuts.append(CARLA_EVENT_DATA_EVENT);

  1235.             }

  1236.             else if (LV2_IS_PORT_MIDI_LL(portTypes))

  1237.             {

  1238.                 if (LV2_IS_PORT_INPUT(portTypes))

  1239.                     evIns.append(CARLA_EVENT_DATA_MIDI_LL);

  1240.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  1241.                     evOuts.append(CARLA_EVENT_DATA_MIDI_LL);

  1242.             }

  1243.             else if (LV2_IS_PORT_CONTROL(portTypes))

  1244.                 params += 1;

  1245.         }

  1246. 

  1247.         // check extensions

  1248.         fExt.options  = nullptr;

  1249.         fExt.programs = nullptr;

  1250.         fExt.state    = nullptr;

  1251.         fExt.worker   = nullptr;

  1252. 

  1253.         if (fDescriptor->extension_data != nullptr)

  1254.         {

  1255.             if (kData->extraHints & PLUGIN_HAS_EXTENSION_OPTIONS)

  1256.                 fExt.options = (const LV2_Options_Interface*)fDescriptor->extension_data(LV2_OPTIONS__interface);

  1257. 

  1258.             if (kData->extraHints & PLUGIN_HAS_EXTENSION_PROGRAMS)

  1259.                 fExt.programs = (const LV2_Programs_Interface*)fDescriptor->extension_data(LV2_PROGRAMS__Interface);

  1260. 

  1261.             if (kData->extraHints & PLUGIN_HAS_EXTENSION_STATE)

  1262.                 fExt.state = (const LV2_State_Interface*)fDescriptor->extension_data(LV2_STATE__interface);

  1263. 

  1264.             if (kData->extraHints & PLUGIN_HAS_EXTENSION_WORKER)

  1265.                 fExt.worker = (const LV2_Worker_Interface*)fDescriptor->extension_data(LV2_WORKER__interface);

  1266.         }

  1267. 

  1268.         if ((fOptions & PLUGIN_OPTION_FORCE_STEREO) != 0 && (aIns == 1 || aOuts == 1) && fExt.state == nullptr && fExt.worker == nullptr)

  1269.         {

  1270.             if (fHandle2 == nullptr)

  1271.                 fHandle2 = fDescriptor->instantiate(fDescriptor, sampleRate, fRdfDescriptor->Bundle, fFeatures);

  1272. 

  1273.             if (aIns == 1)

  1274.             {

  1275.                 aIns = 2;

  1276.                 forcedStereoIn = true;

  1277.             }

  1278. 

  1279.             if (aOuts == 1)

  1280.             {

  1281.                 aOuts = 2;

  1282.                 forcedStereoOut = true;

  1283.             }

  1284.         }

  1285. 

  1286.         if (aIns > 0)

  1287.         {

  1288.             kData->audioIn.createNew(aIns);

  1289.             fAudioInBuffers = new float*[aIns];

  1290. 

  1291.             for (uint32_t i=0; i < aIns; ++i)

  1292.                 fAudioInBuffers[i] = nullptr;

  1293.         }

  1294. 

  1295.         if (aOuts > 0)

  1296.         {

  1297.             kData->audioOut.createNew(aOuts);

  1298.             fAudioOutBuffers = new float*[aOuts];

  1299.             needsCtrlIn = true;

  1300. 

  1301.             for (uint32_t i=0; i < aOuts; ++i)

  1302.                 fAudioOutBuffers[i] = nullptr;

  1303.         }

  1304. 

  1305.         if (params > 0)

  1306.         {

  1307.             kData->param.createNew(params);

  1308.             fParamBuffers = new float[params];

  1309. 

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

  1311.                 fParamBuffers[i] = 0.0f;

  1312.         }

  1313. 

  1314.         if (evIns.count() > 0)

  1315.         {

  1316.             const size_t count(evIns.count());

  1317. 

  1318.             fEventsIn.createNew(count);

  1319. 

  1320.             for (j=0; j < count; ++j)

  1321.             {

  1322.                 const uint32_t& type(evIns.getAt(j));

  1323. 

  1324.                 if (type == CARLA_EVENT_DATA_ATOM)

  1325.                 {

  1326.                     fEventsIn.data[j].type = CARLA_EVENT_DATA_ATOM;

  1327.                     fEventsIn.data[j].atom = (LV2_Atom_Sequence*)std::malloc(sizeof(LV2_Atom_Sequence) + MAX_EVENT_BUFFER);

  1328.                     fEventsIn.data[j].atom->atom.size = 0;

  1329.                     fEventsIn.data[j].atom->atom.type = CARLA_URI_MAP_ID_ATOM_SEQUENCE;

  1330.                     fEventsIn.data[j].atom->body.unit = CARLA_URI_MAP_ID_NULL;

  1331.                     fEventsIn.data[j].atom->body.pad  = 0;

  1332.                 }

  1333.                 else if (type == CARLA_EVENT_DATA_EVENT)

  1334.                 {

  1335.                     fEventsIn.data[j].type  = CARLA_EVENT_DATA_EVENT;

  1336.                     fEventsIn.data[j].event = lv2_event_buffer_new(MAX_EVENT_BUFFER, LV2_EVENT_AUDIO_STAMP);

  1337.                 }

  1338.                 else if (type == CARLA_EVENT_DATA_MIDI_LL)

  1339.                 {

  1340.                     fEventsIn.data[j].type = CARLA_EVENT_DATA_MIDI_LL;

  1341.                     fEventsIn.data[j].midi = new LV2_MIDI;

  1342.                     fEventsIn.data[j].midi->capacity = MAX_EVENT_BUFFER;

  1343.                     fEventsIn.data[j].midi->data     = new unsigned char[MAX_EVENT_BUFFER];

  1344.                 }

  1345.             }

  1346.         }

  1347. 

  1348.         if (evOuts.count() > 0)

  1349.         {

  1350.             const size_t count(evOuts.count());

  1351. 

  1352.             fEventsOut.createNew(count);

  1353. 

  1354.             for (j=0; j < count; ++j)

  1355.             {

  1356.                 const uint32_t& type(evOuts.getAt(j));

  1357. 

  1358.                 if (type == CARLA_EVENT_DATA_ATOM)

  1359.                 {

  1360.                     fEventsOut.data[j].type = CARLA_EVENT_DATA_ATOM;

  1361.                     fEventsOut.data[j].atom = (LV2_Atom_Sequence*)std::malloc(sizeof(LV2_Atom_Sequence) + MAX_EVENT_BUFFER);

  1362.                     fEventsOut.data[j].atom->atom.size = 0;

  1363.                     fEventsOut.data[j].atom->atom.type = CARLA_URI_MAP_ID_ATOM_SEQUENCE;

  1364.                     fEventsOut.data[j].atom->body.unit = CARLA_URI_MAP_ID_NULL;

  1365.                     fEventsOut.data[j].atom->body.pad  = 0;

  1366.                 }

  1367.                 else if (type == CARLA_EVENT_DATA_EVENT)

  1368.                 {

  1369.                     fEventsOut.data[j].type  = CARLA_EVENT_DATA_EVENT;

  1370.                     fEventsOut.data[j].event = lv2_event_buffer_new(MAX_EVENT_BUFFER, LV2_EVENT_AUDIO_STAMP);

  1371.                 }

  1372.                 else if (type == CARLA_EVENT_DATA_MIDI_LL)

  1373.                 {

  1374.                     fEventsOut.data[j].type = CARLA_EVENT_DATA_MIDI_LL;

  1375.                     fEventsOut.data[j].midi = new LV2_MIDI;

  1376.                     fEventsOut.data[j].midi->capacity = MAX_EVENT_BUFFER;

  1377.                     fEventsOut.data[j].midi->data     = new unsigned char[MAX_EVENT_BUFFER];

  1378.                 }

  1379.             }

  1380.         }

  1381. 

  1382.         const uint portNameSize(kData->engine->maxPortNameSize());

  1383.         CarlaString portName;

  1384. 

  1385.         for (uint32_t i=0, iAudioIn=0, iAudioOut=0, iEvIn=0, iEvOut=0, iCtrl=0; i < portCount; ++i)

  1386.         {

  1387.             const LV2_Property portTypes(fRdfDescriptor->Ports[i].Types);

  1388. 

  1389.             portName.clear();

  1390. 

  1391.             if (LV2_IS_PORT_AUDIO(portTypes) || LV2_IS_PORT_ATOM_SEQUENCE(portTypes) || LV2_IS_PORT_CV(portTypes) || LV2_IS_PORT_EVENT(portTypes) || LV2_IS_PORT_MIDI_LL(portTypes))

  1392.             {

  1393.                 if (processMode == PROCESS_MODE_SINGLE_CLIENT)

  1394.                 {

  1395.                     portName  = fName;

  1396.                     portName += ":";

  1397.                 }

  1398. 

  1399.                 portName += fRdfDescriptor->Ports[i].Name;

  1400.                 portName.truncate(portNameSize);

  1401.             }

  1402. 

  1403.             if (LV2_IS_PORT_AUDIO(portTypes))

  1404.             {

  1405.                 if (LV2_IS_PORT_INPUT(portTypes))

  1406.                 {

  1407.                     j = iAudioIn++;

  1408.                     kData->audioIn.ports[j].port   = (CarlaEngineAudioPort*)kData->client->addPort(kEnginePortTypeAudio, portName, true);

  1409.                     kData->audioIn.ports[j].rindex = i;

  1410. 

  1411.                     if (forcedStereoIn)

  1412.                     {

  1413.                         portName += "_2";

  1414.                         kData->audioIn.ports[1].port   = (CarlaEngineAudioPort*)kData->client->addPort(kEnginePortTypeAudio, portName, true);

  1415.                         kData->audioIn.ports[1].rindex = i;

  1416.                     }

  1417.                 }

  1418.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  1419.                 {

  1420.                     j = iAudioOut++;

  1421.                     kData->audioOut.ports[j].port   = (CarlaEngineAudioPort*)kData->client->addPort(kEnginePortTypeAudio, portName, false);

  1422.                     kData->audioOut.ports[j].rindex = i;

  1423. 

  1424.                     if (forcedStereoOut)

  1425.                     {

  1426.                         portName += "_2";

  1427.                         kData->audioOut.ports[1].port   = (CarlaEngineAudioPort*)kData->client->addPort(kEnginePortTypeAudio, portName, false);

  1428.                         kData->audioOut.ports[1].rindex = i;

  1429.                     }

  1430.                 }

  1431.                 else

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

  1433.             }

  1434.             else if (LV2_IS_PORT_CV(portTypes))

  1435.             {

  1436.                 if (LV2_IS_PORT_INPUT(portTypes))

  1437.                 {

  1438.                     carla_stderr("WARNING - CV Ports are not supported yet");

  1439.                 }

  1440.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  1441.                 {

  1442.                     carla_stderr("WARNING - CV Ports are not supported yet");

  1443.                 }

  1444.                 else

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

  1446. 

  1447.                 fDescriptor->connect_port(fHandle, i, nullptr);

  1448. 

  1449.                 if (fHandle2 != nullptr)

  1450.                     fDescriptor->connect_port(fHandle2, i, nullptr);

  1451.             }

  1452.             else if (LV2_IS_PORT_ATOM_SEQUENCE(portTypes))

  1453.             {

  1454.                 if (LV2_IS_PORT_INPUT(portTypes))

  1455.                 {

  1456.                     j = iEvIn++;

  1457. 

  1458.                     fDescriptor->connect_port(fHandle, i, fEventsIn.data[j].atom);

  1459. 

  1460.                     if (fHandle2 != nullptr)

  1461.                         fDescriptor->connect_port(fHandle2, i, fEventsIn.data[j].atom);

  1462. 

  1463.                     fEventsIn.data[j].rindex = i;

  1464. 

  1465.                     if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

  1466.                     {

  1467.                         fEventsIn.data[j].type |= CARLA_EVENT_TYPE_MIDI;

  1468. 

  1469.                         if (evIns.count() == 1)

  1470.                         {

  1471.                             needsCtrlIn = true;

  1472.                             fEventsIn.ctrl = &fEventsIn.data[j];

  1473.                             fEventsIn.ctrlIndex = j;

  1474.                         }

  1475.                         else

  1476.                         {

  1477.                             fEventsIn.data[j].port = (CarlaEngineEventPort*)kData->client->addPort(kEnginePortTypeEvent, portName, true);

  1478. 

  1479.                             if (LV2_IS_PORT_DESIGNATION_CONTROL(fRdfDescriptor->Ports[i].Designation))

  1480.                             {

  1481.                                 fEventsIn.ctrl = &fEventsIn.data[j];

  1482.                                 fEventsIn.ctrlIndex = j;

  1483.                             }

  1484.                         }

  1485.                     }

  1486.                     if (portTypes & LV2_PORT_DATA_PATCH_MESSAGE)

  1487.                     {

  1488.                         fEventsIn.data[j].type |= CARLA_EVENT_TYPE_MESSAGE;

  1489.                     }

  1490.                     if (portTypes & LV2_PORT_DATA_TIME_POSITION)

  1491.                     {

  1492.                         fEventsIn.data[j].type |= CARLA_EVENT_TYPE_TIME;

  1493.                     }

  1494.                 }

  1495.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  1496.                 {

  1497.                     j = iEvOut++;

  1498. 

  1499.                     fDescriptor->connect_port(fHandle, i, fEventsOut.data[j].atom);

  1500. 

  1501.                     if (fHandle2 != nullptr)

  1502.                         fDescriptor->connect_port(fHandle2, i, fEventsOut.data[j].atom);

  1503. 

  1504.                     fEventsOut.data[j].rindex = i;

  1505. 

  1506.                     if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

  1507.                     {

  1508.                         fEventsOut.data[j].type |= CARLA_EVENT_TYPE_MIDI;

  1509. 

  1510.                         if (evOuts.count() == 1)

  1511.                         {

  1512.                             needsCtrlOut = true;

  1513.                             fEventsOut.ctrl = &fEventsOut.data[j];

  1514.                             fEventsOut.ctrlIndex = j;

  1515.                         }

  1516.                         else

  1517.                         {

  1518.                             fEventsOut.data[j].port = (CarlaEngineEventPort*)kData->client->addPort(kEnginePortTypeEvent, portName, false);

  1519. 

  1520.                             if (LV2_IS_PORT_DESIGNATION_CONTROL(fRdfDescriptor->Ports[i].Designation))

  1521.                             {

  1522.                                 fEventsOut.ctrl = &fEventsOut.data[j];

  1523.                                 fEventsOut.ctrlIndex = j;

  1524.                             }

  1525.                         }

  1526.                     }

  1527.                     if (portTypes & LV2_PORT_DATA_PATCH_MESSAGE)

  1528.                     {

  1529.                         fEventsOut.data[j].type |= CARLA_EVENT_TYPE_MESSAGE;

  1530.                     }

  1531.                     if (portTypes & LV2_PORT_DATA_TIME_POSITION)

  1532.                     {

  1533.                         fEventsOut.data[j].type |= CARLA_EVENT_TYPE_TIME;

  1534.                     }

  1535.                 }

  1536.                 else

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

  1538.             }

  1539.             else if (LV2_IS_PORT_EVENT(portTypes))

  1540.             {

  1541.                 if (LV2_IS_PORT_INPUT(portTypes))

  1542.                 {

  1543.                     j = iEvIn++;

  1544. 

  1545.                     fDescriptor->connect_port(fHandle, i, fEventsIn.data[j].event);

  1546. 

  1547.                     if (fHandle2 != nullptr)

  1548.                         fDescriptor->connect_port(fHandle2, i, fEventsIn.data[j].event);

  1549. 

  1550.                     fEventsIn.data[j].rindex = i;

  1551. 

  1552.                     if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

  1553.                     {

  1554.                         fEventsIn.data[j].type |= CARLA_EVENT_TYPE_MIDI;

  1555. 

  1556.                         if (evIns.count() == 1)

  1557.                         {

  1558.                             needsCtrlIn = true;

  1559.                             fEventsIn.ctrl = &fEventsIn.data[j];

  1560.                             fEventsIn.ctrlIndex = j;

  1561.                         }

  1562.                         else

  1563.                         {

  1564.                             fEventsIn.data[j].port = (CarlaEngineEventPort*)kData->client->addPort(kEnginePortTypeEvent, portName, true);

  1565. 

  1566.                             if (LV2_IS_PORT_DESIGNATION_CONTROL(fRdfDescriptor->Ports[i].Designation))

  1567.                             {

  1568.                                 fEventsIn.ctrl = &fEventsIn.data[j];

  1569.                                 fEventsIn.ctrlIndex = j;

  1570.                             }

  1571.                         }

  1572.                     }

  1573.                     if (portTypes & LV2_PORT_DATA_PATCH_MESSAGE)

  1574.                     {

  1575.                         fEventsIn.data[j].type |= CARLA_EVENT_TYPE_MESSAGE;

  1576.                     }

  1577.                     if (portTypes & LV2_PORT_DATA_TIME_POSITION)

  1578.                     {

  1579.                         fEventsIn.data[j].type |= CARLA_EVENT_TYPE_TIME;

  1580.                     }

  1581.                 }

  1582.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  1583.                 {

  1584.                     j = iEvOut++;

  1585. 

  1586.                     fDescriptor->connect_port(fHandle, i, fEventsOut.data[j].event);

  1587. 

  1588.                     if (fHandle2 != nullptr)

  1589.                         fDescriptor->connect_port(fHandle2, i, fEventsOut.data[j].event);

  1590. 

  1591.                     fEventsOut.data[j].rindex = i;

  1592. 

  1593.                     if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

  1594.                     {

  1595.                         fEventsOut.data[j].type |= CARLA_EVENT_TYPE_MIDI;

  1596. 

  1597.                         if (evOuts.count() == 1)

  1598.                         {

  1599.                             needsCtrlOut = true;

  1600.                             fEventsOut.ctrl = &fEventsOut.data[j];

  1601.                             fEventsOut.ctrlIndex = j;

  1602.                         }

  1603.                         else

  1604.                         {

  1605.                             fEventsOut.data[j].port  = (CarlaEngineEventPort*)kData->client->addPort(kEnginePortTypeEvent, portName, false);

  1606. 

  1607.                             if (LV2_IS_PORT_DESIGNATION_CONTROL(fRdfDescriptor->Ports[i].Designation))

  1608.                             {

  1609.                                 fEventsOut.ctrl = &fEventsOut.data[j];

  1610.                                 fEventsOut.ctrlIndex = j;

  1611.                             }

  1612.                         }

  1613.                     }

  1614.                     if (portTypes & LV2_PORT_DATA_PATCH_MESSAGE)

  1615.                     {

  1616.                         fEventsOut.data[j].type |= CARLA_EVENT_TYPE_MESSAGE;

  1617.                     }

  1618.                     if (portTypes & LV2_PORT_DATA_TIME_POSITION)

  1619.                     {

  1620.                         fEventsOut.data[j].type |= CARLA_EVENT_TYPE_TIME;

  1621.                     }

  1622.                 }

  1623.                 else

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

  1625.             }

  1626.             else if (LV2_IS_PORT_MIDI_LL(portTypes))

  1627.             {

  1628.                 if (LV2_IS_PORT_INPUT(portTypes))

  1629.                 {

  1630.                     j = iEvIn++;

  1631. 

  1632.                     fDescriptor->connect_port(fHandle, i, fEventsIn.data[j].midi);

  1633. 

  1634.                     if (fHandle2 != nullptr)

  1635.                         fDescriptor->connect_port(fHandle2, i, fEventsIn.data[j].midi);

  1636. 

  1637.                     fEventsIn.data[j].type  |= CARLA_EVENT_TYPE_MIDI;

  1638.                     fEventsIn.data[j].rindex = i;

  1639. 

  1640.                     if (evIns.count() == 1)

  1641.                     {

  1642.                         needsCtrlIn = true;

  1643.                         fEventsIn.ctrl = &fEventsIn.data[j];

  1644.                         fEventsIn.ctrlIndex = j;

  1645.                     }

  1646.                     else

  1647.                     {

  1648.                         fEventsIn.data[j].port = (CarlaEngineEventPort*)kData->client->addPort(kEnginePortTypeEvent, portName, true);

  1649. 

  1650.                         if (LV2_IS_PORT_DESIGNATION_CONTROL(fRdfDescriptor->Ports[i].Designation))

  1651.                         {

  1652.                             fEventsIn.ctrl = &fEventsIn.data[j];

  1653.                             fEventsIn.ctrlIndex = j;

  1654.                         }

  1655.                     }

  1656.                 }

  1657.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  1658.                 {

  1659.                     j = iEvOut++;

  1660. 

  1661.                     fDescriptor->connect_port(fHandle, i, fEventsOut.data[j].midi);

  1662. 

  1663.                     if (fHandle2 != nullptr)

  1664.                         fDescriptor->connect_port(fHandle2, i, fEventsOut.data[j].midi);

  1665. 

  1666.                     fEventsOut.data[j].type  |= CARLA_EVENT_TYPE_MIDI;

  1667.                     fEventsOut.data[j].rindex = i;

  1668. 

  1669.                     if (evOuts.count() == 1)

  1670.                     {

  1671.                         needsCtrlOut = true;

  1672.                         fEventsOut.ctrl = &fEventsOut.data[j];

  1673.                         fEventsOut.ctrlIndex = j;

  1674.                     }

  1675.                     else

  1676.                     {

  1677.                         fEventsOut.data[j].port = (CarlaEngineEventPort*)kData->client->addPort(kEnginePortTypeEvent, portName, false);

  1678. 

  1679.                         if (LV2_IS_PORT_DESIGNATION_CONTROL(fRdfDescriptor->Ports[i].Designation))

  1680.                         {

  1681.                             fEventsOut.ctrl = &fEventsOut.data[j];

  1682.                             fEventsOut.ctrlIndex = j;

  1683.                         }

  1684.                     }

  1685.                 }

  1686.                 else

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

  1688.             }

  1689.             else if (LV2_IS_PORT_CONTROL(portTypes))

  1690.             {

  1691.                 const LV2_Property portProps(fRdfDescriptor->Ports[i].Properties);

  1692.                 const LV2_Property portDesignation(fRdfDescriptor->Ports[i].Designation);

  1693.                 const LV2_RDF_PortPoints portPoints(fRdfDescriptor->Ports[i].Points);

  1694. 

  1695.                 j = iCtrl++;

  1696.                 kData->param.data[j].index  = j;

  1697.                 kData->param.data[j].rindex = i;

  1698.                 kData->param.data[j].hints  = 0x0;

  1699.                 kData->param.data[j].midiChannel = 0;

  1700.                 kData->param.data[j].midiCC = -1;

  1701. 

  1702.                 float min, max, def, step, stepSmall, stepLarge;

  1703. 

  1704.                 // min value

  1705.                 if (LV2_HAVE_MINIMUM_PORT_POINT(portPoints.Hints))

  1706.                     min = portPoints.Minimum;

  1707.                 else

  1708.                     min = 0.0f;

  1709. 

  1710.                 // max value

  1711.                 if (LV2_HAVE_MAXIMUM_PORT_POINT(portPoints.Hints))

  1712.                     max = portPoints.Maximum;

  1713.                 else

  1714.                     max = 1.0f;

  1715. 

  1716.                 if (min > max)

  1717.                     max = min;

  1718.                 else if (max < min)

  1719.                     min = max;

  1720. 

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

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

  1723.                 {

  1724.                     min = 0.0f;

  1725.                     max = (float)0xffffff;

  1726.                 }

  1727. 

  1728.                 if (max - min == 0.0f)

  1729.                 {

  1730.                     carla_stderr2("WARNING - Broken plugin parameter '%s': max - min == 0.0f", fRdfDescriptor->Ports[i].Name);

  1731.                     max = min + 0.1f;

  1732.                 }

  1733. 

  1734.                 // default value

  1735.                 if (LV2_HAVE_DEFAULT_PORT_POINT(portPoints.Hints))

  1736.                 {

  1737.                     def = portPoints.Default;

  1738.                 }

  1739.                 else

  1740.                 {

  1741.                     // no default value

  1742.                     if (min < 0.0f && max > 0.0f)

  1743.                         def = 0.0f;

  1744.                     else

  1745.                         def = min;

  1746.                 }

  1747. 

  1748.                 if (def < min)

  1749.                     def = min;

  1750.                 else if (def > max)

  1751.                     def = max;

  1752. 

  1753.                 if (LV2_IS_PORT_SAMPLE_RATE(portProps))

  1754.                 {

  1755.                     min *= sampleRate;

  1756.                     max *= sampleRate;

  1757.                     def *= sampleRate;

  1758.                     kData->param.data[j].hints |= PARAMETER_USES_SAMPLERATE;

  1759.                 }

  1760. 

  1761.                 if (LV2_IS_PORT_TOGGLED(portProps))

  1762.                 {

  1763.                     step = max - min;

  1764.                     stepSmall = step;

  1765.                     stepLarge = step;

  1766.                     kData->param.data[j].hints |= PARAMETER_IS_BOOLEAN;

  1767.                 }

  1768.                 else if (LV2_IS_PORT_INTEGER(portProps))

  1769.                 {

  1770.                     step = 1.0f;

  1771.                     stepSmall = 1.0f;

  1772.                     stepLarge = 10.0f;

  1773.                     kData->param.data[j].hints |= PARAMETER_IS_INTEGER;

  1774.                 }

  1775.                 else

  1776.                 {

  1777.                     float range = max - min;

  1778.                     step = range/100.0f;

  1779.                     stepSmall = range/1000.0f;

  1780.                     stepLarge = range/10.0f;

  1781.                 }

  1782. 

  1783.                 if (LV2_IS_PORT_INPUT(portTypes))

  1784.                 {

  1785.                     if (LV2_IS_PORT_DESIGNATION_LATENCY(portDesignation))

  1786.                     {

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

  1788.                     }

  1789.                     else if (LV2_IS_PORT_DESIGNATION_SAMPLE_RATE(portDesignation))

  1790.                     {

  1791.                         def = sampleRate;

  1792.                         step = 1.0f;

  1793.                         stepSmall = 1.0f;

  1794.                         stepLarge = 1.0f;

  1795. 

  1796.                         kData->param.data[j].type  = PARAMETER_SAMPLE_RATE;

  1797.                         kData->param.data[j].hints = 0x0;

  1798.                     }

  1799.                     else if (LV2_IS_PORT_DESIGNATION_FREEWHEELING(portDesignation))

  1800.                     {

  1801.                         kData->param.data[j].type = PARAMETER_LV2_FREEWHEEL;

  1802.                     }

  1803.                     else if (LV2_IS_PORT_DESIGNATION_TIME(portDesignation))

  1804.                     {

  1805.                         kData->param.data[j].type = PARAMETER_LV2_TIME;

  1806.                     }

  1807.                     else

  1808.                     {

  1809.                         kData->param.data[j].type = PARAMETER_INPUT;

  1810.                         kData->param.data[j].hints |= PARAMETER_IS_ENABLED;

  1811.                         kData->param.data[j].hints |= PARAMETER_IS_AUTOMABLE;

  1812.                         needsCtrlIn = true;

  1813.                     }

  1814. 

  1815.                     // MIDI CC value

  1816.                     const LV2_RDF_PortMidiMap& portMidiMap(fRdfDescriptor->Ports[i].MidiMap);

  1817.                     if (LV2_IS_PORT_MIDI_MAP_CC(portMidiMap.Type))

  1818.                     {

  1819.                         if (! MIDI_IS_CONTROL_BANK_SELECT(portMidiMap.Number))

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

  1821.                     }

  1822.                 }

  1823.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  1824.                 {

  1825.                     if (LV2_IS_PORT_DESIGNATION_LATENCY(portDesignation))

  1826.                     {

  1827.                         min = 0.0f;

  1828.                         max = sampleRate;

  1829.                         def = 0.0f;

  1830.                         step = 1.0f;

  1831.                         stepSmall = 1.0f;

  1832.                         stepLarge = 1.0f;

  1833. 

  1834.                         kData->param.data[j].type  = PARAMETER_LATENCY;

  1835.                         kData->param.data[j].hints = 0;

  1836.                     }

  1837.                     else if (LV2_IS_PORT_DESIGNATION_SAMPLE_RATE(portDesignation))

  1838.                     {

  1839.                         def = sampleRate;

  1840.                         step = 1.0f;

  1841.                         stepSmall = 1.0f;

  1842.                         stepLarge = 1.0f;

  1843. 

  1844.                         kData->param.data[j].type  = PARAMETER_SAMPLE_RATE;

  1845.                         kData->param.data[j].hints = 0;

  1846.                     }

  1847.                     else if (LV2_IS_PORT_DESIGNATION_FREEWHEELING(portDesignation))

  1848.                     {

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

  1850.                     }

  1851.                     else if (LV2_IS_PORT_DESIGNATION_TIME(portDesignation))

  1852.                     {

  1853.                         kData->param.data[j].type = PARAMETER_LV2_TIME;

  1854.                     }

  1855.                     else

  1856.                     {

  1857.                         kData->param.data[j].type   = PARAMETER_OUTPUT;

  1858.                         kData->param.data[j].hints |= PARAMETER_IS_ENABLED;

  1859.                         kData->param.data[j].hints |= PARAMETER_IS_AUTOMABLE;

  1860.                         needsCtrlOut = true;

  1861.                     }

  1862.                 }

  1863.                 else

  1864.                 {

  1865.                     kData->param.data[j].type = PARAMETER_UNKNOWN;

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

  1867.                 }

  1868. 

  1869.                 // extra parameter hints

  1870.                 if (LV2_IS_PORT_ENUMERATION(portProps))

  1871.                     kData->param.data[j].hints |= PARAMETER_USES_SCALEPOINTS;

  1872. 

  1873.                 if (LV2_IS_PORT_LOGARITHMIC(portProps))

  1874.                     kData->param.data[j].hints |= PARAMETER_IS_LOGARITHMIC;

  1875. 

  1876.                 if (LV2_IS_PORT_TRIGGER(portProps))

  1877.                     kData->param.data[j].hints |= PARAMETER_IS_TRIGGER;

  1878. 

  1879.                 if (LV2_IS_PORT_STRICT_BOUNDS(portProps))

  1880.                     kData->param.data[j].hints |= PARAMETER_IS_STRICT_BOUNDS;

  1881. 

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

  1883.                 if (LV2_IS_PORT_NOT_ON_GUI(portProps))

  1884.                     kData->param.data[j].hints &= ~PARAMETER_IS_ENABLED;

  1885. 

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

  1887.                     kData->param.data[j].hints &= ~PARAMETER_IS_AUTOMABLE;

  1888. 

  1889.                 kData->param.ranges[j].min = min;

  1890.                 kData->param.ranges[j].max = max;

  1891.                 kData->param.ranges[j].def = def;

  1892.                 kData->param.ranges[j].step = step;

  1893.                 kData->param.ranges[j].stepSmall = stepSmall;

  1894.                 kData->param.ranges[j].stepLarge = stepLarge;

  1895. 

  1896.                 // Start parameters in their default values

  1897.                 fParamBuffers[j] = def;

  1898. 

  1899.                 fDescriptor->connect_port(fHandle, i, &fParamBuffers[j]);

  1900. 

  1901.                 if (fHandle2 != nullptr)

  1902.                     fDescriptor->connect_port(fHandle2, i, &fParamBuffers[j]);

  1903.             }

  1904.             else

  1905.             {

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

  1907.                 fDescriptor->connect_port(fHandle, i, nullptr);

  1908. 

  1909.                 if (fHandle2 != nullptr)

  1910.                     fDescriptor->connect_port(fHandle2, i, nullptr);

  1911.             }

  1912.         }

  1913. 

  1914.         if (needsCtrlIn)

  1915.         {

  1916.             portName.clear();

  1917. 

  1918.             if (processMode == PROCESS_MODE_SINGLE_CLIENT)

  1919.             {

  1920.                 portName  = fName;

  1921.                 portName += ":";

  1922.             }

  1923. 

  1924.             portName += "events-in";

  1925.             portName.truncate(portNameSize);

  1926. 

  1927.             kData->event.portIn = (CarlaEngineEventPort*)kData->client->addPort(kEnginePortTypeEvent, portName, true);

  1928.         }

  1929. 

  1930.         if (needsCtrlOut)

  1931.         {

  1932.             portName.clear();

  1933. 

  1934.             if (processMode == PROCESS_MODE_SINGLE_CLIENT)

  1935.             {

  1936.                 portName  = fName;

  1937.                 portName += ":";

  1938.             }

  1939. 

  1940.             portName += "events-out";

  1941.             portName.truncate(portNameSize);

  1942. 

  1943.             kData->event.portOut = (CarlaEngineEventPort*)kData->client->addPort(kEnginePortTypeEvent, portName, false);

  1944.         }

  1945. 

  1946.         if (fEventsIn.ctrl != nullptr && fEventsIn.ctrl->port == nullptr)

  1947.             fEventsIn.ctrl->port = kData->event.portIn;

  1948. 

  1949.         if (fEventsOut.ctrl != nullptr && fEventsOut.ctrl->port == nullptr)

  1950.             fEventsOut.ctrl->port = kData->event.portOut;

  1951. 

  1952.         if (forcedStereoIn || forcedStereoOut)

  1953.             fOptions |= PLUGIN_OPTION_FORCE_STEREO;

  1954.         else

  1955.             fOptions &= ~PLUGIN_OPTION_FORCE_STEREO;

  1956. 

  1957.         // plugin hints

  1958.         fHints = 0x0;

  1959. 

  1960.         if (fUi.type != PLUGIN_UI_NULL)

  1961.         {

  1962.             fHints |= PLUGIN_HAS_GUI;

  1963. 

  1964.             if (fUi.type == PLUGIN_UI_QT || fUi.type == PLUGIN_UI_PARENT)

  1965.                 fHints |= PLUGIN_HAS_SINGLE_THREAD;

  1966.         }

  1967. 

  1968.         if (LV2_IS_GENERATOR(fRdfDescriptor->Type[0], fRdfDescriptor->Type[1]))

  1969.             fHints |= PLUGIN_IS_SYNTH;

  1970. 

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

  1972.             fHints |= PLUGIN_CAN_DRYWET;

  1973. 

  1974.         if (aOuts > 0)

  1975.             fHints |= PLUGIN_CAN_VOLUME;

  1976. 

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

  1978.             fHints |= PLUGIN_CAN_BALANCE;

  1979. 

  1980.         // extra plugin hints

  1981.         kData->extraHints &= ~PLUGIN_HINT_CAN_RUN_RACK;

  1982. 

  1983.         if (fExt.state != nullptr || fExt.worker != nullptr)

  1984.         {

  1985.             if ((aIns == 0 || aIns == 2) && (aOuts == 0 || aOuts == 2) && evIns.count() <= 1 && evOuts.count() <= 1)

  1986.                 kData->extraHints |= PLUGIN_HINT_CAN_RUN_RACK;

  1987.         }

  1988.         else

  1989.         {

  1990.             if (aIns <= 2 && aOuts <= 2 && (aIns == aOuts || aIns == 0 || aOuts == 0) && evIns.count() <= 1 && evOuts.count() <= 1)

  1991.                 kData->extraHints |= PLUGIN_HINT_CAN_RUN_RACK;

  1992.         }

  1993. 

  1994.         bufferSizeChanged(kData->engine->getBufferSize());

  1995.         reloadPrograms(true);

  1996. 

  1997.         if (kData->active)

  1998.             activate();

  1999. 

  2000.         evIns.clear();

  2001.         evOuts.clear();

  2002. 

  2003.         carla_debug("Lv2Plugin::reload() - end");

  2004.     }

  2005. 

  2006.     void reloadPrograms(const bool init) override

  2007.     {

  2008.         carla_debug("DssiPlugin::reloadPrograms(%s)", bool2str(init));

  2009.         uint32_t i, oldCount  = kData->midiprog.count;

  2010.         const int32_t current = kData->midiprog.current;

  2011. 

  2012.         // Delete old programs

  2013.         kData->midiprog.clear();

  2014. 

  2015.         // Query new programs

  2016.         uint32_t count = 0;

  2017.         if (fExt.programs != nullptr && fExt.programs->get_program != nullptr && fExt.programs->select_program != nullptr)

  2018.         {

  2019.             while (fExt.programs->get_program(fHandle, count))

  2020.                 count++;

  2021.         }

  2022. 

  2023.         if (count > 0)

  2024.         {

  2025.             kData->midiprog.createNew(count);

  2026. 

  2027.             // Update data

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

  2029.             {

  2030.                 const LV2_Program_Descriptor* const pdesc(fExt.programs->get_program(fHandle, i));

  2031.                 CARLA_ASSERT(pdesc != nullptr);

  2032.                 CARLA_ASSERT(pdesc->name != nullptr);

  2033. 

  2034.                 kData->midiprog.data[i].bank    = static_cast<uint32_t>(pdesc->bank);

  2035.                 kData->midiprog.data[i].program = static_cast<uint32_t>(pdesc->program);

  2036.                 kData->midiprog.data[i].name    = carla_strdup(pdesc->name);

  2037.             }

  2038.         }

  2039. 

  2040. #ifndef BUILD_BRIDGE

  2041.         // Update OSC Names

  2042.         if (kData->engine->isOscControlRegistered())

  2043.         {

  2044.             kData->engine->osc_send_control_set_midi_program_count(fId, count);

  2045. 

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

  2047.                 kData->engine->osc_send_control_set_midi_program_data(fId, i, kData->midiprog.data[i].bank, kData->midiprog.data[i].program, kData->midiprog.data[i].name);

  2048.         }

  2049. #endif

  2050. 

  2051.         if (init)

  2052.         {

  2053.             if (count > 0)

  2054.                 setMidiProgram(0, false, false, false);

  2055.         }

  2056.         else

  2057.         {

  2058.             // Check if current program is invalid

  2059.             bool programChanged = false;

  2060. 

  2061.             if (count == oldCount+1)

  2062.             {

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

  2064.                 kData->midiprog.current = oldCount;

  2065.                 programChanged = true;

  2066.             }

  2067.             else if (current < 0 && count > 0)

  2068.             {

  2069.                 // programs exist now, but not before

  2070.                 kData->midiprog.current = 0;

  2071.                 programChanged = true;

  2072.             }

  2073.             else if (current >= 0 && count == 0)

  2074.             {

  2075.                 // programs existed before, but not anymore

  2076.                 kData->midiprog.current = -1;

  2077.                 programChanged = true;

  2078.             }

  2079.             else if (current >= static_cast<int32_t>(count))

  2080.             {

  2081.                 // current midi program > count

  2082.                 kData->midiprog.current = 0;

  2083.                 programChanged = true;

  2084.             }

  2085.             else

  2086.             {

  2087.                 // no change

  2088.                 kData->midiprog.current = current;

  2089.             }

  2090. 

  2091.             if (programChanged)

  2092.                 setMidiProgram(kData->midiprog.current, true, true, true);

  2093. 

  2094.             kData->engine->callback(CALLBACK_RELOAD_PROGRAMS, fId, 0, 0, 0.0f, nullptr);

  2095.         }

  2096.     }

  2097. 

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

  2099.     // Plugin processing

  2100. 

  2101.     void activate() override

  2102.     {

  2103.         CARLA_ASSERT(fDescriptor != nullptr);

  2104.         CARLA_ASSERT(fHandle != nullptr);

  2105. 

  2106.         if (fDescriptor->activate != nullptr)

  2107.         {

  2108.             fDescriptor->activate(fHandle);

  2109. 

  2110.             if (fHandle2 != nullptr)

  2111.                 fDescriptor->activate(fHandle2);

  2112.         }

  2113.     }

  2114. 

  2115.     void deactivate() override

  2116.     {

  2117.         CARLA_ASSERT(fDescriptor != nullptr);

  2118.         CARLA_ASSERT(fHandle != nullptr);

  2119. 

  2120.         if (fDescriptor->deactivate != nullptr)

  2121.         {

  2122.             fDescriptor->deactivate(fHandle);

  2123. 

  2124.             if (fHandle2 != nullptr)

  2125.                 fDescriptor->deactivate(fHandle2);

  2126.         }

  2127.     }

  2128. 

  2129.     void process(float** const inBuffer, float** const outBuffer, const uint32_t frames) override

  2130.     {

  2131.         uint32_t i, k;

  2132. 

  2133.         // --------------------------------------------------------------------------------------------------------

  2134.         // Check if active

  2135. 

  2136.         if (! kData->active)

  2137.         {

  2138.             // disable any output sound

  2139.             for (i=0; i < kData->audioOut.count; ++i)

  2140.                 carla_zeroFloat(outBuffer[i], frames);

  2141. 

  2142.             return;

  2143.         }

  2144. 

  2145.         // handle events from different APIs

  2146.         uint32_t           evInAtomOffsets[fEventsIn.count];

  2147.         LV2_Event_Iterator evInEventIters[fEventsIn.count];

  2148.         LV2_MIDIState      evInMidiStates[fEventsIn.count];

  2149. 

  2150.         for (i=0; i < fEventsIn.count; ++i)

  2151.         {

  2152.             if (fEventsIn.data[i].type & CARLA_EVENT_DATA_ATOM)

  2153.             {

  2154.                 evInAtomOffsets[i] = 0;

  2155.                 fEventsIn.data[i].atom->atom.size = 0;

  2156.                 fEventsIn.data[i].atom->atom.type = CARLA_URI_MAP_ID_ATOM_SEQUENCE;

  2157.                 fEventsIn.data[i].atom->body.unit = CARLA_URI_MAP_ID_NULL;

  2158.                 fEventsIn.data[i].atom->body.pad  = 0;

  2159.             }

  2160.             else if (fEventsIn.data[i].type & CARLA_EVENT_DATA_EVENT)

  2161.             {

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

  2163.                 lv2_event_begin(&evInEventIters[i], fEventsIn.data[i].event);

  2164.             }

  2165.             else if (fEventsIn.data[i].type & CARLA_EVENT_DATA_MIDI_LL)

  2166.             {

  2167.                 evInMidiStates[i].midi = fEventsIn.data[i].midi;

  2168.                 evInMidiStates[i].frame_count = frames;

  2169.                 evInMidiStates[i].position = 0;

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

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

  2172.             }

  2173.         }

  2174. 

  2175.         for (i=0; i < fEventsOut.count; ++i)

  2176.         {

  2177.             if (fEventsOut.data[i].type & CARLA_EVENT_DATA_ATOM)

  2178.             {

  2179.                 fEventsOut.data[i].atom->atom.size = 0;

  2180.                 fEventsOut.data[i].atom->atom.type = CARLA_URI_MAP_ID_ATOM_SEQUENCE;

  2181.                 fEventsOut.data[i].atom->body.unit = CARLA_URI_MAP_ID_NULL;

  2182.                 fEventsOut.data[i].atom->body.pad  = 0;

  2183.             }

  2184.             else if (fEventsOut.data[i].type & CARLA_EVENT_DATA_EVENT)

  2185.             {

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

  2187.             }

  2188.             else if (fEventsOut.data[i].type & CARLA_EVENT_DATA_MIDI_LL)

  2189.             {

  2190.                 // not needed

  2191.             }

  2192.         }

  2193. 

  2194.         CARLA_PROCESS_CONTINUE_CHECK;

  2195. 

  2196.         // --------------------------------------------------------------------------------------------------------

  2197.         // Check if needs reset

  2198. 

  2199.         if (kData->needsReset)

  2200.         {

  2201.             // TODO!

  2202.             if (fOptions & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  2203.             {

  2204.                 //for (unsigned char j=0, l=MAX_MIDI_CHANNELS; j < MAX_MIDI_CHANNELS; ++j)

  2205.                 {

  2206.                 }

  2207.             }

  2208.             else

  2209.             {

  2210.             }

  2211. 

  2212.             if (kData->latency > 0)

  2213.             {

  2214.                 //for (i=0; i < kData->audioIn.count; ++i)

  2215.                 //    carla_zeroFloat(kData->latencyBuffers[i], kData->latency);

  2216.             }

  2217. 

  2218.             kData->needsReset = false;

  2219.         }

  2220. 

  2221.         CARLA_PROCESS_CONTINUE_CHECK;

  2222. 

  2223.         // --------------------------------------------------------------------------------------------------------

  2224.         // Special Parameters

  2225. 

  2226.         {

  2227.             int32_t rindex;

  2228.             const EngineTimeInfo& timeInfo(kData->engine->getTimeInfo());

  2229. 

  2230.             for (k=0; k < kData->param.count; ++k)

  2231.             {

  2232.                 if (kData->param.data[k].type == PARAMETER_LATENCY)

  2233.                 {

  2234.                     // nothing

  2235.                 }

  2236.                 else if (kData->param.data[k].type == PARAMETER_LV2_FREEWHEEL)

  2237.                 {

  2238.                     setParameterValue(k, kData->engine->isOffline() ? 1.0f : 0.0f, false, false, false);

  2239.                 }

  2240.                 else if (kData->param.data[k].type == PARAMETER_LV2_TIME)

  2241.                 {

  2242.                     rindex = kData->param.data[k].rindex;

  2243.                     CARLA_ASSERT(rindex >= 0 && rindex < static_cast<int32_t>(fRdfDescriptor->PortCount));

  2244. 

  2245.                     switch (fRdfDescriptor->Ports[rindex].Designation)

  2246.                     {

  2247.                     // Non-BBT

  2248.                     case LV2_PORT_DESIGNATION_TIME_FRAME:

  2249.                         setParameterValue(k, timeInfo.frame, false, false, false);

  2250.                         break;

  2251.                     case LV2_PORT_DESIGNATION_TIME_FRAMES_PER_SECOND:

  2252.                         break;

  2253.                     //case LV2_PORT_DESIGNATION_TIME_POSITION:

  2254.                     //    setParameterValue(k, timeInfo.usecs, false, false, false);

  2255.                     //    break;

  2256.                     case LV2_PORT_DESIGNATION_TIME_SPEED:

  2257.                         setParameterValue(k, timeInfo.playing ? 1.0f : 0.0f, false, false, false);

  2258.                         break;

  2259.                     // BBT

  2260.                     case LV2_PORT_DESIGNATION_TIME_BAR:

  2261.                         if (timeInfo.valid & EngineTimeInfo::ValidBBT)

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

  2263.                         break;

  2264.                     case LV2_PORT_DESIGNATION_TIME_BAR_BEAT:

  2265.                         if (timeInfo.valid & EngineTimeInfo::ValidBBT)

  2266.                             setParameterValue(k, float(timeInfo.bbt.beat - 1) + (float(timeInfo.bbt.tick) / timeInfo.bbt.ticksPerBeat), false, false, false);

  2267.                         break;

  2268.                     case LV2_PORT_DESIGNATION_TIME_BEAT:

  2269.                         if (timeInfo.valid & EngineTimeInfo::ValidBBT)

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

  2271.                         break;

  2272.                     case LV2_PORT_DESIGNATION_TIME_BEAT_UNIT:

  2273.                         if (timeInfo.valid & EngineTimeInfo::ValidBBT)

  2274.                             setParameterValue(k, timeInfo.bbt.beatType, false, false, false);

  2275.                         break;

  2276.                     case LV2_PORT_DESIGNATION_TIME_BEATS_PER_BAR:

  2277.                         if (timeInfo.valid & EngineTimeInfo::ValidBBT)

  2278.                             setParameterValue(k, timeInfo.bbt.beatsPerBar, false, false, false);

  2279.                         break;

  2280.                     case LV2_PORT_DESIGNATION_TIME_BEATS_PER_MINUTE:

  2281.                         if (timeInfo.valid & EngineTimeInfo::ValidBBT)

  2282.                             setParameterValue(k, timeInfo.bbt.beatsPerMinute, false, false, false);

  2283.                         break;

  2284.                     }

  2285.                 }

  2286.             }

  2287.         }

  2288. 

  2289.         // --------------------------------------------------------------------------------------------------------

  2290.         // Event Input and Processing

  2291. 

  2292.         if (fEventsIn.ctrl != nullptr && fEventsIn.ctrl->port != nullptr)

  2293.         {

  2294.             // ----------------------------------------------------------------------------------------------------

  2295.             // MIDI Input (External)

  2296. 

  2297.             if (kData->extNotes.mutex.tryLock())

  2298.             {

  2299.                 k = fEventsIn.ctrlIndex;

  2300. 

  2301.                 while (! kData->extNotes.data.isEmpty())

  2302.                 {

  2303.                     const ExternalMidiNote& note(kData->extNotes.data.getFirst(true));

  2304. 

  2305.                     CARLA_ASSERT(note.channel >= 0 && note.channel < MAX_MIDI_CHANNELS);

  2306. 

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

  2308.                     midiEvent[0]  = (note.velo > 0) ? MIDI_STATUS_NOTE_ON : MIDI_STATUS_NOTE_OFF;

  2309.                     midiEvent[0] += note.channel;

  2310.                     midiEvent[1]  = note.note;

  2311.                     midiEvent[2]  = note.velo;

  2312. 

  2313.                     if (fEventsIn.ctrl->type & CARLA_EVENT_TYPE_MIDI)

  2314.                     {

  2315.                         if (fEventsIn.ctrl->type & CARLA_EVENT_DATA_ATOM)

  2316.                         {

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

  2318. 

  2319.                             if (evInAtomOffsets[k] + evInPadSize >= MAX_EVENT_BUFFER)

  2320.                                 continue;

  2321. 

  2322.                             LV2_Atom_Event* const aev = getLv2AtomEvent(fEventsIn.ctrl->atom, evInAtomOffsets[k]);

  2323.                             aev->time.frames = 0;

  2324.                             aev->body.type   = CARLA_URI_MAP_ID_MIDI_EVENT;

  2325.                             aev->body.size   = 3;

  2326.                             std::memcpy(LV2_ATOM_BODY(&aev->body), midiEvent, 3);

  2327. 

  2328.                             evInAtomOffsets[k] += evInPadSize;

  2329.                             fEventsIn.ctrl->atom->atom.size = evInAtomOffsets[k];

  2330.                         }

  2331.                         else if (fEventsIn.ctrl->type & CARLA_EVENT_DATA_EVENT)

  2332.                         {

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

  2334.                         }

  2335.                         else if (fEventsIn.ctrl->type & CARLA_EVENT_DATA_MIDI_LL)

  2336.                         {

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

  2338.                         }

  2339.                     }

  2340.                 }

  2341. 

  2342.                 kData->extNotes.mutex.unlock();

  2343. 

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

  2345. 

  2346.             // ----------------------------------------------------------------------------------------------------

  2347.             // Event Input (System)

  2348. 

  2349.             bool allNotesOffSent = false;

  2350.             bool sampleAccurate  = (fOptions & PLUGIN_OPTION_FIXED_BUFFER) == 0;

  2351. 

  2352.             uint32_t time, nEvents = fEventsIn.ctrl->port->getEventCount();

  2353.             uint32_t startTime  = 0;

  2354.             uint32_t timeOffset = 0;

  2355. 

  2356.             uint32_t nextBankId = 0;

  2357.             if (kData->midiprog.current >= 0 && kData->midiprog.count > 0)

  2358.                 nextBankId = kData->midiprog.data[kData->midiprog.current].bank;

  2359. 

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

  2361.             {

  2362.                 const EngineEvent& event(fEventsIn.ctrl->port->getEvent(i));

  2363. 

  2364.                 time = event.time;

  2365. 

  2366.                 if (time >= frames)

  2367.                     continue;

  2368. 

  2369.                 CARLA_ASSERT_INT2(time >= timeOffset, time, timeOffset);

  2370. 

  2371.                 if (time > timeOffset && sampleAccurate)

  2372.                 {

  2373.                     if (processSingle(inBuffer, outBuffer, time - timeOffset, timeOffset))

  2374.                     {

  2375.                         startTime  = 0;

  2376.                         timeOffset = time;

  2377. 

  2378.                         if (kData->midiprog.current >= 0 && kData->midiprog.count > 0)

  2379.                             nextBankId = kData->midiprog.data[kData->midiprog.current].bank;

  2380.                         else

  2381.                             nextBankId = 0;

  2382. 

  2383.                         // reset iters

  2384.                         k = fEventsIn.ctrlIndex;

  2385. 

  2386.                         if (fEventsIn.ctrl->type & CARLA_EVENT_DATA_ATOM)

  2387.                         {

  2388.                             evInAtomOffsets[k] = 0;

  2389.                             fEventsIn.ctrl->atom->atom.size = 0;

  2390.                         }

  2391.                         else if (fEventsIn.ctrl->type & CARLA_EVENT_DATA_EVENT)

  2392.                         {

  2393.                             lv2_event_buffer_reset(fEventsIn.ctrl->event, LV2_EVENT_AUDIO_STAMP, (uint8_t*)(fEventsIn.ctrl->event + 1));

  2394.                             lv2_event_begin(&evInEventIters[k], fEventsIn.ctrl->event);

  2395.                         }

  2396.                         else if (fEventsIn.ctrl->type & CARLA_EVENT_DATA_MIDI_LL)

  2397.                         {

  2398.                             evInMidiStates[k].position = 0;

  2399.                             evInMidiStates[k].midi->event_count = 0;

  2400.                             evInMidiStates[k].midi->size = 0;

  2401.                         }

  2402.                     }

  2403.                     else

  2404.                         startTime += timeOffset;

  2405.                 }

  2406. 

  2407.                 // Control change

  2408.                 switch (event.type)

  2409.                 {

  2410.                 case kEngineEventTypeNull:

  2411.                     break;

  2412. 

  2413.                 case kEngineEventTypeControl:

  2414.                 {

  2415.                     const EngineControlEvent& ctrlEvent = event.ctrl;

  2416. 

  2417.                     switch (ctrlEvent.type)

  2418.                     {

  2419.                     case kEngineControlEventTypeNull:

  2420.                         break;

  2421. 

  2422.                     case kEngineControlEventTypeParameter:

  2423.                     {

  2424.                         // Control backend stuff

  2425.                         if (event.channel == kData->ctrlChannel)

  2426.                         {

  2427.                             float value;

  2428. 

  2429.                             if (MIDI_IS_CONTROL_BREATH_CONTROLLER(ctrlEvent.param) && (fHints & PLUGIN_CAN_DRYWET) > 0)

  2430.                             {

  2431.                                 value = ctrlEvent.value;

  2432.                                 setDryWet(value, false, false);

  2433.                                 postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_DRYWET, 0, value);

  2434.                                 continue;

  2435.                             }

  2436. 

  2437.                             if (MIDI_IS_CONTROL_CHANNEL_VOLUME(ctrlEvent.param) && (fHints & PLUGIN_CAN_VOLUME) > 0)

  2438.                             {

  2439.                                 value = ctrlEvent.value*127.0f/100.0f;

  2440.                                 setVolume(value, false, false);

  2441.                                 postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_VOLUME, 0, value);

  2442.                                 continue;

  2443.                             }

  2444. 

  2445.                             if (MIDI_IS_CONTROL_BALANCE(ctrlEvent.param) && (fHints & PLUGIN_CAN_BALANCE) > 0)

  2446.                             {

  2447.                                 float left, right;

  2448.                                 value = ctrlEvent.value/0.5f - 1.0f;

  2449. 

  2450.                                 if (value < 0.0f)

  2451.                                 {

  2452.                                     left  = -1.0f;

  2453.                                     right = (value*2.0f)+1.0f;

  2454.                                 }

  2455.                                 else if (value > 0.0f)

  2456.                                 {

  2457.                                     left  = (value*2.0f)-1.0f;

  2458.                                     right = 1.0f;

  2459.                                 }

  2460.                                 else

  2461.                                 {

  2462.                                     left  = -1.0f;

  2463.                                     right = 1.0f;

  2464.                                 }

  2465. 

  2466.                                 setBalanceLeft(left, false, false);

  2467.                                 setBalanceRight(right, false, false);

  2468.                                 postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_BALANCE_LEFT, 0, left);

  2469.                                 postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_BALANCE_RIGHT, 0, right);

  2470.                                 continue;

  2471.                             }

  2472.                         }

  2473. 

  2474.                         // Control plugin parameters

  2475.                         for (k=0; k < kData->param.count; ++k)

  2476.                         {

  2477.                             if (kData->param.data[k].midiChannel != event.channel)

  2478.                                 continue;

  2479.                             if (kData->param.data[k].midiCC != ctrlEvent.param)

  2480.                                 continue;

  2481.                             if (kData->param.data[k].type != PARAMETER_INPUT)

  2482.                                 continue;

  2483.                             if ((kData->param.data[k].hints & PARAMETER_IS_AUTOMABLE) == 0)

  2484.                                 continue;

  2485. 

  2486.                             float value;

  2487. 

  2488.                             if (kData->param.data[k].hints & PARAMETER_IS_BOOLEAN)

  2489.                             {

  2490.                                 value = (ctrlEvent.value < 0.5f) ? kData->param.ranges[k].min : kData->param.ranges[k].max;

  2491.                             }

  2492.                             else

  2493.                             {

  2494.                                 value = kData->param.ranges[i].unnormalizeValue(ctrlEvent.value);

  2495. 

  2496.                                 if (kData->param.data[k].hints & PARAMETER_IS_INTEGER)

  2497.                                     value = std::rint(value);

  2498.                             }

  2499. 

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

  2501.                             postponeRtEvent(kPluginPostRtEventParameterChange, static_cast<int32_t>(k), 0, value);

  2502.                         }

  2503. 

  2504.                         break;

  2505.                     }

  2506. 

  2507.                     case kEngineControlEventTypeMidiBank:

  2508.                         if (event.channel == kData->ctrlChannel && (fOptions & PLUGIN_OPTION_MAP_PROGRAM_CHANGES) != 0)

  2509.                             nextBankId = ctrlEvent.param;

  2510.                         break;

  2511. 

  2512.                     case kEngineControlEventTypeMidiProgram:

  2513.                         if (event.channel == kData->ctrlChannel && (fOptions & PLUGIN_OPTION_MAP_PROGRAM_CHANGES) != 0)

  2514.                         {

  2515.                             const uint32_t nextProgramId = ctrlEvent.param;

  2516. 

  2517.                             for (k=0; k < kData->midiprog.count; ++k)

  2518.                             {

  2519.                                 if (kData->midiprog.data[k].bank == nextBankId && kData->midiprog.data[k].program == nextProgramId)

  2520.                                 {

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

  2522.                                     postponeRtEvent(kPluginPostRtEventMidiProgramChange, k, 0, 0.0f);

  2523.                                     break;

  2524.                                 }

  2525.                             }

  2526.                         }

  2527.                         break;

  2528. 

  2529.                     case kEngineControlEventTypeAllSoundOff:

  2530.                         if (event.channel == kData->ctrlChannel)

  2531.                         {

  2532.                             if (! allNotesOffSent)

  2533.                             {

  2534.                                 sendMidiAllNotesOff();

  2535.                                 allNotesOffSent = true;

  2536.                             }

  2537. 

  2538.                             postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_ACTIVE, 0, 0.0f);

  2539.                             postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_ACTIVE, 0, 1.0f);

  2540.                         }

  2541. 

  2542.                         if (fOptions & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  2543.                         {

  2544.                             // TODO

  2545.                         }

  2546. 

  2547.                         break;

  2548. 

  2549.                     case kEngineControlEventTypeAllNotesOff:

  2550.                         if (event.channel == kData->ctrlChannel)

  2551.                         {

  2552.                             if (! allNotesOffSent)

  2553.                             {

  2554.                                 allNotesOffSent = true;

  2555.                                 sendMidiAllNotesOff();

  2556.                             }

  2557.                         }

  2558. 

  2559.                         if (fOptions & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  2560.                         {

  2561.                             // TODO

  2562.                         }

  2563. 

  2564.                         break;

  2565.                     }

  2566. 

  2567.                     break;

  2568.                 }

  2569. 

  2570.                 case kEngineEventTypeMidi:

  2571.                 {

  2572.                     const EngineMidiEvent& midiEvent = event.midi;

  2573. 

  2574.                     uint8_t status  = MIDI_GET_STATUS_FROM_DATA(midiEvent.data);

  2575.                     uint8_t channel = event.channel;

  2576.                     uint32_t mtime  = sampleAccurate ? startTime : time;

  2577. 

  2578.                     if (MIDI_IS_STATUS_AFTERTOUCH(status) && (fOptions & PLUGIN_OPTION_SEND_CHANNEL_PRESSURE) == 0)

  2579.                         continue;

  2580.                     if (MIDI_IS_STATUS_CONTROL_CHANGE(status) && (fOptions & PLUGIN_OPTION_SEND_CONTROL_CHANGES) == 0)

  2581.                         continue;

  2582.                     if (MIDI_IS_STATUS_POLYPHONIC_AFTERTOUCH(status) && (fOptions & PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH) == 0)

  2583.                         continue;

  2584.                     if (MIDI_IS_STATUS_PITCH_WHEEL_CONTROL(status) && (fOptions & PLUGIN_OPTION_SEND_PITCHBEND) == 0)

  2585.                         continue;

  2586. 

  2587.                     // Fix bad note-off

  2588.                     if (status == MIDI_STATUS_NOTE_ON && midiEvent.data[2] == 0)

  2589.                         status -= 0x10;

  2590. 

  2591.                     k = fEventsIn.ctrlIndex;

  2592. 

  2593.                     if (fEventsIn.ctrl->type & CARLA_EVENT_DATA_ATOM)

  2594.                     {

  2595.                         const uint32_t evInPadSize(lv2_atom_pad_size(sizeof(LV2_Atom_Event) + midiEvent.size));

  2596. 

  2597.                         if (evInAtomOffsets[k] + evInPadSize >= MAX_EVENT_BUFFER)

  2598.                             continue;

  2599. 

  2600.                         LV2_Atom_Event* const aev(getLv2AtomEvent(fEventsIn.ctrl->atom, evInAtomOffsets[k]));

  2601.                         aev->time.frames = mtime;

  2602.                         aev->body.type   = CARLA_URI_MAP_ID_MIDI_EVENT;

  2603.                         aev->body.size   = midiEvent.size;

  2604.                         std::memcpy(LV2_ATOM_BODY(&aev->body), midiEvent.data, midiEvent.size);

  2605. 

  2606.                         evInAtomOffsets[k] += evInPadSize;

  2607.                         fEventsIn.ctrl->atom->atom.size = evInAtomOffsets[k];

  2608.                     }

  2609.                     else if (fEventsIn.ctrl->type & CARLA_EVENT_DATA_EVENT)

  2610.                     {

  2611.                         lv2_event_write(&evInEventIters[k], mtime, 0, CARLA_URI_MAP_ID_MIDI_EVENT, midiEvent.size, midiEvent.data);

  2612.                     }

  2613.                     else if (fEventsIn.ctrl->type & CARLA_EVENT_DATA_MIDI_LL)

  2614.                     {

  2615.                         lv2midi_put_event(&evInMidiStates[k], mtime, midiEvent.size, midiEvent.data);

  2616.                     }

  2617. 

  2618.                     if (status == MIDI_STATUS_NOTE_ON)

  2619.                         postponeRtEvent(kPluginPostRtEventNoteOn, channel, midiEvent.data[1], midiEvent.data[2]);

  2620.                     else if (status == MIDI_STATUS_NOTE_OFF)

  2621.                         postponeRtEvent(kPluginPostRtEventNoteOff, channel, midiEvent.data[1], 0.0f);

  2622. 

  2623.                     break;

  2624.                 }

  2625.                 }

  2626.             }

  2627. 

  2628.             kData->postRtEvents.trySplice();

  2629. 

  2630.             if (frames > timeOffset)

  2631.                 processSingle(inBuffer, outBuffer, frames - timeOffset, timeOffset);

  2632. 

  2633.         } // End of Event Input and Processing

  2634. 

  2635.         // --------------------------------------------------------------------------------------------------------

  2636.         // Plugin processing (no events)

  2637. 

  2638.         else

  2639.         {

  2640.             processSingle(inBuffer, outBuffer, frames, 0);

  2641. 

  2642.         } // End of Plugin processing (no events)

  2643. 

  2644.         CARLA_PROCESS_CONTINUE_CHECK;

  2645. 

  2646.         // --------------------------------------------------------------------------------------------------------

  2647.         // Control Output

  2648. 

  2649.         if (kData->event.portOut != nullptr)

  2650.         {

  2651.             uint8_t  channel;

  2652.             uint16_t param;

  2653.             float    value;

  2654. 

  2655.             for (k=0; k < kData->param.count; ++k)

  2656.             {

  2657.                 if (kData->param.data[k].type != PARAMETER_OUTPUT)

  2658.                     continue;

  2659. 

  2660.                 kData->param.ranges[k].fixValue(fParamBuffers[k]);

  2661. 

  2662.                 if (kData->param.data[k].midiCC > 0)

  2663.                 {

  2664.                     channel = kData->param.data[k].midiChannel;

  2665.                     param   = static_cast<uint16_t>(kData->param.data[k].midiCC);

  2666.                     value   = kData->param.ranges[k].normalizeValue(fParamBuffers[k]);

  2667.                     kData->event.portOut->writeControlEvent(0, channel, kEngineControlEventTypeParameter, param, value);

  2668.                 }

  2669.             }

  2670. 

  2671.         } // End of Control Output

  2672. 

  2673.         CARLA_PROCESS_CONTINUE_CHECK;

  2674. 

  2675.         // --------------------------------------------------------------------------------------------------------

  2676.         // Final work

  2677. 

  2678.         if (fExt.worker != nullptr && fExt.worker->end_run != nullptr)

  2679.         {

  2680.             fExt.worker->end_run(fHandle);

  2681. 

  2682.             if (fHandle2 != nullptr)

  2683.                 fExt.worker->end_run(fHandle2);

  2684.         }

  2685. 

  2686.         // --------------------------------------------------------------------------------------------------------

  2687.     }

  2688. 

  2689.     bool processSingle(float** const inBuffer, float** const outBuffer, const uint32_t frames, const uint32_t timeOffset)

  2690.     {

  2691.         CARLA_ASSERT(frames > 0);

  2692. 

  2693.         if (frames == 0)

  2694.             return false;

  2695. 

  2696.         if (kData->audioIn.count > 0)

  2697.         {

  2698.             CARLA_ASSERT(inBuffer != nullptr);

  2699.             if (inBuffer == nullptr)

  2700.                 return false;

  2701.         }

  2702.         if (kData->audioOut.count > 0)

  2703.         {

  2704.             CARLA_ASSERT(outBuffer != nullptr);

  2705.             if (outBuffer == nullptr)

  2706.                 return false;

  2707.         }

  2708. 

  2709.         uint32_t i, k;

  2710. 

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

  2712.         // Try lock, silence otherwise

  2713. 

  2714.         if (kData->engine->isOffline())

  2715.         {

  2716.             kData->singleMutex.lock();

  2717.         }

  2718.         else if (! kData->singleMutex.tryLock())

  2719.         {

  2720.             for (i=0; i < kData->audioOut.count; ++i)

  2721.             {

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

  2723.                     outBuffer[i][k+timeOffset] = 0.0f;

  2724.             }

  2725. 

  2726.             return false;

  2727.         }

  2728. 

  2729.         // --------------------------------------------------------------------------------------------------------

  2730.         // Reset audio buffers

  2731. 

  2732.         for (i=0; i < kData->audioIn.count; ++i)

  2733.             carla_copyFloat(fAudioInBuffers[i], inBuffer[i]+timeOffset, frames);

  2734.         for (i=0; i < kData->audioOut.count; ++i)

  2735.             carla_zeroFloat(fAudioOutBuffers[i], frames);

  2736. 

  2737.         // --------------------------------------------------------------------------------------------------------

  2738.         // Run plugin

  2739. 

  2740.         fDescriptor->run(fHandle, frames);

  2741. 

  2742.         if (fHandle2 != nullptr)

  2743.             fDescriptor->run(fHandle2, frames);

  2744. 

  2745.         // --------------------------------------------------------------------------------------------------------

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

  2747. 

  2748.         {

  2749.             const bool doDryWet  = (fHints & PLUGIN_CAN_DRYWET) != 0 && kData->postProc.dryWet != 1.0f;

  2750.             const bool doBalance = (fHints & PLUGIN_CAN_BALANCE) != 0 && (kData->postProc.balanceLeft != -1.0f || kData->postProc.balanceRight != 1.0f);

  2751. 

  2752.             bool isPair;

  2753.             float bufValue, oldBufLeft[doBalance ? frames : 1];

  2754. 

  2755.             for (i=0; i < kData->audioOut.count; ++i)

  2756.             {

  2757.                 // Dry/Wet

  2758.                 if (doDryWet)

  2759.                 {

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

  2761.                     {

  2762.                         // TODO

  2763.                         //if (k < kData->latency && kData->latency < frames)

  2764.                         //    bufValue = (kData->audioIn.count == 1) ? kData->latencyBuffers[0][k] : kData->latencyBuffers[i][k];

  2765.                         //else

  2766.                         //    bufValue = (kData->audioIn.count == 1) ? inBuffer[0][k-m_latency] : inBuffer[i][k-m_latency];

  2767. 

  2768.                         bufValue = fAudioInBuffers[(kData->audioIn.count == 1) ? 0 : i][k];

  2769.                         fAudioOutBuffers[i][k] = (fAudioOutBuffers[i][k] * kData->postProc.dryWet) + (bufValue * (1.0f - kData->postProc.dryWet));

  2770.                     }

  2771.                 }

  2772. 

  2773.                 // Balance

  2774.                 if (doBalance)

  2775.                 {

  2776.                     isPair = (i % 2 == 0);

  2777. 

  2778.                     if (isPair)

  2779.                     {

  2780.                         CARLA_ASSERT(i+1 < kData->audioOut.count);

  2781.                         carla_copyFloat(oldBufLeft, fAudioOutBuffers[i], frames);

  2782.                     }

  2783. 

  2784.                     float balRangeL = (kData->postProc.balanceLeft  + 1.0f)/2.0f;

  2785.                     float balRangeR = (kData->postProc.balanceRight + 1.0f)/2.0f;

  2786. 

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

  2788.                     {

  2789.                         if (isPair)

  2790.                         {

  2791.                             // left

  2792.                             fAudioOutBuffers[i][k]  = oldBufLeft[k]            * (1.0f - balRangeL);

  2793.                             fAudioOutBuffers[i][k] += fAudioOutBuffers[i+1][k] * (1.0f - balRangeR);

  2794.                         }

  2795.                         else

  2796.                         {

  2797.                             // right

  2798.                             fAudioOutBuffers[i][k]  = fAudioOutBuffers[i][k] * balRangeR;

  2799.                             fAudioOutBuffers[i][k] += oldBufLeft[k]          * balRangeL;

  2800.                         }

  2801.                     }

  2802.                 }

  2803. 

  2804.                 // Volume (and buffer copy)

  2805.                 {

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

  2807.                         outBuffer[i][k+timeOffset] = fAudioOutBuffers[i][k] * kData->postProc.volume;

  2808.                 }

  2809.             }

  2810. 

  2811. #if 0

  2812.             // Latency, save values for next callback, TODO

  2813.             if (kData->latency > 0 && kData->latency < frames)

  2814.             {

  2815.                 for (i=0; i < kData->audioIn.count; ++i)

  2816.                     carla_copyFloat(kData->latencyBuffers[i], inBuffer[i] + (frames - kData->latency), kData->latency);

  2817.             }

  2818. #endif

  2819.         } // End of Post-processing

  2820. 

  2821.         // --------------------------------------------------------------------------------------------------------

  2822. 

  2823.         kData->singleMutex.unlock();

  2824.         return true;

  2825.     }

  2826. 

  2827.     void bufferSizeChanged(const uint32_t newBufferSize) override

  2828.     {

  2829.         CARLA_ASSERT_INT(newBufferSize > 0, newBufferSize);

  2830.         carla_debug("Lv2Plugin::bufferSizeChanged(%i) - start", newBufferSize);

  2831. 

  2832.         for (uint32_t i=0; i < kData->audioIn.count; ++i)

  2833.         {

  2834.             if (fAudioInBuffers[i] != nullptr)

  2835.                 delete[] fAudioInBuffers[i];

  2836.             fAudioInBuffers[i] = new float[newBufferSize];

  2837.         }

  2838. 

  2839.         for (uint32_t i=0; i < kData->audioOut.count; ++i)

  2840.         {

  2841.             if (fAudioOutBuffers[i] != nullptr)

  2842.                 delete[] fAudioOutBuffers[i];

  2843.             fAudioOutBuffers[i] = new float[newBufferSize];

  2844.         }

  2845. 

  2846.         if (fHandle2 == nullptr)

  2847.         {

  2848.             for (uint32_t i=0; i < kData->audioIn.count; ++i)

  2849.             {

  2850.                 CARLA_ASSERT(fAudioInBuffers[i] != nullptr);

  2851.                 fDescriptor->connect_port(fHandle, kData->audioIn.ports[i].rindex, fAudioInBuffers[i]);

  2852.             }

  2853. 

  2854.             for (uint32_t i=0; i < kData->audioOut.count; ++i)

  2855.             {

  2856.                 CARLA_ASSERT(fAudioOutBuffers[i] != nullptr);

  2857.                 fDescriptor->connect_port(fHandle, kData->audioOut.ports[i].rindex, fAudioOutBuffers[i]);

  2858.             }

  2859.         }

  2860.         else

  2861.         {

  2862.             if (kData->audioIn.count > 0)

  2863.             {

  2864.                 CARLA_ASSERT(kData->audioIn.count == 2);

  2865.                 CARLA_ASSERT(fAudioInBuffers[0] != nullptr);

  2866.                 CARLA_ASSERT(fAudioInBuffers[1] != nullptr);

  2867. 

  2868.                 fDescriptor->connect_port(fHandle,  kData->audioIn.ports[0].rindex, fAudioInBuffers[0]);

  2869.                 fDescriptor->connect_port(fHandle2, kData->audioIn.ports[1].rindex, fAudioInBuffers[1]);

  2870.             }

  2871. 

  2872.             if (kData->audioOut.count > 0)

  2873.             {

  2874.                 CARLA_ASSERT(kData->audioOut.count == 2);

  2875.                 CARLA_ASSERT(fAudioOutBuffers[0] != nullptr);

  2876.                 CARLA_ASSERT(fAudioOutBuffers[1] != nullptr);

  2877. 

  2878.                 fDescriptor->connect_port(fHandle,  kData->audioOut.ports[0].rindex, fAudioOutBuffers[0]);

  2879.                 fDescriptor->connect_port(fHandle2, kData->audioOut.ports[1].rindex, fAudioOutBuffers[1]);

  2880.             }

  2881.         }

  2882. 

  2883.         if (fLv2Options.maxBufferSize != static_cast<int>(newBufferSize) || (fLv2Options.minBufferSize > 1 && fLv2Options.minBufferSize != static_cast<int>(newBufferSize)))

  2884.         {

  2885.             fLv2Options.maxBufferSize = newBufferSize;

  2886. 

  2887.             if (fLv2Options.minBufferSize > 1)

  2888.                 fLv2Options.minBufferSize = newBufferSize;

  2889. 

  2890.             if (fExt.options != nullptr && fExt.options->set != nullptr)

  2891.             {

  2892.                 fExt.options->set(fHandle, &fLv2Options.optMinBlockLenth);

  2893.                 fExt.options->set(fHandle, &fLv2Options.optMaxBlockLenth);

  2894.             }

  2895.         }

  2896. 

  2897.         carla_debug("Lv2Plugin::bufferSizeChanged(%i) - end", newBufferSize);

  2898.     }

  2899. 

  2900.     void sampleRateChanged(const double newSampleRate) override

  2901.     {

  2902.         CARLA_ASSERT_INT(newSampleRate > 0.0, newSampleRate);

  2903.         carla_debug("Lv2Plugin::sampleRateChanged(%g) - start", newSampleRate);

  2904. 

  2905.         if (fLv2Options.sampleRate != newSampleRate)

  2906.         {

  2907.             fLv2Options.sampleRate = newSampleRate;

  2908. 

  2909.             if (fExt.options != nullptr && fExt.options->set != nullptr)

  2910.                 fExt.options->set(fHandle, &fLv2Options.optSampleRate);

  2911.         }

  2912. 

  2913.         carla_debug("Lv2Plugin::sampleRateChanged(%g) - end", newSampleRate);

  2914.     }

  2915. 

  2916.     // -------------------------------------------------------------------

  2917.     // Plugin buffers

  2918. 

  2919.     void initBuffers() override

  2920.     {

  2921.         fEventsIn.initBuffers(kData->engine);

  2922.         fEventsOut.initBuffers(kData->engine);

  2923. 

  2924.         CarlaPlugin::initBuffers();

  2925.     }

  2926. 

  2927.     void clearBuffers() override

  2928.     {

  2929.         carla_debug("Lv2Plugin::clearBuffers() - start");

  2930. 

  2931.         if (fAudioInBuffers != nullptr)

  2932.         {

  2933.             for (uint32_t i=0; i < kData->audioIn.count; ++i)

  2934.             {

  2935.                 if (fAudioInBuffers[i] != nullptr)

  2936.                 {

  2937.                     delete[] fAudioInBuffers[i];

  2938.                     fAudioInBuffers[i] = nullptr;

  2939.                 }

  2940.             }

  2941. 

  2942.             delete[] fAudioInBuffers;

  2943.             fAudioInBuffers = nullptr;

  2944.         }

  2945. 

  2946.         if (fAudioOutBuffers != nullptr)

  2947.         {

  2948.             for (uint32_t i=0; i < kData->audioOut.count; ++i)

  2949.             {

  2950.                 if (fAudioOutBuffers[i] != nullptr)

  2951.                 {

  2952.                     delete[] fAudioOutBuffers[i];

  2953.                     fAudioOutBuffers[i] = nullptr;

  2954.                 }

  2955.             }

  2956. 

  2957.             delete[] fAudioOutBuffers;

  2958.             fAudioOutBuffers = nullptr;

  2959.         }

  2960. 

  2961.         if (fParamBuffers != nullptr)

  2962.         {

  2963.             delete[] fParamBuffers;

  2964.             fParamBuffers = nullptr;

  2965.         }

  2966. 

  2967.         fEventsIn.clear();

  2968.         fEventsOut.clear();

  2969. 

  2970.         CarlaPlugin::clearBuffers();

  2971. 

  2972.         carla_debug("Lv2Plugin::clearBuffers() - end");

  2973.     }

  2974. 

  2975.     // -------------------------------------------------------------------

  2976.     // Post-poned UI Stuff

  2977. 

  2978.     void uiParameterChange(const uint32_t index, const float value) override

  2979.     {

  2980.         CARLA_ASSERT(fDescriptor != nullptr);

  2981.         CARLA_ASSERT(fHandle != nullptr);

  2982.         CARLA_ASSERT(index < kData->param.count);

  2983. 

  2984.         if (fDescriptor == nullptr || fHandle == nullptr)

  2985.             return;

  2986.         if (index >= kData->param.count)

  2987.             return;

  2988. 

  2989.         if (fUi.type == PLUGIN_UI_OSC)

  2990.         {

  2991.             if (kData->osc.data.target != nullptr)

  2992.                 osc_send_control(&kData->osc.data, kData->param.data[index].rindex, value);

  2993.         }

  2994.         else

  2995.         {

  2996.             if (fUi.handle != nullptr && fUi.descriptor != nullptr && fUi.descriptor->port_event != nullptr)

  2997.                 fUi.descriptor->port_event(fUi.handle, kData->param.data[index].rindex, sizeof(float), 0, &value);

  2998.         }

  2999.     }

  3000. 

  3001.     void uiMidiProgramChange(const uint32_t index) override

  3002.     {

  3003.         CARLA_ASSERT(index < kData->midiprog.count);

  3004. 

  3005.         if (index >= kData->midiprog.count)

  3006.             return;

  3007. 

  3008.         if (fUi.type == PLUGIN_UI_OSC)

  3009.         {

  3010.             if (kData->osc.data.target != nullptr)

  3011.                 osc_send_midi_program(&kData->osc.data, kData->midiprog.data[index].bank, kData->midiprog.data[index].program);

  3012.         }

  3013.         else

  3014.         {

  3015.             if (fExt.uiprograms != nullptr && fExt.uiprograms->select_program != nullptr)

  3016.                 fExt.uiprograms->select_program(fUi.handle, kData->midiprog.data[index].bank, kData->midiprog.data[index].program);

  3017.         }

  3018.     }

  3019. 

  3020.     void uiNoteOn(const uint8_t channel, const uint8_t note, const uint8_t velo) override

  3021.     {

  3022.         CARLA_ASSERT(channel < MAX_MIDI_CHANNELS);

  3023.         CARLA_ASSERT(note < MAX_MIDI_NOTE);

  3024.         CARLA_ASSERT(velo > 0 && velo < MAX_MIDI_VALUE);

  3025. 

  3026.         if (channel >= MAX_MIDI_CHANNELS)

  3027.             return;

  3028.         if (note >= MAX_MIDI_NOTE)

  3029.             return;

  3030.         if (velo >= MAX_MIDI_VALUE)

  3031.             return;

  3032. 

  3033.         if (fUi.type == PLUGIN_UI_OSC)

  3034.         {

  3035.             if (kData->osc.data.target != nullptr)

  3036.             {

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

  3038.                 midiData[1] = MIDI_STATUS_NOTE_ON + channel;

  3039.                 midiData[2] = note;

  3040.                 midiData[3] = velo;

  3041.                 osc_send_midi(&kData->osc.data, midiData);

  3042.             }

  3043.         }

  3044.         else

  3045.         {

  3046.             if (fUi.handle != nullptr && fUi.descriptor != nullptr && fUi.descriptor->port_event != nullptr)

  3047.             {

  3048.                 LV2_Atom_MidiEvent midiEv;

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

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

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

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

  3053.                 midiEv.data[1] = note;

  3054.                 midiEv.data[2] = velo;

  3055. 

  3056.                 fUi.descriptor->port_event(fUi.handle, 0, 3, CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM, &midiEv);

  3057.             }

  3058.         }

  3059.     }

  3060. 

  3061.     void uiNoteOff(const uint8_t channel, const uint8_t note) override

  3062.     {

  3063.         CARLA_ASSERT(channel < MAX_MIDI_CHANNELS);

  3064.         CARLA_ASSERT(note < MAX_MIDI_NOTE);

  3065. 

  3066.         if (channel >= MAX_MIDI_CHANNELS)

  3067.             return;

  3068.         if (note >= MAX_MIDI_NOTE)

  3069.             return;

  3070. 

  3071.         if (fUi.type == PLUGIN_UI_OSC)

  3072.         {

  3073.             if (kData->osc.data.target != nullptr)

  3074.             {

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

  3076.                 midiData[1] = MIDI_STATUS_NOTE_OFF + channel;

  3077.                 midiData[2] = note;

  3078.                 osc_send_midi(&kData->osc.data, midiData);

  3079.             }

  3080.         }

  3081.         else

  3082.         {

  3083.             if (fUi.handle != nullptr && fUi.descriptor != nullptr && fUi.descriptor->port_event != nullptr)

  3084.             {

  3085.                 LV2_Atom_MidiEvent midiEv;

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

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

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

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

  3090.                 midiEv.data[1] = note;

  3091.                 midiEv.data[2] = 0;

  3092. 

  3093.                 fUi.descriptor->port_event(fUi.handle, 0, 3, CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM, &midiEv);

  3094.             }

  3095.         }

  3096.     }

  3097. 

  3098.     // -------------------------------------------------------------------

  3099. 

  3100. protected:

  3101.     void guiClosedCallback() override

  3102.     {

  3103.         showGui(false);

  3104.         kData->engine->callback(CALLBACK_SHOW_GUI, fId, 0, 0, 0.0f, nullptr);

  3105.     }

  3106. 

  3107.     // -------------------------------------------------------------------

  3108. 

  3109.     uint32_t getCustomURID(const char* const uri)

  3110.     {

  3111.         CARLA_ASSERT(uri != nullptr);

  3112.         carla_debug("Lv2Plugin::getCustomURID(\"%s\")", uri);

  3113. 

  3114.         if (uri == nullptr)

  3115.             return CARLA_URI_MAP_ID_NULL;

  3116. 

  3117.         for (size_t i=0; i < fCustomURIDs.count(); ++i)

  3118.         {

  3119.             const char*& thisUri(fCustomURIDs.getAt(i));

  3120.             if (thisUri != nullptr && std::strcmp(thisUri, uri) == 0)

  3121.                 return i;

  3122.         }

  3123. 

  3124.         fCustomURIDs.append(carla_strdup(uri));

  3125. 

  3126.         return fCustomURIDs.count()-1;

  3127.     }

  3128. 

  3129.     const char* getCustomURIString(const LV2_URID urid)

  3130.     {

  3131.         CARLA_ASSERT(urid != CARLA_URI_MAP_ID_NULL);

  3132.         CARLA_ASSERT_INT2(urid < fCustomURIDs.count(), urid, fCustomURIDs.count());

  3133.         carla_debug("Lv2Plugin::getCustomURIString(%i)", urid);

  3134. 

  3135.         if (urid == CARLA_URI_MAP_ID_NULL)

  3136.             return nullptr;

  3137.         if (urid < fCustomURIDs.count())

  3138.             return fCustomURIDs.getAt(urid);

  3139. 

  3140.         return nullptr;

  3141.     }

  3142. 

  3143.     // -------------------------------------------------------------------

  3144. 

  3145.     void handleProgramChanged(const int32_t index)

  3146.     {

  3147.         if (index == -1)

  3148.         {

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

  3150.             return reloadPrograms(false);

  3151.         }

  3152. 

  3153.         if (index >= 0 && index < static_cast<int32_t>(kData->midiprog.count) && fExt.programs != nullptr && fExt.programs->get_program != nullptr)

  3154.         {

  3155.             if (const LV2_Program_Descriptor* progDesc = fExt.programs->get_program(fHandle, index))

  3156.             {

  3157.                 CARLA_ASSERT(progDesc->name != nullptr);

  3158. 

  3159.                 if (kData->midiprog.data[index].name != nullptr)

  3160.                     delete[] kData->midiprog.data[index].name;

  3161. 

  3162.                 kData->midiprog.data[index].name = carla_strdup(progDesc->name ? progDesc->name : "");

  3163. 

  3164.                 if (index == kData->midiprog.current)

  3165.                     kData->engine->callback(CALLBACK_UPDATE, fId, 0, 0, 0.0, nullptr);

  3166.                 else

  3167.                     kData->engine->callback(CALLBACK_RELOAD_PROGRAMS, fId, 0, 0, 0.0, nullptr);

  3168.             }

  3169.         }

  3170.     }

  3171. 

  3172.     // -------------------------------------------------------------------

  3173. 

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

  3175.     {

  3176.         CARLA_ASSERT(key != CARLA_URI_MAP_ID_NULL);

  3177.         CARLA_ASSERT(value != nullptr);

  3178.         CARLA_ASSERT(size > 0);

  3179. 

  3180.         // basic checks

  3181.         if (key == CARLA_URI_MAP_ID_NULL)

  3182.         {

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

  3184.             return LV2_STATE_ERR_NO_PROPERTY;

  3185.         }

  3186. 

  3187.         if (value == nullptr || size == 0)

  3188.         {

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

  3190.             return LV2_STATE_ERR_NO_PROPERTY;

  3191.         }

  3192. 

  3193.         if ((flags & LV2_STATE_IS_POD) == 0)

  3194.         {

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

  3196.             return LV2_STATE_ERR_BAD_FLAGS;

  3197.         }

  3198. 

  3199.         const char* const stype(carla_lv2_urid_unmap(this, type));

  3200. 

  3201.         if (stype == nullptr)

  3202.         {

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

  3204.             return LV2_STATE_ERR_BAD_TYPE;

  3205.         }

  3206. 

  3207.         const char* const uriKey(carla_lv2_urid_unmap(this, key));

  3208. 

  3209.         if (uriKey == nullptr)

  3210.         {

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

  3212.             return LV2_STATE_ERR_NO_PROPERTY;

  3213.         }

  3214. 

  3215.         // Check if we already have this key

  3216.         for (auto it = kData->custom.begin(); it.valid(); it.next())

  3217.         {

  3218.             CustomData& data(*it);

  3219. 

  3220.             if (std::strcmp(data.key, uriKey) == 0)

  3221.             {

  3222.                 if (data.value != nullptr)

  3223.                     delete[] data.value;

  3224. 

  3225.                 if (std::strcmp(stype, LV2_ATOM__String) == 0 || std::strcmp(stype, LV2_ATOM__Path) == 0)

  3226.                     data.value = carla_strdup((const char*)value);

  3227.                 else

  3228.                     data.value = carla_strdup(QByteArray((const char*)value, size).toBase64().constData());

  3229. 

  3230.                 return LV2_STATE_SUCCESS;

  3231.             }

  3232.         }

  3233. 

  3234.         // Otherwise store it

  3235.         CustomData newData;

  3236.         newData.type = carla_strdup(stype);

  3237.         newData.key  = carla_strdup(uriKey);

  3238. 

  3239.         if (std::strcmp(stype, LV2_ATOM__String) == 0 || std::strcmp(stype, LV2_ATOM__Path) == 0)

  3240.             newData.value = carla_strdup((const char*)value);

  3241.         else

  3242.             newData.value = carla_strdup(QByteArray((const char*)value, size).toBase64().constData());

  3243. 

  3244.         kData->custom.append(newData);

  3245. 

  3246.         return LV2_STATE_SUCCESS;

  3247.     }

  3248. 

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

  3250.     {

  3251.         CARLA_ASSERT(key != CARLA_URI_MAP_ID_NULL);

  3252. 

  3253.         // basic checks

  3254.         if (key == CARLA_URI_MAP_ID_NULL)

  3255.         {

  3256.             carla_stderr2("Lv2Plugin::handleStateRetrieve(%i, %p, %p, %p) - invalid key", key, size, type, flags);

  3257.             return nullptr;

  3258.         }

  3259. 

  3260.         if (size == nullptr || type == nullptr || flags == nullptr)

  3261.         {

  3262.             carla_stderr2("Lv2Plugin::handleStateRetrieve(%i, %p, %p, %p) - invalid data", key, size, type, flags);

  3263.             return nullptr;

  3264.         }

  3265. 

  3266.         const char* const uriKey(carla_lv2_urid_unmap(this, key));

  3267. 

  3268.         if (uriKey == nullptr)

  3269.         {

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

  3271.             return nullptr;

  3272.         }

  3273. 

  3274.         const char* stype = nullptr;

  3275.         const char* stringData = nullptr;

  3276. 

  3277.         for (auto it = kData->custom.begin(); it.valid(); it.next())

  3278.         {

  3279.             CustomData& data(*it);

  3280. 

  3281.             if (std::strcmp(data.key, uriKey) == 0)

  3282.             {

  3283.                 stype      = data.type;

  3284.                 stringData = data.value;

  3285.                 break;

  3286.             }

  3287.         }

  3288. 

  3289.         if (stringData == nullptr)

  3290.         {

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

  3292.             return nullptr;

  3293.         }

  3294. 

  3295.         *type  = key;

  3296.         *flags = LV2_STATE_IS_POD;

  3297. 

  3298.         if (std::strcmp(stype, LV2_ATOM__String) == 0 || std::strcmp(stype, LV2_ATOM__Path) == 0)

  3299.         {

  3300.             *size = std::strlen(stringData);

  3301.             return stringData;

  3302.         }

  3303.         else

  3304.         {

  3305.             static QByteArray chunk;

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

  3307.             *size = chunk.size();

  3308.             return chunk.constData();

  3309.         }

  3310.     }

  3311. 

  3312.     // -------------------------------------------------------------------

  3313. 

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

  3315.     {

  3316.         carla_stdout("Lv2Plugin::handleWorkerSchedule(%i, %p)", size, data);

  3317. 

  3318. #if 0

  3319.         if (! ext.worker)

  3320.         {

  3321.             carla_stderr("Lv2Plugin::handleWorkerSchedule(%i, %p) - plugin has no worker", size, data);

  3322.             return LV2_WORKER_ERR_UNKNOWN;

  3323.         }

  3324. 

  3325.         if (x_engine->isOffline())

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

  3327.         else

  3328.             postponeEvent(PluginPostEventCustom, size, 0, 0.0, data);

  3329. #endif

  3330. 

  3331.         return LV2_WORKER_SUCCESS;

  3332.     }

  3333. 

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

  3335.     {

  3336.         carla_stdout("Lv2Plugin::handleWorkerRespond(%i, %p)", size, data);

  3337. 

  3338. #if 0

  3339.         LV2_Atom_Worker workerAtom;

  3340.         workerAtom.atom.type = CARLA_URI_MAP_ID_ATOM_WORKER;

  3341.         workerAtom.atom.size = sizeof(LV2_Atom_Worker_Body);

  3342.         workerAtom.body.size = size;

  3343.         workerAtom.body.data = data;

  3344. 

  3345.         atomQueueIn.put(0, (const LV2_Atom*)&workerAtom);

  3346. #endif

  3347. 

  3348.         return LV2_WORKER_SUCCESS;

  3349.     }

  3350. 

  3351.     // -------------------------------------------------------------------

  3352. 

  3353.     void handleExternalUiClosed()

  3354.     {

  3355.         CARLA_ASSERT(fUi.type == PLUGIN_UI_EXTERNAL);

  3356. 

  3357.         if (fUi.handle != nullptr && fUi.descriptor != nullptr && fUi.descriptor->cleanup != nullptr)

  3358.             fUi.descriptor->cleanup(fUi.handle);

  3359. 

  3360.         fUi.handle = nullptr;

  3361.         kData->engine->callback(CALLBACK_SHOW_GUI, fId, 0, 0, 0.0, nullptr);

  3362.     }

  3363. 

  3364.     uint32_t handleUiPortMap(const char* const symbol)

  3365.     {

  3366.         CARLA_ASSERT(symbol != nullptr);

  3367. 

  3368.         if (symbol == nullptr)

  3369.             return LV2UI_INVALID_PORT_INDEX;

  3370. 

  3371.         for (uint32_t i=0; i < fRdfDescriptor->PortCount; ++i)

  3372.         {

  3373.             if (std::strcmp(fRdfDescriptor->Ports[i].Symbol, symbol) == 0)

  3374.                 return i;

  3375.         }

  3376. 

  3377.         return LV2UI_INVALID_PORT_INDEX;

  3378.     }

  3379. 

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

  3381.     {

  3382.         CARLA_ASSERT(kData->gui != nullptr);

  3383.         CARLA_ASSERT(width > 0);

  3384.         CARLA_ASSERT(height > 0);

  3385. 

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

  3387.             return 1;

  3388. 

  3389.         if (kData->gui != nullptr)

  3390.             kData->gui->setSize(width, height);

  3391. 

  3392.         return 0;

  3393.     }

  3394. 

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

  3396.     {

  3397.         if (format == 0)

  3398.         {

  3399.             CARLA_ASSERT(buffer != nullptr);

  3400.             CARLA_ASSERT(bufferSize == sizeof(float));

  3401. 

  3402.             if (buffer == nullptr || bufferSize != sizeof(float))

  3403.                 return;

  3404. 

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

  3406. 

  3407.             for (uint32_t i=0; i < kData->param.count; ++i)

  3408.             {

  3409.                 if (kData->param.data[i].rindex == static_cast<int32_t>(rindex))

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

  3411.             }

  3412.         }

  3413.         else if (format == CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM)

  3414.         {

  3415.             CARLA_ASSERT(buffer != nullptr);

  3416. 

  3417.             if (buffer == nullptr)

  3418.                 return;

  3419. 

  3420.             //const LV2_Atom* const atom = (const LV2_Atom*)buffer;

  3421.             //handleTransferAtom(rindex, atom);

  3422.         }

  3423.         else if (format == CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT)

  3424.         {

  3425.             CARLA_ASSERT(buffer != nullptr);

  3426. 

  3427.             if (buffer == nullptr)

  3428.                 return;

  3429. 

  3430.             //const LV2_Atom* const atom = (const LV2_Atom*)buffer;

  3431.             //handleTransferEvent(rindex, atom);

  3432.         }

  3433.     }

  3434. 

  3435.     // -------------------------------------------------------------------

  3436. 

  3437.     bool needsFixedBuffer()

  3438.     {

  3439.         CARLA_ASSERT(fRdfDescriptor != nullptr);

  3440. 

  3441.         for (uint32_t i=0; i < fRdfDescriptor->FeatureCount; ++i)

  3442.         {

  3443.             if (std::strcmp(fRdfDescriptor->Features[i].URI, LV2_BUF_SIZE__fixedBlockLength) == 0)

  3444.                 return true;

  3445.         }

  3446. 

  3447.         return false;

  3448.     }

  3449. 

  3450.     // -------------------------------------------------------------------

  3451. 

  3452.     const char* getUiBridgePath(const LV2_Property type)

  3453.     {

  3454.         const EngineOptions& options(kData->engine->getOptions());

  3455. 

  3456.         switch (type)

  3457.         {

  3458.         case LV2_UI_GTK2:

  3459.             return options.bridge_lv2Gtk2;

  3460.         case LV2_UI_GTK3:

  3461.             return options.bridge_lv2Gtk3;

  3462.         case LV2_UI_QT4:

  3463.             return options.bridge_lv2Qt4;

  3464.         case LV2_UI_QT5:

  3465.             return options.bridge_lv2Qt5;

  3466.         case LV2_UI_COCOA:

  3467.             return options.bridge_lv2Cocoa;

  3468.         case LV2_UI_WINDOWS:

  3469.             return options.bridge_lv2Win;

  3470.         case LV2_UI_X11:

  3471.             return options.bridge_lv2X11;

  3472.         default:

  3473.             return nullptr;

  3474.         }

  3475.     }

  3476. 

  3477.     bool isUiBridgeable(const uint32_t uiId)

  3478.     {

  3479.         const LV2_RDF_UI& rdfUi(fRdfDescriptor->UIs[uiId]);

  3480. 

  3481.         for (uint32_t i=0; i < rdfUi.FeatureCount; ++i)

  3482.         {

  3483.             if (std::strcmp(rdfUi.Features[i].URI, LV2_INSTANCE_ACCESS_URI) == 0)

  3484.                 return false;

  3485.             if (std::strcmp(rdfUi.Features[i].URI, LV2_DATA_ACCESS_URI) == 0)

  3486.                 return false;

  3487.         }

  3488. 

  3489.         return true;

  3490.     }

  3491. 

  3492.     bool isUiResizable()

  3493.     {

  3494.         for (uint32_t i=0; i < fUi.rdfDescriptor->FeatureCount; ++i)

  3495.         {

  3496.             if (std::strcmp(fUi.rdfDescriptor->Features[i].URI, LV2_UI__fixedSize) == 0)

  3497.                 return false;

  3498.             if (std::strcmp(fUi.rdfDescriptor->Features[i].URI, LV2_UI__noUserResize) == 0)

  3499.                 return false;

  3500.         }

  3501. 

  3502.         return true;

  3503.     }

  3504. 

  3505.     void updateUi()

  3506.     {

  3507.         CARLA_ASSERT(fUi.handle != nullptr);

  3508.         CARLA_ASSERT(fUi.descriptor != nullptr);

  3509. 

  3510.         fExt.uiidle = nullptr;

  3511.         fExt.uiprograms = nullptr;

  3512. 

  3513.         if (fUi.descriptor->extension_data != nullptr)

  3514.         {

  3515.             fExt.uiidle     = (const LV2UI_Idle_Interface*)fUi.descriptor->extension_data(LV2_UI__idleInterface);

  3516.             fExt.uiprograms = (const LV2_Programs_UI_Interface*)fUi.descriptor->extension_data(LV2_PROGRAMS__UIInterface);

  3517. 

  3518.             // check if invalid

  3519.             if (fExt.uiidle != nullptr && fExt.uiidle->idle == nullptr)

  3520.                 fExt.uiidle = nullptr;

  3521. 

  3522.             if (fExt.uiprograms != nullptr && fExt.uiprograms->select_program == nullptr)

  3523.                 fExt.uiprograms = nullptr;

  3524. 

  3525.             // update midi program

  3526.             if (fExt.uiprograms && kData->midiprog.count > 0 && kData->midiprog.current >= 0)

  3527.                 fExt.uiprograms->select_program(fUi.handle, kData->midiprog.data[kData->midiprog.current].bank,

  3528.                                                             kData->midiprog.data[kData->midiprog.current].program);

  3529.         }

  3530. 

  3531.         if (fUi.descriptor->port_event != nullptr)

  3532.         {

  3533.             // update control ports

  3534.             float value;

  3535.             for (uint32_t i=0; i < kData->param.count; ++i)

  3536.             {

  3537.                 value = getParameterValue(i);

  3538.                 fUi.descriptor->port_event(fUi.handle, kData->param.data[i].rindex, sizeof(float), CARLA_URI_MAP_ID_NULL, &value);

  3539.             }

  3540.         }

  3541.     }

  3542. 

  3543.     // -------------------------------------------------------------------

  3544. 

  3545. public:

  3546.     bool init(const char* const name, const char* const uri)

  3547.     {

  3548.         CARLA_ASSERT(kData->engine != nullptr);

  3549.         CARLA_ASSERT(kData->client == nullptr);

  3550.         CARLA_ASSERT(uri != nullptr);

  3551. 

  3552.         // ---------------------------------------------------------------

  3553.         // first checks

  3554. 

  3555.         if (kData->engine == nullptr)

  3556.         {

  3557.             return false;

  3558.         }

  3559. 

  3560.         if (kData->client != nullptr)

  3561.         {

  3562.             kData->engine->setLastError("Plugin client is already registered");

  3563.             return false;

  3564.         }

  3565. 

  3566.         if (uri == nullptr)

  3567.         {

  3568.             kData->engine->setLastError("null uri");

  3569.             return false;

  3570.         }

  3571. 

  3572.         // ---------------------------------------------------------------

  3573.         // get plugin from lv2_rdf (lilv)

  3574. 

  3575.         gLv2World.init();

  3576. 

  3577.         fRdfDescriptor = lv2_rdf_new(uri);

  3578. 

  3579.         if (fRdfDescriptor == nullptr)

  3580.         {

  3581.             kData->engine->setLastError("Failed to find the requested plugin in the LV2 Bundle");

  3582.             return false;

  3583.         }

  3584. 

  3585.         // ---------------------------------------------------------------

  3586.         // open DLL

  3587. 

  3588.         if (! kData->libOpen(fRdfDescriptor->Binary))

  3589.         {

  3590.             kData->engine->setLastError(kData->libError(fRdfDescriptor->Binary));

  3591.             return false;

  3592.         }

  3593. 

  3594.         // ---------------------------------------------------------------

  3595.         // initialize options

  3596. 

  3597.         fLv2Options.minBufferSize = 1;

  3598.         fLv2Options.maxBufferSize = kData->engine->getBufferSize();

  3599.         fLv2Options.sampleRate    = kData->engine->getSampleRate();

  3600. 

  3601.         // ---------------------------------------------------------------

  3602.         // initialize features (part 1)

  3603. 

  3604.         LV2_Event_Feature* const eventFt = new LV2_Event_Feature;

  3605.         eventFt->callback_data           = this;

  3606.         eventFt->lv2_event_ref           = carla_lv2_event_ref;

  3607.         eventFt->lv2_event_unref         = carla_lv2_event_unref;

  3608. 

  3609.         LV2_Log_Log* const logFt         = new LV2_Log_Log;

  3610.         logFt->handle                    = this;

  3611.         logFt->printf                    = carla_lv2_log_printf;

  3612.         logFt->vprintf                   = carla_lv2_log_vprintf;

  3613. 

  3614.         LV2_State_Make_Path* const stateMakePathFt = new LV2_State_Make_Path;

  3615.         stateMakePathFt->handle                    = this;

  3616.         stateMakePathFt->path                      = carla_lv2_state_make_path;

  3617. 

  3618.         LV2_State_Map_Path* const stateMapPathFt   = new LV2_State_Map_Path;

  3619.         stateMapPathFt->handle                     = this;

  3620.         stateMapPathFt->abstract_path              = carla_lv2_state_map_abstract_path;

  3621.         stateMapPathFt->absolute_path              = carla_lv2_state_map_absolute_path;

  3622. 

  3623.         LV2_Programs_Host* const programsFt   = new LV2_Programs_Host;

  3624.         programsFt->handle                    = this;

  3625.         programsFt->program_changed           = carla_lv2_program_changed;

  3626. 

  3627.         LV2_RtMemPool_Pool* const rtMemPoolFt = new LV2_RtMemPool_Pool;

  3628.         lv2_rtmempool_init(rtMemPoolFt);

  3629. 

  3630.         LV2_URI_Map_Feature* const uriMapFt = new LV2_URI_Map_Feature;

  3631.         uriMapFt->callback_data             = this;

  3632.         uriMapFt->uri_to_id                 = carla_lv2_uri_to_id;

  3633. 

  3634.         LV2_URID_Map* const uridMapFt       = new LV2_URID_Map;

  3635.         uridMapFt->handle                   = this;

  3636.         uridMapFt->map                      = carla_lv2_urid_map;

  3637. 

  3638.         LV2_URID_Unmap* const uridUnmapFt   = new LV2_URID_Unmap;

  3639.         uridUnmapFt->handle                 = this;

  3640.         uridUnmapFt->unmap                  = carla_lv2_urid_unmap;

  3641. 

  3642.         LV2_Worker_Schedule* const workerFt = new LV2_Worker_Schedule;

  3643.         workerFt->handle                    = this;

  3644.         workerFt->schedule_work             = carla_lv2_worker_schedule;

  3645. 

  3646.         // ---------------------------------------------------------------

  3647.         // initialize features (part 2)

  3648. 

  3649.         fFeatures[kFeatureIdBufSizeBounded]        = new LV2_Feature;

  3650.         fFeatures[kFeatureIdBufSizeBounded]->URI   = LV2_BUF_SIZE__boundedBlockLength;

  3651.         fFeatures[kFeatureIdBufSizeBounded]->data  = nullptr;

  3652. 

  3653.         fFeatures[kFeatureIdBufSizeFixed]          = new LV2_Feature;

  3654.         fFeatures[kFeatureIdBufSizeFixed]->URI     = LV2_BUF_SIZE__fixedBlockLength;

  3655.         fFeatures[kFeatureIdBufSizeFixed]->data    = nullptr;

  3656. 

  3657.         fFeatures[kFeatureIdBufSizePowerOf2]       = new LV2_Feature;

  3658.         fFeatures[kFeatureIdBufSizePowerOf2]->URI  = LV2_BUF_SIZE__powerOf2BlockLength;

  3659.         fFeatures[kFeatureIdBufSizePowerOf2]->data = nullptr;

  3660. 

  3661.         fFeatures[kFeatureIdEvent]          = new LV2_Feature;

  3662.         fFeatures[kFeatureIdEvent]->URI     = LV2_EVENT_URI;

  3663.         fFeatures[kFeatureIdEvent]->data    = eventFt;

  3664. 

  3665.         fFeatures[kFeatureIdLogs]           = new LV2_Feature;

  3666.         fFeatures[kFeatureIdLogs]->URI      = LV2_LOG__log;

  3667.         fFeatures[kFeatureIdLogs]->data     = logFt;

  3668. 

  3669.         fFeatures[kFeatureIdOptions]        = new LV2_Feature;

  3670.         fFeatures[kFeatureIdOptions]->URI   = LV2_OPTIONS__options;

  3671.         fFeatures[kFeatureIdOptions]->data  = fLv2Options.opts;

  3672. 

  3673.         fFeatures[kFeatureIdPrograms]       = new LV2_Feature;

  3674.         fFeatures[kFeatureIdPrograms]->URI  = LV2_PROGRAMS__Host;

  3675.         fFeatures[kFeatureIdPrograms]->data = programsFt;

  3676. 

  3677.         fFeatures[kFeatureIdRtMemPool]       = new LV2_Feature;

  3678.         fFeatures[kFeatureIdRtMemPool]->URI  = LV2_RTSAFE_MEMORY_POOL__Pool;

  3679.         fFeatures[kFeatureIdRtMemPool]->data = rtMemPoolFt;

  3680. 

  3681.         fFeatures[kFeatureIdStateMakePath]       = new LV2_Feature;

  3682.         fFeatures[kFeatureIdStateMakePath]->URI  = LV2_STATE__makePath;

  3683.         fFeatures[kFeatureIdStateMakePath]->data = stateMakePathFt;

  3684. 

  3685.         fFeatures[kFeatureIdStateMapPath]        = new LV2_Feature;

  3686.         fFeatures[kFeatureIdStateMapPath]->URI   = LV2_STATE__mapPath;

  3687.         fFeatures[kFeatureIdStateMapPath]->data  = stateMapPathFt;

  3688. 

  3689.         fFeatures[kFeatureIdStrictBounds]         = new LV2_Feature;

  3690.         fFeatures[kFeatureIdStrictBounds]->URI    = LV2_PORT_PROPS__supportsStrictBounds;

  3691.         fFeatures[kFeatureIdStrictBounds]->data   = nullptr;

  3692. 

  3693.         fFeatures[kFeatureIdUriMap]          = new LV2_Feature;

  3694.         fFeatures[kFeatureIdUriMap]->URI     = LV2_URI_MAP_URI;

  3695.         fFeatures[kFeatureIdUriMap]->data    = uriMapFt;

  3696. 

  3697.         fFeatures[kFeatureIdUridMap]         = new LV2_Feature;

  3698.         fFeatures[kFeatureIdUridMap]->URI    = LV2_URID__map;

  3699.         fFeatures[kFeatureIdUridMap]->data   = uridMapFt;

  3700. 

  3701.         fFeatures[kFeatureIdUridUnmap]       = new LV2_Feature;

  3702.         fFeatures[kFeatureIdUridUnmap]->URI  = LV2_URID__unmap;

  3703.         fFeatures[kFeatureIdUridUnmap]->data = uridUnmapFt;

  3704. 

  3705.         fFeatures[kFeatureIdWorker]           = new LV2_Feature;

  3706.         fFeatures[kFeatureIdWorker]->URI      = LV2_WORKER__schedule;

  3707.         fFeatures[kFeatureIdWorker]->data     = workerFt;

  3708. 

  3709.         if (! needsFixedBuffer())

  3710.             fFeatures[kFeatureIdBufSizeFixed]->URI = LV2_BUF_SIZE__boundedBlockLength;

  3711. 

  3712.         // ---------------------------------------------------------------

  3713.         // get DLL main entry

  3714. 

  3715. #if 0

  3716.         const LV2_Lib_Descriptor_Function libDescFn = (LV2_Lib_Descriptor_Function)kData->libSymbol("lv2_lib_descriptor");

  3717. 

  3718.         if (libDescFn != nullptr)

  3719.         {

  3720.             // -----------------------------------------------------------

  3721.             // get lib descriptor

  3722. 

  3723.             const LV2_Lib_Descriptor* libFn = nullptr; //descLibFn(fRdfDescriptor->Bundle, features);

  3724. 

  3725.             if (libFn == nullptr || libFn->get_plugin == nullptr)

  3726.             {

  3727.                 kData->engine->setLastError("Plugin failed to return library descriptor");

  3728.                 return false;

  3729.             }

  3730. 

  3731.             // -----------------------------------------------------------

  3732.             // get descriptor that matches URI

  3733. 

  3734.             uint32_t i = 0;

  3735.             while ((fDescriptor = libFn->get_plugin(libFn->handle, i++)))

  3736.             {

  3737.                 if (std::strcmp(fDescriptor->URI, uri) == 0)

  3738.                     break;

  3739.             }

  3740. 

  3741.             if (fDescriptor == nullptr)

  3742.                 libFn->cleanup(libFn->handle);

  3743.         else

  3744. #endif

  3745.         {

  3746.             const LV2_Descriptor_Function descFn = (LV2_Descriptor_Function)kData->libSymbol("lv2_descriptor");

  3747. 

  3748.             if (descFn == nullptr)

  3749.             {

  3750.                 kData->engine->setLastError("Could not find the LV2 Descriptor in the plugin library");

  3751.                 return false;

  3752.             }

  3753. 

  3754.             // -----------------------------------------------------------

  3755.             // get descriptor that matches URI

  3756. 

  3757.             uint32_t i = 0;

  3758.             while ((fDescriptor = descFn(i++)))

  3759.             {

  3760.                 if (std::strcmp(fDescriptor->URI, uri) == 0)

  3761.                     break;

  3762.             }

  3763.         }

  3764. 

  3765.         if (fDescriptor == nullptr)

  3766.         {

  3767.             kData->engine->setLastError("Could not find the requested plugin URI in the plugin library");

  3768.             return false;

  3769.         }

  3770. 

  3771.         // ---------------------------------------------------------------

  3772.         // check supported port-types and features

  3773. 

  3774.         bool canContinue = true;

  3775. 

  3776.         // Check supported ports

  3777.         for (uint32_t i=0; i < fRdfDescriptor->PortCount; ++i)

  3778.         {

  3779.             const LV2_Property portTypes(fRdfDescriptor->Ports[i].Types);

  3780. 

  3781.             if (! (LV2_IS_PORT_AUDIO(portTypes) || LV2_IS_PORT_CONTROL(portTypes) || LV2_IS_PORT_ATOM_SEQUENCE(portTypes) || LV2_IS_PORT_EVENT(portTypes) || LV2_IS_PORT_MIDI_LL(portTypes)))

  3782.             {

  3783.                 if (! LV2_IS_PORT_OPTIONAL(fRdfDescriptor->Ports[i].Properties))

  3784.                 {

  3785.                     kData->engine->setLastError("Plugin requires a port type that is not currently supported");

  3786.                     canContinue = false;

  3787.                     break;

  3788.                 }

  3789.             }

  3790.         }

  3791. 

  3792.         // Check supported features

  3793.         for (uint32_t i=0; i < fRdfDescriptor->FeatureCount && canContinue; ++i)

  3794.         {

  3795.             if (LV2_IS_FEATURE_REQUIRED(fRdfDescriptor->Features[i].Type) && ! is_lv2_feature_supported(fRdfDescriptor->Features[i].URI))

  3796.             {

  3797.                 QString msg(QString("Plugin requires a feature that is not supported:\n%1").arg(fRdfDescriptor->Features[i].URI));

  3798.                 kData->engine->setLastError(msg.toUtf8().constData());

  3799.                 canContinue = false;

  3800.                 break;

  3801.             }

  3802.         }

  3803. 

  3804.         // Check extensions

  3805.         for (uint32_t i=0; i < fRdfDescriptor->ExtensionCount; ++i)

  3806.         {

  3807.             if (std::strcmp(fRdfDescriptor->Extensions[i], LV2_OPTIONS__interface) == 0)

  3808.                 kData->extraHints |= PLUGIN_HAS_EXTENSION_OPTIONS;

  3809.             else if (std::strcmp(fRdfDescriptor->Extensions[i], LV2_PROGRAMS__Interface) == 0)

  3810.                 kData->extraHints |= PLUGIN_HAS_EXTENSION_PROGRAMS;

  3811.             else if (std::strcmp(fRdfDescriptor->Extensions[i], LV2_STATE__interface) == 0)

  3812.                 kData->extraHints |= PLUGIN_HAS_EXTENSION_STATE;

  3813.             else if (std::strcmp(fRdfDescriptor->Extensions[i], LV2_WORKER__interface) == 0)

  3814.                 kData->extraHints |= PLUGIN_HAS_EXTENSION_WORKER;

  3815.             else

  3816.                 carla_stdout("Plugin has non-supported extension: '%s'", fRdfDescriptor->Extensions[i]);

  3817.         }

  3818. 

  3819.         if (! canContinue)

  3820.         {

  3821.             // error already set

  3822.             return false;

  3823.         }

  3824. 

  3825.         // ---------------------------------------------------------------

  3826.         // get info

  3827. 

  3828.         if (name != nullptr)

  3829.             fName = kData->engine->getUniquePluginName(name);

  3830.         else

  3831.             fName = kData->engine->getUniquePluginName(fRdfDescriptor->Name);

  3832. 

  3833.         // ---------------------------------------------------------------

  3834.         // register client

  3835. 

  3836.         kData->client = kData->engine->addClient(this);

  3837. 

  3838.         if (kData->client == nullptr || ! kData->client->isOk())

  3839.         {

  3840.             kData->engine->setLastError("Failed to register plugin client");

  3841.             return false;

  3842.         }

  3843. 

  3844.         // ---------------------------------------------------------------

  3845.         // initialize plugin

  3846. 

  3847.         fHandle = fDescriptor->instantiate(fDescriptor, kData->engine->getSampleRate(), fRdfDescriptor->Bundle, fFeatures);

  3848. 

  3849.         if (fHandle == nullptr)

  3850.         {

  3851.             kData->engine->setLastError("Plugin failed to initialize");

  3852.             return false;

  3853.         }

  3854. 

  3855.         // ---------------------------------------------------------------

  3856.         // load plugin settings

  3857. 

  3858.         {

  3859.             // set default options

  3860.             fOptions = 0x0;

  3861. 

  3862.             fOptions |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  3863. 

  3864.             if (needsFixedBuffer())

  3865.                 fOptions |= PLUGIN_OPTION_FIXED_BUFFER;

  3866. 

  3867.             if (kData->engine->getOptions().forceStereo)

  3868.                 fOptions |= PLUGIN_OPTION_FORCE_STEREO;

  3869. 

  3870.             if (midiInCount() > 0)

  3871.             {

  3872.                 fOptions |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  3873.                 fOptions |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

  3874.                 fOptions |= PLUGIN_OPTION_SEND_PITCHBEND;

  3875.                 fOptions |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  3876.             }

  3877. 

  3878.             // load settings

  3879.             kData->idStr  = "LV2/";

  3880.             kData->idStr += uri;

  3881.             fOptions = kData->loadSettings(fOptions, availableOptions());

  3882. 

  3883.             // ignore settings, we need this anyway

  3884.             if (needsFixedBuffer())

  3885.                 fOptions |= PLUGIN_OPTION_FIXED_BUFFER;

  3886.         }

  3887. 

  3888.         // ---------------------------------------------------------------

  3889.         // gui stuff

  3890. 

  3891.         if (fRdfDescriptor->UICount == 0)

  3892.             return true;

  3893. 

  3894.         // -----------------------------------------------------------

  3895.         // find more appropriate ui

  3896. 

  3897.         int eQt4, eQt5, eCocoa, eWindows, eX11, eGtk2, eGtk3, iCocoa, iWindows, iX11, iQt4, iQt5, iExt, iFinal;

  3898.         eQt4 = eQt5 = eCocoa = eWindows = eX11 = eGtk2 = eGtk3 = iQt4 = iQt5 = iCocoa = iWindows = iX11 = iExt = iFinal = -1;

  3899. 

  3900. #ifdef BUILD_BRIDGE

  3901.         const bool preferUiBridges(kData->engine->getOptions().preferUiBridges);

  3902. #else

  3903.         const bool preferUiBridges(kData->engine->getOptions().preferUiBridges && (fHints & PLUGIN_IS_BRIDGE) == 0);

  3904. #endif

  3905. 

  3906.         for (uint32_t i=0; i < fRdfDescriptor->UICount; ++i)

  3907.         {

  3908.             CARLA_ASSERT(fRdfDescriptor->UIs[i].URI != nullptr);

  3909. 

  3910.             if (fRdfDescriptor->UIs[i].URI == nullptr)

  3911.             {

  3912.                 carla_stderr("Plugin has an UI without a valid URI");

  3913.                 continue;

  3914.             }

  3915. 

  3916.             switch (fRdfDescriptor->UIs[i].Type)

  3917.             {

  3918. #if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))

  3919.             case LV2_UI_QT4:

  3920.                 if (isUiBridgeable(i))

  3921.                     eQt4 = i;

  3922.                 break;

  3923. #else

  3924.             case LV2_UI_QT4:

  3925.                 if (isUiBridgeable(i) && preferUiBridges)

  3926.                     eQt4 = i;

  3927.                 iQt4 = i;

  3928.                 break;

  3929. #endif

  3930. 

  3931. #if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))

  3932.             case LV2_UI_QT5:

  3933.                 if (isUiBridgeable(i) && preferUiBridges)

  3934.                     eQt5 = i;

  3935.                 iQt5 = i;

  3936.                 break;

  3937. #else

  3938.             case LV2_UI_QT5:

  3939.                 if (isUiBridgeable(i) && preferUiBridges)

  3940.                     eQt5 = i;

  3941.                 break;

  3942. #endif

  3943. 

  3944. #ifdef CARLA_OS_MAC

  3945.             case LV2_UI_COCOA:

  3946.                 if (isUiBridgeable(i) && preferUiBridges)

  3947.                     eCocoa = i;

  3948.                 iCocoa = i;

  3949.                 break;

  3950. #endif

  3951. 

  3952. #ifdef CARLA_OS_WIN

  3953.             case LV2_UI_WINDOWS:

  3954.                 if (isUiBridgeable(i) && preferUiBridges)

  3955.                     eWindows = i;

  3956.                 iWindows = i;

  3957.                 break;

  3958. #endif

  3959. 

  3960.             case LV2_UI_X11:

  3961.                 if (isUiBridgeable(i) && preferUiBridges)

  3962.                     eX11 = i;

  3963. #ifdef Q_WS_X11

  3964.                 iX11 = i;

  3965. #endif

  3966.                 break;

  3967. 

  3968.             case LV2_UI_GTK2:

  3969.                 if (isUiBridgeable(i))

  3970.                     eGtk2 = i;

  3971.                 break;

  3972. 

  3973.             case LV2_UI_GTK3:

  3974.                 if (isUiBridgeable(i))

  3975.                     eGtk3 = i;

  3976.                 break;

  3977. 

  3978.             case LV2_UI_EXTERNAL:

  3979.             case LV2_UI_OLD_EXTERNAL:

  3980.                 iExt = i;

  3981.                 break;

  3982. 

  3983.             default:

  3984.                 break;

  3985.             }

  3986.         }

  3987. 

  3988.         if (eQt4 >= 0)

  3989.             iFinal = eQt4;

  3990.         else if (eQt5 >= 0)

  3991.             iFinal = eQt5;

  3992.         else if (eCocoa >= 0)

  3993.             iFinal = eCocoa;

  3994.         else if (eWindows >= 0)

  3995.             iFinal = eWindows;

  3996.         else if (eX11 >= 0)

  3997.             iFinal = eX11;

  3998.         else if (iQt4 >= 0)

  3999.             iFinal = iQt4;

  4000.         else if (iQt5 >= 0)

  4001.             iFinal = iQt5;

  4002.         else if (iCocoa >= 0)

  4003.             iFinal = iCocoa;

  4004.         else if (iWindows >= 0)

  4005.             iFinal = iWindows;

  4006.         else if (iX11 >= 0)

  4007.             iFinal = iX11;

  4008.         else if (iExt >= 0)

  4009.             iFinal = iExt;

  4010.         else if (eGtk2 >= 0)

  4011.             iFinal = eGtk2;

  4012.         else if (eGtk3 >= 0)

  4013.             iFinal = eGtk3;

  4014. 

  4015.         if (iFinal < 0)

  4016.         {

  4017.             carla_stderr("Failed to find an appropriate LV2 UI for this plugin");

  4018.             return true;

  4019.         }

  4020. 

  4021.         fUi.rdfDescriptor = &fRdfDescriptor->UIs[iFinal];

  4022. 

  4023.         // -----------------------------------------------------------

  4024.         // check supported ui features

  4025. 

  4026.         canContinue = true;

  4027. 

  4028.         for (uint32_t i=0; i < fUi.rdfDescriptor->FeatureCount; ++i)

  4029.         {

  4030.             if (LV2_IS_FEATURE_REQUIRED(fUi.rdfDescriptor->Features[i].Type) && ! is_lv2_ui_feature_supported(fUi.rdfDescriptor->Features[i].URI))

  4031.             {

  4032.                 carla_stderr2("Plugin UI requires a feature that is not supported:\n%s", fUi.rdfDescriptor->Features[i].URI);

  4033.                 canContinue = false;

  4034.                 break;

  4035.             }

  4036.         }

  4037. 

  4038.         if (! canContinue)

  4039.         {

  4040.             fUi.rdfDescriptor = nullptr;

  4041.             return true;

  4042.         }

  4043. 

  4044.         // -----------------------------------------------------------

  4045.         // initialize ui according to type

  4046. 

  4047.         const LV2_Property uiType(fUi.rdfDescriptor->Type);

  4048. 

  4049.         if (iFinal == eQt4 || iFinal == eQt5 || iFinal == eCocoa || iFinal == eWindows || iFinal == eX11 || iFinal == eGtk2 || iFinal == eGtk3)

  4050.         {

  4051.             // -------------------------------------------------------

  4052.             // initialize ui bridge

  4053. 

  4054.             if (const char* const oscBinary = getUiBridgePath(uiType))

  4055.             {

  4056.                 fUi.type = PLUGIN_UI_OSC;

  4057.                 kData->osc.thread.setOscData(oscBinary, fDescriptor->URI, fUi.rdfDescriptor->URI);

  4058.             }

  4059.         }

  4060.         else

  4061.         {

  4062.             // -------------------------------------------------------

  4063.             // open UI DLL

  4064. 

  4065.             if (! kData->uiLibOpen(fUi.rdfDescriptor->Binary))

  4066.             {

  4067.                 carla_stderr2("Could not load UI library, error was:\n%s", kData->libError(fUi.rdfDescriptor->Binary));

  4068.                 fUi.rdfDescriptor = nullptr;

  4069.                 return true;

  4070.             }

  4071. 

  4072.             // -------------------------------------------------------

  4073.             // get UI DLL main entry

  4074. 

  4075.             LV2UI_DescriptorFunction uiDescFn = (LV2UI_DescriptorFunction)kData->uiLibSymbol("lv2ui_descriptor");

  4076. 

  4077.             if (uiDescFn == nullptr)

  4078.             {

  4079.                 carla_stderr2("Could not find the LV2UI Descriptor in the UI library");

  4080.                 kData->uiLibClose();

  4081.                 fUi.rdfDescriptor = nullptr;

  4082.                 return true;

  4083.             }

  4084. 

  4085.             // -------------------------------------------------------

  4086.             // get UI descriptor that matches UI URI

  4087. 

  4088.             uint32_t i = 0;

  4089.             while ((fUi.descriptor = uiDescFn(i++)))

  4090.             {

  4091.                 if (std::strcmp(fUi.descriptor->URI, fUi.rdfDescriptor->URI) == 0)

  4092.                     break;

  4093.             }

  4094. 

  4095.             if (fUi.descriptor == nullptr)

  4096.             {

  4097.                 carla_stderr2("Could not find the requested GUI in the plugin UI library");

  4098.                 kData->uiLibClose();

  4099.                 fUi.rdfDescriptor = nullptr;

  4100.                 return true;

  4101.             }

  4102. 

  4103.             // -------------------------------------------------------

  4104.             // check if ui is usable

  4105. 

  4106.             switch (uiType)

  4107.             {

  4108. #if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))

  4109.             case LV2_UI_QT5:

  4110.                 carla_debug("Will use LV2 Qt5 UI");

  4111.                 fUi.type = PLUGIN_UI_QT;

  4112.                 break;

  4113. #else

  4114.             case LV2_UI_QT4:

  4115.                 carla_debug("Will use LV2 Qt4 UI");

  4116.                 fUi.type = PLUGIN_UI_QT;

  4117.                 break;

  4118. #endif

  4119. 

  4120. #ifdef CARLA_OS_MAC

  4121.             case LV2_UI_COCOA:

  4122.                 carla_debug("Will use LV2 Cocoa UI");

  4123.                 fUi.type = PLUGIN_UI_PARENT;

  4124.                 break;

  4125. #endif

  4126. 

  4127. #ifdef CARLA_OS_WIN

  4128.             case LV2_UI_WINDOWS:

  4129.                 carla_debug("Will use LV2 Windows UI");

  4130.                 fUi.type = PLUGIN_UI_PARENT;

  4131.                 break;

  4132. #endif

  4133. 

  4134. #ifdef Q_WS_X11

  4135.             case LV2_UI_X11:

  4136.                 carla_debug("Will use LV2 X11 UI");

  4137.                 fUi.type = PLUGIN_UI_PARENT;

  4138.                 break;

  4139. #endif

  4140. 

  4141.             case LV2_UI_GTK2:

  4142.                 carla_debug("Will use LV2 Gtk2 UI, NOT!");

  4143.                 break;

  4144. 

  4145.             case LV2_UI_GTK3:

  4146.                 carla_debug("Will use LV2 Gtk3 UI, NOT!");

  4147.                 break;

  4148. 

  4149.             case LV2_UI_EXTERNAL:

  4150.             case LV2_UI_OLD_EXTERNAL:

  4151.                 carla_debug("Will use LV2 External UI");

  4152.                 fUi.type = PLUGIN_UI_EXTERNAL;

  4153.                 break;

  4154.             }

  4155. 

  4156.             if (fUi.type == PLUGIN_UI_NULL)

  4157.             {

  4158.                 kData->uiLibClose();

  4159.                 fUi.descriptor = nullptr;

  4160.                 fUi.rdfDescriptor = nullptr;

  4161.                 return true;

  4162.             }

  4163. 

  4164.             // -------------------------------------------------------

  4165.             // initialize ui features

  4166. 

  4167.             QString guiTitle(QString("%1 (GUI)").arg((const char*)fName));

  4168. 

  4169.             LV2_Extension_Data_Feature* const uiDataFt = new LV2_Extension_Data_Feature;

  4170.             uiDataFt->data_access                      = fDescriptor->extension_data;

  4171. 

  4172.             LV2UI_Port_Map* const uiPortMapFt = new LV2UI_Port_Map;

  4173.             uiPortMapFt->handle               = this;

  4174.             uiPortMapFt->port_index           = carla_lv2_ui_port_map;

  4175. 

  4176.             LV2UI_Resize* const uiResizeFt    = new LV2UI_Resize;

  4177.             uiResizeFt->handle                = this;

  4178.             uiResizeFt->ui_resize             = carla_lv2_ui_resize;

  4179. 

  4180.             LV2_External_UI_Host* const uiExternalHostFt = new LV2_External_UI_Host;

  4181.             uiExternalHostFt->ui_closed                  = carla_lv2_external_ui_closed;

  4182.             uiExternalHostFt->plugin_human_id            = carla_strdup(guiTitle.toUtf8().constData());

  4183. 

  4184.             fFeatures[kFeatureIdUiDataAccess]           = new LV2_Feature;

  4185.             fFeatures[kFeatureIdUiDataAccess]->URI      = LV2_DATA_ACCESS_URI;

  4186.             fFeatures[kFeatureIdUiDataAccess]->data     = uiDataFt;

  4187. 

  4188.             fFeatures[kFeatureIdUiInstanceAccess]       = new LV2_Feature;

  4189.             fFeatures[kFeatureIdUiInstanceAccess]->URI  = LV2_INSTANCE_ACCESS_URI;

  4190.             fFeatures[kFeatureIdUiInstanceAccess]->data = fHandle;

  4191. 

  4192.             fFeatures[kFeatureIdUiParent]             = new LV2_Feature;

  4193.             fFeatures[kFeatureIdUiParent]->URI        = LV2_UI__parent;

  4194.             fFeatures[kFeatureIdUiParent]->data       = nullptr;

  4195. 

  4196.             fFeatures[kFeatureIdUiPortMap]           = new LV2_Feature;

  4197.             fFeatures[kFeatureIdUiPortMap]->URI      = LV2_UI__portMap;

  4198.             fFeatures[kFeatureIdUiPortMap]->data     = uiPortMapFt;

  4199. 

  4200.             fFeatures[kFeatureIdUiResize]             = new LV2_Feature;

  4201.             fFeatures[kFeatureIdUiResize]->URI        = LV2_UI__resize;

  4202.             fFeatures[kFeatureIdUiResize]->data       = uiResizeFt;

  4203. 

  4204.             fFeatures[kFeatureIdExternalUi]           = new LV2_Feature;

  4205.             fFeatures[kFeatureIdExternalUi]->URI      = LV2_EXTERNAL_UI__Host;

  4206.             fFeatures[kFeatureIdExternalUi]->data     = uiExternalHostFt;

  4207. 

  4208.             fFeatures[kFeatureIdExternalUiOld]       = new LV2_Feature;

  4209.             fFeatures[kFeatureIdExternalUiOld]->URI  = LV2_EXTERNAL_UI_DEPRECATED_URI;

  4210.             fFeatures[kFeatureIdExternalUiOld]->data = uiExternalHostFt;

  4211.         }

  4212. 

  4213.         return true;

  4214.     }

  4215. 

  4216. private:

  4217.     LV2_Handle   fHandle;

  4218.     LV2_Handle   fHandle2;

  4219.     LV2_Feature* fFeatures[kFeatureCount+1];

  4220.     const LV2_Descriptor*     fDescriptor;

  4221.     const LV2_RDF_Descriptor* fRdfDescriptor;

  4222. 

  4223.     float** fAudioInBuffers;

  4224.     float** fAudioOutBuffers;

  4225.     float*  fParamBuffers;

  4226. 

  4227.     Lv2PluginEventData fEventsIn;

  4228.     Lv2PluginEventData fEventsOut;

  4229.     Lv2PluginOptions   fLv2Options;

  4230. 

  4231.     NonRtList<const char*> fCustomURIDs;

  4232. 

  4233.     struct Extensions {

  4234.         const LV2_Options_Interface* options;

  4235.         const LV2_State_Interface* state;

  4236.         const LV2_Worker_Interface* worker;

  4237.         const LV2_Programs_Interface* programs;

  4238.         const LV2UI_Idle_Interface* uiidle;

  4239.         const LV2_Programs_UI_Interface* uiprograms;

  4240. 

  4241.         Extensions()

  4242.             : options(nullptr),

  4243.               state(nullptr),

  4244.               worker(nullptr),

  4245.               programs(nullptr),

  4246.               uiidle(nullptr),

  4247.               uiprograms(nullptr) {}

  4248.     } fExt;

  4249. 

  4250.     struct UI {

  4251.         Lv2PluginGuiType type;

  4252.         LV2UI_Handle handle;

  4253.         LV2UI_Widget widget;

  4254.         const LV2UI_Descriptor* descriptor;

  4255.         const LV2_RDF_UI*       rdfDescriptor;

  4256. 

  4257.         UI()

  4258.             : type(PLUGIN_UI_NULL),

  4259.               handle(nullptr),

  4260.               widget(nullptr),

  4261.               descriptor(nullptr),

  4262.               rdfDescriptor(nullptr) {}

  4263. 

  4264.         ~UI()

  4265.         {

  4266.             CARLA_ASSERT(handle == nullptr);

  4267.             CARLA_ASSERT(widget == nullptr);

  4268.             CARLA_ASSERT(descriptor == nullptr);

  4269.             CARLA_ASSERT(rdfDescriptor == nullptr);

  4270.         }

  4271. 

  4272.     } fUi;

  4273. 

  4274.     // -------------------------------------------------------------------

  4275.     // Event Feature

  4276. 

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

  4278.     {

  4279.         carla_debug("carla_lv2_event_ref(%p, %p)", callback_data, event);

  4280.         CARLA_ASSERT(callback_data != nullptr);

  4281.         CARLA_ASSERT(event != nullptr);

  4282. 

  4283.         return 0;

  4284.     }

  4285. 

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

  4287.     {

  4288.         carla_debug("carla_lv2_event_unref(%p, %p)", callback_data, event);

  4289.         CARLA_ASSERT(callback_data != nullptr);

  4290.         CARLA_ASSERT(event != nullptr);

  4291. 

  4292.         return 0;

  4293.     }

  4294. 

  4295.     // -------------------------------------------------------------------

  4296.     // Logs Feature

  4297. 

  4298.     static int carla_lv2_log_printf(LV2_Log_Handle handle, LV2_URID type, const char* fmt, ...)

  4299.     {

  4300.         CARLA_ASSERT(handle != nullptr);

  4301.         CARLA_ASSERT(type > CARLA_URI_MAP_ID_NULL);

  4302. 

  4303. #ifndef DEBUG

  4304.         if (type == CARLA_URI_MAP_ID_LOG_TRACE)

  4305.             return 0;

  4306. #endif

  4307. 

  4308.         va_list args;

  4309.         va_start(args, fmt);

  4310.         const int ret = carla_lv2_log_vprintf(handle, type, fmt, args);

  4311.         va_end(args);

  4312. 

  4313.         return ret;

  4314.     }

  4315. 

  4316.     static int carla_lv2_log_vprintf(LV2_Log_Handle handle, LV2_URID type, const char* fmt, va_list ap)

  4317.     {

  4318.         CARLA_ASSERT(handle != nullptr);

  4319.         CARLA_ASSERT(type > CARLA_URI_MAP_ID_NULL);

  4320. 

  4321. #ifndef DEBUG

  4322.         if (type == CARLA_URI_MAP_ID_LOG_TRACE)

  4323.             return 0;

  4324. #endif

  4325. 

  4326.         int ret = 0;

  4327. 

  4328.         switch (type)

  4329.         {

  4330.         case CARLA_URI_MAP_ID_LOG_ERROR:

  4331. #ifndef CARLA_OS_WIN

  4332.             std::fprintf(stderr, "\x1b[31m");

  4333. #endif

  4334.             ret = std::vfprintf(stderr, fmt, ap);

  4335. #ifndef CARLA_OS_WIN

  4336.             std::fprintf(stderr, "\x1b[0m");

  4337. #endif

  4338.             break;

  4339. 

  4340.         case CARLA_URI_MAP_ID_LOG_NOTE:

  4341.             ret = std::vfprintf(stdout, fmt, ap);

  4342.             break;

  4343. 

  4344.         case CARLA_URI_MAP_ID_LOG_TRACE:

  4345. #ifdef DEBUG

  4346. # ifndef CARLA_OS_WIN

  4347.             std::fprintf(stdout, "\x1b[30;1m");

  4348. # endif

  4349.             ret = std::vfprintf(stdout, fmt, ap);

  4350. # ifndef CARLA_OS_WIN

  4351.             std::fprintf(stdout, "\x1b[0m");

  4352. # endif

  4353. #endif

  4354.             break;

  4355. 

  4356.         case CARLA_URI_MAP_ID_LOG_WARNING:

  4357.             ret = std::vfprintf(stderr, fmt, ap);

  4358.             break;

  4359. 

  4360.         default:

  4361.             break;

  4362.         }

  4363. 

  4364.         return ret;

  4365.     }

  4366. 

  4367.     // -------------------------------------------------------------------

  4368.     // Programs Feature

  4369. 

  4370.     static void carla_lv2_program_changed(LV2_Programs_Handle handle, int32_t index)

  4371.     {

  4372.         carla_debug("carla_lv2_program_changed(%p, %i)", handle, index);

  4373.         CARLA_ASSERT(handle != nullptr);

  4374. 

  4375.         if (handle == nullptr)

  4376.             return;

  4377. 

  4378.         ((Lv2Plugin*)handle)->handleProgramChanged(index);

  4379.     }

  4380. 

  4381.     // -------------------------------------------------------------------

  4382.     // State Feature

  4383. 

  4384.     static char* carla_lv2_state_make_path(LV2_State_Make_Path_Handle handle, const char* path)

  4385.     {

  4386.         carla_debug("carla_lv2_state_make_path(%p, \"%s\")", handle, path);

  4387.         CARLA_ASSERT(handle != nullptr);

  4388.         CARLA_ASSERT(path != nullptr);

  4389. 

  4390.         if (path == nullptr)

  4391.             return nullptr;

  4392. 

  4393.         QDir dir;

  4394.         dir.mkpath(path);

  4395.         return strdup(path);

  4396.     }

  4397. 

  4398.     static char* carla_lv2_state_map_abstract_path(LV2_State_Map_Path_Handle handle, const char* absolute_path)

  4399.     {

  4400.         carla_debug("carla_lv2_state_map_abstract_path(%p, \"%s\")", handle, absolute_path);

  4401.         CARLA_ASSERT(handle != nullptr);

  4402.         CARLA_ASSERT(absolute_path != nullptr);

  4403. 

  4404.         if (absolute_path == nullptr)

  4405.             return nullptr;

  4406. 

  4407.         QDir dir(absolute_path);

  4408.         return strdup(dir.canonicalPath().toUtf8().constData());

  4409.     }

  4410. 

  4411.     static char* carla_lv2_state_map_absolute_path(LV2_State_Map_Path_Handle handle, const char* abstract_path)

  4412.     {

  4413.         carla_debug("carla_lv2_state_map_absolute_path(%p, \"%s\")", handle, abstract_path);

  4414.         CARLA_ASSERT(handle != nullptr);

  4415.         CARLA_ASSERT(abstract_path != nullptr);

  4416. 

  4417.         if (abstract_path == nullptr)

  4418.             return nullptr;

  4419. 

  4420.         QDir dir(abstract_path);

  4421.         return strdup(dir.absolutePath().toUtf8().constData());

  4422.     }

  4423. 

  4424.     static LV2_State_Status carla_lv2_state_store(LV2_State_Handle handle, uint32_t key, const void* value, size_t size, uint32_t type, uint32_t flags)

  4425.     {

  4426.         carla_debug("carla_lv2_state_store(%p, %i, %p, " P_SIZE ", %i, %i)", handle, key, value, size, type, flags);

  4427.         CARLA_ASSERT(handle != nullptr);

  4428. 

  4429.         if (handle == nullptr)

  4430.             return LV2_STATE_ERR_UNKNOWN;

  4431. 

  4432.         return ((Lv2Plugin*)handle)->handleStateStore(key, value, size, type, flags);

  4433.     }

  4434. 

  4435.     static const void* carla_lv2_state_retrieve(LV2_State_Handle handle, uint32_t key, size_t* size, uint32_t* type, uint32_t* flags)

  4436.     {

  4437.         carla_debug("carla_lv2_state_retrieve(%p, %i, %p, %p, %p)", handle, key, size, type, flags);

  4438.         CARLA_ASSERT(handle != nullptr);

  4439. 

  4440.         if (handle == nullptr)

  4441.             return nullptr;

  4442. 

  4443.         return ((Lv2Plugin*)handle)->handleStateRetrieve(key, size, type, flags);

  4444.     }

  4445. 

  4446.     // -------------------------------------------------------------------

  4447.     // URI-Map Feature

  4448. 

  4449.     static uint32_t carla_lv2_uri_to_id(LV2_URI_Map_Callback_Data data, const char* map, const char* uri)

  4450.     {

  4451.         carla_debug("carla_lv2_uri_to_id(%p, \"%s\", \"%s\")", data, map, uri);

  4452.         return carla_lv2_urid_map((LV2_URID_Map_Handle*)data, uri);

  4453. 

  4454.         // unused

  4455.         (void)map;

  4456.     }

  4457. 

  4458.     // -------------------------------------------------------------------

  4459.     // URID Feature

  4460. 

  4461.     static LV2_URID carla_lv2_urid_map(LV2_URID_Map_Handle handle, const char* uri)

  4462.     {

  4463.         CARLA_ASSERT(handle != nullptr);

  4464.         CARLA_ASSERT(uri != nullptr);

  4465.         carla_debug("carla_lv2_urid_map(%p, \"%s\")", handle, uri);

  4466. 

  4467.         if (uri == nullptr)

  4468.             return CARLA_URI_MAP_ID_NULL;

  4469. 

  4470.         // Atom types

  4471.         if (std::strcmp(uri, LV2_ATOM__Chunk) == 0)

  4472.             return CARLA_URI_MAP_ID_ATOM_CHUNK;

  4473.         if (std::strcmp(uri, LV2_ATOM__Double) == 0)

  4474.             return CARLA_URI_MAP_ID_ATOM_DOUBLE;

  4475.         if (std::strcmp(uri, LV2_ATOM__Int) == 0)

  4476.             return CARLA_URI_MAP_ID_ATOM_INT;

  4477.         if (std::strcmp(uri, LV2_ATOM__Path) == 0)

  4478.             return CARLA_URI_MAP_ID_ATOM_PATH;

  4479.         if (std::strcmp(uri, LV2_ATOM__Sequence) == 0)

  4480.             return CARLA_URI_MAP_ID_ATOM_SEQUENCE;

  4481.         if (std::strcmp(uri, LV2_ATOM__String) == 0)

  4482.             return CARLA_URI_MAP_ID_ATOM_STRING;

  4483.         if (std::strcmp(uri, LV2_ATOM__atomTransfer) == 0)

  4484.             return CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM;

  4485.         if (std::strcmp(uri, LV2_ATOM__eventTransfer) == 0)

  4486.             return CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT;

  4487. 

  4488.         // BufSize types

  4489.         if (std::strcmp(uri, LV2_BUF_SIZE__maxBlockLength) == 0)

  4490.             return CARLA_URI_MAP_ID_BUF_MAX_LENGTH;

  4491.         if (std::strcmp(uri, LV2_BUF_SIZE__minBlockLength) == 0)

  4492.             return CARLA_URI_MAP_ID_BUF_MIN_LENGTH;

  4493.         if (std::strcmp(uri, LV2_BUF_SIZE__sequenceSize) == 0)

  4494.             return CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE;

  4495. 

  4496.         // Log types

  4497.         if (std::strcmp(uri, LV2_LOG__Error) == 0)

  4498.             return CARLA_URI_MAP_ID_LOG_ERROR;

  4499.         if (std::strcmp(uri, LV2_LOG__Note) == 0)

  4500.             return CARLA_URI_MAP_ID_LOG_NOTE;

  4501.         if (std::strcmp(uri, LV2_LOG__Trace) == 0)

  4502.             return CARLA_URI_MAP_ID_LOG_TRACE;

  4503.         if (std::strcmp(uri, LV2_LOG__Warning) == 0)

  4504.             return CARLA_URI_MAP_ID_LOG_WARNING;

  4505. 

  4506.         // Others

  4507.         if (std::strcmp(uri, LV2_MIDI__MidiEvent) == 0)

  4508.             return CARLA_URI_MAP_ID_MIDI_EVENT;

  4509.         if (std::strcmp(uri, LV2_PARAMETERS__sampleRate) == 0)

  4510.             return CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE;

  4511.         if (std::strcmp(uri, LV2_TIME__Position) == 0)

  4512.             return CARLA_URI_MAP_ID_TIME_POSITION;

  4513. 

  4514.         if (handle == nullptr)

  4515.             return CARLA_URI_MAP_ID_NULL;

  4516. 

  4517.         // Custom types

  4518.         return ((Lv2Plugin*)handle)->getCustomURID(uri);

  4519.     }

  4520. 

  4521.     static const char* carla_lv2_urid_unmap(LV2_URID_Map_Handle handle, LV2_URID urid)

  4522.     {

  4523.         carla_debug("carla_lv2_urid_unmap(%p, %i)", handle, urid);

  4524.         CARLA_ASSERT(handle != nullptr);

  4525.         CARLA_ASSERT(urid > CARLA_URI_MAP_ID_NULL);

  4526. 

  4527.         if (urid == CARLA_URI_MAP_ID_NULL)

  4528.             return nullptr;

  4529. 

  4530.         // Atom types

  4531.         if (urid == CARLA_URI_MAP_ID_ATOM_CHUNK)

  4532.             return LV2_ATOM__Chunk;

  4533.         if (urid == CARLA_URI_MAP_ID_ATOM_DOUBLE)

  4534.             return LV2_ATOM__Double;

  4535.         if (urid == CARLA_URI_MAP_ID_ATOM_INT)

  4536.             return LV2_ATOM__Int;

  4537.         if (urid == CARLA_URI_MAP_ID_ATOM_PATH)

  4538.             return LV2_ATOM__Path;

  4539.         if (urid == CARLA_URI_MAP_ID_ATOM_SEQUENCE)

  4540.             return LV2_ATOM__Sequence;

  4541.         if (urid == CARLA_URI_MAP_ID_ATOM_STRING)

  4542.             return LV2_ATOM__String;

  4543.         if (urid == CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM)

  4544.             return LV2_ATOM__atomTransfer;

  4545.         if (urid == CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT)

  4546.             return LV2_ATOM__eventTransfer;

  4547. 

  4548.         // BufSize types

  4549.         if (urid == CARLA_URI_MAP_ID_BUF_MAX_LENGTH)

  4550.             return LV2_BUF_SIZE__maxBlockLength;

  4551.         if (urid == CARLA_URI_MAP_ID_BUF_MIN_LENGTH)

  4552.             return LV2_BUF_SIZE__minBlockLength;

  4553.         if (urid == CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE)

  4554.             return LV2_BUF_SIZE__sequenceSize;

  4555. 

  4556.         // Log types

  4557.         if (urid == CARLA_URI_MAP_ID_LOG_ERROR)

  4558.             return LV2_LOG__Error;

  4559.         if (urid == CARLA_URI_MAP_ID_LOG_NOTE)

  4560.             return LV2_LOG__Note;

  4561.         if (urid == CARLA_URI_MAP_ID_LOG_TRACE)

  4562.             return LV2_LOG__Trace;

  4563.         if (urid == CARLA_URI_MAP_ID_LOG_WARNING)

  4564.             return LV2_LOG__Warning;

  4565. 

  4566.         // Others

  4567.         if (urid == CARLA_URI_MAP_ID_MIDI_EVENT)

  4568.             return LV2_MIDI__MidiEvent;

  4569.         if (urid == CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE)

  4570.             return LV2_PARAMETERS__sampleRate;

  4571.         if (urid == CARLA_URI_MAP_ID_TIME_POSITION)

  4572.             return LV2_TIME__Position;

  4573. 

  4574.         if (handle == nullptr)

  4575.             return nullptr;

  4576. 

  4577.         // Custom types

  4578.         return ((Lv2Plugin*)handle)->getCustomURIString(urid);

  4579.     }

  4580. 

  4581.     // -------------------------------------------------------------------

  4582.     // Worker Feature

  4583. 

  4584.     static LV2_Worker_Status carla_lv2_worker_schedule(LV2_Worker_Schedule_Handle handle, uint32_t size, const void* data)

  4585.     {

  4586.         carla_debug("carla_lv2_worker_schedule(%p, %i, %p)", handle, size, data);

  4587.         CARLA_ASSERT(handle != nullptr);

  4588. 

  4589.         if (handle == nullptr)

  4590.             return LV2_WORKER_ERR_UNKNOWN;

  4591. 

  4592.         return ((Lv2Plugin*)handle)->handleWorkerSchedule(size, data);

  4593.     }

  4594. 

  4595.     static LV2_Worker_Status carla_lv2_worker_respond(LV2_Worker_Respond_Handle handle, uint32_t size, const void* data)

  4596.     {

  4597.         carla_debug("carla_lv2_worker_respond(%p, %i, %p)", handle, size, data);

  4598.         CARLA_ASSERT(handle != nullptr);

  4599. 

  4600.         if (handle == nullptr)

  4601.             return LV2_WORKER_ERR_UNKNOWN;

  4602. 

  4603.         return ((Lv2Plugin*)handle)->handleWorkerRespond(size, data);

  4604.     }

  4605. 

  4606.     // -------------------------------------------------------------------

  4607.     // UI Port-Map Feature

  4608. 

  4609.     static uint32_t carla_lv2_ui_port_map(LV2UI_Feature_Handle handle, const char* symbol)

  4610.     {

  4611.         carla_debug("carla_lv2_ui_port_map(%p, \"%s\")", handle, symbol);

  4612.         CARLA_ASSERT(handle);

  4613. 

  4614.         if (handle == nullptr)

  4615.             return LV2UI_INVALID_PORT_INDEX;

  4616. 

  4617.         return ((Lv2Plugin*)handle)->handleUiPortMap(symbol);

  4618.     }

  4619. 

  4620.     // -------------------------------------------------------------------

  4621.     // UI Resize Feature

  4622. 

  4623.     static int carla_lv2_ui_resize(LV2UI_Feature_Handle handle, int width, int height)

  4624.     {

  4625.         carla_debug("carla_lv2_ui_resize(%p, %i, %i)", handle, width, height);

  4626.         CARLA_ASSERT(handle != nullptr);

  4627. 

  4628.         if (handle == nullptr)

  4629.             return 1;

  4630. 

  4631.         return ((Lv2Plugin*)handle)->handleUiResize(width, height);

  4632.     }

  4633. 

  4634.     // -------------------------------------------------------------------

  4635.     // External UI Feature

  4636. 

  4637.     static void carla_lv2_external_ui_closed(LV2UI_Controller controller)

  4638.     {

  4639.         carla_debug("carla_lv2_external_ui_closed(%p)", controller);

  4640.         CARLA_ASSERT(controller != nullptr);

  4641. 

  4642.         if (controller == nullptr)

  4643.             return;

  4644. 

  4645.         ((Lv2Plugin*)controller)->handleExternalUiClosed();

  4646.     }

  4647. 

  4648.     // -------------------------------------------------------------------

  4649.     // UI Extension

  4650. 

  4651.     static void carla_lv2_ui_write_function(LV2UI_Controller controller, uint32_t port_index, uint32_t buffer_size, uint32_t format, const void* buffer)

  4652.     {

  4653.         carla_debug("carla_lv2_ui_write_function(%p, %i, %i, %i, %p)", controller, port_index, buffer_size, format, buffer);

  4654.         CARLA_ASSERT(controller != nullptr);

  4655. 

  4656.         if (controller == nullptr)

  4657.             return;

  4658. 

  4659.         ((Lv2Plugin*)controller)->handleUiWrite(port_index, buffer_size, format, buffer);

  4660.     }

  4661. 

  4662.     // -------------------------------------------------------------------

  4663. 

  4664.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(Lv2Plugin)

  4665. };

  4666. 

  4667. CARLA_BACKEND_END_NAMESPACE

  4668. 

  4669. #else // WANT_VST

  4670. # warning Building without LV2 support

  4671. #endif

  4672. 

  4673. CARLA_BACKEND_START_NAMESPACE

  4674. 

  4675. CarlaPlugin* CarlaPlugin::newLV2(const Initializer& init)

  4676. {

  4677.     carla_debug("CarlaPlugin::newLV2({%p, \"%s\", \"%s\"})", init.engine, init.name, init.label);

  4678. 

  4679. #ifdef WANT_LV2

  4680.     Lv2Plugin* const plugin(new Lv2Plugin(init.engine, init.id));

  4681. 

  4682.     if (! plugin->init(init.name, init.label))

  4683.     {

  4684.         delete plugin;

  4685.         return nullptr;

  4686.     }

  4687. 

  4688.     plugin->reload();

  4689. 

  4690.     if (init.engine->getProccessMode() == PROCESS_MODE_CONTINUOUS_RACK && ! CarlaPluginProtectedData::canRunInRack(plugin))

  4691.     {

  4692.         init.engine->setLastError("Carla's rack mode can only work with Mono or Stereo LV2 plugins, sorry!");

  4693.         delete plugin;

  4694.         return nullptr;

  4695.     }

  4696. 

  4697.     return plugin;

  4698. #else

  4699.     init.engine->setLastError("LV2 support not available");

  4700.     return nullptr;

  4701. #endif

  4702. }

  4703. 

  4704. CARLA_BACKEND_END_NAMESPACE