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.
437 Commits
17 Branches
243MB
Tree: 707d5ea778
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '707d5ea778'
${ noResults }
Carla/source/backend/plugin/Lv2Plugin.cpp

4561 lines
161KB
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.             delete port;

  164. 

  165.         if (type & CARLA_EVENT_DATA_ATOM)

  166.         {

  167.             CARLA_ASSERT(atom != nullptr);

  168. 

  169.             if (atom != nullptr)

  170.                 std::free(atom);

  171.         }

  172.         else if (type & CARLA_EVENT_DATA_EVENT)

  173.         {

  174.             CARLA_ASSERT(event != nullptr);

  175. 

  176.             if (event != nullptr)

  177.                 std::free(event);

  178.         }

  179.         else if (type & CARLA_EVENT_DATA_MIDI_LL)

  180.         {

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

  182. 

  183.             if (midi != nullptr)

  184.             {

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

  186.                     delete[] midi->data;

  187.                 delete midi;

  188.             }

  189.         }

  190.     }

  191. 

  192.     CARLA_DECLARE_NON_COPY_STRUCT_WITH_LEAK_DETECTOR(Lv2EventData)

  193. };

  194. 

  195. struct Lv2PluginEventData {

  196.     uint32_t count;

  197.     Lv2EventData* data;

  198. 

  199.     Lv2PluginEventData()

  200.         : count(0),

  201.           data(nullptr) {}

  202. 

  203.     ~Lv2PluginEventData()

  204.     {

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

  206.         CARLA_ASSERT(data == nullptr);

  207.     }

  208. 

  209.     void createNew(const uint32_t newCount)

  210.     {

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

  212.         CARLA_ASSERT(data == nullptr);

  213.         CARLA_ASSERT_INT(newCount > 0, newCount);

  214. 

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

  216.             return;

  217. 

  218.         data  = new Lv2EventData[newCount];

  219.         count = newCount;

  220.     }

  221. 

  222.     void clear()

  223.     {

  224.         if (data != nullptr)

  225.         {

  226.             delete[] data;

  227.             data = nullptr;

  228.         }

  229. 

  230.         count = 0;

  231.     }

  232. 

  233.     void initBuffers(CarlaEngine* const engine)

  234.     {

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

  236.         {

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

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

  239.         }

  240.     }

  241. 

  242.     CARLA_DECLARE_NON_COPY_STRUCT_WITH_LEAK_DETECTOR(Lv2PluginEventData)

  243. };

  244. 

  245. struct Lv2PluginOptions {

  246.     int minBufferSize;

  247.     int maxBufferSize;

  248.     int sequenceSize;

  249.     double sampleRate;

  250.     LV2_Options_Option optMinBlockLenth;

  251.     LV2_Options_Option optMaxBlockLenth;

  252.     LV2_Options_Option optSequenceSize;

  253.     LV2_Options_Option optSampleRate;

  254.     LV2_Options_Option optNull;

  255.     LV2_Options_Option* opts[5];

  256. 

  257.     Lv2PluginOptions()

  258.         : minBufferSize(0),

  259.           maxBufferSize(0),

  260.           sequenceSize(MAX_EVENT_BUFFER),

  261.           sampleRate(0.0)

  262.     {

  263.         optMinBlockLenth.context = LV2_OPTIONS_INSTANCE;

  264.         optMinBlockLenth.subject = 0;

  265.         optMinBlockLenth.key     = CARLA_URI_MAP_ID_BUF_MIN_LENGTH;

  266.         optMinBlockLenth.size    = sizeof(int);

  267.         optMinBlockLenth.type    = CARLA_URI_MAP_ID_ATOM_INT;

  268.         optMinBlockLenth.value   = &minBufferSize;

  269. 

  270.         optMaxBlockLenth.context = LV2_OPTIONS_INSTANCE;

  271.         optMaxBlockLenth.subject = 0;

  272.         optMaxBlockLenth.key     = CARLA_URI_MAP_ID_BUF_MAX_LENGTH;

  273.         optMaxBlockLenth.size    = sizeof(int);

  274.         optMaxBlockLenth.type    = CARLA_URI_MAP_ID_ATOM_INT;

  275.         optMaxBlockLenth.value   = &maxBufferSize;

  276. 

  277.         optSequenceSize.context = LV2_OPTIONS_INSTANCE;

  278.         optSequenceSize.subject = 0;

  279.         optSequenceSize.key     = CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE;

  280.         optSequenceSize.size    = sizeof(int);

  281.         optSequenceSize.type    = CARLA_URI_MAP_ID_ATOM_INT;

  282.         optSequenceSize.value   = &sequenceSize;

  283. 

  284.         optSampleRate.context = LV2_OPTIONS_INSTANCE;

  285.         optSampleRate.subject = 0;

  286.         optSampleRate.key     = CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE;

  287.         optSampleRate.size    = sizeof(double);

  288.         optSampleRate.type    = CARLA_URI_MAP_ID_ATOM_DOUBLE;

  289.         optSampleRate.value   = &sampleRate;

  290. 

  291.         optNull.context = LV2_OPTIONS_INSTANCE;

  292.         optNull.subject = 0;

  293.         optNull.key     = CARLA_URI_MAP_ID_NULL;

  294.         optNull.size    = 0;

  295.         optNull.type    = CARLA_URI_MAP_ID_NULL;

  296.         optNull.value   = nullptr;

  297. 

  298.         opts[0] = &optMinBlockLenth;

  299.         opts[1] = &optMaxBlockLenth;

  300.         opts[2] = &optSequenceSize;

  301.         opts[3] = &optSampleRate;

  302.         opts[4] = &optNull;

  303.     }

  304. 

  305.     CARLA_DECLARE_NON_COPY_STRUCT_WITH_LEAK_DETECTOR(Lv2PluginOptions)

  306. };

  307. 

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

  309. {

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

  311. }

  312. 

  313. // -----------------------------------------------------

  314. 

  315. class Lv2Plugin : public CarlaPlugin,

  316.                   public CarlaPluginGui::Callback

  317. {

  318. public:

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

  320.         : CarlaPlugin(engine, id),

  321.           fHandle(nullptr),

  322.           fHandle2(nullptr),

  323.           fFeatures{nullptr},

  324.           fDescriptor(nullptr),

  325.           fRdfDescriptor(nullptr),

  326.           fAudioInBuffers(nullptr),

  327.           fAudioOutBuffers(nullptr),

  328.           fParamBuffers(nullptr)

  329.     {

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

  331. 

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

  333. 

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

  335.             fCustomURIDs.append(nullptr);

  336.     }

  337. 

  338.     ~Lv2Plugin() override

  339.     {

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

  341. 

  342.         // close UI

  343.         if (fUi.type != PLUGIN_UI_NULL)

  344.         {

  345.             showGui(false);

  346. 

  347.             if (fUi.type == PLUGIN_UI_OSC)

  348.             {

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

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

  351.                 {

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

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

  354.                 }

  355.             }

  356.             else

  357.             {

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

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

  360. 

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

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

  363. 

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

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

  366. 

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

  368.                 {

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

  370. 

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

  372.                         delete[] uiHost->plugin_human_id;

  373. 

  374.                     delete uiHost;

  375.                 }

  376. 

  377.                 fUi.descriptor = nullptr;

  378.                 kData->uiLibClose();

  379.             }

  380. 

  381.             fUi.rdfDescriptor = nullptr;

  382.         }

  383. 

  384.         kData->singleMutex.lock();

  385.         kData->masterMutex.lock();

  386. 

  387.         if (kData->active)

  388.         {

  389.             deactivate();

  390.             kData->active = false;

  391.         }

  392. 

  393.         if (fDescriptor != nullptr)

  394.         {

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

  396.             {

  397.                 if (fHandle != nullptr)

  398.                     fDescriptor->cleanup(fHandle);

  399.                 if (fHandle2 != nullptr)

  400.                     fDescriptor->cleanup(fHandle2);

  401.             }

  402. 

  403.             fHandle  = nullptr;

  404.             fHandle2 = nullptr;

  405.             fDescriptor = nullptr;

  406.         }

  407. 

  408.         if (fRdfDescriptor != nullptr)

  409.         {

  410.             delete fRdfDescriptor;

  411.             fRdfDescriptor = nullptr;

  412.         }

  413. 

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

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

  416. 

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

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

  419. 

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

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

  422. 

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

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

  425. 

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

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

  428. 

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

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

  431. 

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

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

  434. 

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

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

  437. 

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

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

  440. 

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

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

  443. 

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

  445.         {

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

  447.                 delete fFeatures[i];

  448.         }

  449. 

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

  451.         {

  452.             const char* const uri(*it);

  453. 

  454.             if (uri != nullptr)

  455.                 delete[] uri;

  456.         }

  457. 

  458.         fCustomURIDs.clear();

  459. 

  460.         clearBuffers();

  461.     }

  462. 

  463.     // -------------------------------------------------------------------

  464.     // Information (base)

  465. 

  466.     PluginType type() const override

  467.     {

  468.         return PLUGIN_LV2;

  469.     }

  470. 

  471.     PluginCategory category() override

  472.     {

  473.         CARLA_ASSERT(fRdfDescriptor != nullptr);

  474. 

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

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

  477. 

  478.         if (LV2_IS_DELAY(cat1, cat2))

  479.             return PLUGIN_CATEGORY_DELAY;

  480.         if (LV2_IS_DISTORTION(cat1, cat2))

  481.             return PLUGIN_CATEGORY_OTHER;

  482.         if (LV2_IS_DYNAMICS(cat1, cat2))

  483.             return PLUGIN_CATEGORY_DYNAMICS;

  484.         if (LV2_IS_EQ(cat1, cat2))

  485.             return PLUGIN_CATEGORY_EQ;

  486.         if (LV2_IS_FILTER(cat1, cat2))

  487.             return PLUGIN_CATEGORY_FILTER;

  488.         if (LV2_IS_GENERATOR(cat1, cat2))

  489.             return PLUGIN_CATEGORY_SYNTH;

  490.         if (LV2_IS_MODULATOR(cat1, cat2))

  491.             return PLUGIN_CATEGORY_MODULATOR;

  492.         if (LV2_IS_REVERB(cat1, cat2))

  493.             return PLUGIN_CATEGORY_DELAY;

  494.         if (LV2_IS_SIMULATOR(cat1, cat2))

  495.             return PLUGIN_CATEGORY_OTHER;

  496.         if (LV2_IS_SPATIAL(cat1, cat2))

  497.             return PLUGIN_CATEGORY_OTHER;

  498.         if (LV2_IS_SPECTRAL(cat1, cat2))

  499.             return PLUGIN_CATEGORY_UTILITY;

  500.         if (LV2_IS_UTILITY(cat1, cat2))

  501.             return PLUGIN_CATEGORY_UTILITY;

  502. 

  503.         return getPluginCategoryFromName(fName);

  504.     }

  505. 

  506.     long uniqueId() const override

  507.     {

  508.         CARLA_ASSERT(fRdfDescriptor != nullptr);

  509. 

  510.         return fRdfDescriptor->UniqueID;

  511.     }

  512. 

  513.     // -------------------------------------------------------------------

  514.     // Information (count)

  515. 

  516.     uint32_t midiInCount() const override

  517.     {

  518.         uint32_t i, count = 0;

  519. 

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

  521.         {

  522.             if (fEventsIn.data[i].type & CARLA_EVENT_TYPE_MIDI)

  523.                 count += 1;

  524.         }

  525. 

  526.         return count;

  527.     }

  528. 

  529.     uint32_t midiOutCount() const override

  530.     {

  531.         uint32_t i, count = 0;

  532. 

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

  534.         {

  535.             if (fEventsOut.data[i].type & CARLA_EVENT_TYPE_MIDI)

  536.                 count += 1;

  537.         }

  538. 

  539.         return count;

  540.     }

  541. 

  542.     uint32_t parameterScalePointCount(const uint32_t parameterId) const override

  543.     {

  544.         CARLA_ASSERT(fRdfDescriptor != nullptr);

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

  546. 

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

  548. 

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

  550.         {

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

  552.             return port.ScalePointCount;

  553.         }

  554. 

  555.         return 0;

  556.     }

  557. 

  558.     // -------------------------------------------------------------------

  559.     // Information (current data)

  560. 

  561.     // nothing

  562. 

  563.     // -------------------------------------------------------------------

  564.     // Information (per-plugin data)

  565. 

  566.     unsigned int availableOptions() override

  567.     {

  568.         unsigned int options = 0x0;

  569. 

  570.         options |= PLUGIN_OPTION_FIXED_BUFFER;

  571.         options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  572. 

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

  574.         {

  575.             if (fOptions & PLUGIN_OPTION_FORCE_STEREO)

  576.                 options |= PLUGIN_OPTION_FORCE_STEREO;

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

  578.                 options |= PLUGIN_OPTION_FORCE_STEREO;

  579.         }

  580. 

  581.         //if (fDescriptor->midiIns > 0)

  582.         {

  583.             options |= PLUGIN_OPTION_SEND_CONTROL_CHANGES;

  584.             options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  585.             options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

  586.             options |= PLUGIN_OPTION_SEND_PITCHBEND;

  587.             options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  588.         }

  589. 

  590.         return options;

  591.     }

  592. 

  593.     float getParameterValue(const uint32_t parameterId) override

  594.     {

  595.         CARLA_ASSERT(fParamBuffers != nullptr);

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

  597. 

  598.         return fParamBuffers[parameterId];

  599.     }

  600. 

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

  602.     {

  603.         CARLA_ASSERT(fRdfDescriptor != nullptr);

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

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

  606. 

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

  608. 

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

  610.         {

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

  612. 

  613.             if (scalePointId < port.ScalePointCount)

  614.             {

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

  616.                 return portScalePoint.Value;

  617.             }

  618.         }

  619. 

  620.         return 0.0f;

  621.     }

  622. 

  623.     void getLabel(char* const strBuf) override

  624.     {

  625.         CARLA_ASSERT(fRdfDescriptor != nullptr);

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

  627. 

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

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

  630.         else

  631.             CarlaPlugin::getLabel(strBuf);

  632.     }

  633. 

  634.     void getMaker(char* const strBuf) override

  635.     {

  636.         CARLA_ASSERT(fRdfDescriptor != nullptr);

  637. 

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

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

  640.         else

  641.             CarlaPlugin::getMaker(strBuf);

  642.     }

  643. 

  644.     void getCopyright(char* const strBuf) override

  645.     {

  646.         CARLA_ASSERT(fRdfDescriptor != nullptr);

  647. 

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

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

  650.         else

  651.             CarlaPlugin::getCopyright(strBuf);

  652.     }

  653. 

  654.     void getRealName(char* const strBuf) override

  655.     {

  656.         CARLA_ASSERT(fRdfDescriptor != nullptr);

  657. 

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

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

  660.         else

  661.             CarlaPlugin::getRealName(strBuf);

  662.     }

  663. 

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

  665.     {

  666.         CARLA_ASSERT(fRdfDescriptor != nullptr);

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

  668. 

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

  670. 

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

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

  673.         else

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

  675.     }

  676. 

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

  678.     {

  679.         CARLA_ASSERT(fRdfDescriptor != nullptr);

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

  681. 

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

  683. 

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

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

  686.         else

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

  688.     }

  689. 

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

  691.     {

  692.         CARLA_ASSERT(fRdfDescriptor != nullptr);

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

  694. 

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

  696. 

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

  698.         {

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

  700. 

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

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

  703. 

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

  705.             {

  706.                 switch (port.Unit.Unit)

  707.                 {

  708.                 case LV2_PORT_UNIT_BAR:

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

  710.                     return;

  711.                 case LV2_PORT_UNIT_BEAT:

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

  713.                     return;

  714.                 case LV2_PORT_UNIT_BPM:

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

  716.                     return;

  717.                 case LV2_PORT_UNIT_CENT:

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

  719.                     return;

  720.                 case LV2_PORT_UNIT_CM:

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

  722.                     return;

  723.                 case LV2_PORT_UNIT_COEF:

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

  725.                     return;

  726.                 case LV2_PORT_UNIT_DB:

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

  728.                     return;

  729.                 case LV2_PORT_UNIT_DEGREE:

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

  731.                     return;

  732.                 case LV2_PORT_UNIT_FRAME:

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

  734.                     return;

  735.                 case LV2_PORT_UNIT_HZ:

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

  737.                     return;

  738.                 case LV2_PORT_UNIT_INCH:

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

  740.                     return;

  741.                 case LV2_PORT_UNIT_KHZ:

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

  743.                     return;

  744.                 case LV2_PORT_UNIT_KM:

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

  746.                     return;

  747.                 case LV2_PORT_UNIT_M:

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

  749.                     return;

  750.                 case LV2_PORT_UNIT_MHZ:

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

  752.                     return;

  753.                 case LV2_PORT_UNIT_MIDINOTE:

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

  755.                     return;

  756.                 case LV2_PORT_UNIT_MILE:

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

  758.                     return;

  759.                 case LV2_PORT_UNIT_MIN:

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

  761.                     return;

  762.                 case LV2_PORT_UNIT_MM:

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

  764.                     return;

  765.                 case LV2_PORT_UNIT_MS:

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

  767.                     return;

  768.                 case LV2_PORT_UNIT_OCT:

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

  770.                     return;

  771.                 case LV2_PORT_UNIT_PC:

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

  773.                     return;

  774.                 case LV2_PORT_UNIT_S:

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

  776.                     return;

  777.                 case LV2_PORT_UNIT_SEMITONE:

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

  779.                     return;

  780.                 }

  781.             }

  782.         }

  783. 

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

  785.     }

  786. 

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

  788.     {

  789.         CARLA_ASSERT(fRdfDescriptor != nullptr);

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

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

  792. 

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

  794. 

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

  796.         {

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

  798. 

  799.             if (scalePointId < port.ScalePointCount)

  800.             {

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

  802. 

  803.                 if (portScalePoint.Label != nullptr)

  804.                 {

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

  806.                     return;

  807.                 }

  808.             }

  809.         }

  810. 

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

  812.     }

  813. 

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

  815.     // Set data (state)

  816. 

  817.     void prepareForSave() override

  818.     {

  819.         CARLA_ASSERT(fHandle != nullptr);

  820. 

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

  822.         {

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

  824. 

  825.             if (fHandle2 != nullptr)

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

  827.         }

  828.     }

  829. 

  830.     // -------------------------------------------------------------------

  831.     // Set data (internal stuff)

  832. 

  833.     // nothing

  834. 

  835.     // -------------------------------------------------------------------

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

  837. 

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

  839.     {

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

  841. 

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

  843.         fParamBuffers[parameterId] = fixedValue;

  844. 

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

  846.     }

  847. 

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

  849.     {

  850.         CARLA_ASSERT(fDescriptor != nullptr);

  851.         CARLA_ASSERT(fHandle != nullptr);

  852.         CARLA_ASSERT(type != nullptr);

  853.         CARLA_ASSERT(key != nullptr);

  854.         CARLA_ASSERT(value != nullptr);

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

  856. 

  857.         if (type == nullptr)

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

  859. 

  860.         if (key == nullptr)

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

  862. 

  863.         if (value == nullptr)

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

  865. 

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

  867. 

  868.         if (fExt.state != nullptr)

  869.         {

  870.             LV2_State_Status status;

  871. 

  872.             {

  873.                 const ScopedSingleProcessLocker spl(this, true);

  874. 

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

  876. 

  877.                 if (fHandle2 != nullptr)

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

  879.             }

  880. 

  881.             switch (status)

  882.             {

  883.             case LV2_STATE_SUCCESS:

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

  885.                 break;

  886.             case LV2_STATE_ERR_UNKNOWN:

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

  888.                 break;

  889.             case LV2_STATE_ERR_BAD_TYPE:

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

  891.                 break;

  892.             case LV2_STATE_ERR_BAD_FLAGS:

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

  894.                 break;

  895.             case LV2_STATE_ERR_NO_FEATURE:

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

  897.                 break;

  898.             case LV2_STATE_ERR_NO_PROPERTY:

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

  900.                 break;

  901.             }

  902.         }

  903. 

  904.         if (sendGui)

  905.         {

  906.             //CustomData cdata;

  907.             //cdata.type  = type;

  908.             //cdata.key   = key;

  909.             //cdata.value = value;

  910.             //uiTransferCustomData(&cdata);

  911.         }

  912.     }

  913. 

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

  915.     {

  916.         CARLA_ASSERT(fDescriptor != nullptr);

  917.         CARLA_ASSERT(fHandle != nullptr);

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

  919. 

  920.         if (index < -1)

  921.             index = -1;

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

  923.             return;

  924. 

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

  926.         {

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

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

  929. 

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

  931. 

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

  933. 

  934.             if (fHandle2 != nullptr)

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

  936.         }

  937. 

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

  939.     }

  940. 

  941.     // -------------------------------------------------------------------

  942.     // Set gui stuff

  943. 

  944.     void showGui(const bool yesNo) override

  945.     {

  946.         if (fUi.type == PLUGIN_UI_NULL)

  947.             return;

  948. 

  949.         if (fUi.type == PLUGIN_UI_OSC)

  950.         {

  951.             if (yesNo)

  952.             {

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

  954.             }

  955.             else

  956.             {

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

  958.                 {

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

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

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

  962.                 }

  963. 

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

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

  966.             }

  967. 

  968.             return;

  969.         }

  970. 

  971.         // take some precautions

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

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

  974. 

  975.         if (fUi.descriptor == nullptr)

  976.             return;

  977.         if (fUi.rdfDescriptor == nullptr)

  978.             return;

  979. 

  980.         if (yesNo)

  981.         {

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

  983. 

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

  985.                 return;

  986.         }

  987.         else

  988.         {

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

  990. 

  991.             if (fUi.handle == nullptr)

  992.                 return;

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

  994.                 return;

  995.         }

  996. 

  997.         if (fUi.type == PLUGIN_UI_EXTERNAL)

  998.         {

  999.             if (yesNo)

  1000.             {

  1001.                 fUi.widget = nullptr;

  1002. 

  1003.                 if (fUi.handle == nullptr)

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

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

  1006. 

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

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

  1009. 

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

  1011.                 {

  1012.                     fUi.handle = nullptr;

  1013.                     fUi.widget = nullptr;

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

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

  1016.                     return;

  1017.                 }

  1018. 

  1019.                 updateUi();

  1020. 

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

  1022.             }

  1023.             else

  1024.             {

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

  1026. 

  1027.                 if (fUi.widget != nullptr)

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

  1029. 

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

  1031.                 fUi.handle = nullptr;

  1032.                 fUi.widget = nullptr;

  1033.             }

  1034.         }

  1035.         else // means PLUGIN_UI_PARENT || PLUGIN_UI_QT

  1036.         {

  1037.             if (yesNo)

  1038.             {

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

  1040.                 {

  1041.                     // TODO

  1042.                     CarlaPluginGui::Options guiOptions;

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

  1044.                     guiOptions.resizable = isUiResizable();

  1045. 

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

  1047.                 }

  1048. 

  1049.                 if (fUi.type == PLUGIN_UI_PARENT)

  1050.                 {

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

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

  1053.                 }

  1054. 

  1055.                 fUi.widget = nullptr;

  1056. 

  1057.                 if (fUi.handle == nullptr)

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

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

  1060. 

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

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

  1063. 

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

  1065.                 {

  1066.                     fUi.handle = nullptr;

  1067.                     fUi.widget = nullptr;

  1068. 

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

  1070.                     delete kData->gui;

  1071.                     kData->gui = nullptr;

  1072. 

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

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

  1075.                     return;

  1076.                 }

  1077. 

  1078.                 if (fUi.type == PLUGIN_UI_QT)

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

  1080. 

  1081.                 updateUi();

  1082. 

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

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

  1085.             }

  1086.             else

  1087.             {

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

  1089.                 fUi.handle = nullptr;

  1090.                 fUi.widget = nullptr;

  1091. 

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

  1093.                 {

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

  1095.                     delete kData->gui;

  1096.                     kData->gui = nullptr;

  1097.                 }

  1098.             }

  1099.         }

  1100.     }

  1101. 

  1102.     void idleGui() override

  1103.     {

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

  1105.         {

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

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

  1108. 

  1109.             if (fExt.uiidle != nullptr)

  1110.             {

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

  1112.                 {

  1113.                     showGui(false);

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

  1115.                 }

  1116.             }

  1117.         }

  1118. 

  1119.         CarlaPlugin::idleGui();

  1120.     }

  1121. 

  1122.     // -------------------------------------------------------------------

  1123.     // Plugin state

  1124. 

  1125.     void reload() override

  1126.     {

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

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

  1129.         CARLA_ASSERT(fHandle != nullptr);

  1130.         CARLA_ASSERT(fDescriptor != nullptr);

  1131.         CARLA_ASSERT(fRdfDescriptor != nullptr);

  1132. 

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

  1134.             return;

  1135.         if (fHandle == nullptr)

  1136.             return;

  1137.         if (fDescriptor == nullptr)

  1138.             return;

  1139.         if (fRdfDescriptor == nullptr)

  1140.             return;

  1141. 

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

  1143. 

  1144.         // Safely disable plugin for reload

  1145.         const ScopedDisabler sd(this);

  1146. 

  1147.         if (kData->active)

  1148.             deactivate();

  1149. 

  1150.         clearBuffers();

  1151. 

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

  1153.         const uint32_t portCount = fRdfDescriptor->PortCount;

  1154. 

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

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

  1157.         NonRtList<uint32_t> evIns, evOuts;

  1158. 

  1159.         bool forcedStereoIn, forcedStereoOut;

  1160.         forcedStereoIn = forcedStereoOut = false;

  1161. 

  1162.         bool needsCtrlIn, needsCtrlOut;

  1163.         needsCtrlIn = needsCtrlOut = false;

  1164. 

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

  1166.         {

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

  1168. 

  1169.             if (LV2_IS_PORT_AUDIO(portTypes))

  1170.             {

  1171.                 if (LV2_IS_PORT_INPUT(portTypes))

  1172.                     aIns += 1;

  1173.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  1174.                     aOuts += 1;

  1175.             }

  1176.             else if (LV2_IS_PORT_CV(portTypes))

  1177.             {

  1178.                 if (LV2_IS_PORT_INPUT(portTypes))

  1179.                     cvIns += 1;

  1180.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  1181.                     cvOuts += 1;

  1182.             }

  1183.             else if (LV2_IS_PORT_ATOM_SEQUENCE(portTypes))

  1184.             {

  1185.                 if (LV2_IS_PORT_INPUT(portTypes))

  1186.                     evIns.append(CARLA_EVENT_DATA_ATOM);

  1187.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  1188.                     evOuts.append(CARLA_EVENT_DATA_ATOM);

  1189.             }

  1190.             else if (LV2_IS_PORT_EVENT(portTypes))

  1191.             {

  1192.                 if (LV2_IS_PORT_INPUT(portTypes))

  1193.                     evIns.append(CARLA_EVENT_DATA_EVENT);

  1194.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  1195.                     evOuts.append(CARLA_EVENT_DATA_EVENT);

  1196.             }

  1197.             else if (LV2_IS_PORT_MIDI_LL(portTypes))

  1198.             {

  1199.                 if (LV2_IS_PORT_INPUT(portTypes))

  1200.                     evIns.append(CARLA_EVENT_DATA_MIDI_LL);

  1201.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  1202.                     evOuts.append(CARLA_EVENT_DATA_MIDI_LL);

  1203.             }

  1204.             else if (LV2_IS_PORT_CONTROL(portTypes))

  1205.                 params += 1;

  1206.         }

  1207. 

  1208.         // check extensions

  1209.         fExt.options  = nullptr;

  1210.         fExt.programs = nullptr;

  1211.         fExt.state    = nullptr;

  1212.         fExt.worker   = nullptr;

  1213. 

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

  1215.         {

  1216.             if (kData->extraHints & PLUGIN_HAS_EXTENSION_OPTIONS)

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

  1218. 

  1219.             if (kData->extraHints & PLUGIN_HAS_EXTENSION_PROGRAMS)

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

  1221. 

  1222.             if (kData->extraHints & PLUGIN_HAS_EXTENSION_STATE)

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

  1224. 

  1225.             if (kData->extraHints & PLUGIN_HAS_EXTENSION_WORKER)

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

  1227.         }

  1228. 

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

  1230.         {

  1231.             if (fHandle2 == nullptr)

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

  1233. 

  1234.             if (aIns == 1)

  1235.             {

  1236.                 aIns = 2;

  1237.                 forcedStereoIn = true;

  1238.             }

  1239. 

  1240.             if (aOuts == 1)

  1241.             {

  1242.                 aOuts = 2;

  1243.                 forcedStereoOut = true;

  1244.             }

  1245.         }

  1246. 

  1247.         if (aIns > 0)

  1248.         {

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

  1250.             fAudioInBuffers = new float*[aIns];

  1251. 

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

  1253.                 fAudioInBuffers[i] = nullptr;

  1254.         }

  1255. 

  1256.         if (aOuts > 0)

  1257.         {

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

  1259.             fAudioOutBuffers = new float*[aOuts];

  1260.             needsCtrlIn = true;

  1261. 

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

  1263.                 fAudioOutBuffers[i] = nullptr;

  1264.         }

  1265. 

  1266.         if (params > 0)

  1267.         {

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

  1269.             fParamBuffers = new float[params];

  1270. 

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

  1272.                 fParamBuffers[i] = 0.0f;

  1273.         }

  1274. 

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

  1276.         {

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

  1278. 

  1279.             fEventsIn.createNew(count);

  1280. 

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

  1282.             {

  1283.                 uint32_t& type(evIns.getAt(j));

  1284. 

  1285.                 if (type == CARLA_EVENT_DATA_ATOM)

  1286.                 {

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

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

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

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

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

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

  1293.                 }

  1294.                 else if (type == CARLA_EVENT_DATA_EVENT)

  1295.                 {

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

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

  1298.                 }

  1299.                 else if (type == CARLA_EVENT_DATA_MIDI_LL)

  1300.                 {

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

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

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

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

  1305.                 }

  1306.             }

  1307.         }

  1308. 

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

  1310.         {

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

  1312. 

  1313.             fEventsOut.createNew(count);

  1314. 

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

  1316.             {

  1317.                 uint32_t& type(evOuts.getAt(j));

  1318. 

  1319.                 if (type == CARLA_EVENT_DATA_ATOM)

  1320.                 {

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

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

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

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

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

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

  1327.                 }

  1328.                 else if (type == CARLA_EVENT_DATA_EVENT)

  1329.                 {

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

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

  1332.                 }

  1333.                 else if (type == CARLA_EVENT_DATA_MIDI_LL)

  1334.                 {

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

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

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

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

  1339.                 }

  1340.             }

  1341.         }

  1342. 

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

  1344.         CarlaString portName;

  1345. 

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

  1347.         {

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

  1349. 

  1350.             portName.clear();

  1351. 

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

  1353.             {

  1354.                 if (processMode == PROCESS_MODE_SINGLE_CLIENT)

  1355.                 {

  1356.                     portName  = fName;

  1357.                     portName += ":";

  1358.                 }

  1359. 

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

  1361.                 portName.truncate(portNameSize);

  1362.             }

  1363. 

  1364.             if (LV2_IS_PORT_AUDIO(portTypes))

  1365.             {

  1366.                 if (LV2_IS_PORT_INPUT(portTypes))

  1367.                 {

  1368.                     j = iAudioIn++;

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

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

  1371. 

  1372.                     if (forcedStereoIn)

  1373.                     {

  1374.                         portName += "_2";

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

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

  1377.                     }

  1378.                 }

  1379.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  1380.                 {

  1381.                     j = iAudioOut++;

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

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

  1384. 

  1385.                     if (forcedStereoOut)

  1386.                     {

  1387.                         portName += "_2";

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

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

  1390.                     }

  1391.                 }

  1392.                 else

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

  1394.             }

  1395.             else if (LV2_IS_PORT_CV(portTypes))

  1396.             {

  1397.                 if (LV2_IS_PORT_INPUT(portTypes))

  1398.                 {

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

  1400.                 }

  1401.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  1402.                 {

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

  1404.                 }

  1405.                 else

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

  1407. 

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

  1409. 

  1410.                 if (fHandle2 != nullptr)

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

  1412.             }

  1413.             else if (LV2_IS_PORT_ATOM_SEQUENCE(portTypes))

  1414.             {

  1415.                 if (LV2_IS_PORT_INPUT(portTypes))

  1416.                 {

  1417.                     j = iEvIn++;

  1418. 

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

  1420. 

  1421.                     if (fHandle2 != nullptr)

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

  1423. 

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

  1425. 

  1426.                     if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

  1427.                     {

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

  1429. 

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

  1431.                             needsCtrlIn = true;

  1432.                         else

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

  1434.                     }

  1435.                     if (portTypes & LV2_PORT_DATA_PATCH_MESSAGE)

  1436.                     {

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

  1438.                     }

  1439.                     if (portTypes & LV2_PORT_DATA_TIME_POSITION)

  1440.                     {

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

  1442.                     }

  1443.                 }

  1444.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  1445.                 {

  1446.                     j = iEvOut++;

  1447. 

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

  1449. 

  1450.                     if (fHandle2 != nullptr)

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

  1452. 

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

  1454. 

  1455.                     if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

  1456.                     {

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

  1458. 

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

  1460.                             needsCtrlOut = true;

  1461.                         else

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

  1463.                     }

  1464.                     if (portTypes & LV2_PORT_DATA_PATCH_MESSAGE)

  1465.                     {

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

  1467.                     }

  1468.                     if (portTypes & LV2_PORT_DATA_TIME_POSITION)

  1469.                     {

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

  1471.                     }

  1472.                 }

  1473.                 else

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

  1475.             }

  1476.             else if (LV2_IS_PORT_EVENT(portTypes))

  1477.             {

  1478.                 if (LV2_IS_PORT_INPUT(portTypes))

  1479.                 {

  1480.                     j = iEvIn++;

  1481. 

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

  1483. 

  1484.                     if (fHandle2 != nullptr)

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

  1486. 

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

  1488. 

  1489.                     if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

  1490.                     {

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

  1492. 

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

  1494.                             needsCtrlIn = true;

  1495.                         else

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

  1497.                     }

  1498.                     if (portTypes & LV2_PORT_DATA_PATCH_MESSAGE)

  1499.                     {

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

  1501.                     }

  1502.                     if (portTypes & LV2_PORT_DATA_TIME_POSITION)

  1503.                     {

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

  1505.                     }

  1506.                 }

  1507.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  1508.                 {

  1509.                     j = iEvOut++;

  1510. 

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

  1512. 

  1513.                     if (fHandle2 != nullptr)

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

  1515. 

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

  1517. 

  1518.                     if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

  1519.                     {

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

  1521. 

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

  1523.                             needsCtrlOut = true;

  1524.                         else

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

  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 (Event, but not input or output)");

  1538.             }

  1539.             else if (LV2_IS_PORT_MIDI_LL(portTypes))

  1540.             {

  1541.                 if (LV2_IS_PORT_INPUT(portTypes))

  1542.                 {

  1543.                     j = iEvIn++;

  1544. 

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

  1546. 

  1547.                     if (fHandle2 != nullptr)

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

  1549. 

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

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

  1552. 

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

  1554.                         needsCtrlIn = true;

  1555.                     else

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

  1557.                 }

  1558.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  1559.                 {

  1560.                     j = iEvOut++;

  1561. 

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

  1563. 

  1564.                     if (fHandle2 != nullptr)

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

  1566. 

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

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

  1569. 

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

  1571.                         needsCtrlOut = true;

  1572.                     else

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

  1574.                 }

  1575.                 else

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

  1577.             }

  1578.             else if (LV2_IS_PORT_CONTROL(portTypes))

  1579.             {

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

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

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

  1583. 

  1584.                 j = iCtrl++;

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

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

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

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

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

  1590. 

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

  1592. 

  1593.                 // min value

  1594.                 if (LV2_HAVE_MINIMUM_PORT_POINT(portPoints.Hints))

  1595.                     min = portPoints.Minimum;

  1596.                 else

  1597.                     min = 0.0f;

  1598. 

  1599.                 // max value

  1600.                 if (LV2_HAVE_MAXIMUM_PORT_POINT(portPoints.Hints))

  1601.                     max = portPoints.Maximum;

  1602.                 else

  1603.                     max = 1.0f;

  1604. 

  1605.                 if (min > max)

  1606.                     max = min;

  1607.                 else if (max < min)

  1608.                     min = max;

  1609. 

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

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

  1612.                 {

  1613.                     min = 0.0f;

  1614.                     max = (float)0xffffff;

  1615.                 }

  1616. 

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

  1618.                 {

  1619.                     carla_stderr("Broken plugin parameter: max - min == 0");

  1620.                     max = min + 0.1f;

  1621.                 }

  1622. 

  1623.                 // default value

  1624.                 if (LV2_HAVE_DEFAULT_PORT_POINT(portPoints.Hints))

  1625.                 {

  1626.                     def = portPoints.Default;

  1627.                 }

  1628.                 else

  1629.                 {

  1630.                     // no default value

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

  1632.                         def = 0.0f;

  1633.                     else

  1634.                         def = min;

  1635.                 }

  1636. 

  1637.                 if (def < min)

  1638.                     def = min;

  1639.                 else if (def > max)

  1640.                     def = max;

  1641. 

  1642.                 if (LV2_IS_PORT_SAMPLE_RATE(portProps))

  1643.                 {

  1644.                     min *= sampleRate;

  1645.                     max *= sampleRate;

  1646.                     def *= sampleRate;

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

  1648.                 }

  1649. 

  1650.                 if (LV2_IS_PORT_TOGGLED(portProps))

  1651.                 {

  1652.                     step = max - min;

  1653.                     stepSmall = step;

  1654.                     stepLarge = step;

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

  1656.                 }

  1657.                 else if (LV2_IS_PORT_INTEGER(portProps))

  1658.                 {

  1659.                     step = 1.0f;

  1660.                     stepSmall = 1.0f;

  1661.                     stepLarge = 10.0f;

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

  1663.                 }

  1664.                 else

  1665.                 {

  1666.                     float range = max - min;

  1667.                     step = range/100.0f;

  1668.                     stepSmall = range/1000.0f;

  1669.                     stepLarge = range/10.0f;

  1670.                 }

  1671. 

  1672.                 if (LV2_IS_PORT_INPUT(portTypes))

  1673.                 {

  1674.                     if (LV2_IS_PORT_DESIGNATION_LATENCY(portDesignation))

  1675.                     {

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

  1677.                     }

  1678.                     else if (LV2_IS_PORT_DESIGNATION_SAMPLE_RATE(portDesignation))

  1679.                     {

  1680.                         def = sampleRate;

  1681.                         step = 1.0f;

  1682.                         stepSmall = 1.0f;

  1683.                         stepLarge = 1.0f;

  1684. 

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

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

  1687.                     }

  1688.                     else if (LV2_IS_PORT_DESIGNATION_FREEWHEELING(portDesignation))

  1689.                     {

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

  1691.                     }

  1692.                     else if (LV2_IS_PORT_DESIGNATION_TIME(portDesignation))

  1693.                     {

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

  1695.                     }

  1696.                     else

  1697.                     {

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

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

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

  1701.                         needsCtrlIn = true;

  1702.                     }

  1703. 

  1704.                     // MIDI CC value

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

  1706.                     if (LV2_IS_PORT_MIDI_MAP_CC(portMidiMap.Type))

  1707.                     {

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

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

  1710.                     }

  1711.                 }

  1712.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  1713.                 {

  1714.                     if (LV2_IS_PORT_DESIGNATION_LATENCY(portDesignation))

  1715.                     {

  1716.                         min = 0.0f;

  1717.                         max = sampleRate;

  1718.                         def = 0.0f;

  1719.                         step = 1.0f;

  1720.                         stepSmall = 1.0f;

  1721.                         stepLarge = 1.0f;

  1722. 

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

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

  1725.                     }

  1726.                     else if (LV2_IS_PORT_DESIGNATION_SAMPLE_RATE(portDesignation))

  1727.                     {

  1728.                         def = sampleRate;

  1729.                         step = 1.0f;

  1730.                         stepSmall = 1.0f;

  1731.                         stepLarge = 1.0f;

  1732. 

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

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

  1735.                     }

  1736.                     else if (LV2_IS_PORT_DESIGNATION_FREEWHEELING(portDesignation))

  1737.                     {

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

  1739.                     }

  1740.                     else if (LV2_IS_PORT_DESIGNATION_TIME(portDesignation))

  1741.                     {

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

  1743.                     }

  1744.                     else

  1745.                     {

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

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

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

  1749.                         needsCtrlOut = true;

  1750.                     }

  1751.                 }

  1752.                 else

  1753.                 {

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

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

  1756.                 }

  1757. 

  1758.                 // extra parameter hints

  1759.                 if (LV2_IS_PORT_ENUMERATION(portProps))

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

  1761. 

  1762.                 if (LV2_IS_PORT_LOGARITHMIC(portProps))

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

  1764. 

  1765.                 if (LV2_IS_PORT_TRIGGER(portProps))

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

  1767. 

  1768.                 if (LV2_IS_PORT_STRICT_BOUNDS(portProps))

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

  1770. 

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

  1772.                 if (LV2_IS_PORT_NOT_ON_GUI(portProps))

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

  1774. 

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

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

  1777. 

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

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

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

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

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

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

  1784. 

  1785.                 // Start parameters in their default values

  1786.                 fParamBuffers[j] = def;

  1787. 

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

  1789. 

  1790.                 if (fHandle2 != nullptr)

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

  1792.             }

  1793.             else

  1794.             {

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

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

  1797. 

  1798.                 if (fHandle2 != nullptr)

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

  1800.             }

  1801.         }

  1802. 

  1803.         if (needsCtrlIn)

  1804.         {

  1805.             portName.clear();

  1806. 

  1807.             if (processMode == PROCESS_MODE_SINGLE_CLIENT)

  1808.             {

  1809.                 portName  = fName;

  1810.                 portName += ":";

  1811.             }

  1812. 

  1813.             portName += "events-in";

  1814.             portName.truncate(portNameSize);

  1815. 

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

  1817.         }

  1818. 

  1819.         if (needsCtrlOut)

  1820.         {

  1821.             portName.clear();

  1822. 

  1823.             if (processMode == PROCESS_MODE_SINGLE_CLIENT)

  1824.             {

  1825.                 portName  = fName;

  1826.                 portName += ":";

  1827.             }

  1828. 

  1829.             portName += "events-out";

  1830.             portName.truncate(portNameSize);

  1831. 

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

  1833.         }

  1834. 

  1835.         if (forcedStereoIn || forcedStereoOut)

  1836.             fOptions |= PLUGIN_OPTION_FORCE_STEREO;

  1837.         else

  1838.             fOptions &= ~PLUGIN_OPTION_FORCE_STEREO;

  1839. 

  1840.         // plugin hints

  1841.         fHints = 0x0;

  1842. 

  1843.         if (fUi.type != PLUGIN_UI_NULL)

  1844.         {

  1845.             fHints |= PLUGIN_HAS_GUI;

  1846. 

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

  1848.                 fHints |= PLUGIN_HAS_SINGLE_THREAD;

  1849.         }

  1850. 

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

  1852.             fHints |= PLUGIN_IS_SYNTH;

  1853. 

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

  1855.             fHints |= PLUGIN_CAN_DRYWET;

  1856. 

  1857.         if (aOuts > 0)

  1858.             fHints |= PLUGIN_CAN_VOLUME;

  1859. 

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

  1861.             fHints |= PLUGIN_CAN_BALANCE;

  1862. 

  1863.         // extra plugin hints

  1864.         kData->extraHints &= ~PLUGIN_HINT_CAN_RUN_RACK;

  1865. 

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

  1867.         {

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

  1869.                 kData->extraHints |= PLUGIN_HINT_CAN_RUN_RACK;

  1870.         }

  1871.         else

  1872.         {

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

  1874.                 kData->extraHints |= PLUGIN_HINT_CAN_RUN_RACK;

  1875.         }

  1876. 

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

  1878.         reloadPrograms(true);

  1879. 

  1880.         if (kData->active)

  1881.             activate();

  1882. 

  1883.         evIns.clear();

  1884.         evOuts.clear();

  1885. 

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

  1887.     }

  1888. 

  1889.     void reloadPrograms(const bool init) override

  1890.     {

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

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

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

  1894. 

  1895.         // Delete old programs

  1896.         kData->midiprog.clear();

  1897. 

  1898.         // Query new programs

  1899.         uint32_t count = 0;

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

  1901.         {

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

  1903.                 count++;

  1904.         }

  1905. 

  1906.         if (count > 0)

  1907.         {

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

  1909. 

  1910.             // Update data

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

  1912.             {

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

  1914.                 CARLA_ASSERT(pdesc != nullptr);

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

  1916. 

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

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

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

  1920.             }

  1921.         }

  1922. 

  1923. #ifndef BUILD_BRIDGE

  1924.         // Update OSC Names

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

  1926.         {

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

  1928. 

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

  1930.                 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);

  1931.         }

  1932. #endif

  1933. 

  1934.         if (init)

  1935.         {

  1936.             if (count > 0)

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

  1938.         }

  1939.         else

  1940.         {

  1941.             // Check if current program is invalid

  1942.             bool programChanged = false;

  1943. 

  1944.             if (count == oldCount+1)

  1945.             {

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

  1947.                 kData->midiprog.current = oldCount;

  1948.                 programChanged = true;

  1949.             }

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

  1951.             {

  1952.                 // programs exist now, but not before

  1953.                 kData->midiprog.current = 0;

  1954.                 programChanged = true;

  1955.             }

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

  1957.             {

  1958.                 // programs existed before, but not anymore

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

  1960.                 programChanged = true;

  1961.             }

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

  1963.             {

  1964.                 // current midi program > count

  1965.                 kData->midiprog.current = 0;

  1966.                 programChanged = true;

  1967.             }

  1968.             else

  1969.             {

  1970.                 // no change

  1971.                 kData->midiprog.current = current;

  1972.             }

  1973. 

  1974.             if (programChanged)

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

  1976. 

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

  1978.         }

  1979.     }

  1980. 

  1981.     // -------------------------------------------------------------------

  1982.     // Plugin processing

  1983. 

  1984.     void activate() override

  1985.     {

  1986.         CARLA_ASSERT(fDescriptor != nullptr);

  1987.         CARLA_ASSERT(fHandle != nullptr);

  1988. 

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

  1990.         {

  1991.             fDescriptor->activate(fHandle);

  1992. 

  1993.             if (fHandle2 != nullptr)

  1994.                 fDescriptor->activate(fHandle2);

  1995.         }

  1996.     }

  1997. 

  1998.     void deactivate() override

  1999.     {

  2000.         CARLA_ASSERT(fDescriptor != nullptr);

  2001.         CARLA_ASSERT(fHandle != nullptr);

  2002. 

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

  2004.         {

  2005.             fDescriptor->deactivate(fHandle);

  2006. 

  2007.             if (fHandle2 != nullptr)

  2008.                 fDescriptor->deactivate(fHandle2);

  2009.         }

  2010.     }

  2011. 

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

  2013.     {

  2014.         uint32_t i, k;

  2015. 

  2016.         // --------------------------------------------------------------------------------------------------------

  2017.         // Check if active

  2018. 

  2019.         if (! kData->active)

  2020.         {

  2021.             // disable any output sound

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

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

  2024. 

  2025.             return;

  2026.         }

  2027. 

  2028.         uint32_t midiEventCount = 0;

  2029. 

  2030.         // handle events from different APIs

  2031.         uint32_t           evInAtomOffsets[fEventsIn.count];

  2032.         LV2_Event_Iterator evInEventIters[fEventsIn.count];

  2033.         LV2_MIDIState      evInMidiStates[fEventsIn.count];

  2034. 

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

  2036.         {

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

  2038.             {

  2039.                 evInAtomOffsets[i] = 0;

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

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

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

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

  2044.             }

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

  2046.             {

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

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

  2049.             }

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

  2051.             {

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

  2053.                 evInMidiStates[i].frame_count = frames;

  2054.                 evInMidiStates[i].position = 0;

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

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

  2057.             }

  2058.         }

  2059. 

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

  2061.         {

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

  2063.             {

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

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

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

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

  2068.             }

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

  2070.             {

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

  2072.             }

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

  2074.             {

  2075.                 // not needed

  2076.             }

  2077.         }

  2078. 

  2079.         CARLA_PROCESS_CONTINUE_CHECK;

  2080. 

  2081.         // --------------------------------------------------------------------------------------------------------

  2082.         // Check if needs reset

  2083. 

  2084.         if (kData->needsReset)

  2085.         {

  2086.             // TODO!

  2087.             if (fOptions & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  2088.             {

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

  2090.                 {

  2091.                 }

  2092. 

  2093.                 midiEventCount = MAX_MIDI_CHANNELS*2;

  2094.             }

  2095.             else

  2096.             {

  2097.             }

  2098. 

  2099.             if (kData->latency > 0)

  2100.             {

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

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

  2103.             }

  2104. 

  2105.             kData->needsReset = false;

  2106.         }

  2107. 

  2108.         CARLA_PROCESS_CONTINUE_CHECK;

  2109. 

  2110.         // --------------------------------------------------------------------------------------------------------

  2111.         // Special Parameters

  2112. 

  2113.         {

  2114.             int32_t rindex;

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

  2116. 

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

  2118.             {

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

  2120.                 {

  2121.                 }

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

  2123.                 {

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

  2125.                 }

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

  2127.                 {

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

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

  2130. 

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

  2132.                     {

  2133.                     // Non-BBT

  2134.                     case LV2_PORT_DESIGNATION_TIME_FRAME:

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

  2136.                         break;

  2137.                     case LV2_PORT_DESIGNATION_TIME_FRAMES_PER_SECOND:

  2138.                         break;

  2139.                     //case LV2_PORT_DESIGNATION_TIME_POSITION:

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

  2141.                     //    break;

  2142.                     case LV2_PORT_DESIGNATION_TIME_SPEED:

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

  2144.                         break;

  2145.                     // BBT

  2146.                     case LV2_PORT_DESIGNATION_TIME_BAR:

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

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

  2149.                         break;

  2150.                     case LV2_PORT_DESIGNATION_TIME_BAR_BEAT:

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

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

  2153.                         break;

  2154.                     case LV2_PORT_DESIGNATION_TIME_BEAT:

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

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

  2157.                         break;

  2158.                     case LV2_PORT_DESIGNATION_TIME_BEAT_UNIT:

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

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

  2161.                         break;

  2162.                     case LV2_PORT_DESIGNATION_TIME_BEATS_PER_BAR:

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

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

  2165.                         break;

  2166.                     case LV2_PORT_DESIGNATION_TIME_BEATS_PER_MINUTE:

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

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

  2169.                         break;

  2170.                     }

  2171.                 }

  2172.             }

  2173.         }

  2174. 

  2175.         // --------------------------------------------------------------------------------------------------------

  2176.         // Event Input and Processing

  2177. 

  2178.         if (kData->event.portIn != nullptr)

  2179.         {

  2180.             // ----------------------------------------------------------------------------------------------------

  2181.             // MIDI Input (External)

  2182. 

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

  2184.             {

  2185.                 while (midiEventCount < MAX_MIDI_EVENTS && ! kData->extNotes.data.isEmpty())

  2186.                 {

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

  2188. 

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

  2190. 

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

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

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

  2194.                     midiEvent[1]  = note.note;

  2195.                     midiEvent[2]  = note.velo;

  2196. 

  2197.                     // send to first midi input

  2198.                     for (k=0; k < fEventsIn.count; ++k)

  2199.                     {

  2200.                         if (fEventsIn.data[k].type & CARLA_EVENT_TYPE_MIDI)

  2201.                         {

  2202.                             if (fEventsIn.data[k].type & CARLA_EVENT_DATA_ATOM)

  2203.                             {

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

  2205. 

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

  2207.                                     continue;

  2208. 

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

  2210.                                 aev->time.frames = 0;

  2211.                                 aev->body.type   = CARLA_URI_MAP_ID_MIDI_EVENT;

  2212.                                 aev->body.size   = 3;

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

  2214. 

  2215.                                 evInAtomOffsets[k] += evInPadSize;

  2216.                                 fEventsIn.data[k].atom->atom.size = evInAtomOffsets[k];

  2217.                             }

  2218.                             else if (fEventsIn.data[k].type & CARLA_EVENT_DATA_EVENT)

  2219.                             {

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

  2221.                             }

  2222.                             else if (fEventsIn.data[k].type & CARLA_EVENT_DATA_MIDI_LL)

  2223.                             {

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

  2225.                             }

  2226. 

  2227.                             break;

  2228.                         }

  2229.                     }

  2230. 

  2231.                     midiEventCount += 1;

  2232.                 }

  2233. 

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

  2235. 

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

  2237. 

  2238.             // ----------------------------------------------------------------------------------------------------

  2239.             // Event Input (System)

  2240. 

  2241.             bool allNotesOffSent = false;

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

  2243. 

  2244.             uint32_t time, nEvents = kData->event.portIn->getEventCount();

  2245.             uint32_t startTime  = 0;

  2246.             uint32_t timeOffset = 0;

  2247. 

  2248.             uint32_t nextBankId = 0;

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

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

  2251. 

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

  2253.             {

  2254.                 const EngineEvent& event = kData->event.portIn->getEvent(i);

  2255. 

  2256.                 time = event.time;

  2257. 

  2258.                 if (time >= frames)

  2259.                     continue;

  2260. 

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

  2262. 

  2263.                 if (time > timeOffset && sampleAccurate)

  2264.                 {

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

  2266.                     {

  2267.                         startTime  = 0;

  2268.                         timeOffset = time;

  2269.                         midiEventCount = 0;

  2270. 

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

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

  2273.                         else

  2274.                             nextBankId = 0;

  2275. 

  2276.                         // reset iters

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

  2278.                         {

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

  2280.                             {

  2281.                                 evInAtomOffsets[i] = 0;

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

  2283.                             }

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

  2285.                             {

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

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

  2288.                             }

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

  2290.                             {

  2291.                                 evInMidiStates[i].position = 0;

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

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

  2294.                             }

  2295.                         }

  2296.                     }

  2297.                     else

  2298.                         startTime += timeOffset;

  2299.                 }

  2300. 

  2301.                 // Control change

  2302.                 switch (event.type)

  2303.                 {

  2304.                 case kEngineEventTypeNull:

  2305.                     break;

  2306. 

  2307.                 case kEngineEventTypeControl:

  2308.                 {

  2309.                     const EngineControlEvent& ctrlEvent = event.ctrl;

  2310. 

  2311.                     switch (ctrlEvent.type)

  2312.                     {

  2313.                     case kEngineControlEventTypeNull:

  2314.                         break;

  2315. 

  2316.                     case kEngineControlEventTypeParameter:

  2317.                     {

  2318.                         // Control backend stuff

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

  2320.                         {

  2321.                             float value;

  2322. 

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

  2324.                             {

  2325.                                 value = ctrlEvent.value;

  2326.                                 setDryWet(value, false, false);

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

  2328.                                 continue;

  2329.                             }

  2330. 

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

  2332.                             {

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

  2334.                                 setVolume(value, false, false);

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

  2336.                                 continue;

  2337.                             }

  2338. 

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

  2340.                             {

  2341.                                 float left, right;

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

  2343. 

  2344.                                 if (value < 0.0f)

  2345.                                 {

  2346.                                     left  = -1.0f;

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

  2348.                                 }

  2349.                                 else if (value > 0.0f)

  2350.                                 {

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

  2352.                                     right = 1.0f;

  2353.                                 }

  2354.                                 else

  2355.                                 {

  2356.                                     left  = -1.0f;

  2357.                                     right = 1.0f;

  2358.                                 }

  2359. 

  2360.                                 setBalanceLeft(left, false, false);

  2361.                                 setBalanceRight(right, false, false);

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

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

  2364.                                 continue;

  2365.                             }

  2366.                         }

  2367. 

  2368.                         // Control plugin parameters

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

  2370.                         {

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

  2372.                                 continue;

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

  2374.                                 continue;

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

  2376.                                 continue;

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

  2378.                                 continue;

  2379. 

  2380.                             float value;

  2381. 

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

  2383.                             {

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

  2385.                             }

  2386.                             else

  2387.                             {

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

  2389. 

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

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

  2392.                             }

  2393. 

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

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

  2396.                         }

  2397. 

  2398.                         break;

  2399.                     }

  2400. 

  2401.                     case kEngineControlEventTypeMidiBank:

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

  2403.                             nextBankId = ctrlEvent.param;

  2404.                         break;

  2405. 

  2406.                     case kEngineControlEventTypeMidiProgram:

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

  2408.                         {

  2409.                             const uint32_t nextProgramId = ctrlEvent.param;

  2410. 

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

  2412.                             {

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

  2414.                                 {

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

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

  2417.                                     break;

  2418.                                 }

  2419.                             }

  2420.                         }

  2421.                         break;

  2422. 

  2423.                     case kEngineControlEventTypeAllSoundOff:

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

  2425.                         {

  2426.                             if (! allNotesOffSent)

  2427.                             {

  2428.                                 sendMidiAllNotesOff();

  2429.                                 allNotesOffSent = true;

  2430.                             }

  2431. 

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

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

  2434.                         }

  2435. 

  2436.                         if (midiEventCount >= MAX_MIDI_EVENTS)

  2437.                             continue;

  2438. 

  2439.                         if (fOptions & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  2440.                         {

  2441.                             // TODO

  2442. 

  2443.                             midiEventCount += 1;

  2444.                         }

  2445. 

  2446.                         break;

  2447. 

  2448.                     case kEngineControlEventTypeAllNotesOff:

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

  2450.                         {

  2451.                             if (! allNotesOffSent)

  2452.                             {

  2453.                                 allNotesOffSent = true;

  2454.                                 sendMidiAllNotesOff();

  2455.                             }

  2456.                         }

  2457. 

  2458.                         if (midiEventCount >= MAX_MIDI_EVENTS)

  2459.                             continue;

  2460. 

  2461.                         if (fOptions & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  2462.                         {

  2463.                             // TODO

  2464. 

  2465.                             midiEventCount += 1;

  2466.                         }

  2467. 

  2468.                         break;

  2469.                     }

  2470. 

  2471.                     break;

  2472.                 }

  2473. 

  2474.                 case kEngineEventTypeMidi:

  2475.                 {

  2476.                     if (midiEventCount >= MAX_MIDI_EVENTS)

  2477.                         continue;

  2478. 

  2479.                     const EngineMidiEvent& midiEvent = event.midi;

  2480. 

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

  2482.                     uint8_t channel = event.channel;

  2483.                     uint32_t time   = sampleAccurate ? startTime : time;

  2484. 

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

  2486.                         continue;

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

  2488.                         continue;

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

  2490.                         continue;

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

  2492.                         continue;

  2493. 

  2494.                     // Fix bad note-off

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

  2496.                         status -= 0x10;

  2497. 

  2498.                     for (k=0; k < fEventsIn.count; ++k)

  2499.                     {

  2500.                         if (midiEvent.port != k)

  2501.                             continue;

  2502. 

  2503.                         if (fEventsIn.data[k].type & CARLA_EVENT_TYPE_MIDI)

  2504.                         {

  2505.                             if (fEventsIn.data[k].type & CARLA_EVENT_DATA_ATOM)

  2506.                             {

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

  2508. 

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

  2510.                                     continue;

  2511. 

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

  2513.                                 aev->time.frames = time;

  2514.                                 aev->body.type   = CARLA_URI_MAP_ID_MIDI_EVENT;

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

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

  2517. 

  2518.                                 evInAtomOffsets[k] += evInPadSize;

  2519.                                 fEventsIn.data[k].atom->atom.size = evInAtomOffsets[k];

  2520.                             }

  2521.                             else if (fEventsIn.data[k].type & CARLA_EVENT_DATA_EVENT)

  2522.                             {

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

  2524.                             }

  2525.                             else if (fEventsIn.data[k].type & CARLA_EVENT_DATA_MIDI_LL)

  2526.                             {

  2527.                                 lv2midi_put_event(&evInMidiStates[k], time, midiEvent.size, midiEvent.data);

  2528.                             }

  2529. 

  2530.                             break;

  2531.                         }

  2532.                     }

  2533. 

  2534.                     midiEventCount += 1;

  2535. 

  2536.                     if (status == MIDI_STATUS_NOTE_ON)

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

  2538.                     else if (status == MIDI_STATUS_NOTE_OFF)

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

  2540. 

  2541.                     break;

  2542.                 }

  2543.                 }

  2544.             }

  2545. 

  2546.             kData->postRtEvents.trySplice();

  2547. 

  2548.             if (frames > timeOffset)

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

  2550. 

  2551.         } // End of Event Input and Processing

  2552. 

  2553.         // --------------------------------------------------------------------------------------------------------

  2554.         // Plugin processing (no events)

  2555. 

  2556.         else

  2557.         {

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

  2559. 

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

  2561. 

  2562.         CARLA_PROCESS_CONTINUE_CHECK;

  2563. 

  2564.         // --------------------------------------------------------------------------------------------------------

  2565.         // Control Output

  2566. 

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

  2568.         {

  2569.             uint8_t  channel;

  2570.             uint16_t param;

  2571.             float    value;

  2572. 

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

  2574.             {

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

  2576.                     continue;

  2577. 

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

  2579. 

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

  2581.                 {

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

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

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

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

  2586.                 }

  2587.             }

  2588. 

  2589.         } // End of Control Output

  2590. 

  2591.         CARLA_PROCESS_CONTINUE_CHECK;

  2592. 

  2593.         // --------------------------------------------------------------------------------------------------------

  2594.         // Final work

  2595. 

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

  2597.         {

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

  2599. 

  2600.             if (fHandle2 != nullptr)

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

  2602.         }

  2603. 

  2604.         // --------------------------------------------------------------------------------------------------------

  2605.     }

  2606. 

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

  2608.     {

  2609.         CARLA_ASSERT(frames > 0);

  2610. 

  2611.         if (frames == 0)

  2612.             return false;

  2613. 

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

  2615.         {

  2616.             CARLA_ASSERT(inBuffer != nullptr);

  2617.             if (inBuffer == nullptr)

  2618.                 return false;

  2619.         }

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

  2621.         {

  2622.             CARLA_ASSERT(outBuffer != nullptr);

  2623.             if (outBuffer == nullptr)

  2624.                 return false;

  2625.         }

  2626. 

  2627.         uint32_t i, k;

  2628. 

  2629.         // --------------------------------------------------------------------------------------------------------

  2630.         // Try lock, silence otherwise

  2631. 

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

  2633.         {

  2634.             kData->singleMutex.lock();

  2635.         }

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

  2637.         {

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

  2639.             {

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

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

  2642.             }

  2643. 

  2644.             return false;

  2645.         }

  2646. 

  2647.         // --------------------------------------------------------------------------------------------------------

  2648.         // Reset audio buffers

  2649. 

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

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

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

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

  2654. 

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

  2656. 

  2657.         if (fHandle2 != nullptr)

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

  2659. 

  2660.         // --------------------------------------------------------------------------------------------------------

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

  2662. 

  2663.         {

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

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

  2666. 

  2667.             bool isPair;

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

  2669. 

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

  2671.             {

  2672.                 // Dry/Wet

  2673.                 if (doDryWet)

  2674.                 {

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

  2676.                     {

  2677.                         // TODO

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

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

  2680.                         //else

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

  2682. 

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

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

  2685.                     }

  2686.                 }

  2687. 

  2688.                 // Balance

  2689.                 if (doBalance)

  2690.                 {

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

  2692. 

  2693.                     if (isPair)

  2694.                     {

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

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

  2697.                     }

  2698. 

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

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

  2701. 

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

  2703.                     {

  2704.                         if (isPair)

  2705.                         {

  2706.                             // left

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

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

  2709.                         }

  2710.                         else

  2711.                         {

  2712.                             // right

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

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

  2715.                         }

  2716.                     }

  2717.                 }

  2718. 

  2719.                 // Volume (and buffer copy)

  2720.                 {

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

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

  2723.                 }

  2724.             }

  2725. 

  2726. #if 0

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

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

  2729.             {

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

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

  2732.             }

  2733. #endif

  2734.         } // End of Post-processing

  2735. 

  2736.         // --------------------------------------------------------------------------------------------------------

  2737. 

  2738.         kData->singleMutex.unlock();

  2739.         return true;

  2740.     }

  2741. 

  2742.     void bufferSizeChanged(const uint32_t newBufferSize) override

  2743.     {

  2744.         CARLA_ASSERT_INT(newBufferSize > 0, newBufferSize);

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

  2746. 

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

  2748.         {

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

  2750.                 delete[] fAudioInBuffers[i];

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

  2752.         }

  2753. 

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

  2755.         {

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

  2757.                 delete[] fAudioOutBuffers[i];

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

  2759.         }

  2760. 

  2761.         if (fHandle2 == nullptr)

  2762.         {

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

  2764.             {

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

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

  2767.             }

  2768. 

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

  2770.             {

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

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

  2773.             }

  2774.         }

  2775.         else

  2776.         {

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

  2778.             {

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

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

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

  2782. 

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

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

  2785.             }

  2786. 

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

  2788.             {

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

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

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

  2792. 

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

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

  2795.             }

  2796.         }

  2797. 

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

  2799.         {

  2800.             fLv2Options.maxBufferSize = newBufferSize;

  2801. 

  2802.             if (fLv2Options.minBufferSize > 1)

  2803.                 fLv2Options.minBufferSize = newBufferSize;

  2804. 

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

  2806.             {

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

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

  2809.             }

  2810.         }

  2811. 

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

  2813.     }

  2814. 

  2815.     void sampleRateChanged(const double newSampleRate) override

  2816.     {

  2817.         CARLA_ASSERT_INT(newSampleRate > 0.0, newSampleRate);

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

  2819. 

  2820.         if (fLv2Options.sampleRate != newSampleRate)

  2821.         {

  2822.             fLv2Options.sampleRate = newSampleRate;

  2823. 

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

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

  2826.         }

  2827. 

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

  2829.     }

  2830. 

  2831.     // -------------------------------------------------------------------

  2832.     // Plugin buffers

  2833. 

  2834.     void initBuffers() override

  2835.     {

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

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

  2838. 

  2839.         CarlaPlugin::initBuffers();

  2840.     }

  2841. 

  2842.     void clearBuffers() override

  2843.     {

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

  2845. 

  2846.         if (fAudioInBuffers != nullptr)

  2847.         {

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

  2849.             {

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

  2851.                 {

  2852.                     delete[] fAudioInBuffers[i];

  2853.                     fAudioInBuffers[i] = nullptr;

  2854.                 }

  2855.             }

  2856. 

  2857.             delete[] fAudioInBuffers;

  2858.             fAudioInBuffers = nullptr;

  2859.         }

  2860. 

  2861.         if (fAudioOutBuffers != nullptr)

  2862.         {

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

  2864.             {

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

  2866.                 {

  2867.                     delete[] fAudioOutBuffers[i];

  2868.                     fAudioOutBuffers[i] = nullptr;

  2869.                 }

  2870.             }

  2871. 

  2872.             delete[] fAudioOutBuffers;

  2873.             fAudioOutBuffers = nullptr;

  2874.         }

  2875. 

  2876.         if (fParamBuffers != nullptr)

  2877.         {

  2878.             delete[] fParamBuffers;

  2879.             fParamBuffers = nullptr;

  2880.         }

  2881. 

  2882.         fEventsIn.clear();

  2883.         fEventsOut.clear();

  2884. 

  2885.         CarlaPlugin::clearBuffers();

  2886. 

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

  2888.     }

  2889. 

  2890.     // -------------------------------------------------------------------

  2891.     // Post-poned UI Stuff

  2892. 

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

  2894.     {

  2895.         CARLA_ASSERT(fDescriptor != nullptr);

  2896.         CARLA_ASSERT(fHandle != nullptr);

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

  2898. 

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

  2900.             return;

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

  2902.             return;

  2903. 

  2904.         if (fUi.type == PLUGIN_UI_OSC)

  2905.         {

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

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

  2908.         }

  2909.         else

  2910.         {

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

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

  2913.         }

  2914.     }

  2915. 

  2916.     void uiMidiProgramChange(const uint32_t index) override

  2917.     {

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

  2919. 

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

  2921.             return;

  2922. 

  2923.         if (fUi.type == PLUGIN_UI_OSC)

  2924.         {

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

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

  2927.         }

  2928.         else

  2929.         {

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

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

  2932.         }

  2933.     }

  2934. 

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

  2936.     {

  2937.         CARLA_ASSERT(channel < MAX_MIDI_CHANNELS);

  2938.         CARLA_ASSERT(note < MAX_MIDI_NOTE);

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

  2940. 

  2941.         if (channel >= MAX_MIDI_CHANNELS)

  2942.             return;

  2943.         if (note >= MAX_MIDI_NOTE)

  2944.             return;

  2945.         if (velo >= MAX_MIDI_VALUE)

  2946.             return;

  2947. 

  2948.         if (fUi.type == PLUGIN_UI_OSC)

  2949.         {

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

  2951.             {

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

  2953.                 midiData[1] = MIDI_STATUS_NOTE_ON + channel;

  2954.                 midiData[2] = note;

  2955.                 midiData[3] = velo;

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

  2957.             }

  2958.         }

  2959.         else

  2960.         {

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

  2962.             {

  2963.                 LV2_Atom_MidiEvent midiEv;

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

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

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

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

  2968.                 midiEv.data[1] = note;

  2969.                 midiEv.data[2] = velo;

  2970. 

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

  2972.             }

  2973.         }

  2974.     }

  2975. 

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

  2977.     {

  2978.         CARLA_ASSERT(channel < MAX_MIDI_CHANNELS);

  2979.         CARLA_ASSERT(note < MAX_MIDI_NOTE);

  2980. 

  2981.         if (channel >= MAX_MIDI_CHANNELS)

  2982.             return;

  2983.         if (note >= MAX_MIDI_NOTE)

  2984.             return;

  2985. 

  2986.         if (fUi.type == PLUGIN_UI_OSC)

  2987.         {

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

  2989.             {

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

  2991.                 midiData[1] = MIDI_STATUS_NOTE_OFF + channel;

  2992.                 midiData[2] = note;

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

  2994.             }

  2995.         }

  2996.         else

  2997.         {

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

  2999.             {

  3000.                 LV2_Atom_MidiEvent midiEv;

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

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

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

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

  3005.                 midiEv.data[1] = note;

  3006.                 midiEv.data[2] = 0;

  3007. 

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

  3009.             }

  3010.         }

  3011.     }

  3012. 

  3013.     // -------------------------------------------------------------------

  3014. 

  3015. protected:

  3016.     void guiClosedCallback() override

  3017.     {

  3018.         showGui(false);

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

  3020.     }

  3021. 

  3022.     // -------------------------------------------------------------------

  3023. 

  3024.     uint32_t getCustomURID(const char* const uri)

  3025.     {

  3026.         CARLA_ASSERT(uri != nullptr);

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

  3028. 

  3029.         if (uri == nullptr)

  3030.             return CARLA_URI_MAP_ID_NULL;

  3031. 

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

  3033.         {

  3034.             const char* const thisUri(fCustomURIDs.getAt(i));

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

  3036.                 return i;

  3037.         }

  3038. 

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

  3040. 

  3041.         return fCustomURIDs.count()-1;

  3042.     }

  3043. 

  3044.     const char* getCustomURIString(const LV2_URID urid)

  3045.     {

  3046.         CARLA_ASSERT(urid != CARLA_URI_MAP_ID_NULL);

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

  3048. 

  3049.         if (urid == CARLA_URI_MAP_ID_NULL)

  3050.             return nullptr;

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

  3052.             return fCustomURIDs.getAt(urid);

  3053. 

  3054.         return nullptr;

  3055.     }

  3056. 

  3057.     // -------------------------------------------------------------------

  3058. 

  3059.     void handleProgramChanged(const int32_t index)

  3060.     {

  3061.         if (index == -1)

  3062.         {

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

  3064.             return reloadPrograms(false);

  3065.         }

  3066. 

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

  3068.         {

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

  3070.             {

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

  3072. 

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

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

  3075. 

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

  3077. 

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

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

  3080.                 else

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

  3082.             }

  3083.         }

  3084.     }

  3085. 

  3086.     // -------------------------------------------------------------------

  3087. 

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

  3089.     {

  3090.         CARLA_ASSERT(key != CARLA_URI_MAP_ID_NULL);

  3091.         CARLA_ASSERT(value != nullptr);

  3092.         CARLA_ASSERT(size > 0);

  3093. 

  3094.         // basic checks

  3095.         if (key == CARLA_URI_MAP_ID_NULL)

  3096.         {

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

  3098.             return LV2_STATE_ERR_NO_PROPERTY;

  3099.         }

  3100. 

  3101.         if (value == nullptr || size == 0)

  3102.         {

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

  3104.             return LV2_STATE_ERR_NO_PROPERTY;

  3105.         }

  3106. 

  3107.         if ((flags & LV2_STATE_IS_POD) == 0)

  3108.         {

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

  3110.             return LV2_STATE_ERR_BAD_FLAGS;

  3111.         }

  3112. 

  3113.         const char* const stype(getCustomURIString(type));

  3114. 

  3115.         if (stype == nullptr)

  3116.         {

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

  3118.             return LV2_STATE_ERR_BAD_TYPE;

  3119.         }

  3120. 

  3121.         const char* const uriKey(getCustomURIString(key));

  3122. 

  3123.         if (uriKey == nullptr)

  3124.         {

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

  3126.             return LV2_STATE_ERR_NO_PROPERTY;

  3127.         }

  3128. 

  3129.         // Check if we already have this key

  3130.         for (auto it = kData->custom.begin(); it.valid(); it.next())

  3131.         {

  3132.             CustomData& data(*it);

  3133. 

  3134.             if (std::strcmp(data.key, uriKey) == 0)

  3135.             {

  3136.                 if (data.value != nullptr)

  3137.                     delete[] data.value;

  3138. 

  3139.                 if (std::strcmp(stype, LV2_ATOM__String) == 0 || std::strcmp(stype, LV2_ATOM__Path) == 0)

  3140.                     data.value = carla_strdup((const char*)value);

  3141.                 else

  3142.                     data.value = carla_strdup(QByteArray((const char*)value, size).toBase64().constData());

  3143. 

  3144.                 return LV2_STATE_SUCCESS;

  3145.             }

  3146.         }

  3147. 

  3148.         // Otherwise store it

  3149.         CustomData newData;

  3150.         newData.type = carla_strdup(stype);

  3151.         newData.key  = carla_strdup(uriKey);

  3152. 

  3153.         if (std::strcmp(stype, LV2_ATOM__String) == 0 || std::strcmp(stype, LV2_ATOM__Path) == 0)

  3154.             newData.value = carla_strdup((const char*)value);

  3155.         else

  3156.             newData.value = carla_strdup(QByteArray((const char*)value, size).toBase64().constData());

  3157. 

  3158.         kData->custom.append(newData);

  3159. 

  3160.         return LV2_STATE_SUCCESS;

  3161.     }

  3162. 

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

  3164.     {

  3165.         CARLA_ASSERT(key != CARLA_URI_MAP_ID_NULL);

  3166. 

  3167.         // basic checks

  3168.         if (key == CARLA_URI_MAP_ID_NULL)

  3169.         {

  3170.             carla_stderr2("Lv2Plugin::handleStateRetrieve(%i, %p, %p, %p) - invalid key", key, size, type, flags);

  3171.             return nullptr;

  3172.         }

  3173. 

  3174.         if (size == nullptr || type == nullptr || flags == nullptr)

  3175.         {

  3176.             carla_stderr2("Lv2Plugin::handleStateRetrieve(%i, %p, %p, %p) - invalid data", key, size, type, flags);

  3177.             return nullptr;

  3178.         }

  3179. 

  3180.         const char* const uriKey(getCustomURIString(key));

  3181. 

  3182.         if (uriKey == nullptr)

  3183.         {

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

  3185.             return nullptr;

  3186.         }

  3187. 

  3188.         const char* stype = nullptr;

  3189.         const char* stringData = nullptr;

  3190. 

  3191.         for (auto it = kData->custom.begin(); it.valid(); it.next())

  3192.         {

  3193.             CustomData& data(*it);

  3194. 

  3195.             if (std::strcmp(data.key, uriKey) == 0)

  3196.             {

  3197.                 stype      = data.type;

  3198.                 stringData = data.value;

  3199.                 break;

  3200.             }

  3201.         }

  3202. 

  3203.         if (stringData == nullptr)

  3204.         {

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

  3206.             return nullptr;

  3207.         }

  3208. 

  3209.         *type  = key;

  3210.         *flags = LV2_STATE_IS_POD;

  3211. 

  3212.         if (std::strcmp(stype, LV2_ATOM__String) == 0 || std::strcmp(stype, LV2_ATOM__Path) == 0)

  3213.         {

  3214.             *size = std::strlen(stringData);

  3215.             return stringData;

  3216.         }

  3217.         else

  3218.         {

  3219.             static QByteArray chunk;

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

  3221.             *size = chunk.size();

  3222.             return chunk.constData();

  3223.         }

  3224.     }

  3225. 

  3226.     // -------------------------------------------------------------------

  3227. 

  3228.     void handleExternalUiClosed()

  3229.     {

  3230.         CARLA_ASSERT(fUi.type == PLUGIN_UI_EXTERNAL);

  3231. 

  3232.         if (fUi.handle != nullptr && fUi.descriptor != nullptr && fUi.descriptor->cleanup != nullptr)

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

  3234. 

  3235.         fUi.handle = nullptr;

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

  3237.     }

  3238. 

  3239.     uint32_t handleUiPortMap(const char* const symbol)

  3240.     {

  3241.         CARLA_ASSERT(symbol != nullptr);

  3242. 

  3243.         if (symbol == nullptr)

  3244.             return LV2UI_INVALID_PORT_INDEX;

  3245. 

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

  3247.         {

  3248.             if (std::strcmp(fRdfDescriptor->Ports[i].Symbol, symbol) == 0)

  3249.                 return i;

  3250.         }

  3251. 

  3252.         return LV2UI_INVALID_PORT_INDEX;

  3253.     }

  3254. 

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

  3256.     {

  3257.         CARLA_ASSERT(kData->gui != nullptr);

  3258.         CARLA_ASSERT(width > 0);

  3259.         CARLA_ASSERT(height > 0);

  3260. 

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

  3262.             return 1;

  3263. 

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

  3265.             kData->gui->setSize(width, height);

  3266. 

  3267.         return 0;

  3268.     }

  3269. 

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

  3271.     {

  3272.         if (format == 0)

  3273.         {

  3274.             CARLA_ASSERT(buffer != nullptr);

  3275.             CARLA_ASSERT(bufferSize == sizeof(float));

  3276. 

  3277.             if (buffer == nullptr || bufferSize != sizeof(float))

  3278.                 return;

  3279. 

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

  3281. 

  3282.             for (uint32_t i=0; i < kData->param.count; ++i)

  3283.             {

  3284.                 if (kData->param.data[i].rindex == static_cast<int32_t>(rindex))

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

  3286.             }

  3287.         }

  3288.         else if (format == CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM)

  3289.         {

  3290.             CARLA_ASSERT(buffer != nullptr);

  3291. 

  3292.             if (buffer == nullptr)

  3293.                 return;

  3294. 

  3295.             //const LV2_Atom* const atom = (const LV2_Atom*)buffer;

  3296.             //handleTransferAtom(rindex, atom);

  3297.         }

  3298.         else if (format == CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT)

  3299.         {

  3300.             CARLA_ASSERT(buffer != nullptr);

  3301. 

  3302.             if (buffer == nullptr)

  3303.                 return;

  3304. 

  3305.             //const LV2_Atom* const atom = (const LV2_Atom*)buffer;

  3306.             //handleTransferEvent(rindex, atom);

  3307.         }

  3308.     }

  3309. 

  3310.     // -------------------------------------------------------------------

  3311. 

  3312.     const char* getUiBridgePath(const LV2_Property type)

  3313.     {

  3314.         const EngineOptions& options(kData->engine->getOptions());

  3315. 

  3316.         switch (type)

  3317.         {

  3318.         case LV2_UI_GTK2:

  3319.             return options.bridge_lv2Gtk2;

  3320.         case LV2_UI_GTK3:

  3321.             return options.bridge_lv2Gtk3;

  3322.         case LV2_UI_QT4:

  3323.             return options.bridge_lv2Qt4;

  3324.         case LV2_UI_QT5:

  3325.             return options.bridge_lv2Qt5;

  3326.         case LV2_UI_COCOA:

  3327.             return options.bridge_lv2Cocoa;

  3328.         case LV2_UI_WINDOWS:

  3329.             return options.bridge_lv2Win;

  3330.         case LV2_UI_X11:

  3331.             return options.bridge_lv2X11;

  3332.         default:

  3333.             return nullptr;

  3334.         }

  3335.     }

  3336. 

  3337.     bool isUiBridgeable(const uint32_t uiId)

  3338.     {

  3339.         const LV2_RDF_UI& rdfUi(fRdfDescriptor->UIs[uiId]);

  3340. 

  3341.         // Calf Analyzer is useless without instance-data

  3342.         if (std::strcmp(rdfUi.URI, "http://calf.sourceforge.net/plugins/Analyzer") == 0)

  3343.             return false;

  3344. 

  3345.         for (uint32_t i=0; i < rdfUi.FeatureCount; ++i)

  3346.         {

  3347.             if (std::strcmp(rdfUi.Features[i].URI, LV2_INSTANCE_ACCESS_URI) == 0)

  3348.                 return false;

  3349.             if (std::strcmp(rdfUi.Features[i].URI, LV2_DATA_ACCESS_URI) == 0)

  3350.                 return false;

  3351.         }

  3352. 

  3353.         return true;

  3354.     }

  3355. 

  3356.     bool isUiResizable()

  3357.     {

  3358.         for (uint32_t i=0; i < fUi.rdfDescriptor->FeatureCount; ++i)

  3359.         {

  3360.             if (std::strcmp(fUi.rdfDescriptor->Features[i].URI, LV2_UI__fixedSize) == 0)

  3361.                 return false;

  3362.             if (std::strcmp(fUi.rdfDescriptor->Features[i].URI, LV2_UI__noUserResize) == 0)

  3363.                 return false;

  3364.         }

  3365. 

  3366.         return true;

  3367.     }

  3368. 

  3369.     void updateUi()

  3370.     {

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

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

  3373. 

  3374.         fExt.uiidle = nullptr;

  3375.         fExt.uiprograms = nullptr;

  3376. 

  3377.         if (fUi.descriptor->extension_data != nullptr)

  3378.         {

  3379.             fExt.uiidle     = (const LV2UI_Idle_Interface*)fUi.descriptor->extension_data(LV2_UI__idleInterface);

  3380.             fExt.uiprograms = (const LV2_Programs_UI_Interface*)fUi.descriptor->extension_data(LV2_PROGRAMS__UIInterface);

  3381. 

  3382.             // check if invalid

  3383.             if (fExt.uiidle != nullptr && fExt.uiidle->idle == nullptr)

  3384.                 fExt.uiidle = nullptr;

  3385. 

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

  3387.                 fExt.uiprograms = nullptr;

  3388. 

  3389.             // update midi program

  3390.             if (fExt.uiprograms && kData->midiprog.count > 0 && kData->midiprog.current >= 0)

  3391.                 fExt.uiprograms->select_program(fUi.handle, kData->midiprog.data[kData->midiprog.current].bank,

  3392.                                                             kData->midiprog.data[kData->midiprog.current].program);

  3393.         }

  3394. 

  3395.         if (fUi.descriptor->port_event != nullptr)

  3396.         {

  3397.             // update control ports

  3398.             float value;

  3399.             for (uint32_t i=0; i < kData->param.count; ++i)

  3400.             {

  3401.                 value = getParameterValue(i);

  3402.                 fUi.descriptor->port_event(fUi.handle, kData->param.data[i].rindex, sizeof(float), CARLA_URI_MAP_ID_NULL, &value);

  3403.             }

  3404.         }

  3405.     }

  3406. 

  3407.     // -------------------------------------------------------------------

  3408. 

  3409. public:

  3410.     bool init(const char* const name, const char* const uri)

  3411.     {

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

  3413.         CARLA_ASSERT(kData->client == nullptr);

  3414.         CARLA_ASSERT(uri != nullptr);

  3415. 

  3416.         // ---------------------------------------------------------------

  3417.         // first checks

  3418. 

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

  3420.         {

  3421.             return false;

  3422.         }

  3423. 

  3424.         if (kData->client != nullptr)

  3425.         {

  3426.             kData->engine->setLastError("Plugin client is already registered");

  3427.             return false;

  3428.         }

  3429. 

  3430.         if (uri == nullptr)

  3431.         {

  3432.             kData->engine->setLastError("null uri");

  3433.             return false;

  3434.         }

  3435. 

  3436.         // ---------------------------------------------------------------

  3437.         // get plugin from lv2_rdf (lilv)

  3438. 

  3439.         gLv2World.init();

  3440. 

  3441.         fRdfDescriptor = lv2_rdf_new(uri);

  3442. 

  3443.         if (fRdfDescriptor == nullptr)

  3444.         {

  3445.             kData->engine->setLastError("Failed to find the requested plugin in the LV2 Bundle");

  3446.             return false;

  3447.         }

  3448. 

  3449.         // ---------------------------------------------------------------

  3450.         // open DLL

  3451. 

  3452.         if (! kData->libOpen(fRdfDescriptor->Binary))

  3453.         {

  3454.             kData->engine->setLastError(kData->libError(fRdfDescriptor->Binary));

  3455.             return false;

  3456.         }

  3457. 

  3458.         // ---------------------------------------------------------------

  3459.         // initialize options

  3460. 

  3461.         fLv2Options.minBufferSize = 1;

  3462.         fLv2Options.maxBufferSize = kData->engine->getBufferSize();

  3463.         fLv2Options.sampleRate    = kData->engine->getSampleRate();

  3464. 

  3465.         // ---------------------------------------------------------------

  3466.         // initialize features (part 1)

  3467. 

  3468.         LV2_Event_Feature* const eventFt = new LV2_Event_Feature;

  3469.         eventFt->callback_data           = this;

  3470.         eventFt->lv2_event_ref           = carla_lv2_event_ref;

  3471.         eventFt->lv2_event_unref         = carla_lv2_event_unref;

  3472. 

  3473.         LV2_Log_Log* const logFt         = new LV2_Log_Log;

  3474.         logFt->handle                    = this;

  3475.         logFt->printf                    = carla_lv2_log_printf;

  3476.         logFt->vprintf                   = carla_lv2_log_vprintf;

  3477. 

  3478.         LV2_State_Make_Path* const stateMakePathFt = new LV2_State_Make_Path;

  3479.         stateMakePathFt->handle                    = this;

  3480.         stateMakePathFt->path                      = carla_lv2_state_make_path;

  3481. 

  3482.         LV2_State_Map_Path* const stateMapPathFt   = new LV2_State_Map_Path;

  3483.         stateMapPathFt->handle                     = this;

  3484.         stateMapPathFt->abstract_path              = carla_lv2_state_map_abstract_path;

  3485.         stateMapPathFt->absolute_path              = carla_lv2_state_map_absolute_path;

  3486. 

  3487.         LV2_Programs_Host* const programsFt   = new LV2_Programs_Host;

  3488.         programsFt->handle                    = this;

  3489.         programsFt->program_changed           = carla_lv2_program_changed;

  3490. 

  3491.         LV2_RtMemPool_Pool* const rtMemPoolFt = new LV2_RtMemPool_Pool;

  3492.         lv2_rtmempool_init(rtMemPoolFt);

  3493. 

  3494.         LV2_URI_Map_Feature* const uriMapFt = new LV2_URI_Map_Feature;

  3495.         uriMapFt->callback_data             = this;

  3496.         uriMapFt->uri_to_id                 = carla_lv2_uri_to_id;

  3497. 

  3498.         LV2_URID_Map* const uridMapFt       = new LV2_URID_Map;

  3499.         uridMapFt->handle                   = this;

  3500.         uridMapFt->map                      = carla_lv2_urid_map;

  3501. 

  3502.         LV2_URID_Unmap* const uridUnmapFt   = new LV2_URID_Unmap;

  3503.         uridUnmapFt->handle                 = this;

  3504.         uridUnmapFt->unmap                  = carla_lv2_urid_unmap;

  3505. 

  3506.         LV2_Worker_Schedule* const workerFt = new LV2_Worker_Schedule;

  3507.         workerFt->handle                    = this;

  3508.         workerFt->schedule_work             = carla_lv2_worker_schedule;

  3509. 

  3510.         // ---------------------------------------------------------------

  3511.         // initialize features (part 2)

  3512. 

  3513.         fFeatures[kFeatureIdBufSizeBounded]        = new LV2_Feature;

  3514.         fFeatures[kFeatureIdBufSizeBounded]->URI   = LV2_BUF_SIZE__boundedBlockLength;

  3515.         fFeatures[kFeatureIdBufSizeBounded]->data  = nullptr;

  3516. 

  3517.         fFeatures[kFeatureIdBufSizeFixed]          = new LV2_Feature;

  3518.         fFeatures[kFeatureIdBufSizeFixed]->URI     = LV2_BUF_SIZE__fixedBlockLength;

  3519.         fFeatures[kFeatureIdBufSizeFixed]->data    = nullptr;

  3520. 

  3521.         fFeatures[kFeatureIdBufSizePowerOf2]       = new LV2_Feature;

  3522.         fFeatures[kFeatureIdBufSizePowerOf2]->URI  = LV2_BUF_SIZE__powerOf2BlockLength;

  3523.         fFeatures[kFeatureIdBufSizePowerOf2]->data = nullptr;

  3524. 

  3525.         fFeatures[kFeatureIdEvent]          = new LV2_Feature;

  3526.         fFeatures[kFeatureIdEvent]->URI     = LV2_EVENT_URI;

  3527.         fFeatures[kFeatureIdEvent]->data    = eventFt;

  3528. 

  3529.         fFeatures[kFeatureIdLogs]           = new LV2_Feature;

  3530.         fFeatures[kFeatureIdLogs]->URI      = LV2_LOG__log;

  3531.         fFeatures[kFeatureIdLogs]->data     = logFt;

  3532. 

  3533.         fFeatures[kFeatureIdOptions]        = new LV2_Feature;

  3534.         fFeatures[kFeatureIdOptions]->URI   = LV2_OPTIONS__options;

  3535.         fFeatures[kFeatureIdOptions]->data  = fLv2Options.opts;

  3536. 

  3537.         fFeatures[kFeatureIdPrograms]       = new LV2_Feature;

  3538.         fFeatures[kFeatureIdPrograms]->URI  = LV2_PROGRAMS__Host;

  3539.         fFeatures[kFeatureIdPrograms]->data = programsFt;

  3540. 

  3541.         fFeatures[kFeatureIdRtMemPool]       = new LV2_Feature;

  3542.         fFeatures[kFeatureIdRtMemPool]->URI  = LV2_RTSAFE_MEMORY_POOL__Pool;

  3543.         fFeatures[kFeatureIdRtMemPool]->data = rtMemPoolFt;

  3544. 

  3545.         fFeatures[kFeatureIdStateMakePath]       = new LV2_Feature;

  3546.         fFeatures[kFeatureIdStateMakePath]->URI  = LV2_STATE__makePath;

  3547.         fFeatures[kFeatureIdStateMakePath]->data = stateMakePathFt;

  3548. 

  3549.         fFeatures[kFeatureIdStateMapPath]        = new LV2_Feature;

  3550.         fFeatures[kFeatureIdStateMapPath]->URI   = LV2_STATE__mapPath;

  3551.         fFeatures[kFeatureIdStateMapPath]->data  = stateMapPathFt;

  3552. 

  3553.         fFeatures[kFeatureIdStrictBounds]         = new LV2_Feature;

  3554.         fFeatures[kFeatureIdStrictBounds]->URI    = LV2_PORT_PROPS__supportsStrictBounds;

  3555.         fFeatures[kFeatureIdStrictBounds]->data   = nullptr;

  3556. 

  3557.         fFeatures[kFeatureIdUriMap]          = new LV2_Feature;

  3558.         fFeatures[kFeatureIdUriMap]->URI     = LV2_URI_MAP_URI;

  3559.         fFeatures[kFeatureIdUriMap]->data    = uriMapFt;

  3560. 

  3561.         fFeatures[kFeatureIdUridMap]         = new LV2_Feature;

  3562.         fFeatures[kFeatureIdUridMap]->URI    = LV2_URID__map;

  3563.         fFeatures[kFeatureIdUridMap]->data   = uridMapFt;

  3564. 

  3565.         fFeatures[kFeatureIdUridUnmap]       = new LV2_Feature;

  3566.         fFeatures[kFeatureIdUridUnmap]->URI  = LV2_URID__unmap;

  3567.         fFeatures[kFeatureIdUridUnmap]->data = uridUnmapFt;

  3568. 

  3569.         fFeatures[kFeatureIdWorker]           = new LV2_Feature;

  3570.         fFeatures[kFeatureIdWorker]->URI      = LV2_WORKER__schedule;

  3571.         fFeatures[kFeatureIdWorker]->data     = workerFt;

  3572. 

  3573.         // ---------------------------------------------------------------

  3574.         // get DLL main entry

  3575. 

  3576. #if 0

  3577.         const LV2_Lib_Descriptor_Function libDescFn = (LV2_Lib_Descriptor_Function)kData->libSymbol("lv2_lib_descriptor");

  3578. 

  3579.         if (libDescFn != nullptr)

  3580.         {

  3581.             // -----------------------------------------------------------

  3582.             // get lib descriptor

  3583. 

  3584.             const LV2_Lib_Descriptor* libFn = nullptr; //descLibFn(fRdfDescriptor->Bundle, features);

  3585. 

  3586.             if (libFn == nullptr || libFn->get_plugin == nullptr)

  3587.             {

  3588.                 kData->engine->setLastError("Plugin failed to return library descriptor");

  3589.                 return false;

  3590.             }

  3591. 

  3592.             // -----------------------------------------------------------

  3593.             // get descriptor that matches URI

  3594. 

  3595.             uint32_t i = 0;

  3596.             while ((fDescriptor = libFn->get_plugin(libFn->handle, i++)))

  3597.             {

  3598.                 if (std::strcmp(fDescriptor->URI, uri) == 0)

  3599.                     break;

  3600.             }

  3601. 

  3602.             if (fDescriptor == nullptr)

  3603.                 libFn->cleanup(libFn->handle);

  3604.         else

  3605. #endif

  3606.         {

  3607.             const LV2_Descriptor_Function descFn = (LV2_Descriptor_Function)kData->libSymbol("lv2_descriptor");

  3608. 

  3609.             if (descFn == nullptr)

  3610.             {

  3611.                 kData->engine->setLastError("Could not find the LV2 Descriptor in the plugin library");

  3612.                 return false;

  3613.             }

  3614. 

  3615.             // -----------------------------------------------------------

  3616.             // get descriptor that matches URI

  3617. 

  3618.             uint32_t i = 0;

  3619.             while ((fDescriptor = descFn(i++)))

  3620.             {

  3621.                 if (std::strcmp(fDescriptor->URI, uri) == 0)

  3622.                     break;

  3623.             }

  3624.         }

  3625. 

  3626.         if (fDescriptor == nullptr)

  3627.         {

  3628.             kData->engine->setLastError("Could not find the requested plugin URI in the plugin library");

  3629.             return false;

  3630.         }

  3631. 

  3632.         // ---------------------------------------------------------------

  3633.         // check supported port-types and features

  3634. 

  3635.         bool canContinue = true;

  3636. 

  3637.         // Check supported ports

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

  3639.         {

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

  3641. 

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

  3643.             {

  3644.                 if (! LV2_IS_PORT_OPTIONAL(fRdfDescriptor->Ports[i].Properties))

  3645.                 {

  3646.                     kData->engine->setLastError("Plugin requires a port type that is not currently supported");

  3647.                     canContinue = false;

  3648.                     break;

  3649.                 }

  3650.             }

  3651.         }

  3652. 

  3653.         // Check supported features

  3654.         for (uint32_t i=0; i < fRdfDescriptor->FeatureCount && canContinue; ++i)

  3655.         {

  3656.             if (LV2_IS_FEATURE_REQUIRED(fRdfDescriptor->Features[i].Type) && ! is_lv2_feature_supported(fRdfDescriptor->Features[i].URI))

  3657.             {

  3658.                 QString msg(QString("Plugin requires a feature that is not supported:\n%1").arg(fRdfDescriptor->Features[i].URI));

  3659.                 kData->engine->setLastError(msg.toUtf8().constData());

  3660.                 canContinue = false;

  3661.                 break;

  3662.             }

  3663.         }

  3664. 

  3665.         // Check extensions

  3666.         for (uint32_t i=0; i < fRdfDescriptor->ExtensionCount; ++i)

  3667.         {

  3668.             if (std::strcmp(fRdfDescriptor->Extensions[i], LV2_OPTIONS__interface) == 0)

  3669.                 kData->extraHints |= PLUGIN_HAS_EXTENSION_OPTIONS;

  3670.             else if (std::strcmp(fRdfDescriptor->Extensions[i], LV2_PROGRAMS__Interface) == 0)

  3671.                 kData->extraHints |= PLUGIN_HAS_EXTENSION_PROGRAMS;

  3672.             else if (std::strcmp(fRdfDescriptor->Extensions[i], LV2_STATE__interface) == 0)

  3673.                 kData->extraHints |= PLUGIN_HAS_EXTENSION_STATE;

  3674.             else if (std::strcmp(fRdfDescriptor->Extensions[i], LV2_WORKER__interface) == 0)

  3675.                 kData->extraHints |= PLUGIN_HAS_EXTENSION_WORKER;

  3676.             else

  3677.                 carla_stdout("Plugin has non-supported extension: '%s'", fRdfDescriptor->Extensions[i]);

  3678.         }

  3679. 

  3680.         if (! canContinue)

  3681.         {

  3682.             // error already set

  3683.             return false;

  3684.         }

  3685. 

  3686.         // ---------------------------------------------------------------

  3687.         // get info

  3688. 

  3689.         if (name != nullptr)

  3690.             fName = kData->engine->getUniquePluginName(name);

  3691.         else

  3692.             fName = kData->engine->getUniquePluginName(fRdfDescriptor->Name);

  3693. 

  3694.         // ---------------------------------------------------------------

  3695.         // register client

  3696. 

  3697.         kData->client = kData->engine->addClient(this);

  3698. 

  3699.         if (kData->client == nullptr || ! kData->client->isOk())

  3700.         {

  3701.             kData->engine->setLastError("Failed to register plugin client");

  3702.             return false;

  3703.         }

  3704. 

  3705.         // ---------------------------------------------------------------

  3706.         // initialize plugin

  3707. 

  3708.         fHandle = fDescriptor->instantiate(fDescriptor, kData->engine->getSampleRate(), fRdfDescriptor->Bundle, fFeatures);

  3709. 

  3710.         if (fHandle == nullptr)

  3711.         {

  3712.             kData->engine->setLastError("Plugin failed to initialize");

  3713.             return false;

  3714.         }

  3715. 

  3716.         // ---------------------------------------------------------------

  3717.         // load plugin settings

  3718. 

  3719.         {

  3720.             // set default options

  3721.             fOptions = 0x0;

  3722. 

  3723.             fOptions |= PLUGIN_OPTION_FIXED_BUFFER;

  3724.             fOptions |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  3725. 

  3726.             if (kData->engine->getOptions().forceStereo)

  3727.                 fOptions |= PLUGIN_OPTION_FORCE_STEREO;

  3728. 

  3729.             //if (fDescriptor->midiIns > 0)

  3730.             {

  3731.                 fOptions |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  3732.                 fOptions |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

  3733.                 fOptions |= PLUGIN_OPTION_SEND_PITCHBEND;

  3734.                 fOptions |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  3735.             }

  3736. 

  3737.             // load settings

  3738.             kData->idStr  = "LV2/";

  3739.             kData->idStr += uri;

  3740.             fOptions = kData->loadSettings(fOptions, availableOptions());

  3741.         }

  3742. 

  3743.         // ---------------------------------------------------------------

  3744.         // gui stuff

  3745. 

  3746.         if (fRdfDescriptor->UICount == 0)

  3747.             return true;

  3748. 

  3749.         // -----------------------------------------------------------

  3750.         // find more appropriate ui

  3751. 

  3752.         int eQt4, eQt5, eCocoa, eWindows, eX11, eGtk2, eGtk3, iCocoa, iWindows, iX11, iQt4, iQt5, iExt, iFinal;

  3753.         eQt4 = eQt5 = eCocoa = eWindows = eX11 = eGtk2 = eGtk3 = iQt4 = iQt5 = iCocoa = iWindows = iX11 = iExt = iFinal = -1;

  3754. 

  3755. #ifdef BUILD_BRIDGE

  3756.         const bool preferUiBridges(kData->engine->getOptions().preferUiBridges);

  3757. #else

  3758.         const bool preferUiBridges(kData->engine->getOptions().preferUiBridges && (fHints & PLUGIN_IS_BRIDGE) == 0);

  3759. #endif

  3760. 

  3761.         for (uint32_t i=0; i < fRdfDescriptor->UICount; ++i)

  3762.         {

  3763.             CARLA_ASSERT(fRdfDescriptor->UIs[i].URI != nullptr);

  3764. 

  3765.             if (fRdfDescriptor->UIs[i].URI == nullptr)

  3766.             {

  3767.                 carla_stderr("Plugin has an UI without a valid URI");

  3768.                 continue;

  3769.             }

  3770. 

  3771.             switch (fRdfDescriptor->UIs[i].Type)

  3772.             {

  3773. #if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))

  3774.             case LV2_UI_QT4:

  3775.                 if (isUiBridgeable(i))

  3776.                     eQt4 = i;

  3777.                 break;

  3778. #else

  3779.             case LV2_UI_QT4:

  3780.                 if (isUiBridgeable(i) && preferUiBridges)

  3781.                     eQt4 = i;

  3782.                 iQt4 = i;

  3783.                 break;

  3784. #endif

  3785. 

  3786. #if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))

  3787.             case LV2_UI_QT5:

  3788.                 if (isUiBridgeable(i) && preferUiBridges)

  3789.                     eQt5 = i;

  3790.                 iQt5 = i;

  3791.                 break;

  3792. #else

  3793.             case LV2_UI_QT5:

  3794.                 if (isUiBridgeable(i) && preferUiBridges)

  3795.                     eQt5 = i;

  3796.                 break;

  3797. #endif

  3798. 

  3799. #ifdef CARLA_OS_MAC

  3800.             case LV2_UI_COCOA:

  3801.                 if (isUiBridgeable(i) && preferUiBridges)

  3802.                     eCocoa = i;

  3803.                 iCocoa = i;

  3804.                 break;

  3805. #endif

  3806. 

  3807. #ifdef CARLA_OS_WIN

  3808.             case LV2_UI_WINDOWS:

  3809.                 if (isUiBridgeable(i) && preferUiBridges)

  3810.                     eWindows = i;

  3811.                 iWindows = i;

  3812.                 break;

  3813. #endif

  3814. 

  3815.             case LV2_UI_X11:

  3816.                 if (isUiBridgeable(i) && preferUiBridges)

  3817.                     eX11 = i;

  3818. #ifdef Q_WS_X11

  3819.                 iX11 = i;

  3820. #endif

  3821.                 break;

  3822. 

  3823.             case LV2_UI_GTK2:

  3824.                 if (isUiBridgeable(i))

  3825.                     eGtk2 = i;

  3826.                 break;

  3827. 

  3828.             case LV2_UI_GTK3:

  3829.                 if (isUiBridgeable(i))

  3830.                     eGtk3 = i;

  3831.                 break;

  3832. 

  3833.             case LV2_UI_EXTERNAL:

  3834.             case LV2_UI_OLD_EXTERNAL:

  3835.                 // Calf Analyzer is useless using external-ui

  3836.                 if (std::strcmp(fRdfDescriptor->URI, "http://calf.sourceforge.net/plugins/Analyzer") != 0)

  3837.                     iExt = i;

  3838.                 break;

  3839. 

  3840.             default:

  3841.                 break;

  3842.             }

  3843.         }

  3844. 

  3845.         if (eQt4 >= 0)

  3846.             iFinal = eQt4;

  3847.         else if (eQt5 >= 0)

  3848.             iFinal = eQt5;

  3849.         else if (eCocoa >= 0)

  3850.             iFinal = eCocoa;

  3851.         else if (eWindows >= 0)

  3852.             iFinal = eWindows;

  3853.         else if (eX11 >= 0)

  3854.             iFinal = eX11;

  3855.         else if (eGtk2 >= 0)

  3856.             iFinal = eGtk2;

  3857.         else if (eGtk3 >= 0)

  3858.             iFinal = eGtk3;

  3859.         else if (iQt4 >= 0)

  3860.             iFinal = iQt4;

  3861.         else if (iQt5 >= 0)

  3862.             iFinal = iQt5;

  3863.         else if (iCocoa >= 0)

  3864.             iFinal = iCocoa;

  3865.         else if (iWindows >= 0)

  3866.             iFinal = iWindows;

  3867.         else if (iX11 >= 0)

  3868.             iFinal = iX11;

  3869.         else if (iExt >= 0)

  3870.             iFinal = iExt;

  3871. 

  3872.         if (iFinal < 0)

  3873.         {

  3874.             carla_stderr("Failed to find an appropriate LV2 UI for this plugin");

  3875.             return true;

  3876.         }

  3877. 

  3878.         fUi.rdfDescriptor = &fRdfDescriptor->UIs[iFinal];

  3879. 

  3880.         // -----------------------------------------------------------

  3881.         // check supported ui features

  3882. 

  3883.         canContinue = true;

  3884. 

  3885.         for (uint32_t i=0; i < fUi.rdfDescriptor->FeatureCount; ++i)

  3886.         {

  3887.             if (LV2_IS_FEATURE_REQUIRED(fUi.rdfDescriptor->Features[i].Type) && ! is_lv2_ui_feature_supported(fUi.rdfDescriptor->Features[i].URI))

  3888.             {

  3889.                 carla_stderr2("Plugin UI requires a feature that is not supported:\n%s", fUi.rdfDescriptor->Features[i].URI);

  3890.                 canContinue = false;

  3891.                 break;

  3892.             }

  3893.         }

  3894. 

  3895.         if (! canContinue)

  3896.         {

  3897.             fUi.rdfDescriptor = nullptr;

  3898.             return true;

  3899.         }

  3900. 

  3901.         // -----------------------------------------------------------

  3902.         // initialize ui according to type

  3903. 

  3904.         const LV2_Property uiType(fUi.rdfDescriptor->Type);

  3905. 

  3906.         if (iFinal == eQt4 || iFinal == eQt5 || iFinal == eCocoa || iFinal == eWindows || iFinal == eX11 || iFinal == eGtk2 || iFinal == eGtk3)

  3907.         {

  3908.             // -------------------------------------------------------

  3909.             // initialize ui bridge

  3910. 

  3911.             if (const char* const oscBinary = getUiBridgePath(uiType))

  3912.             {

  3913.                 fUi.type = PLUGIN_UI_OSC;

  3914.                 kData->osc.thread.setOscData(oscBinary, fDescriptor->URI, fUi.rdfDescriptor->URI);

  3915.             }

  3916.         }

  3917.         else

  3918.         {

  3919.             // -------------------------------------------------------

  3920.             // open UI DLL

  3921. 

  3922.             if (! kData->uiLibOpen(fUi.rdfDescriptor->Binary))

  3923.             {

  3924.                 carla_stderr2("Could not load UI library, error was:\n%s", kData->libError(fUi.rdfDescriptor->Binary));

  3925.                 fUi.rdfDescriptor = nullptr;

  3926.                 return true;

  3927.             }

  3928. 

  3929.             // -------------------------------------------------------

  3930.             // get UI DLL main entry

  3931. 

  3932.             LV2UI_DescriptorFunction uiDescFn = (LV2UI_DescriptorFunction)kData->uiLibSymbol("lv2ui_descriptor");

  3933. 

  3934.             if (uiDescFn == nullptr)

  3935.             {

  3936.                 carla_stderr2("Could not find the LV2UI Descriptor in the UI library");

  3937.                 kData->uiLibClose();

  3938.                 fUi.rdfDescriptor = nullptr;

  3939.                 return true;

  3940.             }

  3941. 

  3942.             // -------------------------------------------------------

  3943.             // get UI descriptor that matches UI URI

  3944. 

  3945.             uint32_t i = 0;

  3946.             while ((fUi.descriptor = uiDescFn(i++)))

  3947.             {

  3948.                 if (std::strcmp(fUi.descriptor->URI, fUi.rdfDescriptor->URI) == 0)

  3949.                     break;

  3950.             }

  3951. 

  3952.             if (fUi.descriptor == nullptr)

  3953.             {

  3954.                 carla_stderr2("Could not find the requested GUI in the plugin UI library");

  3955.                 kData->uiLibClose();

  3956.                 fUi.rdfDescriptor = nullptr;

  3957.                 return true;

  3958.             }

  3959. 

  3960.             // -------------------------------------------------------

  3961.             // check if ui is usable

  3962. 

  3963.             switch (uiType)

  3964.             {

  3965. #if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))

  3966.             case LV2_UI_QT5:

  3967.                 carla_debug("Will use LV2 Qt5 UI");

  3968.                 fUi.type = PLUGIN_UI_QT;

  3969.                 break;

  3970. #else

  3971.             case LV2_UI_QT4:

  3972.                 carla_debug("Will use LV2 Qt4 UI");

  3973.                 fUi.type = PLUGIN_UI_QT;

  3974.                 break;

  3975. #endif

  3976. 

  3977. #ifdef CARLA_OS_MAC

  3978.             case LV2_UI_COCOA:

  3979.                 carla_debug("Will use LV2 Cocoa UI");

  3980.                 fUi.type = PLUGIN_UI_PARENT;

  3981.                 break;

  3982. #endif

  3983. 

  3984. #ifdef CARLA_OS_WIN

  3985.             case LV2_UI_WINDOWS:

  3986.                 carla_debug("Will use LV2 Windows UI");

  3987.                 fUi.type = PLUGIN_UI_PARENT;

  3988.                 break;

  3989. #endif

  3990. 

  3991. #ifdef Q_WS_X11

  3992.             case LV2_UI_X11:

  3993.                 carla_debug("Will use LV2 X11 UI");

  3994.                 fUi.type = PLUGIN_UI_PARENT;

  3995.                 break;

  3996. #endif

  3997. 

  3998.             case LV2_UI_GTK2:

  3999.                 carla_debug("Will use LV2 Gtk2 UI, NOT!");

  4000.                 break;

  4001. 

  4002.             case LV2_UI_GTK3:

  4003.                 carla_debug("Will use LV2 Gtk3 UI, NOT!");

  4004.                 break;

  4005. 

  4006.             case LV2_UI_EXTERNAL:

  4007.             case LV2_UI_OLD_EXTERNAL:

  4008.                 carla_debug("Will use LV2 External UI");

  4009.                 fUi.type = PLUGIN_UI_EXTERNAL;

  4010.                 break;

  4011.             }

  4012. 

  4013.             if (fUi.type == PLUGIN_UI_NULL)

  4014.             {

  4015.                 kData->uiLibClose();

  4016.                 fUi.descriptor = nullptr;

  4017.                 fUi.rdfDescriptor = nullptr;

  4018.                 return true;

  4019.             }

  4020. 

  4021.             // -------------------------------------------------------

  4022.             // initialize ui features

  4023. 

  4024.             QString guiTitle(QString("%1 (GUI)").arg((const char*)fName));

  4025. 

  4026.             LV2_Extension_Data_Feature* const uiDataFt = new LV2_Extension_Data_Feature;

  4027.             uiDataFt->data_access                      = fDescriptor->extension_data;

  4028. 

  4029.             LV2UI_Port_Map* const uiPortMapFt = new LV2UI_Port_Map;

  4030.             uiPortMapFt->handle               = this;

  4031.             uiPortMapFt->port_index           = carla_lv2_ui_port_map;

  4032. 

  4033.             LV2UI_Resize* const uiResizeFt    = new LV2UI_Resize;

  4034.             uiResizeFt->handle                = this;

  4035.             uiResizeFt->ui_resize             = carla_lv2_ui_resize;

  4036. 

  4037.             LV2_External_UI_Host* const uiExternalHostFt = new LV2_External_UI_Host;

  4038.             uiExternalHostFt->ui_closed                  = carla_lv2_external_ui_closed;

  4039.             uiExternalHostFt->plugin_human_id            = carla_strdup(guiTitle.toUtf8().constData());

  4040. 

  4041.             fFeatures[kFeatureIdUiDataAccess]           = new LV2_Feature;

  4042.             fFeatures[kFeatureIdUiDataAccess]->URI      = LV2_DATA_ACCESS_URI;

  4043.             fFeatures[kFeatureIdUiDataAccess]->data     = uiDataFt;

  4044. 

  4045.             fFeatures[kFeatureIdUiInstanceAccess]       = new LV2_Feature;

  4046.             fFeatures[kFeatureIdUiInstanceAccess]->URI  = LV2_INSTANCE_ACCESS_URI;

  4047.             fFeatures[kFeatureIdUiInstanceAccess]->data = fHandle;

  4048. 

  4049.             fFeatures[kFeatureIdUiParent]             = new LV2_Feature;

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

  4051.             fFeatures[kFeatureIdUiParent]->data       = nullptr;

  4052. 

  4053.             fFeatures[kFeatureIdUiPortMap]           = new LV2_Feature;

  4054.             fFeatures[kFeatureIdUiPortMap]->URI      = LV2_UI__portMap;

  4055.             fFeatures[kFeatureIdUiPortMap]->data     = uiPortMapFt;

  4056. 

  4057.             fFeatures[kFeatureIdUiResize]             = new LV2_Feature;

  4058.             fFeatures[kFeatureIdUiResize]->URI        = LV2_UI__resize;

  4059.             fFeatures[kFeatureIdUiResize]->data       = uiResizeFt;

  4060. 

  4061.             fFeatures[kFeatureIdExternalUi]           = new LV2_Feature;

  4062.             fFeatures[kFeatureIdExternalUi]->URI      = LV2_EXTERNAL_UI__Host;

  4063.             fFeatures[kFeatureIdExternalUi]->data     = uiExternalHostFt;

  4064. 

  4065.             fFeatures[kFeatureIdExternalUiOld]       = new LV2_Feature;

  4066.             fFeatures[kFeatureIdExternalUiOld]->URI  = LV2_EXTERNAL_UI_DEPRECATED_URI;

  4067.             fFeatures[kFeatureIdExternalUiOld]->data = uiExternalHostFt;

  4068.         }

  4069. 

  4070.         return true;

  4071.     }

  4072. 

  4073. private:

  4074.     LV2_Handle   fHandle;

  4075.     LV2_Handle   fHandle2;

  4076.     LV2_Feature* fFeatures[kFeatureCount+1];

  4077.     const LV2_Descriptor*     fDescriptor;

  4078.     const LV2_RDF_Descriptor* fRdfDescriptor;

  4079. 

  4080.     float** fAudioInBuffers;

  4081.     float** fAudioOutBuffers;

  4082.     float*  fParamBuffers;

  4083. 

  4084.     Lv2PluginEventData fEventsIn;

  4085.     Lv2PluginEventData fEventsOut;

  4086.     Lv2PluginOptions   fLv2Options;

  4087. 

  4088.     NonRtList<const char*> fCustomURIDs;

  4089. 

  4090.     struct Extensions {

  4091.         const LV2_Options_Interface* options;

  4092.         const LV2_State_Interface* state;

  4093.         const LV2_Worker_Interface* worker;

  4094.         const LV2_Programs_Interface* programs;

  4095.         const LV2UI_Idle_Interface* uiidle;

  4096.         const LV2_Programs_UI_Interface* uiprograms;

  4097. 

  4098.         Extensions()

  4099.             : options(nullptr),

  4100.               state(nullptr),

  4101.               worker(nullptr),

  4102.               programs(nullptr),

  4103.               uiidle(nullptr),

  4104.               uiprograms(nullptr) {}

  4105.     } fExt;

  4106. 

  4107.     struct UI {

  4108.         Lv2PluginGuiType type;

  4109.         LV2UI_Handle handle;

  4110.         LV2UI_Widget widget;

  4111.         const LV2UI_Descriptor* descriptor;

  4112.         const LV2_RDF_UI*       rdfDescriptor;

  4113. 

  4114.         UI()

  4115.             : type(PLUGIN_UI_NULL),

  4116.               handle(nullptr),

  4117.               widget(nullptr),

  4118.               descriptor(nullptr),

  4119.               rdfDescriptor(nullptr) {}

  4120. 

  4121.         ~UI()

  4122.         {

  4123.             CARLA_ASSERT(handle == nullptr);

  4124.             CARLA_ASSERT(widget == nullptr);

  4125.             CARLA_ASSERT(descriptor == nullptr);

  4126.             CARLA_ASSERT(rdfDescriptor == nullptr);

  4127.         }

  4128. 

  4129.     } fUi;

  4130. 

  4131.     // -------------------------------------------------------------------

  4132.     // Event Feature

  4133. 

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

  4135.     {

  4136.         carla_debug("carla_lv2_event_ref(%p, %p)", callback_data, event);

  4137.         CARLA_ASSERT(callback_data != nullptr);

  4138.         CARLA_ASSERT(event != nullptr);

  4139. 

  4140.         return 0;

  4141.     }

  4142. 

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

  4144.     {

  4145.         carla_debug("carla_lv2_event_unref(%p, %p)", callback_data, event);

  4146.         CARLA_ASSERT(callback_data != nullptr);

  4147.         CARLA_ASSERT(event != nullptr);

  4148. 

  4149.         return 0;

  4150.     }

  4151. 

  4152.     // -------------------------------------------------------------------

  4153.     // Logs Feature

  4154. 

  4155.     static int carla_lv2_log_printf(LV2_Log_Handle handle, LV2_URID type, const char* fmt, ...)

  4156.     {

  4157.         CARLA_ASSERT(handle != nullptr);

  4158.         CARLA_ASSERT(type > CARLA_URI_MAP_ID_NULL);

  4159. 

  4160. #ifndef DEBUG

  4161.         if (type == CARLA_URI_MAP_ID_LOG_TRACE)

  4162.             return 0;

  4163. #endif

  4164. 

  4165.         va_list args;

  4166.         va_start(args, fmt);

  4167.         const int ret = carla_lv2_log_vprintf(handle, type, fmt, args);

  4168.         va_end(args);

  4169. 

  4170.         return ret;

  4171.     }

  4172. 

  4173.     static int carla_lv2_log_vprintf(LV2_Log_Handle handle, LV2_URID type, const char* fmt, va_list ap)

  4174.     {

  4175.         CARLA_ASSERT(handle != nullptr);

  4176.         CARLA_ASSERT(type > CARLA_URI_MAP_ID_NULL);

  4177. 

  4178. #ifndef DEBUG

  4179.         if (type == CARLA_URI_MAP_ID_LOG_TRACE)

  4180.             return 0;

  4181. #endif

  4182. 

  4183.         int ret = 0;

  4184. 

  4185.         switch (type)

  4186.         {

  4187.         case CARLA_URI_MAP_ID_LOG_ERROR:

  4188. #ifndef CARLA_OS_WIN

  4189.             std::fprintf(stderr, "\x1b[31m");

  4190. #endif

  4191.             ret = std::vfprintf(stderr, fmt, ap);

  4192. #ifndef CARLA_OS_WIN

  4193.             std::fprintf(stderr, "\x1b[0m");

  4194. #endif

  4195.             break;

  4196. 

  4197.         case CARLA_URI_MAP_ID_LOG_NOTE:

  4198.             ret = std::vfprintf(stdout, fmt, ap);

  4199.             break;

  4200. 

  4201.         case CARLA_URI_MAP_ID_LOG_TRACE:

  4202. #ifdef DEBUG

  4203. # ifndef CARLA_OS_WIN

  4204.             std::fprintf(stdout, "\x1b[30;1m");

  4205. # endif

  4206.             ret = std::vfprintf(stdout, fmt, ap);

  4207. # ifndef CARLA_OS_WIN

  4208.             std::fprintf(stdout, "\x1b[0m");

  4209. # endif

  4210. #endif

  4211.             break;

  4212. 

  4213.         case CARLA_URI_MAP_ID_LOG_WARNING:

  4214.             ret = std::vfprintf(stderr, fmt, ap);

  4215.             break;

  4216. 

  4217.         default:

  4218.             break;

  4219.         }

  4220. 

  4221.         return ret;

  4222.     }

  4223. 

  4224.     // -------------------------------------------------------------------

  4225.     // Programs Feature

  4226. 

  4227.     static void carla_lv2_program_changed(LV2_Programs_Handle handle, int32_t index)

  4228.     {

  4229.         carla_debug("carla_lv2_program_changed(%p, %i)", handle, index);

  4230.         CARLA_ASSERT(handle != nullptr);

  4231. 

  4232.         if (handle == nullptr)

  4233.             return;

  4234. 

  4235.         ((Lv2Plugin*)handle)->handleProgramChanged(index);

  4236.     }

  4237. 

  4238.     // -------------------------------------------------------------------

  4239.     // State Feature

  4240. 

  4241.     static char* carla_lv2_state_make_path(LV2_State_Make_Path_Handle handle, const char* path)

  4242.     {

  4243.         carla_debug("carla_lv2_state_make_path(%p, \"%s\")", handle, path);

  4244.         CARLA_ASSERT(handle != nullptr);

  4245.         CARLA_ASSERT(path != nullptr);

  4246. 

  4247.         if (path == nullptr)

  4248.             return nullptr;

  4249. 

  4250.         QDir dir;

  4251.         dir.mkpath(path);

  4252.         return strdup(path);

  4253.     }

  4254. 

  4255.     static char* carla_lv2_state_map_abstract_path(LV2_State_Map_Path_Handle handle, const char* absolute_path)

  4256.     {

  4257.         carla_debug("carla_lv2_state_map_abstract_path(%p, \"%s\")", handle, absolute_path);

  4258.         CARLA_ASSERT(handle != nullptr);

  4259.         CARLA_ASSERT(absolute_path != nullptr);

  4260. 

  4261.         if (absolute_path == nullptr)

  4262.             return nullptr;

  4263. 

  4264.         QDir dir(absolute_path);

  4265.         return strdup(dir.canonicalPath().toUtf8().constData());

  4266.     }

  4267. 

  4268.     static char* carla_lv2_state_map_absolute_path(LV2_State_Map_Path_Handle handle, const char* abstract_path)

  4269.     {

  4270.         carla_debug("carla_lv2_state_map_absolute_path(%p, \"%s\")", handle, abstract_path);

  4271.         CARLA_ASSERT(handle != nullptr);

  4272.         CARLA_ASSERT(abstract_path != nullptr);

  4273. 

  4274.         if (abstract_path == nullptr)

  4275.             return nullptr;

  4276. 

  4277.         QDir dir(abstract_path);

  4278.         return strdup(dir.absolutePath().toUtf8().constData());

  4279.     }

  4280. 

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

  4282.     {

  4283.         carla_debug("carla_lv2_state_store(%p, %i, %p, " P_SIZE ", %i, %i)", handle, key, value, size, type, flags);

  4284.         CARLA_ASSERT(handle != nullptr);

  4285. 

  4286.         if (handle == nullptr)

  4287.             return LV2_STATE_ERR_UNKNOWN;

  4288. 

  4289.         return ((Lv2Plugin*)handle)->handleStateStore(key, value, size, type, flags);

  4290.     }

  4291. 

  4292.     static const void* carla_lv2_state_retrieve(LV2_State_Handle handle, uint32_t key, size_t* size, uint32_t* type, uint32_t* flags)

  4293.     {

  4294.         carla_debug("carla_lv2_state_retrieve(%p, %i, %p, %p, %p)", handle, key, size, type, flags);

  4295.         CARLA_ASSERT(handle != nullptr);

  4296. 

  4297.         if (handle == nullptr)

  4298.             return nullptr;

  4299. 

  4300.         return ((Lv2Plugin*)handle)->handleStateRetrieve(key, size, type, flags);

  4301.     }

  4302. 

  4303.     // -------------------------------------------------------------------

  4304.     // URI-Map Feature

  4305. 

  4306.     static uint32_t carla_lv2_uri_to_id(LV2_URI_Map_Callback_Data data, const char* map, const char* uri)

  4307.     {

  4308.         carla_debug("carla_lv2_uri_to_id(%p, \"%s\", \"%s\")", data, map, uri);

  4309.         return carla_lv2_urid_map((LV2_URID_Map_Handle*)data, uri);

  4310.     }

  4311. 

  4312.     // -------------------------------------------------------------------

  4313.     // URID Feature

  4314. 

  4315.     static LV2_URID carla_lv2_urid_map(LV2_URID_Map_Handle handle, const char* uri)

  4316.     {

  4317.         CARLA_ASSERT(handle != nullptr);

  4318.         CARLA_ASSERT(uri != nullptr);

  4319.         carla_debug("carla_lv2_urid_map(%p, \"%s\")", handle, uri);

  4320. 

  4321.         if (uri == nullptr)

  4322.             return CARLA_URI_MAP_ID_NULL;

  4323. 

  4324.         // Atom types

  4325.         if (std::strcmp(uri, LV2_ATOM__Chunk) == 0)

  4326.             return CARLA_URI_MAP_ID_ATOM_CHUNK;

  4327.         if (std::strcmp(uri, LV2_ATOM__Double) == 0)

  4328.             return CARLA_URI_MAP_ID_ATOM_DOUBLE;

  4329.         if (std::strcmp(uri, LV2_ATOM__Int) == 0)

  4330.             return CARLA_URI_MAP_ID_ATOM_INT;

  4331.         if (std::strcmp(uri, LV2_ATOM__Path) == 0)

  4332.             return CARLA_URI_MAP_ID_ATOM_PATH;

  4333.         if (std::strcmp(uri, LV2_ATOM__Sequence) == 0)

  4334.             return CARLA_URI_MAP_ID_ATOM_SEQUENCE;

  4335.         if (std::strcmp(uri, LV2_ATOM__String) == 0)

  4336.             return CARLA_URI_MAP_ID_ATOM_STRING;

  4337.         if (std::strcmp(uri, LV2_ATOM__atomTransfer) == 0)

  4338.             return CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM;

  4339.         if (std::strcmp(uri, LV2_ATOM__eventTransfer) == 0)

  4340.             return CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT;

  4341. 

  4342.         // BufSize types

  4343.         if (std::strcmp(uri, LV2_BUF_SIZE__maxBlockLength) == 0)

  4344.             return CARLA_URI_MAP_ID_BUF_MAX_LENGTH;

  4345.         if (std::strcmp(uri, LV2_BUF_SIZE__minBlockLength) == 0)

  4346.             return CARLA_URI_MAP_ID_BUF_MIN_LENGTH;

  4347.         if (std::strcmp(uri, LV2_BUF_SIZE__sequenceSize) == 0)

  4348.             return CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE;

  4349. 

  4350.         // Log types

  4351.         if (std::strcmp(uri, LV2_LOG__Error) == 0)

  4352.             return CARLA_URI_MAP_ID_LOG_ERROR;

  4353.         if (std::strcmp(uri, LV2_LOG__Note) == 0)

  4354.             return CARLA_URI_MAP_ID_LOG_NOTE;

  4355.         if (std::strcmp(uri, LV2_LOG__Trace) == 0)

  4356.             return CARLA_URI_MAP_ID_LOG_TRACE;

  4357.         if (std::strcmp(uri, LV2_LOG__Warning) == 0)

  4358.             return CARLA_URI_MAP_ID_LOG_WARNING;

  4359. 

  4360.         // Others

  4361.         if (std::strcmp(uri, LV2_MIDI__MidiEvent) == 0)

  4362.             return CARLA_URI_MAP_ID_MIDI_EVENT;

  4363.         if (std::strcmp(uri, LV2_PARAMETERS__sampleRate) == 0)

  4364.             return CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE;

  4365.         if (std::strcmp(uri, LV2_TIME__Position) == 0)

  4366.             return CARLA_URI_MAP_ID_TIME_POSITION;

  4367. 

  4368.         if (handle == nullptr)

  4369.             return CARLA_URI_MAP_ID_NULL;

  4370. 

  4371.         // Custom types

  4372.         return ((Lv2Plugin*)handle)->getCustomURID(uri);

  4373.     }

  4374. 

  4375.     static const char* carla_lv2_urid_unmap(LV2_URID_Map_Handle handle, LV2_URID urid)

  4376.     {

  4377.         carla_debug("carla_lv2_urid_unmap(%p, %i)", handle, urid);

  4378.         CARLA_ASSERT(handle != nullptr);

  4379.         CARLA_ASSERT(urid > CARLA_URI_MAP_ID_NULL);

  4380. 

  4381.         if (urid == CARLA_URI_MAP_ID_NULL)

  4382.             return nullptr;

  4383. 

  4384.         // Atom types

  4385.         if (urid == CARLA_URI_MAP_ID_ATOM_CHUNK)

  4386.             return LV2_ATOM__Chunk;

  4387.         if (urid == CARLA_URI_MAP_ID_ATOM_DOUBLE)

  4388.             return LV2_ATOM__Double;

  4389.         if (urid == CARLA_URI_MAP_ID_ATOM_INT)

  4390.             return LV2_ATOM__Int;

  4391.         if (urid == CARLA_URI_MAP_ID_ATOM_PATH)

  4392.             return LV2_ATOM__Path;

  4393.         if (urid == CARLA_URI_MAP_ID_ATOM_SEQUENCE)

  4394.             return LV2_ATOM__Sequence;

  4395.         if (urid == CARLA_URI_MAP_ID_ATOM_STRING)

  4396.             return LV2_ATOM__String;

  4397.         if (urid == CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM)

  4398.             return LV2_ATOM__atomTransfer;

  4399.         if (urid == CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT)

  4400.             return LV2_ATOM__eventTransfer;

  4401. 

  4402.         // BufSize types

  4403.         if (urid == CARLA_URI_MAP_ID_BUF_MAX_LENGTH)

  4404.             return LV2_BUF_SIZE__maxBlockLength;

  4405.         if (urid == CARLA_URI_MAP_ID_BUF_MIN_LENGTH)

  4406.             return LV2_BUF_SIZE__minBlockLength;

  4407.         if (urid == CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE)

  4408.             return LV2_BUF_SIZE__sequenceSize;

  4409. 

  4410.         // Log types

  4411.         if (urid == CARLA_URI_MAP_ID_LOG_ERROR)

  4412.             return LV2_LOG__Error;

  4413.         if (urid == CARLA_URI_MAP_ID_LOG_NOTE)

  4414.             return LV2_LOG__Note;

  4415.         if (urid == CARLA_URI_MAP_ID_LOG_TRACE)

  4416.             return LV2_LOG__Trace;

  4417.         if (urid == CARLA_URI_MAP_ID_LOG_WARNING)

  4418.             return LV2_LOG__Warning;

  4419. 

  4420.         // Others

  4421.         if (urid == CARLA_URI_MAP_ID_MIDI_EVENT)

  4422.             return LV2_MIDI__MidiEvent;

  4423.         if (urid == CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE)

  4424.             return LV2_PARAMETERS__sampleRate;

  4425.         if (urid == CARLA_URI_MAP_ID_TIME_POSITION)

  4426.             return LV2_TIME__Position;

  4427. 

  4428.         if (handle == nullptr)

  4429.             return nullptr;

  4430. 

  4431.         // Custom types

  4432.         return ((Lv2Plugin*)handle)->getCustomURIString(urid);

  4433.     }

  4434. 

  4435.     // -------------------------------------------------------------------

  4436.     // Worker Feature

  4437. 

  4438.     static LV2_Worker_Status carla_lv2_worker_schedule(LV2_Worker_Schedule_Handle handle, uint32_t size, const void* data)

  4439.     {

  4440.         carla_debug("carla_lv2_worker_schedule(%p, %i, %p)", handle, size, data);

  4441.         CARLA_ASSERT(handle != nullptr);

  4442. 

  4443.         if (handle == nullptr)

  4444.             return LV2_WORKER_ERR_UNKNOWN;

  4445. 

  4446.         //return ((Lv2Plugin*)handle)->handleWorkerSchedule(size, data);

  4447.         return LV2_WORKER_ERR_UNKNOWN;

  4448.     }

  4449. 

  4450.     static LV2_Worker_Status carla_lv2_worker_respond(LV2_Worker_Respond_Handle handle, uint32_t size, const void* data)

  4451.     {

  4452.         carla_debug("carla_lv2_worker_respond(%p, %i, %p)", handle, size, data);

  4453.         CARLA_ASSERT(handle != nullptr);

  4454. 

  4455.         if (handle == nullptr)

  4456.             return LV2_WORKER_ERR_UNKNOWN;

  4457. 

  4458.         //return ((Lv2Plugin*)handle)->handleWorkerRespond(size, data);

  4459.         return LV2_WORKER_ERR_UNKNOWN;

  4460.     }

  4461. 

  4462.     // -------------------------------------------------------------------

  4463.     // UI Port-Map Feature

  4464. 

  4465.     static uint32_t carla_lv2_ui_port_map(LV2UI_Feature_Handle handle, const char* symbol)

  4466.     {

  4467.         carla_debug("carla_lv2_ui_port_map(%p, \"%s\")", handle, symbol);

  4468.         CARLA_ASSERT(handle);

  4469. 

  4470.         if (handle == nullptr)

  4471.             return LV2UI_INVALID_PORT_INDEX;

  4472. 

  4473.         return ((Lv2Plugin*)handle)->handleUiPortMap(symbol);

  4474.     }

  4475. 

  4476.     // -------------------------------------------------------------------

  4477.     // UI Resize Feature

  4478. 

  4479.     static int carla_lv2_ui_resize(LV2UI_Feature_Handle handle, int width, int height)

  4480.     {

  4481.         carla_debug("carla_lv2_ui_resize(%p, %i, %i)", handle, width, height);

  4482.         CARLA_ASSERT(handle != nullptr);

  4483. 

  4484.         if (handle == nullptr)

  4485.             return 1;

  4486. 

  4487.         return ((Lv2Plugin*)handle)->handleUiResize(width, height);

  4488.     }

  4489. 

  4490.     // -------------------------------------------------------------------

  4491.     // External UI Feature

  4492. 

  4493.     static void carla_lv2_external_ui_closed(LV2UI_Controller controller)

  4494.     {

  4495.         carla_debug("carla_lv2_external_ui_closed(%p)", controller);

  4496.         CARLA_ASSERT(controller != nullptr);

  4497. 

  4498.         if (controller == nullptr)

  4499.             return;

  4500. 

  4501.         ((Lv2Plugin*)controller)->handleExternalUiClosed();

  4502.     }

  4503. 

  4504.     // -------------------------------------------------------------------

  4505.     // UI Extension

  4506. 

  4507.     static void carla_lv2_ui_write_function(LV2UI_Controller controller, uint32_t port_index, uint32_t buffer_size, uint32_t format, const void* buffer)

  4508.     {

  4509.         carla_debug("carla_lv2_ui_write_function(%p, %i, %i, %i, %p)", controller, port_index, buffer_size, format, buffer);

  4510.         CARLA_ASSERT(controller != nullptr);

  4511. 

  4512.         if (controller == nullptr)

  4513.             return;

  4514. 

  4515.         ((Lv2Plugin*)controller)->handleUiWrite(port_index, buffer_size, format, buffer);

  4516.     }

  4517. 

  4518.     // -------------------------------------------------------------------

  4519. 

  4520.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(Lv2Plugin)

  4521. };

  4522. 

  4523. CARLA_BACKEND_END_NAMESPACE

  4524. 

  4525. #else // WANT_VST

  4526. # warning Building without LV2 support

  4527. #endif

  4528. 

  4529. CARLA_BACKEND_START_NAMESPACE

  4530. 

  4531. CarlaPlugin* CarlaPlugin::newLV2(const Initializer& init)

  4532. {

  4533.     carla_debug("CarlaPlugin::newLV2({%p, \"%s\", \"%s\"})", init.engine, init.name, init.label);

  4534. 

  4535. #ifdef WANT_LV2

  4536.     Lv2Plugin* const plugin(new Lv2Plugin(init.engine, init.id));

  4537. 

  4538.     if (! plugin->init(init.name, init.label))

  4539.     {

  4540.         delete plugin;

  4541.         return nullptr;

  4542.     }

  4543. 

  4544.     plugin->reload();

  4545. 

  4546.     if (init.engine->getProccessMode() == PROCESS_MODE_CONTINUOUS_RACK && ! CarlaPluginProtectedData::canRunInRack(plugin))

  4547.     {

  4548.         init.engine->setLastError("Carla's rack mode can only work with Mono or Stereo LV2 plugins, sorry!");

  4549.         delete plugin;

  4550.         return nullptr;

  4551.     }

  4552. 

  4553.     return plugin;

  4554. #else

  4555.     init.engine->setLastError("LV2 support not available");

  4556.     return nullptr;

  4557. #endif

  4558. }

  4559. 

  4560. CARLA_BACKEND_END_NAMESPACE