falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 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.
3377 Commits
16 Branches
229MB
Tree: 72b1a13df1
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '72b1a13df1'
${ noResults }
Carla/source/backend/plugin/CarlaPluginLV2.cpp

6249 lines
236KB
Raw Blame History 

  1. /*

  2.  * Carla LV2 Plugin

  3.  * Copyright (C) 2011-2016 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 doc/GPL.txt file.

  16.  */

  17. 

  18. // testing macros

  19. // #define LV2_UIS_ONLY_BRIDGES

  20. // #define LV2_UIS_ONLY_INPROCESS

  21. 

  22. #include "CarlaPluginInternal.hpp"

  23. #include "CarlaEngine.hpp"

  24. 

  25. #include "CarlaLv2Utils.hpp"

  26. 

  27. #include "CarlaBase64Utils.hpp"

  28. #include "CarlaEngineUtils.hpp"

  29. #include "CarlaPipeUtils.hpp"

  30. #include "CarlaPluginUI.hpp"

  31. #include "Lv2AtomRingBuffer.hpp"

  32. 

  33. #include "../engine/CarlaEngineOsc.hpp"

  34. #include "../modules/lilv/config/lilv_config.h"

  35. 

  36. extern "C" {

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

  38. }

  39. 

  40. #include "juce_core/juce_core.h"

  41. 

  42. #include <string>

  43. #include <vector>

  44. 

  45. using juce::File;

  46. 

  47. #define URI_CARLA_ATOM_WORKER "http://kxstudio.sf.net/ns/carla/atomWorker"

  48. 

  49. CARLA_BACKEND_START_NAMESPACE

  50. 

  51. // -------------------------------------------------------------------------------------------------------------------

  52. // Fallback data

  53. 

  54. static const CustomData       kCustomDataFallback       = { nullptr, nullptr, nullptr };

  55. static /* */ CustomData       kCustomDataFallbackNC     = { nullptr, nullptr, nullptr };

  56. static const ExternalMidiNote kExternalMidiNoteFallback = { -1, 0, 0 };

  57. 

  58. // -------------------------------------------------------------------------------------------------------------------

  59. 

  60. // Maximum default buffer size

  61. const uint MAX_DEFAULT_BUFFER_SIZE = 8192; // 0x2000

  62. 

  63. // Extra Plugin Hints

  64. const uint PLUGIN_HAS_EXTENSION_OPTIONS  = 0x1000;

  65. const uint PLUGIN_HAS_EXTENSION_PROGRAMS = 0x2000;

  66. const uint PLUGIN_HAS_EXTENSION_STATE    = 0x4000;

  67. const uint PLUGIN_HAS_EXTENSION_WORKER   = 0x8000;

  68. 

  69. // Extra Parameter Hints

  70. const uint PARAMETER_IS_STRICT_BOUNDS = 0x1000;

  71. const uint PARAMETER_IS_TRIGGER       = 0x2000;

  72. 

  73. // LV2 Event Data/Types

  74. const uint CARLA_EVENT_DATA_ATOM    = 0x01;

  75. const uint CARLA_EVENT_DATA_EVENT   = 0x02;

  76. const uint CARLA_EVENT_DATA_MIDI_LL = 0x04;

  77. const uint CARLA_EVENT_TYPE_MESSAGE = 0x10; // unused

  78. const uint CARLA_EVENT_TYPE_MIDI    = 0x20;

  79. const uint CARLA_EVENT_TYPE_TIME    = 0x40;

  80. 

  81. // LV2 URI Map Ids

  82. const uint32_t CARLA_URI_MAP_ID_NULL                   =  0;

  83. const uint32_t CARLA_URI_MAP_ID_ATOM_BLANK             =  1;

  84. const uint32_t CARLA_URI_MAP_ID_ATOM_BOOL              =  2;

  85. const uint32_t CARLA_URI_MAP_ID_ATOM_CHUNK             =  3;

  86. const uint32_t CARLA_URI_MAP_ID_ATOM_DOUBLE            =  4;

  87. const uint32_t CARLA_URI_MAP_ID_ATOM_EVENT             =  5;

  88. const uint32_t CARLA_URI_MAP_ID_ATOM_FLOAT             =  6;

  89. const uint32_t CARLA_URI_MAP_ID_ATOM_INT               =  7;

  90. const uint32_t CARLA_URI_MAP_ID_ATOM_LITERAL           =  8;

  91. const uint32_t CARLA_URI_MAP_ID_ATOM_LONG              =  9;

  92. const uint32_t CARLA_URI_MAP_ID_ATOM_NUMBER            = 10;

  93. const uint32_t CARLA_URI_MAP_ID_ATOM_OBJECT            = 11;

  94. const uint32_t CARLA_URI_MAP_ID_ATOM_PATH              = 12;

  95. const uint32_t CARLA_URI_MAP_ID_ATOM_PROPERTY          = 13;

  96. const uint32_t CARLA_URI_MAP_ID_ATOM_RESOURCE          = 14;

  97. const uint32_t CARLA_URI_MAP_ID_ATOM_SEQUENCE          = 15;

  98. const uint32_t CARLA_URI_MAP_ID_ATOM_SOUND             = 16;

  99. const uint32_t CARLA_URI_MAP_ID_ATOM_STRING            = 17;

  100. const uint32_t CARLA_URI_MAP_ID_ATOM_TUPLE             = 18;

  101. const uint32_t CARLA_URI_MAP_ID_ATOM_URI               = 19;

  102. const uint32_t CARLA_URI_MAP_ID_ATOM_URID              = 20;

  103. const uint32_t CARLA_URI_MAP_ID_ATOM_VECTOR            = 21;

  104. const uint32_t CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM     = 22;

  105. const uint32_t CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT    = 23;

  106. const uint32_t CARLA_URI_MAP_ID_BUF_MAX_LENGTH         = 24;

  107. const uint32_t CARLA_URI_MAP_ID_BUF_MIN_LENGTH         = 25;

  108. const uint32_t CARLA_URI_MAP_ID_BUF_NOMINAL_LENGTH     = 26;

  109. const uint32_t CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE      = 27;

  110. const uint32_t CARLA_URI_MAP_ID_LOG_ERROR              = 28;

  111. const uint32_t CARLA_URI_MAP_ID_LOG_NOTE               = 29;

  112. const uint32_t CARLA_URI_MAP_ID_LOG_TRACE              = 30;

  113. const uint32_t CARLA_URI_MAP_ID_LOG_WARNING            = 31;

  114. const uint32_t CARLA_URI_MAP_ID_TIME_POSITION          = 32; // base type

  115. const uint32_t CARLA_URI_MAP_ID_TIME_BAR               = 33; // values

  116. const uint32_t CARLA_URI_MAP_ID_TIME_BAR_BEAT          = 34;

  117. const uint32_t CARLA_URI_MAP_ID_TIME_BEAT              = 35;

  118. const uint32_t CARLA_URI_MAP_ID_TIME_BEAT_UNIT         = 36;

  119. const uint32_t CARLA_URI_MAP_ID_TIME_BEATS_PER_BAR     = 37;

  120. const uint32_t CARLA_URI_MAP_ID_TIME_BEATS_PER_MINUTE  = 38;

  121. const uint32_t CARLA_URI_MAP_ID_TIME_FRAME             = 39;

  122. const uint32_t CARLA_URI_MAP_ID_TIME_FRAMES_PER_SECOND = 40;

  123. const uint32_t CARLA_URI_MAP_ID_TIME_SPEED             = 41;

  124. const uint32_t CARLA_URI_MAP_ID_TIME_TICKS_PER_BEAT    = 42;

  125. const uint32_t CARLA_URI_MAP_ID_MIDI_EVENT             = 43;

  126. const uint32_t CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE      = 44;

  127. const uint32_t CARLA_URI_MAP_ID_UI_WINDOW_TITLE        = 45;

  128. const uint32_t CARLA_URI_MAP_ID_CARLA_ATOM_WORKER      = 46;

  129. const uint32_t CARLA_URI_MAP_ID_CARLA_TRANSIENT_WIN_ID = 47;

  130. const uint32_t CARLA_URI_MAP_ID_COUNT                  = 48;

  131. 

  132. // LV2 Feature Ids

  133. const uint32_t kFeatureIdBufSizeBounded   =  0;

  134. const uint32_t kFeatureIdBufSizeFixed     =  1;

  135. const uint32_t kFeatureIdBufSizePowerOf2  =  2;

  136. const uint32_t kFeatureIdEvent            =  3;

  137. const uint32_t kFeatureIdHardRtCapable    =  4;

  138. const uint32_t kFeatureIdInPlaceBroken    =  5;

  139. const uint32_t kFeatureIdIsLive           =  6;

  140. const uint32_t kFeatureIdLogs             =  7;

  141. const uint32_t kFeatureIdOptions          =  8;

  142. const uint32_t kFeatureIdPrograms         =  9;

  143. const uint32_t kFeatureIdResizePort       = 10;

  144. const uint32_t kFeatureIdRtMemPool        = 11;

  145. const uint32_t kFeatureIdRtMemPoolOld     = 12;

  146. const uint32_t kFeatureIdStateMakePath    = 13;

  147. const uint32_t kFeatureIdStateMapPath     = 14;

  148. const uint32_t kFeatureIdStrictBounds     = 15;

  149. const uint32_t kFeatureIdUriMap           = 16;

  150. const uint32_t kFeatureIdUridMap          = 17;

  151. const uint32_t kFeatureIdUridUnmap        = 18;

  152. const uint32_t kFeatureIdWorker           = 19;

  153. const uint32_t kFeatureCountPlugin        = 20;

  154. const uint32_t kFeatureIdUiDataAccess     = 20;

  155. const uint32_t kFeatureIdUiInstanceAccess = 21;

  156. const uint32_t kFeatureIdUiIdleInterface  = 22;

  157. const uint32_t kFeatureIdUiFixedSize      = 23;

  158. const uint32_t kFeatureIdUiMakeResident   = 24;

  159. const uint32_t kFeatureIdUiMakeResident2  = 25;

  160. const uint32_t kFeatureIdUiNoUserResize   = 26;

  161. const uint32_t kFeatureIdUiParent         = 27;

  162. const uint32_t kFeatureIdUiPortMap        = 28;

  163. const uint32_t kFeatureIdUiPortSubscribe  = 29;

  164. const uint32_t kFeatureIdUiResize         = 30;

  165. const uint32_t kFeatureIdUiTouch          = 31;

  166. const uint32_t kFeatureIdExternalUi       = 32;

  167. const uint32_t kFeatureIdExternalUiOld    = 33;

  168. const uint32_t kFeatureCountAll           = 34;

  169. 

  170. // -------------------------------------------------------------------------------------------------------------------

  171. 

  172. struct Lv2EventData {

  173.     uint32_t type;

  174.     uint32_t rindex;

  175.     CarlaEngineEventPort* port;

  176. 

  177.     union {

  178.         LV2_Atom_Buffer* atom;

  179.         LV2_Event_Buffer* event;

  180.         LV2_MIDI midi;

  181.     };

  182. 

  183.     Lv2EventData() noexcept

  184.         : type(0x0),

  185.           rindex(0),

  186.           port(nullptr) {}

  187. 

  188.     ~Lv2EventData() noexcept

  189.     {

  190.         if (port != nullptr)

  191.         {

  192.             delete port;

  193.             port = nullptr;

  194.         }

  195. 

  196.         const uint32_t rtype(type);

  197.         type = 0x0;

  198. 

  199.         if (rtype & CARLA_EVENT_DATA_ATOM)

  200.         {

  201.             CARLA_SAFE_ASSERT_RETURN(atom != nullptr,);

  202. 

  203.             std::free(atom);

  204.             atom = nullptr;

  205.         }

  206.         else if (rtype & CARLA_EVENT_DATA_EVENT)

  207.         {

  208.             CARLA_SAFE_ASSERT_RETURN(event != nullptr,);

  209. 

  210.             std::free(event);

  211.             event = nullptr;

  212.         }

  213.         else if (rtype & CARLA_EVENT_DATA_MIDI_LL)

  214.         {

  215.             CARLA_SAFE_ASSERT_RETURN(midi.data != nullptr,);

  216. 

  217.             delete[] midi.data;

  218.             midi.data = nullptr;

  219.         }

  220.     }

  221. 

  222.     CARLA_DECLARE_NON_COPY_STRUCT(Lv2EventData)

  223. };

  224. 

  225. struct CarlaPluginLV2EventData {

  226.     uint32_t count;

  227.     Lv2EventData* data;

  228.     Lv2EventData* ctrl; // default port, either this->data[x] or pData->portIn/Out

  229.     uint32_t ctrlIndex;

  230. 

  231.     CarlaPluginLV2EventData() noexcept

  232.         : count(0),

  233.           data(nullptr),

  234.           ctrl(nullptr),

  235.           ctrlIndex(0) {}

  236. 

  237.     ~CarlaPluginLV2EventData() noexcept

  238.     {

  239.         CARLA_SAFE_ASSERT_INT(count == 0, count);

  240.         CARLA_SAFE_ASSERT(data == nullptr);

  241.         CARLA_SAFE_ASSERT(ctrl == nullptr);

  242.         CARLA_SAFE_ASSERT_INT(ctrlIndex == 0, ctrlIndex);

  243.     }

  244. 

  245.     void createNew(const uint32_t newCount)

  246.     {

  247.         CARLA_SAFE_ASSERT_INT(count == 0, count);

  248.         CARLA_SAFE_ASSERT_INT(ctrlIndex == 0, ctrlIndex);

  249.         CARLA_SAFE_ASSERT_RETURN(data == nullptr,);

  250.         CARLA_SAFE_ASSERT_RETURN(ctrl == nullptr,);

  251.         CARLA_SAFE_ASSERT_RETURN(newCount > 0,);

  252. 

  253.         data  = new Lv2EventData[newCount];

  254.         count = newCount;

  255. 

  256.         ctrl      = nullptr;

  257.         ctrlIndex = 0;

  258.     }

  259. 

  260.     void clear() noexcept

  261.     {

  262.         if (data != nullptr)

  263.         {

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

  265.             {

  266.                 if (data[i].port != nullptr && ctrl != nullptr && data[i].port == ctrl->port)

  267.                     data[i].port = nullptr;

  268.             }

  269. 

  270.             delete[] data;

  271.             data = nullptr;

  272.         }

  273. 

  274.         count = 0;

  275. 

  276.         ctrl      = nullptr;

  277.         ctrlIndex = 0;

  278.     }

  279. 

  280.     void initBuffers() const noexcept

  281.     {

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

  283.         {

  284.             if (data[i].port != nullptr && (ctrl == nullptr || data[i].port != ctrl->port))

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

  286.         }

  287.     }

  288. 

  289.     CARLA_DECLARE_NON_COPY_STRUCT(CarlaPluginLV2EventData)

  290. };

  291. 

  292. // -------------------------------------------------------------------------------------------------------------------

  293. 

  294. struct CarlaPluginLV2Options {

  295.     enum OptIndex {

  296.         MaxBlockLenth = 0,

  297.         MinBlockLenth,

  298.         NominalBlockLenth,

  299.         SequenceSize,

  300.         SampleRate,

  301.         FrontendWinId,

  302.         WindowTitle,

  303.         Null,

  304.         Count

  305.     };

  306. 

  307.     int maxBufferSize;

  308.     int minBufferSize;

  309.     int nominalBufferSize;

  310.     int sequenceSize;

  311.     double sampleRate;

  312.     int64_t frontendWinId;

  313.     const char* windowTitle;

  314.     LV2_Options_Option opts[Count];

  315. 

  316.     CarlaPluginLV2Options() noexcept

  317.         : maxBufferSize(0),

  318.           minBufferSize(0),

  319.           sequenceSize(MAX_DEFAULT_BUFFER_SIZE),

  320.           sampleRate(0.0),

  321.           frontendWinId(0),

  322.           windowTitle(nullptr)

  323.     {

  324.         LV2_Options_Option& optMaxBlockLenth(opts[MaxBlockLenth]);

  325.         optMaxBlockLenth.context = LV2_OPTIONS_INSTANCE;

  326.         optMaxBlockLenth.subject = 0;

  327.         optMaxBlockLenth.key     = CARLA_URI_MAP_ID_BUF_MAX_LENGTH;

  328.         optMaxBlockLenth.size    = sizeof(int);

  329.         optMaxBlockLenth.type    = CARLA_URI_MAP_ID_ATOM_INT;

  330.         optMaxBlockLenth.value   = &maxBufferSize;

  331. 

  332.         LV2_Options_Option& optMinBlockLenth(opts[MinBlockLenth]);

  333.         optMinBlockLenth.context = LV2_OPTIONS_INSTANCE;

  334.         optMinBlockLenth.subject = 0;

  335.         optMinBlockLenth.key     = CARLA_URI_MAP_ID_BUF_MIN_LENGTH;

  336.         optMinBlockLenth.size    = sizeof(int);

  337.         optMinBlockLenth.type    = CARLA_URI_MAP_ID_ATOM_INT;

  338.         optMinBlockLenth.value   = &minBufferSize;

  339. 

  340.         LV2_Options_Option& optNominalBlockLenth(opts[NominalBlockLenth]);

  341.         optNominalBlockLenth.context = LV2_OPTIONS_INSTANCE;

  342.         optNominalBlockLenth.subject = 0;

  343.         optNominalBlockLenth.key     = CARLA_URI_MAP_ID_BUF_NOMINAL_LENGTH;

  344.         optNominalBlockLenth.size    = sizeof(int);

  345.         optNominalBlockLenth.type    = CARLA_URI_MAP_ID_ATOM_INT;

  346.         optNominalBlockLenth.value   = &nominalBufferSize;

  347. 

  348.         LV2_Options_Option& optSequenceSize(opts[SequenceSize]);

  349.         optSequenceSize.context = LV2_OPTIONS_INSTANCE;

  350.         optSequenceSize.subject = 0;

  351.         optSequenceSize.key     = CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE;

  352.         optSequenceSize.size    = sizeof(int);

  353.         optSequenceSize.type    = CARLA_URI_MAP_ID_ATOM_INT;

  354.         optSequenceSize.value   = &sequenceSize;

  355. 

  356.         LV2_Options_Option& optSampleRate(opts[SampleRate]);

  357.         optSampleRate.context = LV2_OPTIONS_INSTANCE;

  358.         optSampleRate.subject = 0;

  359.         optSampleRate.key     = CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE;

  360.         optSampleRate.size    = sizeof(double);

  361.         optSampleRate.type    = CARLA_URI_MAP_ID_ATOM_DOUBLE;

  362.         optSampleRate.value   = &sampleRate;

  363. 

  364.         LV2_Options_Option& optFrontendWinId(opts[FrontendWinId]);

  365.         optFrontendWinId.context = LV2_OPTIONS_INSTANCE;

  366.         optFrontendWinId.subject = 0;

  367.         optFrontendWinId.key     = CARLA_URI_MAP_ID_CARLA_TRANSIENT_WIN_ID;

  368.         optFrontendWinId.size    = sizeof(int64_t);

  369.         optFrontendWinId.type    = CARLA_URI_MAP_ID_ATOM_LONG;

  370.         optFrontendWinId.value   = &frontendWinId;

  371. 

  372.         LV2_Options_Option& optWindowTitle(opts[WindowTitle]);

  373.         optWindowTitle.context = LV2_OPTIONS_INSTANCE;

  374.         optWindowTitle.subject = 0;

  375.         optWindowTitle.key     = CARLA_URI_MAP_ID_UI_WINDOW_TITLE;

  376.         optWindowTitle.size    = 0;

  377.         optWindowTitle.type    = CARLA_URI_MAP_ID_ATOM_STRING;

  378.         optWindowTitle.value   = nullptr;

  379. 

  380.         LV2_Options_Option& optNull(opts[Null]);

  381.         optNull.context = LV2_OPTIONS_INSTANCE;

  382.         optNull.subject = 0;

  383.         optNull.key     = CARLA_URI_MAP_ID_NULL;

  384.         optNull.size    = 0;

  385.         optNull.type    = CARLA_URI_MAP_ID_NULL;

  386.         optNull.value   = nullptr;

  387.     }

  388. 

  389.     ~CarlaPluginLV2Options() noexcept

  390.     {

  391.         LV2_Options_Option& optWindowTitle(opts[WindowTitle]);

  392. 

  393.         optWindowTitle.size  = 0;

  394.         optWindowTitle.value = nullptr;

  395. 

  396.         if (windowTitle != nullptr)

  397.         {

  398.             delete[] windowTitle;

  399.             windowTitle = nullptr;

  400.         }

  401.     }

  402. 

  403.     CARLA_DECLARE_NON_COPY_STRUCT(CarlaPluginLV2Options);

  404. };

  405. 

  406. // -------------------------------------------------------------------------------------------------------------------

  407. 

  408. class CarlaPluginLV2;

  409. 

  410. class CarlaPipeServerLV2 : public CarlaPipeServer

  411. {

  412. public:

  413.     enum UiState {

  414.         UiNone = 0,

  415.         UiHide,

  416.         UiShow,

  417.         UiCrashed

  418.     };

  419. 

  420.     CarlaPipeServerLV2(CarlaEngine* const engine, CarlaPluginLV2* const plugin)

  421.         : kEngine(engine),

  422.           kPlugin(plugin),

  423.           fFilename(),

  424.           fPluginURI(),

  425.           fUiURI(),

  426.           fUiState(UiNone) {}

  427. 

  428.     ~CarlaPipeServerLV2() noexcept override

  429.     {

  430.         CARLA_SAFE_ASSERT_INT(fUiState == UiNone, fUiState);

  431.     }

  432. 

  433.     UiState getAndResetUiState() noexcept

  434.     {

  435.         const UiState uiState(fUiState);

  436.         fUiState = UiNone;

  437.         return uiState;

  438.     }

  439. 

  440.     void setData(const char* const filename, const char* const pluginURI, const char* const uiURI) noexcept

  441.     {

  442.         fFilename  = filename;

  443.         fPluginURI = pluginURI;

  444.         fUiURI     = uiURI;

  445.     }

  446. 

  447.     bool startPipeServer(const int size) noexcept

  448.     {

  449.         const ScopedEngineEnvironmentLocker _seel(kEngine);

  450.         const ScopedEnvVar _sev1("LV2_PATH", kEngine->getOptions().pathLV2);

  451. #ifdef CARLA_OS_LINUX

  452.         const ScopedEnvVar _sev2("LD_PRELOAD", nullptr);

  453. #endif

  454. 

  455.         return CarlaPipeServer::startPipeServer(fFilename, fPluginURI, fUiURI, size);

  456.     }

  457. 

  458.     void writeUiTitleMessage(const char* const title) const noexcept

  459.     {

  460.         CARLA_SAFE_ASSERT_RETURN(title != nullptr && title[0] != '\0',);

  461. 

  462.         const CarlaMutexLocker cml(getPipeLock());

  463. 

  464.         _writeMsgBuffer("uiTitle\n", 8);

  465.         writeAndFixMessage(title);

  466.         flushMessages();

  467.     }

  468. 

  469. protected:

  470.     // returns true if msg was handled

  471.     bool msgReceived(const char* const msg) noexcept override;

  472. 

  473. private:

  474.     CarlaEngine*    const kEngine;

  475.     CarlaPluginLV2* const kPlugin;

  476. 

  477.     CarlaString fFilename;

  478.     CarlaString fPluginURI;

  479.     CarlaString fUiURI;

  480.     UiState     fUiState;

  481. 

  482.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaPipeServerLV2)

  483. };

  484. 

  485. // -------------------------------------------------------------------------------------------------------------------

  486. 

  487. class CarlaPluginLV2 : public CarlaPlugin,

  488.                        private CarlaPluginUI::CloseCallback

  489. {

  490. public:

  491.     CarlaPluginLV2(CarlaEngine* const engine, const uint id)

  492.         : CarlaPlugin(engine, id),

  493.           fHandle(nullptr),

  494.           fHandle2(nullptr),

  495.           fDescriptor(nullptr),

  496.           fRdfDescriptor(nullptr),

  497.           fAudioInBuffers(nullptr),

  498.           fAudioOutBuffers(nullptr),

  499.           fCvInBuffers(nullptr),

  500.           fCvOutBuffers(nullptr),

  501.           fParamBuffers(nullptr),

  502.           fCanInit2(true),

  503.           fNeedsUiClose(false),

  504.           //fLatencyChanged(false),

  505.           fLatencyIndex(-1),

  506.           fAtomBufferIn(),

  507.           fAtomBufferOut(),

  508.           fAtomForge(),

  509.           fTmpAtomBuffer(nullptr),

  510.           fEventsIn(),

  511.           fEventsOut(),

  512.           fLv2Options(),

  513.           fPipeServer(engine, this),

  514.           fCustomURIDs(CARLA_URI_MAP_ID_COUNT, std::string("urn:null")),

  515.           fFirstActive(true),

  516.           fLastStateChunk(nullptr),

  517.           fLastTimeInfo(),

  518.           fExt(),

  519.           fUI()

  520.     {

  521.         carla_debug("CarlaPluginLV2::CarlaPluginLV2(%p, %i)", engine, id);

  522.         CARLA_SAFE_ASSERT(fCustomURIDs.size() == CARLA_URI_MAP_ID_COUNT);

  523. 

  524.         carla_zeroPointers(fFeatures, kFeatureCountAll+1);

  525. 

  526. #if defined(__clang__)

  527. # pragma clang diagnostic push

  528. # pragma clang diagnostic ignored "-Wdeprecated-declarations"

  529. #elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))

  530. # pragma GCC diagnostic push

  531. # pragma GCC diagnostic ignored "-Wdeprecated-declarations"

  532. #endif

  533.         fAtomForge.Blank    = CARLA_URI_MAP_ID_ATOM_BLANK;

  534.         fAtomForge.Bool     = CARLA_URI_MAP_ID_ATOM_BOOL;

  535.         fAtomForge.Chunk    = CARLA_URI_MAP_ID_ATOM_CHUNK;

  536.         fAtomForge.Double   = CARLA_URI_MAP_ID_ATOM_DOUBLE;

  537.         fAtomForge.Float    = CARLA_URI_MAP_ID_ATOM_FLOAT;

  538.         fAtomForge.Int      = CARLA_URI_MAP_ID_ATOM_INT;

  539.         fAtomForge.Literal  = CARLA_URI_MAP_ID_ATOM_LITERAL;

  540.         fAtomForge.Long     = CARLA_URI_MAP_ID_ATOM_LONG;

  541.         fAtomForge.Object   = CARLA_URI_MAP_ID_ATOM_OBJECT;

  542.         fAtomForge.Path     = CARLA_URI_MAP_ID_ATOM_PATH;

  543.         fAtomForge.Property = CARLA_URI_MAP_ID_ATOM_PROPERTY;

  544.         fAtomForge.Resource = CARLA_URI_MAP_ID_ATOM_RESOURCE;

  545.         fAtomForge.Sequence = CARLA_URI_MAP_ID_ATOM_SEQUENCE;

  546.         fAtomForge.String   = CARLA_URI_MAP_ID_ATOM_STRING;

  547.         fAtomForge.Tuple    = CARLA_URI_MAP_ID_ATOM_TUPLE;

  548.         fAtomForge.URI      = CARLA_URI_MAP_ID_ATOM_URI;

  549.         fAtomForge.URID     = CARLA_URI_MAP_ID_ATOM_URID;

  550.         fAtomForge.Vector   = CARLA_URI_MAP_ID_ATOM_VECTOR;

  551. #if defined(__clang__)

  552. # pragma clang diagnostic pop

  553. #elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))

  554. # pragma GCC diagnostic pop

  555. #endif

  556.     }

  557. 

  558.     ~CarlaPluginLV2() override

  559.     {

  560.         carla_debug("CarlaPluginLV2::~CarlaPluginLV2()");

  561. 

  562.         // close UI

  563.         if (fUI.type != UI::TYPE_NULL)

  564.         {

  565.             showCustomUI(false);

  566. 

  567.             if (fUI.type == UI::TYPE_BRIDGE)

  568.             {

  569.                 fPipeServer.stopPipeServer(pData->engine->getOptions().uiBridgesTimeout);

  570.             }

  571.             else

  572.             {

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

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

  575. 

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

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

  578. 

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

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

  581. 

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

  583.                     delete (LV2_External_UI_Host*)fFeatures[kFeatureIdExternalUi]->data;

  584. 

  585.                 fUI.descriptor = nullptr;

  586.                 pData->uiLibClose();

  587.             }

  588. 

  589. #ifndef LV2_UIS_ONLY_BRIDGES

  590.             if (fUI.window != nullptr)

  591.             {

  592.                 delete fUI.window;

  593.                 fUI.window = nullptr;

  594.             }

  595. #endif

  596. 

  597.             fUI.rdfDescriptor = nullptr;

  598.         }

  599. 

  600.         pData->singleMutex.lock();

  601.         pData->masterMutex.lock();

  602. 

  603.         if (pData->client != nullptr && pData->client->isActive())

  604.             pData->client->deactivate();

  605. 

  606.         if (pData->active)

  607.         {

  608.             deactivate();

  609.             pData->active = false;

  610.         }

  611. 

  612.         if (fDescriptor != nullptr)

  613.         {

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

  615.             {

  616.                 if (fHandle != nullptr)

  617.                     fDescriptor->cleanup(fHandle);

  618.                 if (fHandle2 != nullptr)

  619.                     fDescriptor->cleanup(fHandle2);

  620.             }

  621. 

  622.             fHandle  = nullptr;

  623.             fHandle2 = nullptr;

  624.             fDescriptor = nullptr;

  625.         }

  626. 

  627.         if (fRdfDescriptor != nullptr)

  628.         {

  629.             delete fRdfDescriptor;

  630.             fRdfDescriptor = nullptr;

  631.         }

  632. 

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

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

  635. 

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

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

  638. 

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

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

  641. 

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

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

  644. 

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

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

  647. 

  648.         if (fFeatures[kFeatureIdResizePort] != nullptr && fFeatures[kFeatureIdResizePort]->data != nullptr)

  649.             delete (LV2_Resize_Port_Resize*)fFeatures[kFeatureIdResizePort]->data;

  650. 

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

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

  653. 

  654.         if (fFeatures[kFeatureIdRtMemPoolOld] != nullptr && fFeatures[kFeatureIdRtMemPoolOld]->data != nullptr)

  655.             delete (LV2_RtMemPool_Pool_Deprecated*)fFeatures[kFeatureIdRtMemPoolOld]->data;

  656. 

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

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

  659. 

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

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

  662. 

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

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

  665. 

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

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

  668. 

  669.         for (uint32_t i=0; i < kFeatureCountAll; ++i)

  670.         {

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

  672.             {

  673.                 delete fFeatures[i];

  674.                 fFeatures[i] = nullptr;

  675.             }

  676.         }

  677. 

  678.         if (fLastStateChunk != nullptr)

  679.         {

  680.             std::free(fLastStateChunk);

  681.             fLastStateChunk = nullptr;

  682.         }

  683. 

  684.         if (fTmpAtomBuffer != nullptr)

  685.         {

  686.             delete[] fTmpAtomBuffer;

  687.             fTmpAtomBuffer = nullptr;

  688.         }

  689. 

  690.         clearBuffers();

  691.     }

  692. 

  693.     // -------------------------------------------------------------------

  694.     // Information (base)

  695. 

  696.     PluginType getType() const noexcept override

  697.     {

  698.         return PLUGIN_LV2;

  699.     }

  700. 

  701.     PluginCategory getCategory() const noexcept override

  702.     {

  703.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr, CarlaPlugin::getCategory());

  704. 

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

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

  707. 

  708.         if (LV2_IS_DELAY(cat1, cat2))

  709.             return PLUGIN_CATEGORY_DELAY;

  710.         if (LV2_IS_DISTORTION(cat1, cat2))

  711.             return PLUGIN_CATEGORY_OTHER;

  712.         if (LV2_IS_DYNAMICS(cat1, cat2))

  713.             return PLUGIN_CATEGORY_DYNAMICS;

  714.         if (LV2_IS_EQ(cat1, cat2))

  715.             return PLUGIN_CATEGORY_EQ;

  716.         if (LV2_IS_FILTER(cat1, cat2))

  717.             return PLUGIN_CATEGORY_FILTER;

  718.         if (LV2_IS_GENERATOR(cat1, cat2))

  719.             return PLUGIN_CATEGORY_SYNTH;

  720.         if (LV2_IS_MODULATOR(cat1, cat2))

  721.             return PLUGIN_CATEGORY_MODULATOR;

  722.         if (LV2_IS_REVERB(cat1, cat2))

  723.             return PLUGIN_CATEGORY_DELAY;

  724.         if (LV2_IS_SIMULATOR(cat1, cat2))

  725.             return PLUGIN_CATEGORY_OTHER;

  726.         if (LV2_IS_SPATIAL(cat1, cat2))

  727.             return PLUGIN_CATEGORY_OTHER;

  728.         if (LV2_IS_SPECTRAL(cat1, cat2))

  729.             return PLUGIN_CATEGORY_UTILITY;

  730.         if (LV2_IS_UTILITY(cat1, cat2))

  731.             return PLUGIN_CATEGORY_UTILITY;

  732. 

  733.         return CarlaPlugin::getCategory();

  734.     }

  735. 

  736.     // -------------------------------------------------------------------

  737.     // Information (count)

  738. 

  739.     uint32_t getMidiInCount() const noexcept override

  740.     {

  741.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr, 0);

  742. 

  743.         uint32_t count = 0;

  744. 

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

  746.         {

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

  748. 

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

  750.                 ++count;

  751.         }

  752. 

  753.         return count;

  754.     }

  755. 

  756.     uint32_t getMidiOutCount() const noexcept override

  757.     {

  758.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr, 0);

  759. 

  760.         uint32_t count = 0;

  761. 

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

  763.         {

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

  765. 

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

  767.                 ++count;

  768.         }

  769. 

  770.         return count;

  771.     }

  772. 

  773.     uint32_t getParameterScalePointCount(const uint32_t parameterId) const noexcept override

  774.     {

  775.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr, 0);

  776.         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, 0);

  777. 

  778.         const int32_t rindex(pData->param.data[parameterId].rindex);

  779. 

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

  781.         {

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

  783.             return port->ScalePointCount;

  784.         }

  785. 

  786.         return 0;

  787.     }

  788. 

  789.     // -------------------------------------------------------------------

  790.     // Information (current data)

  791. 

  792.     // nothing

  793. 

  794.     // -------------------------------------------------------------------

  795.     // Information (per-plugin data)

  796. 

  797.     uint getOptionsAvailable() const noexcept override

  798.     {

  799.         const bool hasMidiIn(getMidiInCount() > 0);

  800. 

  801.         uint options = 0x0;

  802. 

  803.         if (fExt.programs != nullptr)

  804.             options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  805. 

  806.         if (fLatencyIndex == -1 && ! (hasMidiIn || needsFixedBuffer()))

  807.             options |= PLUGIN_OPTION_FIXED_BUFFERS;

  808. 

  809.         if (fCanInit2 && pData->engine->getProccessMode() != ENGINE_PROCESS_MODE_CONTINUOUS_RACK)

  810.         {

  811.             if (pData->options & PLUGIN_OPTION_FORCE_STEREO)

  812.                 options |= PLUGIN_OPTION_FORCE_STEREO;

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

  814.                 options |= PLUGIN_OPTION_FORCE_STEREO;

  815.         }

  816. 

  817.         if (hasMidiIn)

  818.         {

  819.             options |= PLUGIN_OPTION_SEND_PROGRAM_CHANGES;

  820.             options |= PLUGIN_OPTION_SEND_CONTROL_CHANGES;

  821.             options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  822.             options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

  823.             options |= PLUGIN_OPTION_SEND_PITCHBEND;

  824.             options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  825.         }

  826. 

  827.         return options;

  828.     }

  829. 

  830.     float getParameterValue(const uint32_t parameterId) const noexcept override

  831.     {

  832.         CARLA_SAFE_ASSERT_RETURN(fParamBuffers != nullptr, 0.0f);

  833.         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, 0.0f);

  834. 

  835.         if (pData->param.data[parameterId].hints & PARAMETER_IS_STRICT_BOUNDS)

  836.             pData->param.ranges[parameterId].fixValue(fParamBuffers[parameterId]);

  837. 

  838.         return fParamBuffers[parameterId];

  839.     }

  840. 

  841.     float getParameterScalePointValue(const uint32_t parameterId, const uint32_t scalePointId) const noexcept override

  842.     {

  843.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr, 0.0f);

  844.         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, 0.0f);

  845. 

  846.         const int32_t rindex(pData->param.data[parameterId].rindex);

  847. 

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

  849.         {

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

  851.             CARLA_SAFE_ASSERT_RETURN(scalePointId < port->ScalePointCount, 0.0f);

  852. 

  853.             const LV2_RDF_PortScalePoint* const portScalePoint(&port->ScalePoints[scalePointId]);

  854.             return portScalePoint->Value;

  855.         }

  856. 

  857.         return 0.0f;

  858.     }

  859. 

  860.     void getLabel(char* const strBuf) const noexcept override

  861.     {

  862.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr,);

  863.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor->URI != nullptr,);

  864. 

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

  866.     }

  867. 

  868.     void getMaker(char* const strBuf) const noexcept override

  869.     {

  870.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr,);

  871. 

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

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

  874.         else

  875.             CarlaPlugin::getMaker(strBuf);

  876.     }

  877. 

  878.     void getCopyright(char* const strBuf) const noexcept override

  879.     {

  880.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr,);

  881. 

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

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

  884.         else

  885.             CarlaPlugin::getCopyright(strBuf);

  886.     }

  887. 

  888.     void getRealName(char* const strBuf) const noexcept override

  889.     {

  890.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr,);

  891. 

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

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

  894.         else

  895.             CarlaPlugin::getRealName(strBuf);

  896.     }

  897. 

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

  899.     {

  900.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr,);

  901.         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count,);

  902. 

  903.         const int32_t rindex(pData->param.data[parameterId].rindex);

  904. 

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

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

  907.         else

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

  909.     }

  910. 

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

  912.     {

  913.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr,);

  914.         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count,);

  915. 

  916.         const int32_t rindex(pData->param.data[parameterId].rindex);

  917. 

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

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

  920.         else

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

  922.     }

  923. 

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

  925.     {

  926.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr,);

  927.         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count,);

  928. 

  929.         const int32_t rindex(pData->param.data[parameterId].rindex);

  930. 

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

  932.         {

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

  934. 

  935.             if (LV2_HAVE_PORT_UNIT_SYMBOL(port->Unit.Hints) && port->Unit.Symbol != nullptr)

  936.             {

  937.                 std::strncpy(strBuf, port->Unit.Symbol, STR_MAX);

  938.                 return;

  939.             }

  940. 

  941.             if (LV2_HAVE_PORT_UNIT_UNIT(port->Unit.Hints))

  942.             {

  943.                 switch (port->Unit.Unit)

  944.                 {

  945.                 case LV2_PORT_UNIT_BAR:

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

  947.                     return;

  948.                 case LV2_PORT_UNIT_BEAT:

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

  950.                     return;

  951.                 case LV2_PORT_UNIT_BPM:

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

  953.                     return;

  954.                 case LV2_PORT_UNIT_CENT:

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

  956.                     return;

  957.                 case LV2_PORT_UNIT_CM:

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

  959.                     return;

  960.                 case LV2_PORT_UNIT_COEF:

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

  962.                     return;

  963.                 case LV2_PORT_UNIT_DB:

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

  965.                     return;

  966.                 case LV2_PORT_UNIT_DEGREE:

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

  968.                     return;

  969.                 case LV2_PORT_UNIT_FRAME:

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

  971.                     return;

  972.                 case LV2_PORT_UNIT_HZ:

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

  974.                     return;

  975.                 case LV2_PORT_UNIT_INCH:

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

  977.                     return;

  978.                 case LV2_PORT_UNIT_KHZ:

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

  980.                     return;

  981.                 case LV2_PORT_UNIT_KM:

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

  983.                     return;

  984.                 case LV2_PORT_UNIT_M:

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

  986.                     return;

  987.                 case LV2_PORT_UNIT_MHZ:

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

  989.                     return;

  990.                 case LV2_PORT_UNIT_MIDINOTE:

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

  992.                     return;

  993.                 case LV2_PORT_UNIT_MILE:

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

  995.                     return;

  996.                 case LV2_PORT_UNIT_MIN:

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

  998.                     return;

  999.                 case LV2_PORT_UNIT_MM:

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

  1001.                     return;

  1002.                 case LV2_PORT_UNIT_MS:

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

  1004.                     return;

  1005.                 case LV2_PORT_UNIT_OCT:

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

  1007.                     return;

  1008.                 case LV2_PORT_UNIT_PC:

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

  1010.                     return;

  1011.                 case LV2_PORT_UNIT_S:

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

  1013.                     return;

  1014.                 case LV2_PORT_UNIT_SEMITONE:

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

  1016.                     return;

  1017.                 }

  1018.             }

  1019.         }

  1020. 

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

  1022.     }

  1023. 

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

  1025.     {

  1026.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr,);

  1027.         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count,);

  1028. 

  1029.         const int32_t rindex(pData->param.data[parameterId].rindex);

  1030. 

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

  1032.         {

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

  1034.             CARLA_SAFE_ASSERT_RETURN(scalePointId < port->ScalePointCount,);

  1035. 

  1036.             const LV2_RDF_PortScalePoint* const portScalePoint(&port->ScalePoints[scalePointId]);

  1037. 

  1038.             if (portScalePoint->Label != nullptr)

  1039.             {

  1040.                 std::strncpy(strBuf, portScalePoint->Label, STR_MAX);

  1041.                 return;

  1042.             }

  1043.         }

  1044. 

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

  1046.     }

  1047. 

  1048.     // -------------------------------------------------------------------

  1049.     // Set data (state)

  1050. 

  1051.     void prepareForSave() override

  1052.     {

  1053.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  1054. 

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

  1056.         {

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

  1058. 

  1059.             if (fHandle2 != nullptr)

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

  1061.         }

  1062.     }

  1063. 

  1064.     // -------------------------------------------------------------------

  1065.     // Set data (internal stuff)

  1066. 

  1067.     void setName(const char* const newName) override

  1068.     {

  1069.         CarlaPlugin::setName(newName);

  1070. 

  1071.         if (fLv2Options.windowTitle == nullptr)

  1072.             return;

  1073. 

  1074.         CarlaString guiTitle(pData->name);

  1075.         guiTitle += " (GUI)";

  1076. 

  1077.         delete[] fLv2Options.windowTitle;

  1078.         fLv2Options.windowTitle = guiTitle.dup();

  1079. 

  1080.         fLv2Options.opts[CarlaPluginLV2Options::WindowTitle].size  = (uint32_t)std::strlen(fLv2Options.windowTitle);

  1081.         fLv2Options.opts[CarlaPluginLV2Options::WindowTitle].value = fLv2Options.windowTitle;

  1082. 

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

  1084.             ((LV2_External_UI_Host*)fFeatures[kFeatureIdExternalUi]->data)->plugin_human_id = fLv2Options.windowTitle;

  1085. 

  1086.         if (fPipeServer.isPipeRunning())

  1087.             fPipeServer.writeUiTitleMessage(fLv2Options.windowTitle);

  1088. 

  1089. #ifndef LV2_UIS_ONLY_BRIDGES

  1090.         if (fUI.window != nullptr)

  1091.             fUI.window->setTitle(fLv2Options.windowTitle);

  1092. #endif

  1093.     }

  1094. 

  1095.     // -------------------------------------------------------------------

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

  1097. 

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

  1099.     {

  1100.         CARLA_SAFE_ASSERT_RETURN(fParamBuffers != nullptr,);

  1101.         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count,);

  1102. 

  1103.         const float fixedValue(pData->param.getFixedValue(parameterId, value));

  1104.         fParamBuffers[parameterId] = fixedValue;

  1105. 

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

  1107.     }

  1108. 

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

  1110.     {

  1111.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  1112.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  1113.         CARLA_SAFE_ASSERT_RETURN(type != nullptr && type[0] != '\0',);

  1114.         CARLA_SAFE_ASSERT_RETURN(key != nullptr && key[0] != '\0',);

  1115.         CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

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

  1117. 

  1118.         if (std::strcmp(type, CUSTOM_DATA_TYPE_PROPERTY) == 0)

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

  1120. 

  1121.         // we should only call state restore once

  1122.         // so inject this in CarlaPlugin::loadSaveState

  1123.         if (std::strcmp(type, CUSTOM_DATA_TYPE_STRING) == 0 && std::strcmp(key, "CarlaLoadLv2StateNow") == 0 && std::strcmp(value, "true") == 0)

  1124.         {

  1125.             if (fExt.state == nullptr)

  1126.                 return;

  1127. 

  1128.             LV2_State_Status status = LV2_STATE_ERR_UNKNOWN;

  1129. 

  1130.             {

  1131.                 const ScopedSingleProcessLocker spl(this, true);

  1132. 

  1133.                 try {

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

  1135.                 } catch(...) {}

  1136. 

  1137.                 if (fHandle2 != nullptr)

  1138.                 {

  1139.                     try {

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

  1141.                     } catch(...) {}

  1142.                 }

  1143.             }

  1144. 

  1145.             switch (status)

  1146.             {

  1147.             case LV2_STATE_SUCCESS:

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

  1149.                 break;

  1150.             case LV2_STATE_ERR_UNKNOWN:

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

  1152.                 break;

  1153.             case LV2_STATE_ERR_BAD_TYPE:

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

  1155.                 break;

  1156.             case LV2_STATE_ERR_BAD_FLAGS:

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

  1158.                 break;

  1159.             case LV2_STATE_ERR_NO_FEATURE:

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

  1161.                 break;

  1162.             case LV2_STATE_ERR_NO_PROPERTY:

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

  1164.                 break;

  1165.             }

  1166.             return;

  1167.         }

  1168. 

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

  1170.     }

  1171. 

  1172.     void setProgram(const int32_t index, const bool sendGui, const bool sendOsc, const bool sendCallback) noexcept override

  1173.     {

  1174.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  1175.         CARLA_SAFE_ASSERT_RETURN(index >= -1 && index < static_cast<int32_t>(pData->prog.count),);

  1176. 

  1177.         if (index >= 0 && index < static_cast<int32_t>(fRdfDescriptor->PresetCount))

  1178.         {

  1179.             CARLA_SAFE_ASSERT_RETURN(fExt.state != nullptr,);

  1180. 

  1181.             LilvState* const state = Lv2WorldClass::getInstance().getStateFromURI(fRdfDescriptor->Presets[index].URI, (const LV2_URID_Map*)fFeatures[kFeatureIdUridMap]->data);

  1182.             CARLA_SAFE_ASSERT_RETURN(state != nullptr,);

  1183. 

  1184.             // invalidate midi-program selection

  1185.             CarlaPlugin::setMidiProgram(-1, false, false, sendCallback);

  1186. 

  1187.             {

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

  1189. 

  1190.                 lilv_state_restore(state, fExt.state, fHandle, carla_lilv_set_port_value, this, 0, fFeatures);

  1191. 

  1192.                 if (fHandle2 != nullptr)

  1193.                     lilv_state_restore(state, fExt.state, fHandle2, carla_lilv_set_port_value, this, 0, fFeatures);

  1194.             }

  1195. 

  1196.             lilv_state_free(state);

  1197.         }

  1198. 

  1199.         CarlaPlugin::setProgram(index, sendGui, sendOsc, sendCallback);

  1200.     }

  1201. 

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

  1203.     {

  1204.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  1205.         CARLA_SAFE_ASSERT_RETURN(index >= -1 && index < static_cast<int32_t>(pData->midiprog.count),);

  1206. 

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

  1208.         {

  1209.             const uint32_t bank(pData->midiprog.data[index].bank);

  1210.             const uint32_t program(pData->midiprog.data[index].program);

  1211. 

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

  1213. 

  1214.             try {

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

  1216.             } catch(...) {}

  1217. 

  1218.             if (fHandle2 != nullptr)

  1219.             {

  1220.                 try {

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

  1222.                 } catch(...) {}

  1223.             }

  1224.         }

  1225. 

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

  1227.     }

  1228. 

  1229.     // -------------------------------------------------------------------

  1230.     // Set ui stuff

  1231. 

  1232.     void showCustomUI(const bool yesNo) override

  1233.     {

  1234.         CARLA_SAFE_ASSERT_RETURN(fUI.type != UI::TYPE_NULL,);

  1235. 

  1236.         const uintptr_t frontendWinId(pData->engine->getOptions().frontendWinId);

  1237. 

  1238.         if (! yesNo)

  1239.             pData->transientTryCounter = 0;

  1240. 

  1241.         if (fUI.type == UI::TYPE_BRIDGE)

  1242.         {

  1243.             if (yesNo)

  1244.             {

  1245.                 if (fPipeServer.isPipeRunning())

  1246.                 {

  1247.                     fPipeServer.writeFocusMessage();

  1248.                     return;

  1249.                 }

  1250. 

  1251.                 if (! fPipeServer.startPipeServer(std::min(fLv2Options.sequenceSize, 819200)))

  1252.                 {

  1253.                     pData->engine->callback(ENGINE_CALLBACK_UI_STATE_CHANGED, pData->id, 0, 0, 0.0f, nullptr);

  1254.                     return;

  1255.                 }

  1256. 

  1257.                 // manually write messages so we can take the lock for ourselves

  1258.                 {

  1259.                     char tmpBuf[0xff+1];

  1260.                     tmpBuf[0xff] = '\0';

  1261. 

  1262.                     const CarlaMutexLocker cml(fPipeServer.getPipeLock());

  1263.                     const ScopedLocale csl;

  1264. 

  1265.                     // write URI mappings

  1266.                     uint32_t i = 0;

  1267.                     for (auto it=fCustomURIDs.begin(), end=fCustomURIDs.end(); it != end; ++it, ++i)

  1268.                     {

  1269.                         if (i < CARLA_URI_MAP_ID_COUNT)

  1270.                             continue;

  1271.                         const std::string& uri(*it);

  1272. 

  1273.                         std::snprintf(tmpBuf, 0xff, "%u\n", i);

  1274. 

  1275.                         fPipeServer.writeMessage("urid\n", 5);

  1276.                         fPipeServer.writeMessage(tmpBuf);

  1277.                         fPipeServer.writeAndFixMessage(uri.c_str());

  1278.                     }

  1279. 

  1280.                     // write UI options

  1281.                     fPipeServer.writeMessage("uiOptions\n", 10);

  1282. 

  1283.                     std::snprintf(tmpBuf, 0xff, "%g\n", pData->engine->getSampleRate());

  1284.                     fPipeServer.writeMessage(tmpBuf);

  1285. 

  1286.                     std::snprintf(tmpBuf, 0xff, "%s\n", bool2str(true)); // useTheme

  1287.                     fPipeServer.writeMessage(tmpBuf);

  1288. 

  1289.                     std::snprintf(tmpBuf, 0xff, "%s\n", bool2str(true)); // useThemeColors

  1290.                     fPipeServer.writeMessage(tmpBuf);

  1291. 

  1292.                     fPipeServer.writeAndFixMessage(fLv2Options.windowTitle != nullptr ? fLv2Options.windowTitle : "");

  1293. 

  1294.                     std::snprintf(tmpBuf, 0xff, P_INTPTR "\n", frontendWinId);

  1295.                     fPipeServer.writeMessage(tmpBuf);

  1296. 

  1297.                     // write parameter values

  1298.                     for (uint32_t i=0; i < pData->param.count; ++i)

  1299.                     {

  1300.                         fPipeServer.writeMessage("control\n", 8);

  1301. 

  1302.                         std::snprintf(tmpBuf, 0xff, "%i\n", pData->param.data[i].rindex);

  1303.                         fPipeServer.writeMessage(tmpBuf);

  1304. 

  1305.                         std::snprintf(tmpBuf, 0xff, "%f\n", getParameterValue(i));

  1306.                         fPipeServer.writeMessage(tmpBuf);

  1307.                     }

  1308. 

  1309.                     // ready to show

  1310.                     fPipeServer.writeMessage("show\n", 5);

  1311. 

  1312.                     fPipeServer.flushMessages();

  1313.                 }

  1314. 

  1315. #ifndef BUILD_BRIDGE

  1316.                 if (fUI.rdfDescriptor->Type == LV2_UI_MOD)

  1317.                     pData->tryTransient();

  1318. #endif

  1319.             }

  1320.             else

  1321.             {

  1322.                 fPipeServer.stopPipeServer(pData->engine->getOptions().uiBridgesTimeout);

  1323.             }

  1324.             return;

  1325.         }

  1326. 

  1327.         // take some precautions

  1328.         CARLA_SAFE_ASSERT_RETURN(fUI.descriptor != nullptr,);

  1329.         CARLA_SAFE_ASSERT_RETURN(fUI.rdfDescriptor != nullptr,);

  1330. 

  1331.         if (yesNo)

  1332.         {

  1333.             CARLA_SAFE_ASSERT_RETURN(fUI.descriptor->instantiate != nullptr,);

  1334.             CARLA_SAFE_ASSERT_RETURN(fUI.descriptor->cleanup != nullptr,);

  1335.         }

  1336.         else

  1337.         {

  1338.             if (fUI.handle == nullptr)

  1339.                 return;

  1340.         }

  1341. 

  1342.         if (yesNo)

  1343.         {

  1344.             if (fUI.handle == nullptr)

  1345.             {

  1346. #ifndef LV2_UIS_ONLY_BRIDGES

  1347.                 if (fUI.type == UI::TYPE_EMBED && fUI.window == nullptr)

  1348.                 {

  1349.                     const char* msg = nullptr;

  1350. 

  1351.                     switch (fUI.rdfDescriptor->Type)

  1352.                     {

  1353.                     case LV2_UI_GTK2:

  1354.                     case LV2_UI_GTK3:

  1355.                     case LV2_UI_QT4:

  1356.                     case LV2_UI_QT5:

  1357.                     case LV2_UI_EXTERNAL:

  1358.                     case LV2_UI_OLD_EXTERNAL:

  1359.                         msg = "Invalid UI type";

  1360.                         break;

  1361. 

  1362.                     case LV2_UI_COCOA:

  1363. # ifdef CARLA_OS_MAC

  1364.                         fUI.window = CarlaPluginUI::newCocoa(this, frontendWinId, isUiResizable());

  1365. # else

  1366.                         msg = "UI is for MacOS only";

  1367. # endif

  1368.                         break;

  1369. 

  1370.                     case LV2_UI_WINDOWS:

  1371. # ifdef CARLA_OS_WIN

  1372.                         fUI.window = CarlaPluginUI::newWindows(this, frontendWinId, isUiResizable());

  1373. # else

  1374.                         msg = "UI is for Windows only";

  1375. # endif

  1376.                         break;

  1377. 

  1378.                     case LV2_UI_X11:

  1379. # ifdef HAVE_X11

  1380.                         fUI.window = CarlaPluginUI::newX11(this, frontendWinId, isUiResizable());

  1381. # else

  1382.                         msg = "UI is only for systems with X11";

  1383. # endif

  1384.                         break;

  1385. 

  1386.                     default:

  1387.                         msg = "Unknown UI type";

  1388.                         break;

  1389.                     }

  1390. 

  1391.                     if (fUI.window == nullptr && fExt.uishow == nullptr)

  1392.                         return pData->engine->callback(ENGINE_CALLBACK_UI_STATE_CHANGED, pData->id, -1, 0, 0.0f, msg);

  1393. 

  1394.                     if (fUI.window != nullptr)

  1395.                         fFeatures[kFeatureIdUiParent]->data = fUI.window->getPtr();

  1396.                 }

  1397. #endif

  1398.                 if (fUI.window != nullptr)

  1399.                     fUI.window->setTitle(fLv2Options.windowTitle);

  1400. 

  1401.                 fUI.widget = nullptr;

  1402.                 fUI.handle = fUI.descriptor->instantiate(fUI.descriptor, fRdfDescriptor->URI, fUI.rdfDescriptor->Bundle,

  1403.                                                          carla_lv2_ui_write_function, this, &fUI.widget, fFeatures);

  1404.             }

  1405. 

  1406.             CARLA_SAFE_ASSERT(fUI.handle != nullptr);

  1407.             CARLA_SAFE_ASSERT(fUI.type != UI::TYPE_EXTERNAL || fUI.widget != nullptr);

  1408. 

  1409.             if (fUI.handle == nullptr || (fUI.type == UI::TYPE_EXTERNAL && fUI.widget == nullptr))

  1410.             {

  1411.                 fUI.widget = nullptr;

  1412. 

  1413.                 if (fUI.handle != nullptr)

  1414.                 {

  1415.                     fUI.descriptor->cleanup(fUI.handle);

  1416.                     fUI.handle = nullptr;

  1417.                 }

  1418. 

  1419.                 return pData->engine->callback(ENGINE_CALLBACK_UI_STATE_CHANGED, pData->id, -1, 0, 0.0f, "Plugin refused to open its own UI");

  1420.             }

  1421. 

  1422.             updateUi();

  1423. 

  1424. #ifndef LV2_UIS_ONLY_BRIDGES

  1425.             if (fUI.type == UI::TYPE_EMBED)

  1426.             {

  1427.                 if (fUI.window != nullptr)

  1428.                 {

  1429.                     fUI.window->show();

  1430.                 }

  1431.                 else if (fExt.uishow != nullptr)

  1432.                 {

  1433.                     fExt.uishow->show(fUI.handle);

  1434. # ifndef BUILD_BRIDGE

  1435.                     pData->tryTransient();

  1436. # endif

  1437.                 }

  1438.             }

  1439.             else

  1440. #endif

  1441.             {

  1442.                 LV2_EXTERNAL_UI_SHOW((LV2_External_UI_Widget*)fUI.widget);

  1443. #ifndef BUILD_BRIDGE

  1444.                 pData->tryTransient();

  1445. #endif

  1446.             }

  1447.         }

  1448.         else

  1449.         {

  1450. #ifndef LV2_UIS_ONLY_BRIDGES

  1451.             if (fUI.type == UI::TYPE_EMBED)

  1452.             {

  1453.                 if (fUI.window != nullptr)

  1454.                     fUI.window->hide();

  1455.                 else if (fExt.uishow != nullptr)

  1456.                     fExt.uishow->hide(fUI.handle);

  1457.             }

  1458.             else

  1459. #endif

  1460.             {

  1461.                 CARLA_SAFE_ASSERT(fUI.widget != nullptr);

  1462. 

  1463.                 if (fUI.widget != nullptr)

  1464.                     LV2_EXTERNAL_UI_HIDE((LV2_External_UI_Widget*)fUI.widget);

  1465.             }

  1466. 

  1467.             fUI.descriptor->cleanup(fUI.handle);

  1468.             fUI.handle = nullptr;

  1469.             fUI.widget = nullptr;

  1470.         }

  1471.     }

  1472. 

  1473. #if 0 // TODO

  1474.     void idle() override

  1475.     {

  1476.         if (fLatencyChanged && fLatencyIndex != -1)

  1477.         {

  1478.             fLatencyChanged = false;

  1479. 

  1480.             const int32_t latency(static_cast<int32_t>(fParamBuffers[fLatencyIndex]));

  1481. 

  1482.             if (latency >= 0)

  1483.             {

  1484.                 const uint32_t ulatency(static_cast<uint32_t>(latency));

  1485. 

  1486.                 if (pData->latency != ulatency)

  1487.                 {

  1488.                     carla_stdout("latency changed to %i", latency);

  1489. 

  1490.                     const ScopedSingleProcessLocker sspl(this, true);

  1491. 

  1492.                     pData->latency = ulatency;

  1493.                     pData->client->setLatency(ulatency);

  1494. #ifndef BUILD_BRIDGE

  1495.                     pData->recreateLatencyBuffers();

  1496. #endif

  1497.                 }

  1498.             }

  1499.             else

  1500.                 carla_safe_assert_int("latency >= 0", __FILE__, __LINE__, latency);

  1501.         }

  1502. 

  1503.         CarlaPlugin::idle();

  1504.     }

  1505. #endif

  1506. 

  1507.     void uiIdle() override

  1508.     {

  1509.         if (fAtomBufferOut.isDataAvailableForReading())

  1510.         {

  1511.             Lv2AtomRingBuffer tmpRingBuffer(fAtomBufferOut, fTmpAtomBuffer);

  1512.             CARLA_SAFE_ASSERT(tmpRingBuffer.isDataAvailableForReading());

  1513. 

  1514.             uint32_t portIndex;

  1515.             const LV2_Atom* atom;

  1516.             const bool hasPortEvent(fUI.handle != nullptr && fUI.descriptor != nullptr &&

  1517.                                     fUI.descriptor->port_event != nullptr && ! fNeedsUiClose);

  1518. 

  1519.             for (; tmpRingBuffer.get(atom, portIndex);)

  1520.             {

  1521.                 if (atom->type == CARLA_URI_MAP_ID_CARLA_ATOM_WORKER)

  1522.                 {

  1523.                     CARLA_SAFE_ASSERT_CONTINUE(fExt.worker != nullptr && fExt.worker->work != nullptr);

  1524.                     fExt.worker->work(fHandle, carla_lv2_worker_respond, this, atom->size, LV2_ATOM_BODY_CONST(atom));

  1525.                 }

  1526.                 else if (fUI.type == UI::TYPE_BRIDGE)

  1527.                 {

  1528.                     if (fPipeServer.isPipeRunning())

  1529.                         fPipeServer.writeLv2AtomMessage(portIndex, atom);

  1530.                 }

  1531.                 else

  1532.                 {

  1533.                     if (hasPortEvent)

  1534.                         fUI.descriptor->port_event(fUI.handle, portIndex, lv2_atom_total_size(atom), CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT, atom);

  1535.                 }

  1536.             }

  1537.         }

  1538. 

  1539.         if (fPipeServer.isPipeRunning())

  1540.         {

  1541.             fPipeServer.idlePipe();

  1542. 

  1543.             switch (fPipeServer.getAndResetUiState())

  1544.             {

  1545.             case CarlaPipeServerLV2::UiNone:

  1546.             case CarlaPipeServerLV2::UiShow:

  1547.                 break;

  1548.             case CarlaPipeServerLV2::UiHide:

  1549.                 fPipeServer.stopPipeServer(2000);

  1550.                 // nobreak

  1551.             case CarlaPipeServerLV2::UiCrashed:

  1552.                 pData->transientTryCounter = 0;

  1553.                 pData->engine->callback(ENGINE_CALLBACK_UI_STATE_CHANGED, pData->id, 0, 0, 0.0f, nullptr);

  1554.                 break;

  1555.             }

  1556.         }

  1557.         else

  1558.         {

  1559.             // TODO - detect if ui-bridge crashed

  1560.         }

  1561. 

  1562.         if (fNeedsUiClose)

  1563.         {

  1564.             fNeedsUiClose = false;

  1565.             showCustomUI(false);

  1566.             pData->engine->callback(ENGINE_CALLBACK_UI_STATE_CHANGED, pData->id, 0, 0, 0.0f, nullptr);

  1567.         }

  1568.         else if (fUI.handle != nullptr && fUI.descriptor != nullptr)

  1569.         {

  1570.             if (fUI.type == UI::TYPE_EXTERNAL && fUI.widget != nullptr)

  1571.                 LV2_EXTERNAL_UI_RUN((LV2_External_UI_Widget*)fUI.widget);

  1572. #ifndef LV2_UIS_ONLY_BRIDGES

  1573.             else if (fUI.type == UI::TYPE_EMBED && fUI.window != nullptr)

  1574.                 fUI.window->idle();

  1575. 

  1576.             // note: UI might have been closed by window idle

  1577.             if (fNeedsUiClose)

  1578.                 pass();

  1579.             else if (fUI.handle != nullptr && fExt.uiidle != nullptr && fExt.uiidle->idle(fUI.handle) != 0)

  1580.             {

  1581.                 showCustomUI(false);

  1582.                 pData->engine->callback(ENGINE_CALLBACK_UI_STATE_CHANGED, pData->id, 0, 0, 0.0f, nullptr);

  1583.                 CARLA_SAFE_ASSERT(fUI.handle == nullptr);

  1584.             }

  1585. #endif

  1586.         }

  1587. 

  1588.         CarlaPlugin::uiIdle();

  1589.     }

  1590. 

  1591.     // -------------------------------------------------------------------

  1592.     // Plugin state

  1593. 

  1594.     void reload() override

  1595.     {

  1596.         CARLA_SAFE_ASSERT_RETURN(pData->engine != nullptr,);

  1597.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  1598.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  1599.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr,);

  1600.         carla_debug("CarlaPluginLV2::reload() - start");

  1601. 

  1602.         const EngineProcessMode processMode(pData->engine->getProccessMode());

  1603. 

  1604.         // Safely disable plugin for reload

  1605.         const ScopedDisabler sd(this);

  1606. 

  1607.         if (pData->active)

  1608.             deactivate();

  1609. 

  1610.         clearBuffers();

  1611. 

  1612.         const float sampleRate(static_cast<float>(pData->engine->getSampleRate()));

  1613.         const uint32_t portCount(fRdfDescriptor->PortCount);

  1614. 

  1615.         uint32_t aIns, aOuts, cvIns, cvOuts, params;

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

  1617.         LinkedList<uint> evIns, evOuts;

  1618. 

  1619.         const uint32_t eventBufferSize(static_cast<uint32_t>(fLv2Options.sequenceSize)+0xff);

  1620. 

  1621.         bool forcedStereoIn, forcedStereoOut;

  1622.         forcedStereoIn = forcedStereoOut = false;

  1623. 

  1624.         bool needsCtrlIn, needsCtrlOut;

  1625.         needsCtrlIn = needsCtrlOut = false;

  1626. 

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

  1628.         {

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

  1630. 

  1631.             if (LV2_IS_PORT_AUDIO(portTypes))

  1632.             {

  1633.                 if (LV2_IS_PORT_INPUT(portTypes))

  1634.                     aIns += 1;

  1635.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  1636.                     aOuts += 1;

  1637.             }

  1638.             else if (LV2_IS_PORT_CV(portTypes))

  1639.             {

  1640.                 if (LV2_IS_PORT_INPUT(portTypes))

  1641.                     cvIns += 1;

  1642.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  1643.                     cvOuts += 1;

  1644.             }

  1645.             else if (LV2_IS_PORT_ATOM_SEQUENCE(portTypes))

  1646.             {

  1647.                 if (LV2_IS_PORT_INPUT(portTypes))

  1648.                     evIns.append(CARLA_EVENT_DATA_ATOM);

  1649.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  1650.                     evOuts.append(CARLA_EVENT_DATA_ATOM);

  1651.             }

  1652.             else if (LV2_IS_PORT_EVENT(portTypes))

  1653.             {

  1654.                 if (LV2_IS_PORT_INPUT(portTypes))

  1655.                     evIns.append(CARLA_EVENT_DATA_EVENT);

  1656.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  1657.                     evOuts.append(CARLA_EVENT_DATA_EVENT);

  1658.             }

  1659.             else if (LV2_IS_PORT_MIDI_LL(portTypes))

  1660.             {

  1661.                 if (LV2_IS_PORT_INPUT(portTypes))

  1662.                     evIns.append(CARLA_EVENT_DATA_MIDI_LL);

  1663.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  1664.                     evOuts.append(CARLA_EVENT_DATA_MIDI_LL);

  1665.             }

  1666.             else if (LV2_IS_PORT_CONTROL(portTypes))

  1667.                 params += 1;

  1668.         }

  1669. 

  1670.         if ((pData->options & PLUGIN_OPTION_FORCE_STEREO) != 0 && aIns <= 1 && aOuts <= 1 && fExt.state == nullptr && fExt.worker == nullptr)

  1671.         {

  1672.             if (fHandle2 == nullptr)

  1673.             {

  1674.                 try {

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

  1676.                 } catch(...) {}

  1677.             }

  1678. 

  1679.             if (fHandle2 != nullptr)

  1680.             {

  1681.                 if (aIns == 1)

  1682.                 {

  1683.                     aIns = 2;

  1684.                     forcedStereoIn = true;

  1685.                 }

  1686. 

  1687.                 if (aOuts == 1)

  1688.                 {

  1689.                     aOuts = 2;

  1690.                     forcedStereoOut = true;

  1691.                 }

  1692.             }

  1693.         }

  1694. 

  1695.         if (aIns > 0)

  1696.         {

  1697.             pData->audioIn.createNew(aIns);

  1698.             fAudioInBuffers = new float*[aIns];

  1699. 

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

  1701.                 fAudioInBuffers[i] = nullptr;

  1702.         }

  1703. 

  1704.         if (aOuts > 0)

  1705.         {

  1706.             pData->audioOut.createNew(aOuts);

  1707.             fAudioOutBuffers = new float*[aOuts];

  1708.             needsCtrlIn = true;

  1709. 

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

  1711.                 fAudioOutBuffers[i] = nullptr;

  1712.         }

  1713. 

  1714.         if (cvIns > 0)

  1715.         {

  1716.             pData->cvIn.createNew(cvIns);

  1717.             fCvInBuffers = new float*[cvIns];

  1718. 

  1719.             for (uint32_t i=0; i < cvIns; ++i)

  1720.                 fCvInBuffers[i] = nullptr;

  1721.         }

  1722. 

  1723.         if (cvOuts > 0)

  1724.         {

  1725.             pData->cvOut.createNew(cvOuts);

  1726.             fCvOutBuffers = new float*[cvOuts];

  1727. 

  1728.             for (uint32_t i=0; i < cvOuts; ++i)

  1729.                 fCvOutBuffers[i] = nullptr;

  1730.         }

  1731. 

  1732.         if (params > 0)

  1733.         {

  1734.             pData->param.createNew(params, true);

  1735.             fParamBuffers = new float[params];

  1736.             FloatVectorOperations::clear(fParamBuffers, static_cast<int>(params));

  1737.         }

  1738. 

  1739.         if (const uint32_t count = static_cast<uint32_t>(evIns.count()))

  1740.         {

  1741.             fEventsIn.createNew(count);

  1742. 

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

  1744.             {

  1745.                 const uint32_t& type(evIns.getAt(i, 0x0));

  1746. 

  1747.                 if (type == CARLA_EVENT_DATA_ATOM)

  1748.                 {

  1749.                     fEventsIn.data[i].type = CARLA_EVENT_DATA_ATOM;

  1750.                     fEventsIn.data[i].atom = lv2_atom_buffer_new(eventBufferSize, CARLA_URI_MAP_ID_NULL, CARLA_URI_MAP_ID_ATOM_SEQUENCE, true);

  1751.                 }

  1752.                 else if (type == CARLA_EVENT_DATA_EVENT)

  1753.                 {

  1754.                     fEventsIn.data[i].type  = CARLA_EVENT_DATA_EVENT;

  1755.                     fEventsIn.data[i].event = lv2_event_buffer_new(eventBufferSize, LV2_EVENT_AUDIO_STAMP);

  1756.                 }

  1757.                 else if (type == CARLA_EVENT_DATA_MIDI_LL)

  1758.                 {

  1759.                     fEventsIn.data[i].type = CARLA_EVENT_DATA_MIDI_LL;

  1760.                     fEventsIn.data[i].midi.capacity = eventBufferSize;

  1761.                     fEventsIn.data[i].midi.data     = new uchar[eventBufferSize];

  1762.                 }

  1763.             }

  1764.         }

  1765.         else

  1766.         {

  1767.             fEventsIn.createNew(1);

  1768.             fEventsIn.ctrl = &fEventsIn.data[0];

  1769.         }

  1770. 

  1771.         if (const uint32_t count = static_cast<uint32_t>(evOuts.count()))

  1772.         {

  1773.             fEventsOut.createNew(count);

  1774. 

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

  1776.             {

  1777.                 const uint32_t& type(evOuts.getAt(i, 0x0));

  1778. 

  1779.                 if (type == CARLA_EVENT_DATA_ATOM)

  1780.                 {

  1781.                     fEventsOut.data[i].type = CARLA_EVENT_DATA_ATOM;

  1782.                     fEventsOut.data[i].atom = lv2_atom_buffer_new(eventBufferSize, CARLA_URI_MAP_ID_NULL, CARLA_URI_MAP_ID_ATOM_SEQUENCE, false);

  1783.                 }

  1784.                 else if (type == CARLA_EVENT_DATA_EVENT)

  1785.                 {

  1786.                     fEventsOut.data[i].type  = CARLA_EVENT_DATA_EVENT;

  1787.                     fEventsOut.data[i].event = lv2_event_buffer_new(eventBufferSize, LV2_EVENT_AUDIO_STAMP);

  1788.                 }

  1789.                 else if (type == CARLA_EVENT_DATA_MIDI_LL)

  1790.                 {

  1791.                     fEventsOut.data[i].type = CARLA_EVENT_DATA_MIDI_LL;

  1792.                     fEventsOut.data[i].midi.capacity = eventBufferSize;

  1793.                     fEventsOut.data[i].midi.data     = new uchar[eventBufferSize];

  1794.                 }

  1795.             }

  1796.         }

  1797. 

  1798.         const uint portNameSize(pData->engine->getMaxPortNameSize());

  1799.         CarlaString portName;

  1800. 

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

  1802.         {

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

  1804. 

  1805.             portName.clear();

  1806. 

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

  1808.             {

  1809.                 if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  1810.                 {

  1811.                     portName  = pData->name;

  1812.                     portName += ":";

  1813.                 }

  1814. 

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

  1816.                 portName.truncate(portNameSize);

  1817.             }

  1818. 

  1819.             if (LV2_IS_PORT_AUDIO(portTypes))

  1820.             {

  1821.                 if (LV2_IS_PORT_INPUT(portTypes))

  1822.                 {

  1823.                     const uint32_t j = iAudioIn++;

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

  1825.                     pData->audioIn.ports[j].rindex = i;

  1826. 

  1827.                     if (forcedStereoIn)

  1828.                     {

  1829.                         portName += "_2";

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

  1831.                         pData->audioIn.ports[1].rindex = i;

  1832.                     }

  1833.                 }

  1834.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  1835.                 {

  1836.                     const uint32_t j = iAudioOut++;

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

  1838.                     pData->audioOut.ports[j].rindex = i;

  1839. 

  1840.                     if (forcedStereoOut)

  1841.                     {

  1842.                         portName += "_2";

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

  1844.                         pData->audioOut.ports[1].rindex = i;

  1845.                     }

  1846.                 }

  1847.                 else

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

  1849.             }

  1850.             else if (LV2_IS_PORT_CV(portTypes))

  1851.             {

  1852.                 if (LV2_IS_PORT_INPUT(portTypes))

  1853.                 {

  1854.                     const uint32_t j = iCvIn++;

  1855.                     pData->cvIn.ports[j].port   = (CarlaEngineCVPort*)pData->client->addPort(kEnginePortTypeCV, portName, true, j);

  1856.                     pData->cvIn.ports[j].rindex = i;

  1857.                 }

  1858.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  1859.                 {

  1860.                     const uint32_t j = iCvOut++;

  1861.                     pData->cvOut.ports[j].port   = (CarlaEngineCVPort*)pData->client->addPort(kEnginePortTypeCV, portName, false, j);

  1862.                     pData->cvOut.ports[j].rindex = i;

  1863.                 }

  1864.                 else

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

  1866.             }

  1867.             else if (LV2_IS_PORT_ATOM_SEQUENCE(portTypes))

  1868.             {

  1869.                 if (LV2_IS_PORT_INPUT(portTypes))

  1870.                 {

  1871.                     const uint32_t j = iEvIn++;

  1872. 

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

  1874. 

  1875.                     if (fHandle2 != nullptr)

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

  1877. 

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

  1879. 

  1880.                     if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

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

  1882.                     if (portTypes & LV2_PORT_DATA_PATCH_MESSAGE)

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

  1884.                     if (portTypes & LV2_PORT_DATA_TIME_POSITION)

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

  1886. 

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

  1888.                     {

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

  1890.                         fEventsIn.ctrlIndex = j;

  1891. 

  1892.                         if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

  1893.                             needsCtrlIn = true;

  1894.                     }

  1895.                     else

  1896.                     {

  1897.                         if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

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

  1899. 

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

  1901.                         {

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

  1903.                             fEventsIn.ctrlIndex = j;

  1904.                         }

  1905.                     }

  1906.                 }

  1907.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  1908.                 {

  1909.                     const uint32_t j = iEvOut++;

  1910. 

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

  1912. 

  1913.                     if (fHandle2 != nullptr)

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

  1915. 

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

  1917. 

  1918.                     if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

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

  1920.                     if (portTypes & LV2_PORT_DATA_PATCH_MESSAGE)

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

  1922.                     if (portTypes & LV2_PORT_DATA_TIME_POSITION)

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

  1924. 

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

  1926.                     {

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

  1928.                         fEventsOut.ctrlIndex = j;

  1929. 

  1930.                         if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

  1931.                             needsCtrlOut = true;

  1932.                     }

  1933.                     else

  1934.                     {

  1935.                         if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

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

  1937. 

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

  1939.                         {

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

  1941.                             fEventsOut.ctrlIndex = j;

  1942.                         }

  1943.                     }

  1944.                 }

  1945.                 else

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

  1947.             }

  1948.             else if (LV2_IS_PORT_EVENT(portTypes))

  1949.             {

  1950.                 if (LV2_IS_PORT_INPUT(portTypes))

  1951.                 {

  1952.                     const uint32_t j = iEvIn++;

  1953. 

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

  1955. 

  1956.                     if (fHandle2 != nullptr)

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

  1958. 

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

  1960. 

  1961.                     if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

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

  1963.                     if (portTypes & LV2_PORT_DATA_PATCH_MESSAGE)

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

  1965.                     if (portTypes & LV2_PORT_DATA_TIME_POSITION)

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

  1967. 

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

  1969.                     {

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

  1971.                         fEventsIn.ctrlIndex = j;

  1972. 

  1973.                         if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

  1974.                             needsCtrlIn = true;

  1975.                     }

  1976.                     else

  1977.                     {

  1978.                         if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

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

  1980. 

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

  1982.                         {

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

  1984.                             fEventsIn.ctrlIndex = j;

  1985.                         }

  1986.                     }

  1987.                 }

  1988.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  1989.                 {

  1990.                     const uint32_t j = iEvOut++;

  1991. 

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

  1993. 

  1994.                     if (fHandle2 != nullptr)

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

  1996. 

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

  1998. 

  1999.                     if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

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

  2001.                     if (portTypes & LV2_PORT_DATA_PATCH_MESSAGE)

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

  2003.                     if (portTypes & LV2_PORT_DATA_TIME_POSITION)

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

  2005. 

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

  2007.                     {

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

  2009.                         fEventsOut.ctrlIndex = j;

  2010. 

  2011.                         if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

  2012.                             needsCtrlOut = true;

  2013.                     }

  2014.                     else

  2015.                     {

  2016.                         if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

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

  2018. 

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

  2020.                         {

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

  2022.                             fEventsOut.ctrlIndex = j;

  2023.                         }

  2024.                     }

  2025.                 }

  2026.                 else

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

  2028.             }

  2029.             else if (LV2_IS_PORT_MIDI_LL(portTypes))

  2030.             {

  2031.                 if (LV2_IS_PORT_INPUT(portTypes))

  2032.                 {

  2033.                     const uint32_t j = iEvIn++;

  2034. 

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

  2036. 

  2037.                     if (fHandle2 != nullptr)

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

  2039. 

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

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

  2042. 

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

  2044.                     {

  2045.                         needsCtrlIn = true;

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

  2047.                         fEventsIn.ctrlIndex = j;

  2048.                     }

  2049.                     else

  2050.                     {

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

  2052. 

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

  2054.                         {

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

  2056.                             fEventsIn.ctrlIndex = j;

  2057.                         }

  2058.                     }

  2059.                 }

  2060.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  2061.                 {

  2062.                     const uint32_t j = iEvOut++;

  2063. 

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

  2065. 

  2066.                     if (fHandle2 != nullptr)

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

  2068. 

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

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

  2071. 

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

  2073.                     {

  2074.                         needsCtrlOut = true;

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

  2076.                         fEventsOut.ctrlIndex = j;

  2077.                     }

  2078.                     else

  2079.                     {

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

  2081. 

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

  2083.                         {

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

  2085.                             fEventsOut.ctrlIndex = j;

  2086.                         }

  2087.                     }

  2088.                 }

  2089.                 else

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

  2091.             }

  2092.             else if (LV2_IS_PORT_CONTROL(portTypes))

  2093.             {

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

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

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

  2097. 

  2098.                 const uint32_t j = iCtrl++;

  2099.                 pData->param.data[j].index  = static_cast<int32_t>(j);

  2100.                 pData->param.data[j].rindex = static_cast<int32_t>(i);

  2101. 

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

  2103. 

  2104.                 // min value

  2105.                 if (LV2_HAVE_MINIMUM_PORT_POINT(portPoints.Hints))

  2106.                     min = portPoints.Minimum;

  2107.                 else

  2108.                     min = 0.0f;

  2109. 

  2110.                 // max value

  2111.                 if (LV2_HAVE_MAXIMUM_PORT_POINT(portPoints.Hints))

  2112.                     max = portPoints.Maximum;

  2113.                 else

  2114.                     max = 1.0f;

  2115. 

  2116.                 if (LV2_IS_PORT_SAMPLE_RATE(portProps))

  2117.                 {

  2118.                     min *= sampleRate;

  2119.                     max *= sampleRate;

  2120.                     pData->param.data[j].hints |= PARAMETER_USES_SAMPLERATE;

  2121.                 }

  2122. 

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

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

  2125.                 {

  2126.                     min = 0.0f;

  2127.                     max = (float)0xffffff;

  2128.                 }

  2129. 

  2130.                 if (min >= max)

  2131.                 {

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

  2133.                     max = min + 0.1f;

  2134.                 }

  2135. 

  2136.                 // default value

  2137.                 if (LV2_HAVE_DEFAULT_PORT_POINT(portPoints.Hints))

  2138.                 {

  2139.                     def = portPoints.Default;

  2140.                 }

  2141.                 else

  2142.                 {

  2143.                     // no default value

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

  2145.                         def = 0.0f;

  2146.                     else

  2147.                         def = min;

  2148.                 }

  2149. 

  2150.                 if (def < min)

  2151.                     def = min;

  2152.                 else if (def > max)

  2153.                     def = max;

  2154. 

  2155.                 if (LV2_IS_PORT_TOGGLED(portProps))

  2156.                 {

  2157.                     step = max - min;

  2158.                     stepSmall = step;

  2159.                     stepLarge = step;

  2160.                     pData->param.data[j].hints |= PARAMETER_IS_BOOLEAN;

  2161.                 }

  2162.                 else if (LV2_IS_PORT_INTEGER(portProps))

  2163.                 {

  2164.                     step = 1.0f;

  2165.                     stepSmall = 1.0f;

  2166.                     stepLarge = 10.0f;

  2167.                     pData->param.data[j].hints |= PARAMETER_IS_INTEGER;

  2168.                 }

  2169.                 else

  2170.                 {

  2171.                     float range = max - min;

  2172.                     step = range/100.0f;

  2173.                     stepSmall = range/1000.0f;

  2174.                     stepLarge = range/10.0f;

  2175.                 }

  2176. 

  2177.                 if (LV2_IS_PORT_INPUT(portTypes))

  2178.                 {

  2179.                     pData->param.data[j].type = PARAMETER_INPUT;

  2180. 

  2181.                     if (LV2_IS_PORT_DESIGNATION_LATENCY(portDesignation))

  2182.                     {

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

  2184.                     }

  2185.                     else if (LV2_IS_PORT_DESIGNATION_SAMPLE_RATE(portDesignation))

  2186.                     {

  2187.                         def = sampleRate;

  2188.                         step = 1.0f;

  2189.                         stepSmall = 1.0f;

  2190.                         stepLarge = 1.0f;

  2191.                         pData->param.special[j] = PARAMETER_SPECIAL_SAMPLE_RATE;

  2192.                     }

  2193.                     else if (LV2_IS_PORT_DESIGNATION_FREEWHEELING(portDesignation))

  2194.                     {

  2195.                         pData->param.special[j] = PARAMETER_SPECIAL_FREEWHEEL;

  2196.                     }

  2197.                     else if (LV2_IS_PORT_DESIGNATION_TIME(portDesignation))

  2198.                     {

  2199.                         pData->param.special[j] = PARAMETER_SPECIAL_TIME;

  2200.                     }

  2201.                     else

  2202.                     {

  2203.                         pData->param.data[j].hints |= PARAMETER_IS_ENABLED;

  2204.                         pData->param.data[j].hints |= PARAMETER_IS_AUTOMABLE;

  2205.                         needsCtrlIn = true;

  2206.                     }

  2207. 

  2208.                     // MIDI CC value

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

  2210. 

  2211.                     if (LV2_IS_PORT_MIDI_MAP_CC(portMidiMap.Type))

  2212.                     {

  2213.                         if (portMidiMap.Number < MAX_MIDI_CONTROL && ! MIDI_IS_CONTROL_BANK_SELECT(portMidiMap.Number))

  2214.                             pData->param.data[j].midiCC = static_cast<int16_t>(portMidiMap.Number);

  2215.                     }

  2216.                 }

  2217.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  2218.                 {

  2219.                     pData->param.data[j].type = PARAMETER_OUTPUT;

  2220. 

  2221.                     if (LV2_IS_PORT_DESIGNATION_LATENCY(portDesignation))

  2222.                     {

  2223.                         min = 0.0f;

  2224.                         max = sampleRate;

  2225.                         def = 0.0f;

  2226.                         step = 1.0f;

  2227.                         stepSmall = 1.0f;

  2228.                         stepLarge = 1.0f;

  2229.                         pData->param.special[j] = PARAMETER_SPECIAL_LATENCY;

  2230.                         CARLA_SAFE_ASSERT_INT2(fLatencyIndex == static_cast<int32_t>(j), fLatencyIndex, j);

  2231.                     }

  2232.                     else if (LV2_IS_PORT_DESIGNATION_SAMPLE_RATE(portDesignation))

  2233.                     {

  2234.                         def = sampleRate;

  2235.                         step = 1.0f;

  2236.                         stepSmall = 1.0f;

  2237.                         stepLarge = 1.0f;

  2238.                         pData->param.special[j] = PARAMETER_SPECIAL_SAMPLE_RATE;

  2239.                     }

  2240.                     else if (LV2_IS_PORT_DESIGNATION_FREEWHEELING(portDesignation))

  2241.                     {

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

  2243.                     }

  2244.                     else if (LV2_IS_PORT_DESIGNATION_TIME(portDesignation))

  2245.                     {

  2246.                         pData->param.special[j] = PARAMETER_SPECIAL_TIME;

  2247.                     }

  2248.                     else

  2249.                     {

  2250.                         pData->param.data[j].hints |= PARAMETER_IS_ENABLED;

  2251.                         pData->param.data[j].hints |= PARAMETER_IS_AUTOMABLE;

  2252.                         needsCtrlOut = true;

  2253.                     }

  2254.                 }

  2255.                 else

  2256.                 {

  2257.                     pData->param.data[j].type = PARAMETER_UNKNOWN;

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

  2259.                 }

  2260. 

  2261.                 // extra parameter hints

  2262.                 if (LV2_IS_PORT_LOGARITHMIC(portProps))

  2263.                     pData->param.data[j].hints |= PARAMETER_IS_LOGARITHMIC;

  2264. 

  2265.                 if (LV2_IS_PORT_TRIGGER(portProps))

  2266.                     pData->param.data[j].hints |= PARAMETER_IS_TRIGGER;

  2267. 

  2268.                 if (LV2_IS_PORT_STRICT_BOUNDS(portProps))

  2269.                     pData->param.data[j].hints |= PARAMETER_IS_STRICT_BOUNDS;

  2270. 

  2271.                 if (LV2_IS_PORT_ENUMERATION(portProps))

  2272.                     pData->param.data[j].hints |= PARAMETER_USES_SCALEPOINTS;

  2273. 

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

  2275.                 if (LV2_IS_PORT_NOT_ON_GUI(portProps))

  2276.                     pData->param.data[j].hints &= ~(PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE);

  2277.                 else if (LV2_IS_PORT_CAUSES_ARTIFACTS(portProps) || LV2_IS_PORT_EXPENSIVE(portProps))

  2278.                     pData->param.data[j].hints &= ~PARAMETER_IS_AUTOMABLE;

  2279.                 else if (LV2_IS_PORT_NOT_AUTOMATIC(portProps) || LV2_IS_PORT_NON_AUTOMABLE(portProps))

  2280.                     pData->param.data[j].hints &= ~PARAMETER_IS_AUTOMABLE;

  2281. 

  2282.                 pData->param.ranges[j].min = min;

  2283.                 pData->param.ranges[j].max = max;

  2284.                 pData->param.ranges[j].def = def;

  2285.                 pData->param.ranges[j].step = step;

  2286.                 pData->param.ranges[j].stepSmall = stepSmall;

  2287.                 pData->param.ranges[j].stepLarge = stepLarge;

  2288. 

  2289.                 // Start parameters in their default values (except freewheel, which is off by default)

  2290.                 if (pData->param.data[j].type == PARAMETER_INPUT && pData->param.special[j] == PARAMETER_SPECIAL_FREEWHEEL)

  2291.                     fParamBuffers[j] = min;

  2292.                 else

  2293.                     fParamBuffers[j] = def;

  2294. 

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

  2296. 

  2297.                 if (fHandle2 != nullptr)

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

  2299.             }

  2300.             else

  2301.             {

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

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

  2304. 

  2305.                 if (fHandle2 != nullptr)

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

  2307.             }

  2308.         }

  2309. 

  2310.         if (needsCtrlIn)

  2311.         {

  2312.             portName.clear();

  2313. 

  2314.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  2315.             {

  2316.                 portName  = pData->name;

  2317.                 portName += ":";

  2318.             }

  2319. 

  2320.             portName += "events-in";

  2321.             portName.truncate(portNameSize);

  2322. 

  2323.             pData->event.portIn = (CarlaEngineEventPort*)pData->client->addPort(kEnginePortTypeEvent, portName, true, 0);

  2324.         }

  2325. 

  2326.         if (needsCtrlOut)

  2327.         {

  2328.             portName.clear();

  2329. 

  2330.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  2331.             {

  2332.                 portName  = pData->name;

  2333.                 portName += ":";

  2334.             }

  2335. 

  2336.             portName += "events-out";

  2337.             portName.truncate(portNameSize);

  2338. 

  2339.             pData->event.portOut = (CarlaEngineEventPort*)pData->client->addPort(kEnginePortTypeEvent, portName, false, 0);

  2340.         }

  2341. 

  2342.         if (fExt.worker != nullptr || (fUI.type != UI::TYPE_NULL && fEventsIn.count > 0 && (fEventsIn.data[0].type & CARLA_EVENT_DATA_ATOM) != 0))

  2343.             fAtomBufferIn.createBuffer(eventBufferSize);

  2344. 

  2345.         if (fExt.worker != nullptr || (fUI.type != UI::TYPE_NULL && fEventsOut.count > 0 && (fEventsOut.data[0].type & CARLA_EVENT_DATA_ATOM) != 0))

  2346.         {

  2347.             fAtomBufferOut.createBuffer(eventBufferSize);

  2348.             fTmpAtomBuffer = new uint8_t[fAtomBufferOut.getSize()];

  2349.         }

  2350. 

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

  2352.             fEventsIn.ctrl->port = pData->event.portIn;

  2353. 

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

  2355.             fEventsOut.ctrl->port = pData->event.portOut;

  2356. 

  2357.         if (fCanInit2 && (forcedStereoIn || forcedStereoOut))

  2358.             pData->options |= PLUGIN_OPTION_FORCE_STEREO;

  2359.         else

  2360.             pData->options &= ~PLUGIN_OPTION_FORCE_STEREO;

  2361. 

  2362.         // plugin hints

  2363.         pData->hints = 0x0;

  2364. 

  2365.         if (isRealtimeSafe())

  2366.             pData->hints |= PLUGIN_IS_RTSAFE;

  2367. 

  2368.         if (fUI.type != UI::TYPE_NULL)

  2369.         {

  2370.             pData->hints |= PLUGIN_HAS_CUSTOM_UI;

  2371. 

  2372.             if (fUI.type == UI::TYPE_EMBED || fUI.type == UI::TYPE_EXTERNAL)

  2373.                 pData->hints |= PLUGIN_NEEDS_UI_MAIN_THREAD;

  2374.         }

  2375. 

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

  2377.             pData->hints |= PLUGIN_IS_SYNTH;

  2378. 

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

  2380.             pData->hints |= PLUGIN_CAN_DRYWET;

  2381. 

  2382.         if (aOuts > 0)

  2383.             pData->hints |= PLUGIN_CAN_VOLUME;

  2384. 

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

  2386.             pData->hints |= PLUGIN_CAN_BALANCE;

  2387. 

  2388.         // extra plugin hints

  2389.         pData->extraHints = 0x0;

  2390. 

  2391.         if (! fCanInit2)

  2392.         {

  2393.             // can't run in rack

  2394.         }

  2395.         else if (fExt.state != nullptr || fExt.worker != nullptr)

  2396.         {

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

  2398.                 pData->extraHints |= PLUGIN_EXTRA_HINT_CAN_RUN_RACK;

  2399.         }

  2400.         else

  2401.         {

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

  2403.                 pData->extraHints |= PLUGIN_EXTRA_HINT_CAN_RUN_RACK;

  2404.         }

  2405. 

  2406. #if 0 // TODO

  2407.         // check latency

  2408.         if (fLatencyIndex >= 0)

  2409.         {

  2410.             // we need to pre-run the plugin so it can update its latency control-port

  2411. 

  2412.             float tmpIn [(aIns > 0)  ? aIns  : 1][2];

  2413.             float tmpOut[(aOuts > 0) ? aOuts : 1][2];

  2414. 

  2415.             for (uint32_t j=0; j < aIns; ++j)

  2416.             {

  2417.                 tmpIn[j][0] = 0.0f;

  2418.                 tmpIn[j][1] = 0.0f;

  2419. 

  2420.                 try {

  2421.                     fDescriptor->connect_port(fHandle, pData->audioIn.ports[j].rindex, tmpIn[j]);

  2422.                 } CARLA_SAFE_EXCEPTION("LV2 connect_port latency input");

  2423.             }

  2424. 

  2425.             for (uint32_t j=0; j < aOuts; ++j)

  2426.             {

  2427.                 tmpOut[j][0] = 0.0f;

  2428.                 tmpOut[j][1] = 0.0f;

  2429. 

  2430.                 try {

  2431.                     fDescriptor->connect_port(fHandle, pData->audioOut.ports[j].rindex, tmpOut[j]);

  2432.                 } CARLA_SAFE_EXCEPTION("LV2 connect_port latency output");

  2433.             }

  2434. 

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

  2436.             {

  2437.                 try {

  2438.                     fDescriptor->activate(fHandle);

  2439.                 } CARLA_SAFE_EXCEPTION("LV2 latency activate");

  2440.             }

  2441. 

  2442.             try {

  2443.                 fDescriptor->run(fHandle, 2);

  2444.             } CARLA_SAFE_EXCEPTION("LV2 latency run");

  2445. 

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

  2447.             {

  2448.                 try {

  2449.                     fDescriptor->deactivate(fHandle);

  2450.                 } CARLA_SAFE_EXCEPTION("LV2 latency deactivate");

  2451.             }

  2452. 

  2453.             const int32_t latency(static_cast<int32_t>(fParamBuffers[fLatencyIndex]));

  2454. 

  2455.             if (latency >= 0)

  2456.             {

  2457.                 const uint32_t ulatency(static_cast<uint32_t>(latency));

  2458. 

  2459.                 if (pData->latency != ulatency)

  2460.                 {

  2461.                     carla_stdout("latency = %i", latency);

  2462. 

  2463.                     pData->latency = ulatency;

  2464.                     pData->client->setLatency(ulatency);

  2465. #ifndef BUILD_BRIDGE

  2466.                     pData->recreateLatencyBuffers();

  2467. #endif

  2468.                 }

  2469.             }

  2470.             else

  2471.                 carla_safe_assert_int("latency >= 0", __FILE__, __LINE__, latency);

  2472. 

  2473.             fLatencyChanged = false;

  2474.         }

  2475. #endif

  2476. 

  2477.         bufferSizeChanged(pData->engine->getBufferSize());

  2478.         reloadPrograms(true);

  2479. 

  2480.         evIns.clear();

  2481.         evOuts.clear();

  2482. 

  2483.         if (pData->active)

  2484.             activate();

  2485. 

  2486.         carla_debug("CarlaPluginLV2::reload() - end");

  2487.     }

  2488. 

  2489.     void reloadPrograms(const bool doInit) override

  2490.     {

  2491.         carla_debug("CarlaPluginLV2::reloadPrograms(%s)", bool2str(doInit));

  2492.         const uint32_t oldCount = pData->midiprog.count;

  2493.         const int32_t  current  = pData->midiprog.current;

  2494. 

  2495.         // special LV2 programs handling

  2496.         if (doInit)

  2497.         {

  2498.             pData->prog.clear();

  2499. 

  2500.             const uint32_t presetCount(fRdfDescriptor->PresetCount);

  2501. 

  2502.             if (presetCount > 0)

  2503.             {

  2504.                 pData->prog.createNew(presetCount);

  2505. 

  2506.                 for (uint32_t i=0; i < presetCount; ++i)

  2507.                     pData->prog.names[i] = carla_strdup(fRdfDescriptor->Presets[i].Label);

  2508.             }

  2509.         }

  2510. 

  2511.         // Delete old programs

  2512.         pData->midiprog.clear();

  2513. 

  2514.         // Query new programs

  2515.         uint32_t newCount = 0;

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

  2517.         {

  2518.             for (; fExt.programs->get_program(fHandle, newCount);)

  2519.                 ++newCount;

  2520.         }

  2521. 

  2522.         if (newCount > 0)

  2523.         {

  2524.             pData->midiprog.createNew(newCount);

  2525. 

  2526.             // Update data

  2527.             for (uint32_t i=0; i < newCount; ++i)

  2528.             {

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

  2530.                 CARLA_SAFE_ASSERT_CONTINUE(pdesc != nullptr);

  2531.                 CARLA_SAFE_ASSERT(pdesc->name != nullptr);

  2532. 

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

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

  2535.                 pData->midiprog.data[i].name    = carla_strdup(pdesc->name);

  2536.             }

  2537.         }

  2538. 

  2539. #if defined(HAVE_LIBLO) && ! defined(BUILD_BRIDGE)

  2540.         // Update OSC Names

  2541.         if (pData->engine->isOscControlRegistered() && pData->id < pData->engine->getCurrentPluginCount())

  2542.         {

  2543.             pData->engine->oscSend_control_set_midi_program_count(pData->id, newCount);

  2544. 

  2545.             for (uint32_t i=0; i < newCount; ++i)

  2546.                 pData->engine->oscSend_control_set_midi_program_data(pData->id, i, pData->midiprog.data[i].bank, pData->midiprog.data[i].program, pData->midiprog.data[i].name);

  2547.         }

  2548. #endif

  2549. 

  2550.         if (doInit)

  2551.         {

  2552.             if (newCount > 0)

  2553.             {

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

  2555.             }

  2556.             else

  2557.             {

  2558.                 // load default state

  2559.                 if (LilvState* const state = Lv2WorldClass::getInstance().getStateFromURI(fDescriptor->URI, (const LV2_URID_Map*)fFeatures[kFeatureIdUridMap]->data))

  2560.                 {

  2561.                     lilv_state_restore(state, fExt.state, fHandle, carla_lilv_set_port_value, this, 0, fFeatures);

  2562. 

  2563.                     if (fHandle2 != nullptr)

  2564.                         lilv_state_restore(state, fExt.state, fHandle2, carla_lilv_set_port_value, this, 0, fFeatures);

  2565. 

  2566.                     lilv_state_free(state);

  2567.                 }

  2568.             }

  2569.         }

  2570.         else

  2571.         {

  2572.             // Check if current program is invalid

  2573.             bool programChanged = false;

  2574. 

  2575.             if (newCount == oldCount+1)

  2576.             {

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

  2578.                 pData->midiprog.current = static_cast<int32_t>(oldCount);

  2579.                 programChanged = true;

  2580.             }

  2581.             else if (current < 0 && newCount > 0)

  2582.             {

  2583.                 // programs exist now, but not before

  2584.                 pData->midiprog.current = 0;

  2585.                 programChanged = true;

  2586.             }

  2587.             else if (current >= 0 && newCount == 0)

  2588.             {

  2589.                 // programs existed before, but not anymore

  2590.                 pData->midiprog.current = -1;

  2591.                 programChanged = true;

  2592.             }

  2593.             else if (current >= static_cast<int32_t>(newCount))

  2594.             {

  2595.                 // current midi program > count

  2596.                 pData->midiprog.current = 0;

  2597.                 programChanged = true;

  2598.             }

  2599.             else

  2600.             {

  2601.                 // no change

  2602.                 pData->midiprog.current = current;

  2603.             }

  2604. 

  2605.             if (programChanged)

  2606.                 setMidiProgram(pData->midiprog.current, true, true, true);

  2607. 

  2608.             pData->engine->callback(ENGINE_CALLBACK_RELOAD_PROGRAMS, pData->id, 0, 0, 0.0f, nullptr);

  2609.         }

  2610.     }

  2611. 

  2612.     // -------------------------------------------------------------------

  2613.     // Plugin processing

  2614. 

  2615.     void activate() noexcept override

  2616.     {

  2617.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  2618.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  2619. 

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

  2621.         {

  2622.             try {

  2623.                 fDescriptor->activate(fHandle);

  2624.             } CARLA_SAFE_EXCEPTION("LV2 activate");

  2625. 

  2626.             if (fHandle2 != nullptr)

  2627.             {

  2628.                 try {

  2629.                     fDescriptor->activate(fHandle2);

  2630.                 } CARLA_SAFE_EXCEPTION("LV2 activate #2");

  2631.             }

  2632.         }

  2633. 

  2634.         fFirstActive = true;

  2635.     }

  2636. 

  2637.     void deactivate() noexcept override

  2638.     {

  2639.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  2640.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  2641. 

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

  2643.         {

  2644.             try {

  2645.                 fDescriptor->deactivate(fHandle);

  2646.             } CARLA_SAFE_EXCEPTION("LV2 deactivate");

  2647. 

  2648.             if (fHandle2 != nullptr)

  2649.             {

  2650.                 try {

  2651.                     fDescriptor->deactivate(fHandle2);

  2652.                 } CARLA_SAFE_EXCEPTION("LV2 deactivate #2");

  2653.             }

  2654.         }

  2655.     }

  2656. 

  2657.     void process(const float** const audioIn, float** const audioOut, const float** const cvIn, float** const cvOut, const uint32_t frames) override

  2658.     {

  2659.         // --------------------------------------------------------------------------------------------------------

  2660.         // Check if active

  2661. 

  2662.         if (! pData->active)

  2663.         {

  2664.             // disable any output sound

  2665.             for (uint32_t i=0; i < pData->audioOut.count; ++i)

  2666.                 FloatVectorOperations::clear(audioOut[i], static_cast<int>(frames));

  2667.             for (uint32_t i=0; i < pData->cvOut.count; ++i)

  2668.                 FloatVectorOperations::clear(cvOut[i], static_cast<int>(frames));

  2669.             return;

  2670.         }

  2671. 

  2672.         // --------------------------------------------------------------------------------------------------------

  2673.         // Event itenerators from different APIs (input)

  2674. 

  2675.         LV2_Atom_Buffer_Iterator evInAtomIters[fEventsIn.count];

  2676.         LV2_Event_Iterator       evInEventIters[fEventsIn.count];

  2677.         LV2_MIDIState            evInMidiStates[fEventsIn.count];

  2678. 

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

  2680.         {

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

  2682.             {

  2683.                 lv2_atom_buffer_reset(fEventsIn.data[i].atom, true);

  2684.                 lv2_atom_buffer_begin(&evInAtomIters[i], fEventsIn.data[i].atom);

  2685.             }

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

  2687.             {

  2688.                 lv2_event_buffer_reset(fEventsIn.data[i].event, LV2_EVENT_AUDIO_STAMP, fEventsIn.data[i].event->data);

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

  2690.             }

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

  2692.             {

  2693.                 fEventsIn.data[i].midi.event_count = 0;

  2694.                 fEventsIn.data[i].midi.size        = 0;

  2695.                 evInMidiStates[i].midi        = &fEventsIn.data[i].midi;

  2696.                 evInMidiStates[i].frame_count = frames;

  2697.                 evInMidiStates[i].position    = 0;

  2698.             }

  2699.         }

  2700. 

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

  2702.         {

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

  2704.             {

  2705.                 lv2_atom_buffer_reset(fEventsOut.data[i].atom, false);

  2706.             }

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

  2708.             {

  2709.                 lv2_event_buffer_reset(fEventsOut.data[i].event, LV2_EVENT_AUDIO_STAMP, fEventsOut.data[i].event->data);

  2710.             }

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

  2712.             {

  2713.                 // not needed

  2714.             }

  2715.         }

  2716. 

  2717.         // --------------------------------------------------------------------------------------------------------

  2718.         // Check if needs reset

  2719. 

  2720.         if (pData->needsReset)

  2721.         {

  2722.             uint8_t midiData[3] = { 0, 0, 0 };

  2723. 

  2724.             if (fEventsIn.ctrl != nullptr && (fEventsIn.ctrl->type & CARLA_EVENT_TYPE_MIDI) != 0)

  2725.             {

  2726.                 const uint32_t j = fEventsIn.ctrlIndex;

  2727.                 CARLA_SAFE_ASSERT(j < fEventsIn.count);

  2728. 

  2729.                 if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  2730.                 {

  2731.                     for (uint8_t i=0; i < MAX_MIDI_CHANNELS; ++i)

  2732.                     {

  2733.                         midiData[0] = uint8_t(MIDI_STATUS_CONTROL_CHANGE | (i & MIDI_CHANNEL_BIT));

  2734.                         midiData[1] = MIDI_CONTROL_ALL_NOTES_OFF;

  2735. 

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

  2737.                             lv2_atom_buffer_write(&evInAtomIters[j], 0, 0, CARLA_URI_MAP_ID_MIDI_EVENT, 3, midiData);

  2738. 

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

  2740.                             lv2_event_write(&evInEventIters[j], 0, 0, CARLA_URI_MAP_ID_MIDI_EVENT, 3, midiData);

  2741. 

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

  2743.                             lv2midi_put_event(&evInMidiStates[j], 0.0, 3, midiData);

  2744. 

  2745.                         midiData[0] = uint8_t(MIDI_STATUS_CONTROL_CHANGE | (i & MIDI_CHANNEL_BIT));

  2746.                         midiData[1] = MIDI_CONTROL_ALL_SOUND_OFF;

  2747. 

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

  2749.                             lv2_atom_buffer_write(&evInAtomIters[j], 0, 0, CARLA_URI_MAP_ID_MIDI_EVENT, 3, midiData);

  2750. 

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

  2752.                             lv2_event_write(&evInEventIters[j], 0, 0, CARLA_URI_MAP_ID_MIDI_EVENT, 3, midiData);

  2753. 

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

  2755.                             lv2midi_put_event(&evInMidiStates[j], 0.0, 3, midiData);

  2756.                     }

  2757.                 }

  2758.                 else if (pData->ctrlChannel >= 0 && pData->ctrlChannel < MAX_MIDI_CHANNELS)

  2759.                 {

  2760.                     for (uint8_t k=0; k < MAX_MIDI_NOTE; ++k)

  2761.                     {

  2762.                         midiData[0] = uint8_t(MIDI_STATUS_NOTE_OFF | (pData->ctrlChannel & MIDI_CHANNEL_BIT));

  2763.                         midiData[1] = k;

  2764. 

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

  2766.                             lv2_atom_buffer_write(&evInAtomIters[j], 0, 0, CARLA_URI_MAP_ID_MIDI_EVENT, 3, midiData);

  2767. 

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

  2769.                             lv2_event_write(&evInEventIters[j], 0, 0, CARLA_URI_MAP_ID_MIDI_EVENT, 3, midiData);

  2770. 

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

  2772.                             lv2midi_put_event(&evInMidiStates[j], 0.0, 3, midiData);

  2773.                     }

  2774.                 }

  2775.             }

  2776. 

  2777. #ifndef BUILD_BRIDGE

  2778. #if 0 // TODO

  2779.             if (pData->latency > 0)

  2780.             {

  2781.                 for (uint32_t i=0; i < pData->audioIn.count; ++i)

  2782.                     FloatVectorOperations::clear(pData->latencyBuffers[i], static_cast<int>(pData->latency));

  2783.             }

  2784. #endif

  2785. #endif

  2786. 

  2787.             pData->needsReset = false;

  2788.         }

  2789. 

  2790.         // --------------------------------------------------------------------------------------------------------

  2791.         // TimeInfo

  2792. 

  2793.         const EngineTimeInfo& timeInfo(pData->engine->getTimeInfo());

  2794. 

  2795.         if (fFirstActive || fLastTimeInfo != timeInfo)

  2796.         {

  2797.             bool doPostRt;

  2798.             int32_t rindex;

  2799. 

  2800.             // update input ports

  2801.             for (uint32_t k=0; k < pData->param.count; ++k)

  2802.             {

  2803.                 if (pData->param.data[k].type != PARAMETER_INPUT)

  2804.                     continue;

  2805.                 if (pData->param.special[k] != PARAMETER_SPECIAL_TIME)

  2806.                     continue;

  2807. 

  2808.                 doPostRt = false;

  2809.                 rindex = pData->param.data[k].rindex;

  2810. 

  2811.                 CARLA_SAFE_ASSERT_CONTINUE(rindex >= 0 && rindex < static_cast<int32_t>(fRdfDescriptor->PortCount));

  2812. 

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

  2814.                 {

  2815.                 // Non-BBT

  2816.                 case LV2_PORT_DESIGNATION_TIME_SPEED:

  2817.                     if (fLastTimeInfo.playing != timeInfo.playing)

  2818.                     {

  2819.                         fParamBuffers[k] = timeInfo.playing ? 1.0f : 0.0f;

  2820.                         doPostRt = true;

  2821.                     }

  2822.                     break;

  2823.                 case LV2_PORT_DESIGNATION_TIME_FRAME:

  2824.                     if (fLastTimeInfo.frame != timeInfo.frame)

  2825.                     {

  2826.                         fParamBuffers[k] = static_cast<float>(timeInfo.frame);

  2827.                         doPostRt = true;

  2828.                     }

  2829.                     break;

  2830.                 case LV2_PORT_DESIGNATION_TIME_FRAMES_PER_SECOND:

  2831.                     break;

  2832. 

  2833.                 // BBT

  2834.                 case LV2_PORT_DESIGNATION_TIME_BAR:

  2835.                     if ((timeInfo.valid & EngineTimeInfo::kValidBBT) != 0 && fLastTimeInfo.bbt.bar != timeInfo.bbt.bar)

  2836.                     {

  2837.                         fParamBuffers[k] = static_cast<float>(timeInfo.bbt.bar - 1);

  2838.                         doPostRt = true;

  2839.                     }

  2840.                     break;

  2841.                 case LV2_PORT_DESIGNATION_TIME_BAR_BEAT:

  2842.                     if ((timeInfo.valid & EngineTimeInfo::kValidBBT) != 0 && (fLastTimeInfo.bbt.tick != timeInfo.bbt.tick ||

  2843.                                                                               fLastTimeInfo.bbt.beat != timeInfo.bbt.beat))

  2844.                     {

  2845.                         fParamBuffers[k] = static_cast<float>(static_cast<double>(timeInfo.bbt.beat) - 1.0 + (static_cast<double>(timeInfo.bbt.tick) / timeInfo.bbt.ticksPerBeat));

  2846.                         doPostRt = true;

  2847.                     }

  2848.                     break;

  2849.                 case LV2_PORT_DESIGNATION_TIME_BEAT:

  2850.                     if ((timeInfo.valid & EngineTimeInfo::kValidBBT) != 0 && fLastTimeInfo.bbt.beat != timeInfo.bbt.beat)

  2851.                     {

  2852.                         fParamBuffers[k] = static_cast<float>(timeInfo.bbt.beat - 1);

  2853.                         doPostRt = true;

  2854.                     }

  2855.                     break;

  2856.                 case LV2_PORT_DESIGNATION_TIME_BEAT_UNIT:

  2857.                     if ((timeInfo.valid & EngineTimeInfo::kValidBBT) != 0 && carla_isNotEqual(fLastTimeInfo.bbt.beatType, timeInfo.bbt.beatType))

  2858.                     {

  2859.                         fParamBuffers[k] = timeInfo.bbt.beatType;

  2860.                         doPostRt = true;

  2861.                     }

  2862.                     break;

  2863.                 case LV2_PORT_DESIGNATION_TIME_BEATS_PER_BAR:

  2864.                     if ((timeInfo.valid & EngineTimeInfo::kValidBBT) != 0 && carla_isNotEqual(fLastTimeInfo.bbt.beatsPerBar, timeInfo.bbt.beatsPerBar))

  2865.                     {

  2866.                         fParamBuffers[k] = timeInfo.bbt.beatsPerBar;

  2867.                         doPostRt = true;

  2868.                     }

  2869.                     break;

  2870.                 case LV2_PORT_DESIGNATION_TIME_BEATS_PER_MINUTE:

  2871.                     if ((timeInfo.valid & EngineTimeInfo::kValidBBT) != 0 && carla_isNotEqual(fLastTimeInfo.bbt.beatsPerMinute, timeInfo.bbt.beatsPerMinute))

  2872.                     {

  2873.                         fParamBuffers[k] = static_cast<float>(timeInfo.bbt.beatsPerMinute);

  2874.                         doPostRt = true;

  2875.                     }

  2876.                     break;

  2877.                 case LV2_PORT_DESIGNATION_TIME_TICKS_PER_BEAT:

  2878.                     if ((timeInfo.valid & EngineTimeInfo::kValidBBT) != 0 && carla_isNotEqual(fLastTimeInfo.bbt.ticksPerBeat, timeInfo.bbt.ticksPerBeat))

  2879.                     {

  2880.                         fParamBuffers[k] = static_cast<float>(timeInfo.bbt.ticksPerBeat);

  2881.                         doPostRt = true;

  2882.                     }

  2883.                     break;

  2884.                 }

  2885. 

  2886.                 if (doPostRt)

  2887.                     pData->postponeRtEvent(kPluginPostRtEventParameterChange, static_cast<int32_t>(k), 1, fParamBuffers[k]);

  2888.             }

  2889. 

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

  2891.             {

  2892.                 if ((fEventsIn.data[i].type & CARLA_EVENT_DATA_ATOM) == 0 || (fEventsIn.data[i].type & CARLA_EVENT_TYPE_TIME) == 0)

  2893.                     continue;

  2894. 

  2895.                 uint8_t timeInfoBuf[256];

  2896.                 lv2_atom_forge_set_buffer(&fAtomForge, timeInfoBuf, sizeof(timeInfoBuf));

  2897. 

  2898.                 LV2_Atom_Forge_Frame forgeFrame;

  2899.                 lv2_atom_forge_object(&fAtomForge, &forgeFrame, CARLA_URI_MAP_ID_NULL, CARLA_URI_MAP_ID_TIME_POSITION);

  2900. 

  2901.                 lv2_atom_forge_key(&fAtomForge, CARLA_URI_MAP_ID_TIME_SPEED);

  2902.                 lv2_atom_forge_float(&fAtomForge, timeInfo.playing ? 1.0f : 0.0f);

  2903. 

  2904.                 lv2_atom_forge_key(&fAtomForge, CARLA_URI_MAP_ID_TIME_FRAME);

  2905.                 lv2_atom_forge_long(&fAtomForge, static_cast<int64_t>(timeInfo.frame));

  2906. 

  2907.                 if (timeInfo.valid & EngineTimeInfo::kValidBBT)

  2908.                 {

  2909.                     lv2_atom_forge_key(&fAtomForge, CARLA_URI_MAP_ID_TIME_BAR);

  2910.                     lv2_atom_forge_long(&fAtomForge, timeInfo.bbt.bar - 1);

  2911. 

  2912.                     lv2_atom_forge_key(&fAtomForge, CARLA_URI_MAP_ID_TIME_BAR_BEAT);

  2913.                     lv2_atom_forge_float(&fAtomForge, static_cast<float>(static_cast<double>(timeInfo.bbt.beat) - 1.0 + (static_cast<double>(timeInfo.bbt.tick) / timeInfo.bbt.ticksPerBeat)));

  2914. 

  2915.                     lv2_atom_forge_key(&fAtomForge, CARLA_URI_MAP_ID_TIME_BEAT);

  2916.                     lv2_atom_forge_double(&fAtomForge, timeInfo.bbt.beat - 1);

  2917. 

  2918.                     lv2_atom_forge_key(&fAtomForge, CARLA_URI_MAP_ID_TIME_BEAT_UNIT);

  2919.                     lv2_atom_forge_int(&fAtomForge, static_cast<int32_t>(timeInfo.bbt.beatType));

  2920. 

  2921.                     lv2_atom_forge_key(&fAtomForge, CARLA_URI_MAP_ID_TIME_BEATS_PER_BAR);

  2922.                     lv2_atom_forge_float(&fAtomForge, timeInfo.bbt.beatsPerBar);

  2923. 

  2924.                     lv2_atom_forge_key(&fAtomForge, CARLA_URI_MAP_ID_TIME_BEATS_PER_MINUTE);

  2925.                     lv2_atom_forge_float(&fAtomForge, static_cast<float>(timeInfo.bbt.beatsPerMinute));

  2926. 

  2927.                     lv2_atom_forge_key(&fAtomForge, CARLA_URI_MAP_ID_TIME_TICKS_PER_BEAT);

  2928.                     lv2_atom_forge_double(&fAtomForge, timeInfo.bbt.ticksPerBeat);

  2929.                 }

  2930. 

  2931.                 lv2_atom_forge_pop(&fAtomForge, &forgeFrame);

  2932. 

  2933.                 LV2_Atom* const atom((LV2_Atom*)timeInfoBuf);

  2934.                 CARLA_SAFE_ASSERT_BREAK(atom->size < 256);

  2935. 

  2936.                 // send only deprecated blank object for now

  2937.                 lv2_atom_buffer_write(&evInAtomIters[i], 0, 0, CARLA_URI_MAP_ID_ATOM_BLANK, atom->size, LV2_ATOM_BODY_CONST(atom));

  2938. 

  2939.                 // for atom:object

  2940.                 //lv2_atom_buffer_write(&evInAtomIters[i], 0, 0, atom->type, atom->size, LV2_ATOM_BODY_CONST(atom));

  2941.             }

  2942. 

  2943.             pData->postRtEvents.trySplice();

  2944. 

  2945.             carla_copyStruct(fLastTimeInfo, timeInfo);

  2946.         }

  2947. 

  2948.         // --------------------------------------------------------------------------------------------------------

  2949.         // Event Input and Processing

  2950. 

  2951.         if (fEventsIn.ctrl != nullptr)

  2952.         {

  2953.             // ----------------------------------------------------------------------------------------------------

  2954.             // Message Input

  2955. 

  2956.             if (fAtomBufferIn.tryLock())

  2957.             {

  2958.                 if (fAtomBufferIn.isDataAvailableForReading())

  2959.                 {

  2960.                     const LV2_Atom* atom;

  2961.                     uint32_t j, portIndex;

  2962. 

  2963.                     for (; fAtomBufferIn.get(atom, portIndex);)

  2964.                     {

  2965.                         j = (portIndex < fEventsIn.count) ? portIndex : fEventsIn.ctrlIndex;

  2966. 

  2967.                         if (atom->type == CARLA_URI_MAP_ID_CARLA_ATOM_WORKER)

  2968.                         {

  2969.                             CARLA_SAFE_ASSERT_CONTINUE(fExt.worker != nullptr && fExt.worker->work_response != nullptr);

  2970.                             fExt.worker->work_response(fHandle, atom->size, LV2_ATOM_BODY_CONST(atom));

  2971.                         }

  2972.                         else if (! lv2_atom_buffer_write(&evInAtomIters[j], 0, 0, atom->type, atom->size, LV2_ATOM_BODY_CONST(atom)))

  2973.                         {

  2974.                             carla_stdout("Event input buffer full, at least 1 message lost");

  2975.                             continue;

  2976.                         }

  2977.                     }

  2978.                 }

  2979. 

  2980.                 fAtomBufferIn.unlock();

  2981.             }

  2982. 

  2983.             // ----------------------------------------------------------------------------------------------------

  2984.             // MIDI Input (External)

  2985. 

  2986.             if (pData->extNotes.mutex.tryLock())

  2987.             {

  2988.                 if ((fEventsIn.ctrl->type & CARLA_EVENT_TYPE_MIDI) == 0)

  2989.                 {

  2990.                     // does not handle MIDI

  2991.                     pData->extNotes.data.clear();

  2992.                 }

  2993.                 else

  2994.                 {

  2995.                     const uint32_t j = fEventsIn.ctrlIndex;

  2996. 

  2997.                     for (RtLinkedList<ExternalMidiNote>::Itenerator it = pData->extNotes.data.begin2(); it.valid(); it.next())

  2998.                     {

  2999.                         const ExternalMidiNote& note(it.getValue(kExternalMidiNoteFallback));

  3000.                         CARLA_SAFE_ASSERT_CONTINUE(note.channel >= 0 && note.channel < MAX_MIDI_CHANNELS);

  3001. 

  3002.                         uint8_t midiEvent[3];

  3003.                         midiEvent[0] = uint8_t((note.velo > 0 ? MIDI_STATUS_NOTE_ON : MIDI_STATUS_NOTE_OFF) | (note.channel & MIDI_CHANNEL_BIT));

  3004.                         midiEvent[1] = note.note;

  3005.                         midiEvent[2] = note.velo;

  3006. 

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

  3008.                             lv2_atom_buffer_write(&evInAtomIters[j], 0, 0, CARLA_URI_MAP_ID_MIDI_EVENT, 3, midiEvent);

  3009. 

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

  3011.                             lv2_event_write(&evInEventIters[j], 0, 0, CARLA_URI_MAP_ID_MIDI_EVENT, 3, midiEvent);

  3012. 

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

  3014.                             lv2midi_put_event(&evInMidiStates[j], 0.0, 3, midiEvent);

  3015.                     }

  3016. 

  3017.                     pData->extNotes.data.clear();

  3018.                 }

  3019. 

  3020.                 pData->extNotes.mutex.unlock();

  3021. 

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

  3023. 

  3024.             // ----------------------------------------------------------------------------------------------------

  3025.             // Event Input (System)

  3026. 

  3027. #ifndef BUILD_BRIDGE

  3028.             bool allNotesOffSent  = false;

  3029. #endif

  3030.             bool isSampleAccurate = (pData->options & PLUGIN_OPTION_FIXED_BUFFERS) == 0;

  3031. 

  3032.             uint32_t startTime  = 0;

  3033.             uint32_t timeOffset = 0;

  3034.             uint32_t nextBankId;

  3035. 

  3036.             if (pData->midiprog.current >= 0 && pData->midiprog.count > 0)

  3037.                 nextBankId = pData->midiprog.data[pData->midiprog.current].bank;

  3038.             else

  3039.                 nextBankId = 0;

  3040. 

  3041.             const uint32_t numEvents = (fEventsIn.ctrl->port != nullptr) ? fEventsIn.ctrl->port->getEventCount() : 0;

  3042. 

  3043.             for (uint32_t i=0; i < numEvents; ++i)

  3044.             {

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

  3046. 

  3047.                 if (event.time >= frames)

  3048.                     continue;

  3049. 

  3050.                 CARLA_ASSERT_INT2(event.time >= timeOffset, event.time, timeOffset);

  3051. 

  3052.                 if (isSampleAccurate && event.time > timeOffset)

  3053.                 {

  3054.                     if (processSingle(audioIn, audioOut, cvIn, cvOut, event.time - timeOffset, timeOffset))

  3055.                     {

  3056.                         startTime  = 0;

  3057.                         timeOffset = event.time;

  3058. 

  3059.                         if (pData->midiprog.current >= 0 && pData->midiprog.count > 0)

  3060.                             nextBankId = pData->midiprog.data[pData->midiprog.current].bank;

  3061.                         else

  3062.                             nextBankId = 0;

  3063. 

  3064.                         // reset iters

  3065.                         const uint32_t j = fEventsIn.ctrlIndex;

  3066. 

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

  3068.                         {

  3069.                             lv2_atom_buffer_reset(fEventsIn.data[j].atom, true);

  3070.                             lv2_atom_buffer_begin(&evInAtomIters[j], fEventsIn.data[j].atom);

  3071.                         }

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

  3073.                         {

  3074.                             lv2_event_buffer_reset(fEventsIn.data[j].event, LV2_EVENT_AUDIO_STAMP, fEventsIn.data[j].event->data);

  3075.                             lv2_event_begin(&evInEventIters[j], fEventsIn.data[j].event);

  3076.                         }

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

  3078.                         {

  3079.                             fEventsIn.data[j].midi.event_count = 0;

  3080.                             fEventsIn.data[j].midi.size        = 0;

  3081.                             evInMidiStates[j].position = event.time;

  3082.                         }

  3083.                     }

  3084.                     else

  3085.                         startTime += timeOffset;

  3086.                 }

  3087. 

  3088.                 switch (event.type)

  3089.                 {

  3090.                 case kEngineEventTypeNull:

  3091.                     break;

  3092. 

  3093.                 case kEngineEventTypeControl: {

  3094.                     const EngineControlEvent& ctrlEvent(event.ctrl);

  3095. 

  3096.                     switch (ctrlEvent.type)

  3097.                     {

  3098.                     case kEngineControlEventTypeNull:

  3099.                         break;

  3100. 

  3101.                     case kEngineControlEventTypeParameter: {

  3102. #ifndef BUILD_BRIDGE

  3103.                         // Control backend stuff

  3104.                         if (event.channel == pData->ctrlChannel)

  3105.                         {

  3106.                             float value;

  3107. 

  3108.                             if (MIDI_IS_CONTROL_BREATH_CONTROLLER(ctrlEvent.param) && (pData->hints & PLUGIN_CAN_DRYWET) != 0)

  3109.                             {

  3110.                                 value = ctrlEvent.value;

  3111.                                 setDryWet(value, false, false);

  3112.                                 pData->postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_DRYWET, 0, value);

  3113.                             }

  3114. 

  3115.                             if (MIDI_IS_CONTROL_CHANNEL_VOLUME(ctrlEvent.param) && (pData->hints & PLUGIN_CAN_VOLUME) != 0)

  3116.                             {

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

  3118.                                 setVolume(value, false, false);

  3119.                                 pData->postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_VOLUME, 0, value);

  3120.                             }

  3121. 

  3122.                             if (MIDI_IS_CONTROL_BALANCE(ctrlEvent.param) && (pData->hints & PLUGIN_CAN_BALANCE) != 0)

  3123.                             {

  3124.                                 float left, right;

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

  3126. 

  3127.                                 if (value < 0.0f)

  3128.                                 {

  3129.                                     left  = -1.0f;

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

  3131.                                 }

  3132.                                 else if (value > 0.0f)

  3133.                                 {

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

  3135.                                     right = 1.0f;

  3136.                                 }

  3137.                                 else

  3138.                                 {

  3139.                                     left  = -1.0f;

  3140.                                     right = 1.0f;

  3141.                                 }

  3142. 

  3143.                                 setBalanceLeft(left, false, false);

  3144.                                 setBalanceRight(right, false, false);

  3145.                                 pData->postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_BALANCE_LEFT, 0, left);

  3146.                                 pData->postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_BALANCE_RIGHT, 0, right);

  3147.                             }

  3148.                         }

  3149. #endif

  3150.                         // Control plugin parameters

  3151.                         uint32_t k;

  3152.                         for (k=0; k < pData->param.count; ++k)

  3153.                         {

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

  3155.                                 continue;

  3156.                             if (pData->param.data[k].midiCC != ctrlEvent.param)

  3157.                                 continue;

  3158.                             if (pData->param.data[k].type != PARAMETER_INPUT)

  3159.                                 continue;

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

  3161.                                 continue;

  3162. 

  3163.                             float value;

  3164. 

  3165.                             if (pData->param.data[k].hints & PARAMETER_IS_BOOLEAN)

  3166.                             {

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

  3168.                             }

  3169.                             else

  3170.                             {

  3171.                                 if (pData->param.data[k].hints & PARAMETER_IS_LOGARITHMIC)

  3172.                                     value = pData->param.ranges[k].getUnnormalizedLogValue(ctrlEvent.value);

  3173.                                 else

  3174.                                     value = pData->param.ranges[k].getUnnormalizedValue(ctrlEvent.value);

  3175. 

  3176.                                 if (pData->param.data[k].hints & PARAMETER_IS_INTEGER)

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

  3178.                             }

  3179. 

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

  3181.                             pData->postponeRtEvent(kPluginPostRtEventParameterChange, static_cast<int32_t>(k), 0, value);

  3182.                         }

  3183. 

  3184.                         if ((pData->options & PLUGIN_OPTION_SEND_CONTROL_CHANGES) != 0 && ctrlEvent.param < MAX_MIDI_CONTROL)

  3185.                         {

  3186.                             uint8_t midiData[3];

  3187.                             midiData[0] = uint8_t(MIDI_STATUS_CONTROL_CHANGE | (event.channel & MIDI_CHANNEL_BIT));

  3188.                             midiData[1] = uint8_t(ctrlEvent.param);

  3189.                             midiData[2] = uint8_t(ctrlEvent.value*127.0f);

  3190. 

  3191.                             const uint32_t mtime(isSampleAccurate ? startTime : event.time);

  3192. 

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

  3194.                                 lv2_atom_buffer_write(&evInAtomIters[fEventsIn.ctrlIndex], mtime, 0, CARLA_URI_MAP_ID_MIDI_EVENT, 3, midiData);

  3195. 

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

  3197.                                 lv2_event_write(&evInEventIters[fEventsIn.ctrlIndex], mtime, 0, CARLA_URI_MAP_ID_MIDI_EVENT, 3, midiData);

  3198. 

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

  3200.                                 lv2midi_put_event(&evInMidiStates[fEventsIn.ctrlIndex], mtime, 3, midiData);

  3201.                         }

  3202. 

  3203.                         break;

  3204.                     } // case kEngineControlEventTypeParameter

  3205. 

  3206.                     case kEngineControlEventTypeMidiBank:

  3207.                         if (pData->options & PLUGIN_OPTION_MAP_PROGRAM_CHANGES)

  3208.                         {

  3209.                             if (event.channel == pData->ctrlChannel)

  3210.                                 nextBankId = ctrlEvent.param;

  3211.                         }

  3212.                         else if (pData->options & PLUGIN_OPTION_SEND_PROGRAM_CHANGES)

  3213.                         {

  3214.                             uint8_t midiData[3];

  3215.                             midiData[0] = uint8_t(MIDI_STATUS_CONTROL_CHANGE | (event.channel & MIDI_CHANNEL_BIT));

  3216.                             midiData[1] = MIDI_CONTROL_BANK_SELECT;

  3217.                             midiData[2] = uint8_t(ctrlEvent.param);

  3218. 

  3219.                             const uint32_t mtime(isSampleAccurate ? startTime : event.time);

  3220. 

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

  3222.                                 lv2_atom_buffer_write(&evInAtomIters[fEventsIn.ctrlIndex], mtime, 0, CARLA_URI_MAP_ID_MIDI_EVENT, 3, midiData);

  3223. 

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

  3225.                                 lv2_event_write(&evInEventIters[fEventsIn.ctrlIndex], mtime, 0, CARLA_URI_MAP_ID_MIDI_EVENT, 3, midiData);

  3226. 

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

  3228.                                 lv2midi_put_event(&evInMidiStates[fEventsIn.ctrlIndex], mtime, 3, midiData);

  3229.                         }

  3230.                         break;

  3231. 

  3232.                     case kEngineControlEventTypeMidiProgram:

  3233.                         if (pData->options & PLUGIN_OPTION_MAP_PROGRAM_CHANGES)

  3234.                         {

  3235.                             if (event.channel == pData->ctrlChannel)

  3236.                             {

  3237.                                 const uint32_t nextProgramId(ctrlEvent.param);

  3238. 

  3239.                                 for (uint32_t k=0; k < pData->midiprog.count; ++k)

  3240.                                 {

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

  3242.                                     {

  3243.                                         const int32_t index(static_cast<int32_t>(k));

  3244.                                         setMidiProgram(index, false, false, false);

  3245.                                         pData->postponeRtEvent(kPluginPostRtEventMidiProgramChange, index, 0, 0.0f);

  3246.                                         break;

  3247.                                     }

  3248.                                 }

  3249.                             }

  3250.                         }

  3251.                         else if (pData->options & PLUGIN_OPTION_SEND_PROGRAM_CHANGES)

  3252.                         {

  3253.                             uint8_t midiData[2];

  3254.                             midiData[0] = uint8_t(MIDI_STATUS_PROGRAM_CHANGE | (event.channel & MIDI_CHANNEL_BIT));

  3255.                             midiData[1] = uint8_t(ctrlEvent.param);

  3256. 

  3257.                             const uint32_t mtime(isSampleAccurate ? startTime : event.time);

  3258. 

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

  3260.                                 lv2_atom_buffer_write(&evInAtomIters[fEventsIn.ctrlIndex], mtime, 0, CARLA_URI_MAP_ID_MIDI_EVENT, 2, midiData);

  3261. 

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

  3263.                                 lv2_event_write(&evInEventIters[fEventsIn.ctrlIndex], mtime, 0, CARLA_URI_MAP_ID_MIDI_EVENT, 2, midiData);

  3264. 

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

  3266.                                 lv2midi_put_event(&evInMidiStates[fEventsIn.ctrlIndex], mtime, 2, midiData);

  3267.                         }

  3268.                         break;

  3269. 

  3270.                     case kEngineControlEventTypeAllSoundOff:

  3271.                         if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  3272.                         {

  3273.                             const uint32_t mtime(isSampleAccurate ? startTime : event.time);

  3274. 

  3275.                             uint8_t midiData[3];

  3276.                             midiData[0] = uint8_t(MIDI_STATUS_CONTROL_CHANGE | (event.channel & MIDI_CHANNEL_BIT));

  3277.                             midiData[1] = MIDI_CONTROL_ALL_SOUND_OFF;

  3278.                             midiData[2] = 0;

  3279. 

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

  3281.                                 lv2_atom_buffer_write(&evInAtomIters[fEventsIn.ctrlIndex], mtime, 0, CARLA_URI_MAP_ID_MIDI_EVENT, 3, midiData);

  3282. 

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

  3284.                                 lv2_event_write(&evInEventIters[fEventsIn.ctrlIndex], mtime, 0, CARLA_URI_MAP_ID_MIDI_EVENT, 3, midiData);

  3285. 

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

  3287.                                 lv2midi_put_event(&evInMidiStates[fEventsIn.ctrlIndex], mtime, 3, midiData);

  3288.                         }

  3289.                         break;

  3290. 

  3291.                     case kEngineControlEventTypeAllNotesOff:

  3292.                         if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  3293.                         {

  3294. #ifndef BUILD_BRIDGE

  3295.                             if (event.channel == pData->ctrlChannel && ! allNotesOffSent)

  3296.                             {

  3297.                                 allNotesOffSent = true;

  3298.                                 sendMidiAllNotesOffToCallback();

  3299.                             }

  3300. #endif

  3301. 

  3302.                             const uint32_t mtime(isSampleAccurate ? startTime : event.time);

  3303. 

  3304.                             uint8_t midiData[3];

  3305.                             midiData[0] = uint8_t(MIDI_STATUS_CONTROL_CHANGE | (event.channel & MIDI_CHANNEL_BIT));

  3306.                             midiData[1] = MIDI_CONTROL_ALL_NOTES_OFF;

  3307.                             midiData[2] = 0;

  3308. 

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

  3310.                                 lv2_atom_buffer_write(&evInAtomIters[fEventsIn.ctrlIndex], mtime, 0, CARLA_URI_MAP_ID_MIDI_EVENT, 3, midiData);

  3311. 

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

  3313.                                 lv2_event_write(&evInEventIters[fEventsIn.ctrlIndex], mtime, 0, CARLA_URI_MAP_ID_MIDI_EVENT, 3, midiData);

  3314. 

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

  3316.                                 lv2midi_put_event(&evInMidiStates[fEventsIn.ctrlIndex], mtime, 3, midiData);

  3317.                         }

  3318.                         break;

  3319.                     } // switch (ctrlEvent.type)

  3320.                     break;

  3321.                 } // case kEngineEventTypeControl

  3322. 

  3323.                 case kEngineEventTypeMidi: {

  3324.                     const EngineMidiEvent& midiEvent(event.midi);

  3325. 

  3326.                     const uint8_t* const midiData(midiEvent.size > EngineMidiEvent::kDataSize ? midiEvent.dataExt : midiEvent.data);

  3327. 

  3328.                     uint8_t status = uint8_t(MIDI_GET_STATUS_FROM_DATA(midiData));

  3329. 

  3330.                     if (status == MIDI_STATUS_CHANNEL_PRESSURE && (pData->options & PLUGIN_OPTION_SEND_CHANNEL_PRESSURE) == 0)

  3331.                         continue;

  3332.                     if (status == MIDI_STATUS_CONTROL_CHANGE && (pData->options & PLUGIN_OPTION_SEND_CONTROL_CHANGES) == 0)

  3333.                         continue;

  3334.                     if (status == MIDI_STATUS_POLYPHONIC_AFTERTOUCH && (pData->options & PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH) == 0)

  3335.                         continue;

  3336.                     if (status == MIDI_STATUS_PITCH_WHEEL_CONTROL && (pData->options & PLUGIN_OPTION_SEND_PITCHBEND) == 0)

  3337.                         continue;

  3338. 

  3339.                     // Fix bad note-off (per LV2 spec)

  3340.                     if (status == MIDI_STATUS_NOTE_ON && midiData[2] == 0)

  3341.                         status = MIDI_STATUS_NOTE_OFF;

  3342. 

  3343.                     const uint32_t j     = fEventsIn.ctrlIndex;

  3344.                     const uint32_t mtime = isSampleAccurate ? startTime : event.time;

  3345. 

  3346.                     // put back channel in data

  3347.                     uint8_t midiData2[midiEvent.size];

  3348.                     midiData2[0] = uint8_t(status | (event.channel & MIDI_CHANNEL_BIT));

  3349.                     std::memcpy(midiData2+1, midiData+1, static_cast<std::size_t>(midiEvent.size-1));

  3350. 

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

  3352.                         lv2_atom_buffer_write(&evInAtomIters[j], mtime, 0, CARLA_URI_MAP_ID_MIDI_EVENT, midiEvent.size, midiData2);

  3353. 

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

  3355.                         lv2_event_write(&evInEventIters[j], mtime, 0, CARLA_URI_MAP_ID_MIDI_EVENT, midiEvent.size, midiData2);

  3356. 

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

  3358.                         lv2midi_put_event(&evInMidiStates[j], mtime, midiEvent.size, midiData2);

  3359. 

  3360.                     if (status == MIDI_STATUS_NOTE_ON)

  3361.                         pData->postponeRtEvent(kPluginPostRtEventNoteOn, event.channel, midiData[1], midiData[2]);

  3362.                     else if (status == MIDI_STATUS_NOTE_OFF)

  3363.                         pData->postponeRtEvent(kPluginPostRtEventNoteOff, event.channel, midiData[1], 0.0f);

  3364.                 } break;

  3365.                 } // switch (event.type)

  3366.             }

  3367. 

  3368.             pData->postRtEvents.trySplice();

  3369. 

  3370.             if (frames > timeOffset)

  3371.                 processSingle(audioIn, audioOut, cvIn, cvOut, frames - timeOffset, timeOffset);

  3372. 

  3373.         } // End of Event Input and Processing

  3374. 

  3375.         // --------------------------------------------------------------------------------------------------------

  3376.         // Plugin processing (no events)

  3377. 

  3378.         else

  3379.         {

  3380.             processSingle(audioIn, audioOut, cvIn, cvOut, frames, 0);

  3381. 

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

  3383. 

  3384. #ifndef BUILD_BRIDGE

  3385. #if 0 // TODO

  3386.         // --------------------------------------------------------------------------------------------------------

  3387.         // Latency, save values for next callback

  3388. 

  3389.         if (fLatencyIndex != -1)

  3390.         {

  3391.             if (pData->latency != static_cast<uint32_t>(fParamBuffers[fLatencyIndex]))

  3392.             {

  3393.                 fLatencyChanged = true;

  3394.             }

  3395.             else if (pData->latency > 0)

  3396.             {

  3397.                 if (pData->latency <= frames)

  3398.                 {

  3399.                     for (uint32_t i=0; i < pData->audioIn.count; ++i)

  3400.                         FloatVectorOperations::copy(pData->latencyBuffers[i], audioIn[i]+(frames-pData->latency), static_cast<int>(pData->latency));

  3401.                 }

  3402.                 else

  3403.                 {

  3404.                     for (uint32_t i=0, j, k; i < pData->audioIn.count; ++i)

  3405.                     {

  3406.                         for (k=0; k < pData->latency-frames; ++k)

  3407.                             pData->latencyBuffers[i][k] = pData->latencyBuffers[i][k+frames];

  3408.                         for (j=0; k < pData->latency; ++j, ++k)

  3409.                             pData->latencyBuffers[i][k] = audioIn[i][j];

  3410.                     }

  3411.                 }

  3412.             }

  3413.         }

  3414. #endif

  3415. #endif

  3416. 

  3417.         // --------------------------------------------------------------------------------------------------------

  3418.         // MIDI Output

  3419. 

  3420.         if (fEventsOut.ctrl != nullptr)

  3421.         {

  3422.             if (fEventsOut.ctrl->type & CARLA_EVENT_DATA_ATOM)

  3423.             {

  3424.                 const LV2_Atom_Event* ev;

  3425.                 LV2_Atom_Buffer_Iterator iter;

  3426. 

  3427.                 uint8_t* data;

  3428.                 lv2_atom_buffer_begin(&iter, fEventsOut.ctrl->atom);

  3429. 

  3430.                 for (;;)

  3431.                 {

  3432.                     data = nullptr;

  3433.                     ev = lv2_atom_buffer_get(&iter, &data);

  3434. 

  3435.                     if (ev == nullptr || ev->body.size == 0 || data == nullptr)

  3436.                         break;

  3437. 

  3438.                     if (ev->body.type == CARLA_URI_MAP_ID_MIDI_EVENT)

  3439.                     {

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

  3441.                         {

  3442.                             CARLA_SAFE_ASSERT_CONTINUE(ev->time.frames >= 0);

  3443.                             CARLA_SAFE_ASSERT_CONTINUE(ev->body.size < 0xFF);

  3444.                             fEventsOut.ctrl->port->writeMidiEvent(static_cast<uint32_t>(ev->time.frames), static_cast<uint8_t>(ev->body.size), data);

  3445.                         }

  3446.                     }

  3447.                     else //if (ev->body.type == CARLA_URI_MAP_ID_ATOM_BLANK)

  3448.                     {

  3449.                         //carla_stdout("Got out event, %s", carla_lv2_urid_unmap(this, ev->body.type));

  3450.                         fAtomBufferOut.put(&ev->body, fEventsOut.ctrl->rindex);

  3451.                     }

  3452. 

  3453.                     lv2_atom_buffer_increment(&iter);

  3454.                 }

  3455.             }

  3456.             else if ((fEventsOut.ctrl->type & CARLA_EVENT_DATA_EVENT) != 0 && fEventsOut.ctrl->port != nullptr)

  3457.             {

  3458.                 const LV2_Event* ev;

  3459.                 LV2_Event_Iterator iter;

  3460. 

  3461.                 uint8_t* data;

  3462.                 lv2_event_begin(&iter, fEventsOut.ctrl->event);

  3463. 

  3464.                 for (;;)

  3465.                 {

  3466.                     data = nullptr;

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

  3468. 

  3469.                     if (ev == nullptr || data == nullptr)

  3470.                         break;

  3471. 

  3472.                     if (ev->type == CARLA_URI_MAP_ID_MIDI_EVENT)

  3473.                     {

  3474.                         CARLA_SAFE_ASSERT_CONTINUE(ev->size < 0xFF);

  3475.                         fEventsOut.ctrl->port->writeMidiEvent(ev->frames, static_cast<uint8_t>(ev->size), data);

  3476.                     }

  3477. 

  3478.                     lv2_event_increment(&iter);

  3479.                 }

  3480.             }

  3481.             else if ((fEventsOut.ctrl->type & CARLA_EVENT_DATA_MIDI_LL) != 0 && fEventsOut.ctrl->port != nullptr)

  3482.             {

  3483.                 LV2_MIDIState state = { &fEventsOut.ctrl->midi, frames, 0 };

  3484. 

  3485.                 uint32_t eventSize;

  3486.                 double   eventTime;

  3487.                 uchar* eventData;

  3488. 

  3489.                 for (;;)

  3490.                 {

  3491.                     eventSize = 0;

  3492.                     eventTime = 0.0;

  3493.                     eventData = nullptr;

  3494.                     lv2midi_get_event(&state, &eventTime, &eventSize, &eventData);

  3495. 

  3496.                     if (eventData == nullptr || eventSize == 0)

  3497.                         break;

  3498. 

  3499.                     CARLA_SAFE_ASSERT_CONTINUE(eventSize < 0xFF);

  3500.                     CARLA_SAFE_ASSERT_CONTINUE(eventTime >= 0.0);

  3501. 

  3502.                     fEventsOut.ctrl->port->writeMidiEvent(static_cast<uint32_t>(eventTime), static_cast<uint8_t>(eventSize), eventData);

  3503.                     lv2midi_step(&state);

  3504.                 }

  3505.             }

  3506.         }

  3507. 

  3508. #ifndef BUILD_BRIDGE

  3509.         // --------------------------------------------------------------------------------------------------------

  3510.         // Control Output

  3511. 

  3512.         if (pData->event.portOut != nullptr)

  3513.         {

  3514.             uint8_t  channel;

  3515.             uint16_t param;

  3516.             float    value;

  3517. 

  3518.             for (uint32_t k=0; k < pData->param.count; ++k)

  3519.             {

  3520.                 if (pData->param.data[k].type != PARAMETER_OUTPUT)

  3521.                     continue;

  3522. 

  3523.                 pData->param.ranges[k].fixValue(fParamBuffers[k]);

  3524. 

  3525.                 if (pData->param.data[k].midiCC > 0)

  3526.                 {

  3527.                     channel = pData->param.data[k].midiChannel;

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

  3529.                     value   = pData->param.ranges[k].getNormalizedValue(fParamBuffers[k]);

  3530.                     pData->event.portOut->writeControlEvent(0, channel, kEngineControlEventTypeParameter, param, value);

  3531.                 }

  3532.             }

  3533.         } // End of Control Output

  3534. #endif

  3535. 

  3536.         // --------------------------------------------------------------------------------------------------------

  3537.         // Final work

  3538. 

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

  3540.         {

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

  3542. 

  3543.             if (fHandle2 != nullptr)

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

  3545.         }

  3546. 

  3547.         fFirstActive = false;

  3548. 

  3549.         // --------------------------------------------------------------------------------------------------------

  3550.     }

  3551. 

  3552.     bool processSingle(const float** const audioIn, float** const audioOut, const float** const cvIn, float** const cvOut, const uint32_t frames, const uint32_t timeOffset)

  3553.     {

  3554.         CARLA_SAFE_ASSERT_RETURN(frames > 0, false);

  3555. 

  3556.         if (pData->audioIn.count > 0)

  3557.         {

  3558.             CARLA_SAFE_ASSERT_RETURN(audioIn != nullptr, false);

  3559.         }

  3560.         if (pData->audioOut.count > 0)

  3561.         {

  3562.             CARLA_SAFE_ASSERT_RETURN(audioOut != nullptr, false);

  3563.         }

  3564.         if (pData->cvIn.count > 0)

  3565.         {

  3566.             CARLA_SAFE_ASSERT_RETURN(cvIn != nullptr, false);

  3567.         }

  3568.         if (pData->cvOut.count > 0)

  3569.         {

  3570.             CARLA_SAFE_ASSERT_RETURN(cvOut != nullptr, false);

  3571.         }

  3572. 

  3573.         // --------------------------------------------------------------------------------------------------------

  3574.         // Try lock, silence otherwise

  3575. 

  3576.         if (pData->engine->isOffline())

  3577.         {

  3578.             pData->singleMutex.lock();

  3579.         }

  3580.         else if (! pData->singleMutex.tryLock())

  3581.         {

  3582.             for (uint32_t i=0; i < pData->audioOut.count; ++i)

  3583.             {

  3584.                 for (uint32_t k=0; k < frames; ++k)

  3585.                     audioOut[i][k+timeOffset] = 0.0f;

  3586.             }

  3587.             for (uint32_t i=0; i < pData->cvOut.count; ++i)

  3588.             {

  3589.                 for (uint32_t k=0; k < frames; ++k)

  3590.                     cvOut[i][k+timeOffset] = 0.0f;

  3591.             }

  3592. 

  3593.             return false;

  3594.         }

  3595. 

  3596.         // --------------------------------------------------------------------------------------------------------

  3597.         // Set audio buffers

  3598. 

  3599.         for (uint32_t i=0; i < pData->audioIn.count; ++i)

  3600.             FloatVectorOperations::copy(fAudioInBuffers[i], audioIn[i]+timeOffset, static_cast<int>(frames));

  3601. 

  3602.         for (uint32_t i=0; i < pData->audioOut.count; ++i)

  3603.             FloatVectorOperations::clear(fAudioOutBuffers[i], static_cast<int>(frames));

  3604. 

  3605.         // --------------------------------------------------------------------------------------------------------

  3606.         // Set CV buffers

  3607. 

  3608.         for (uint32_t i=0; i < pData->cvIn.count; ++i)

  3609.             FloatVectorOperations::copy(fCvInBuffers[i], cvIn[i]+timeOffset, static_cast<int>(frames));

  3610. 

  3611.         for (uint32_t i=0; i < pData->cvOut.count; ++i)

  3612.             FloatVectorOperations::clear(fCvOutBuffers[i], static_cast<int>(frames));

  3613. 

  3614.         // --------------------------------------------------------------------------------------------------------

  3615.         // Run plugin

  3616. 

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

  3618. 

  3619.         if (fHandle2 != nullptr)

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

  3621. 

  3622.         // --------------------------------------------------------------------------------------------------------

  3623.         // Handle trigger parameters

  3624. 

  3625.         for (uint32_t k=0; k < pData->param.count; ++k)

  3626.         {

  3627.             if (pData->param.data[k].type != PARAMETER_INPUT)

  3628.                 continue;

  3629. 

  3630.             if (pData->param.data[k].hints & PARAMETER_IS_TRIGGER)

  3631.             {

  3632.                 if (carla_isNotEqual(fParamBuffers[k], pData->param.ranges[k].def))

  3633.                 {

  3634.                     fParamBuffers[k] = pData->param.ranges[k].def;

  3635.                     pData->postponeRtEvent(kPluginPostRtEventParameterChange, static_cast<int32_t>(k), 0, fParamBuffers[k]);

  3636.                 }

  3637.             }

  3638.         }

  3639. 

  3640.         pData->postRtEvents.trySplice();

  3641. 

  3642. #ifndef BUILD_BRIDGE

  3643.         // --------------------------------------------------------------------------------------------------------

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

  3645. 

  3646.         {

  3647.             const bool doDryWet  = (pData->hints & PLUGIN_CAN_DRYWET) != 0 && carla_isNotEqual(pData->postProc.dryWet, 1.0f);

  3648.             const bool doBalance = (pData->hints & PLUGIN_CAN_BALANCE) != 0 && ! (carla_isEqual(pData->postProc.balanceLeft, -1.0f) && carla_isEqual(pData->postProc.balanceRight, 1.0f));

  3649.             const bool isMono    = (pData->audioIn.count == 1);

  3650. 

  3651.             bool isPair;

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

  3653. 

  3654.             for (uint32_t i=0; i < pData->audioOut.count; ++i)

  3655.             {

  3656.                 // Dry/Wet

  3657.                 if (doDryWet)

  3658.                 {

  3659.                     for (uint32_t k=0; k < frames; ++k)

  3660.                     {

  3661. #if 0 // TODO

  3662.                         if (k < pData->latency)

  3663.                             bufValue = pData->latencyBuffers[isMono ? 0 : i][k];

  3664.                         else if (pData->latency < frames)

  3665.                             bufValue = fAudioInBuffers[isMono ? 0 : i][k-pData->latency];

  3666.                         else

  3667. #endif

  3668.                             bufValue = fAudioInBuffers[isMono ? 0 : i][k];

  3669. 

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

  3671.                     }

  3672.                 }

  3673. 

  3674.                 // Balance

  3675.                 if (doBalance)

  3676.                 {

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

  3678. 

  3679.                     if (isPair)

  3680.                     {

  3681.                         CARLA_ASSERT(i+1 < pData->audioOut.count);

  3682.                         FloatVectorOperations::copy(oldBufLeft, fAudioOutBuffers[i], static_cast<int>(frames));

  3683.                     }

  3684. 

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

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

  3687. 

  3688.                     for (uint32_t k=0; k < frames; ++k)

  3689.                     {

  3690.                         if (isPair)

  3691.                         {

  3692.                             // left

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

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

  3695.                         }

  3696.                         else

  3697.                         {

  3698.                             // right

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

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

  3701.                         }

  3702.                     }

  3703.                 }

  3704. 

  3705.                 // Volume (and buffer copy)

  3706.                 {

  3707.                     for (uint32_t k=0; k < frames; ++k)

  3708.                         audioOut[i][k+timeOffset] = fAudioOutBuffers[i][k] * pData->postProc.volume;

  3709.                 }

  3710.             }

  3711.         } // End of Post-processing

  3712. 

  3713. #else // BUILD_BRIDGE

  3714.         for (uint32_t i=0; i < pData->audioOut.count; ++i)

  3715.         {

  3716.             for (uint32_t k=0; k < frames; ++k)

  3717.                 audioOut[i][k+timeOffset] = fAudioOutBuffers[i][k];

  3718.         }

  3719. #endif

  3720. 

  3721.         for (uint32_t i=0; i < pData->cvOut.count; ++i)

  3722.         {

  3723.             for (uint32_t k=0; k < frames; ++k)

  3724.                 cvOut[i][k+timeOffset] = fCvOutBuffers[i][k];

  3725.         }

  3726. 

  3727.         // --------------------------------------------------------------------------------------------------------

  3728. 

  3729.         pData->singleMutex.unlock();

  3730.         return true;

  3731.     }

  3732. 

  3733.     void bufferSizeChanged(const uint32_t newBufferSize) override

  3734.     {

  3735.         CARLA_ASSERT_INT(newBufferSize > 0, newBufferSize);

  3736.         carla_debug("CarlaPluginLV2::bufferSizeChanged(%i) - start", newBufferSize);

  3737. 

  3738.         for (uint32_t i=0; i < pData->audioIn.count; ++i)

  3739.         {

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

  3741.                 delete[] fAudioInBuffers[i];

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

  3743.         }

  3744. 

  3745.         for (uint32_t i=0; i < pData->audioOut.count; ++i)

  3746.         {

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

  3748.                 delete[] fAudioOutBuffers[i];

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

  3750.         }

  3751. 

  3752.         if (fHandle2 == nullptr)

  3753.         {

  3754.             for (uint32_t i=0; i < pData->audioIn.count; ++i)

  3755.             {

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

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

  3758.             }

  3759. 

  3760.             for (uint32_t i=0; i < pData->audioOut.count; ++i)

  3761.             {

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

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

  3764.             }

  3765.         }

  3766.         else

  3767.         {

  3768.             if (pData->audioIn.count > 0)

  3769.             {

  3770.                 CARLA_ASSERT(pData->audioIn.count == 2);

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

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

  3773. 

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

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

  3776.             }

  3777. 

  3778.             if (pData->audioOut.count > 0)

  3779.             {

  3780.                 CARLA_ASSERT(pData->audioOut.count == 2);

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

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

  3783. 

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

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

  3786.             }

  3787.         }

  3788. 

  3789.         for (uint32_t i=0; i < pData->cvIn.count; ++i)

  3790.         {

  3791.             if (fCvInBuffers[i] != nullptr)

  3792.                 delete[] fCvInBuffers[i];

  3793.             fCvInBuffers[i] = new float[newBufferSize];

  3794. 

  3795.             fDescriptor->connect_port(fHandle, pData->cvIn.ports[i].rindex, fCvInBuffers[i]);

  3796. 

  3797.             if (fHandle2 != nullptr)

  3798.                 fDescriptor->connect_port(fHandle2, pData->cvIn.ports[i].rindex, fCvInBuffers[i]);

  3799.         }

  3800. 

  3801.         for (uint32_t i=0; i < pData->cvOut.count; ++i)

  3802.         {

  3803.             if (fCvOutBuffers[i] != nullptr)

  3804.                 delete[] fCvOutBuffers[i];

  3805.             fCvOutBuffers[i] = new float[newBufferSize];

  3806. 

  3807.             fDescriptor->connect_port(fHandle, pData->cvOut.ports[i].rindex, fCvOutBuffers[i]);

  3808. 

  3809.             if (fHandle2 != nullptr)

  3810.                 fDescriptor->connect_port(fHandle2, pData->cvOut.ports[i].rindex, fCvOutBuffers[i]);

  3811.         }

  3812. 

  3813.         const int newBufferSizeInt(static_cast<int>(newBufferSize));

  3814. 

  3815.         if (fLv2Options.maxBufferSize != newBufferSizeInt || (fLv2Options.minBufferSize != 1 && fLv2Options.minBufferSize != newBufferSizeInt))

  3816.         {

  3817.             fLv2Options.maxBufferSize = fLv2Options.nominalBufferSize = newBufferSizeInt;

  3818. 

  3819.             if (fLv2Options.minBufferSize != 1)

  3820.                 fLv2Options.minBufferSize = newBufferSizeInt;

  3821. 

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

  3823.             {

  3824.                 fExt.options->set(fHandle, &fLv2Options.opts[CarlaPluginLV2Options::MaxBlockLenth]);

  3825.                 fExt.options->set(fHandle, &fLv2Options.opts[CarlaPluginLV2Options::NominalBlockLenth]);

  3826. 

  3827.                 if (fLv2Options.minBufferSize != 1)

  3828.                     fExt.options->set(fHandle, &fLv2Options.opts[CarlaPluginLV2Options::MinBlockLenth]);

  3829.             }

  3830.         }

  3831. 

  3832.         carla_debug("CarlaPluginLV2::bufferSizeChanged(%i) - end", newBufferSize);

  3833.     }

  3834. 

  3835.     void sampleRateChanged(const double newSampleRate) override

  3836.     {

  3837.         CARLA_ASSERT_INT(newSampleRate > 0.0, newSampleRate);

  3838.         carla_debug("CarlaPluginLV2::sampleRateChanged(%g) - start", newSampleRate);

  3839. 

  3840.         if (carla_isNotEqual(fLv2Options.sampleRate, newSampleRate))

  3841.         {

  3842.             fLv2Options.sampleRate = newSampleRate;

  3843. 

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

  3845.                 fExt.options->set(fHandle, &fLv2Options.opts[CarlaPluginLV2Options::SampleRate]);

  3846.         }

  3847. 

  3848.         for (uint32_t k=0; k < pData->param.count; ++k)

  3849.         {

  3850.             if (pData->param.data[k].type == PARAMETER_INPUT && pData->param.special[k] == PARAMETER_SPECIAL_SAMPLE_RATE)

  3851.             {

  3852.                 fParamBuffers[k] = static_cast<float>(newSampleRate);

  3853.                 pData->postponeRtEvent(kPluginPostRtEventParameterChange, static_cast<int32_t>(k), 1, fParamBuffers[k]);

  3854.                 break;

  3855.             }

  3856.         }

  3857. 

  3858.         carla_debug("CarlaPluginLV2::sampleRateChanged(%g) - end", newSampleRate);

  3859.     }

  3860. 

  3861.     void offlineModeChanged(const bool isOffline) override

  3862.     {

  3863.         for (uint32_t k=0; k < pData->param.count; ++k)

  3864.         {

  3865.             if (pData->param.data[k].type == PARAMETER_INPUT && pData->param.special[k] == PARAMETER_SPECIAL_FREEWHEEL)

  3866.             {

  3867.                 fParamBuffers[k] = isOffline ? pData->param.ranges[k].max : pData->param.ranges[k].min;

  3868.                 pData->postponeRtEvent(kPluginPostRtEventParameterChange, static_cast<int32_t>(k), 1, fParamBuffers[k]);

  3869.                 break;

  3870.             }

  3871.         }

  3872.     }

  3873. 

  3874.     // -------------------------------------------------------------------

  3875.     // Plugin buffers

  3876. 

  3877.     void initBuffers() const noexcept override

  3878.     {

  3879.         fEventsIn.initBuffers();

  3880.         fEventsOut.initBuffers();

  3881. 

  3882.         CarlaPlugin::initBuffers();

  3883.     }

  3884. 

  3885.     void clearBuffers() noexcept override

  3886.     {

  3887.         carla_debug("CarlaPluginLV2::clearBuffers() - start");

  3888. 

  3889.         if (fAudioInBuffers != nullptr)

  3890.         {

  3891.             for (uint32_t i=0; i < pData->audioIn.count; ++i)

  3892.             {

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

  3894.                 {

  3895.                     delete[] fAudioInBuffers[i];

  3896.                     fAudioInBuffers[i] = nullptr;

  3897.                 }

  3898.             }

  3899. 

  3900.             delete[] fAudioInBuffers;

  3901.             fAudioInBuffers = nullptr;

  3902.         }

  3903. 

  3904.         if (fAudioOutBuffers != nullptr)

  3905.         {

  3906.             for (uint32_t i=0; i < pData->audioOut.count; ++i)

  3907.             {

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

  3909.                 {

  3910.                     delete[] fAudioOutBuffers[i];

  3911.                     fAudioOutBuffers[i] = nullptr;

  3912.                 }

  3913.             }

  3914. 

  3915.             delete[] fAudioOutBuffers;

  3916.             fAudioOutBuffers = nullptr;

  3917.         }

  3918. 

  3919.         if (fCvInBuffers != nullptr)

  3920.         {

  3921.             for (uint32_t i=0; i < pData->cvIn.count; ++i)

  3922.             {

  3923.                 if (fCvInBuffers[i] != nullptr)

  3924.                 {

  3925.                     delete[] fCvInBuffers[i];

  3926.                     fCvInBuffers[i] = nullptr;

  3927.                 }

  3928.             }

  3929. 

  3930.             delete[] fCvInBuffers;

  3931.             fCvInBuffers = nullptr;

  3932.         }

  3933. 

  3934.         if (fCvOutBuffers != nullptr)

  3935.         {

  3936.             for (uint32_t i=0; i < pData->cvOut.count; ++i)

  3937.             {

  3938.                 if (fCvOutBuffers[i] != nullptr)

  3939.                 {

  3940.                     delete[] fCvOutBuffers[i];

  3941.                     fCvOutBuffers[i] = nullptr;

  3942.                 }

  3943.             }

  3944. 

  3945.             delete[] fCvOutBuffers;

  3946.             fCvOutBuffers = nullptr;

  3947.         }

  3948. 

  3949.         if (fParamBuffers != nullptr)

  3950.         {

  3951.             delete[] fParamBuffers;

  3952.             fParamBuffers = nullptr;

  3953.         }

  3954. 

  3955.         fEventsIn.clear();

  3956.         fEventsOut.clear();

  3957. 

  3958.         CarlaPlugin::clearBuffers();

  3959. 

  3960.         carla_debug("CarlaPluginLV2::clearBuffers() - end");

  3961.     }

  3962. 

  3963.     // -------------------------------------------------------------------

  3964.     // Post-poned UI Stuff

  3965. 

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

  3967.     {

  3968.         CARLA_SAFE_ASSERT_RETURN(fUI.type != UI::TYPE_NULL,);

  3969.         CARLA_SAFE_ASSERT_RETURN(index < pData->param.count,);

  3970. 

  3971.         if (fUI.type == UI::TYPE_BRIDGE)

  3972.         {

  3973.             if (fPipeServer.isPipeRunning())

  3974.                 fPipeServer.writeControlMessage(static_cast<uint32_t>(pData->param.data[index].rindex), value);

  3975.         }

  3976.         else

  3977.         {

  3978.             if (fUI.handle != nullptr && fUI.descriptor != nullptr && fUI.descriptor->port_event != nullptr && ! fNeedsUiClose)

  3979.             {

  3980.                 CARLA_SAFE_ASSERT_RETURN(pData->param.data[index].rindex >= 0,);

  3981.                 fUI.descriptor->port_event(fUI.handle, static_cast<uint32_t>(pData->param.data[index].rindex), sizeof(float), CARLA_URI_MAP_ID_NULL, &value);

  3982.             }

  3983.         }

  3984.     }

  3985. 

  3986.     void uiMidiProgramChange(const uint32_t index) noexcept override

  3987.     {

  3988.         CARLA_SAFE_ASSERT_RETURN(fUI.type != UI::TYPE_NULL,);

  3989.         CARLA_SAFE_ASSERT_RETURN(index < pData->midiprog.count,);

  3990. 

  3991.         if (fUI.type == UI::TYPE_BRIDGE)

  3992.         {

  3993.             if (fPipeServer.isPipeRunning())

  3994.                 fPipeServer.writeMidiProgramMessage(pData->midiprog.data[index].bank, pData->midiprog.data[index].program);

  3995.         }

  3996.         else

  3997.         {

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

  3999.                 fExt.uiprograms->select_program(fUI.handle, pData->midiprog.data[index].bank, pData->midiprog.data[index].program);

  4000.         }

  4001.     }

  4002. 

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

  4004.     {

  4005.         CARLA_SAFE_ASSERT_RETURN(fUI.type != UI::TYPE_NULL,);

  4006.         CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  4007.         CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

  4008.         CARLA_SAFE_ASSERT_RETURN(velo > 0 && velo < MAX_MIDI_VALUE,);

  4009. 

  4010.         if (fUI.type == UI::TYPE_BRIDGE)

  4011.         {

  4012.             if (fPipeServer.isPipeRunning())

  4013.                 fPipeServer.writeMidiNoteMessage(false, channel, note, velo);

  4014.         }

  4015.         else

  4016.         {

  4017.             if (fUI.handle != nullptr && fUI.descriptor != nullptr && fUI.descriptor->port_event != nullptr && fEventsIn.ctrl != nullptr && ! fNeedsUiClose)

  4018.             {

  4019.                 LV2_Atom_MidiEvent midiEv;

  4020.                 midiEv.atom.type = CARLA_URI_MAP_ID_MIDI_EVENT;

  4021.                 midiEv.atom.size = 3;

  4022.                 midiEv.data[0] = uint8_t(MIDI_STATUS_NOTE_ON | (channel & MIDI_CHANNEL_BIT));

  4023.                 midiEv.data[1] = note;

  4024.                 midiEv.data[2] = velo;

  4025. 

  4026.                 fUI.descriptor->port_event(fUI.handle, fEventsIn.ctrl->rindex, lv2_atom_total_size(midiEv), CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT, &midiEv);

  4027.             }

  4028.         }

  4029.     }

  4030. 

  4031.     void uiNoteOff(const uint8_t channel, const uint8_t note) noexcept override

  4032.     {

  4033.         CARLA_SAFE_ASSERT_RETURN(fUI.type != UI::TYPE_NULL,);

  4034.         CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  4035.         CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

  4036. 

  4037.         if (fUI.type == UI::TYPE_BRIDGE)

  4038.         {

  4039.             if (fPipeServer.isPipeRunning())

  4040.                 fPipeServer.writeMidiNoteMessage(false, channel, note, 0);

  4041.         }

  4042.         else

  4043.         {

  4044.             if (fUI.handle != nullptr && fUI.descriptor != nullptr && fUI.descriptor->port_event != nullptr && fEventsIn.ctrl != nullptr && ! fNeedsUiClose)

  4045.             {

  4046.                 LV2_Atom_MidiEvent midiEv;

  4047.                 midiEv.atom.type = CARLA_URI_MAP_ID_MIDI_EVENT;

  4048.                 midiEv.atom.size = 3;

  4049.                 midiEv.data[0] = uint8_t(MIDI_STATUS_NOTE_OFF | (channel & MIDI_CHANNEL_BIT));

  4050.                 midiEv.data[1] = note;

  4051.                 midiEv.data[2] = 0;

  4052. 

  4053.                 fUI.descriptor->port_event(fUI.handle, fEventsIn.ctrl->rindex, lv2_atom_total_size(midiEv), CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT, &midiEv);

  4054.             }

  4055.         }

  4056.     }

  4057. 

  4058.     // -------------------------------------------------------------------

  4059. 

  4060.     bool isRealtimeSafe() const noexcept

  4061.     {

  4062.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr, false);

  4063. 

  4064.         for (uint32_t i=0; i < fRdfDescriptor->FeatureCount; ++i)

  4065.         {

  4066.             if (std::strcmp(fRdfDescriptor->Features[i].URI, LV2_CORE__hardRTCapable) == 0)

  4067.                 return true;

  4068.         }

  4069. 

  4070.         return false;

  4071.     }

  4072. 

  4073.     bool needsFixedBuffer() const noexcept

  4074.     {

  4075.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr, false);

  4076. 

  4077.         for (uint32_t i=0; i < fRdfDescriptor->FeatureCount; ++i)

  4078.         {

  4079.             if (std::strcmp(fRdfDescriptor->Features[i].URI, LV2_BUF_SIZE__fixedBlockLength) == 0)

  4080.                 return true;

  4081.         }

  4082. 

  4083.         return false;

  4084.     }

  4085. 

  4086.     // -------------------------------------------------------------------

  4087. 

  4088.     bool isUiBridgeable(const uint32_t uiId) const noexcept

  4089.     {

  4090.         CARLA_SAFE_ASSERT_RETURN(uiId < fRdfDescriptor->UICount, false);

  4091. 

  4092. #ifndef LV2_UIS_ONLY_INPROCESS

  4093.         const LV2_RDF_UI* const rdfUI(&fRdfDescriptor->UIs[uiId]);

  4094. 

  4095.         for (uint32_t i=0; i < rdfUI->FeatureCount; ++i)

  4096.         {

  4097.             const LV2_RDF_Feature& feat(rdfUI->Features[i]);

  4098. 

  4099.             if (! feat.Required)

  4100.                 continue;

  4101.             if (std::strcmp(feat.URI, LV2_INSTANCE_ACCESS_URI) == 0)

  4102.                 return false;

  4103.             if (std::strcmp(feat.URI, LV2_DATA_ACCESS_URI) == 0)

  4104.                 return false;

  4105.         }

  4106. 

  4107.         // Calf UIs are mostly useless without their special graphs

  4108.         // but they can be crashy under certain conditions, so follow user preferences

  4109.         if (std::strstr(rdfUI->URI, "http://calf.sourceforge.net/plugins/gui/") != nullptr)

  4110.             return pData->engine->getOptions().preferUiBridges;

  4111. 

  4112.         return true;

  4113. #else

  4114.         return false;

  4115. #endif

  4116.     }

  4117. 

  4118.     bool isUiResizable() const noexcept

  4119.     {

  4120.         CARLA_SAFE_ASSERT_RETURN(fUI.rdfDescriptor != nullptr, false);

  4121. 

  4122.         for (uint32_t i=0; i < fUI.rdfDescriptor->FeatureCount; ++i)

  4123.         {

  4124.             if (std::strcmp(fUI.rdfDescriptor->Features[i].URI, LV2_UI__fixedSize) == 0)

  4125.                 return false;

  4126.             if (std::strcmp(fUI.rdfDescriptor->Features[i].URI, LV2_UI__noUserResize) == 0)

  4127.                 return false;

  4128.         }

  4129. 

  4130.         return true;

  4131.     }

  4132. 

  4133.     const char* getUiBridgeBinary(const LV2_Property type) const

  4134.     {

  4135.         CarlaString bridgeBinary(pData->engine->getOptions().binaryDir);

  4136. 

  4137.         if (bridgeBinary.isEmpty())

  4138.             return nullptr;

  4139. 

  4140.         switch (type)

  4141.         {

  4142.         case LV2_UI_GTK2:

  4143.             bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-lv2-gtk2";

  4144.             break;

  4145.         case LV2_UI_GTK3:

  4146.             bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-lv2-gtk3";

  4147.             break;

  4148.         case LV2_UI_QT4:

  4149.             bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-lv2-qt4";

  4150.             break;

  4151.         case LV2_UI_QT5:

  4152.             bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-lv2-qt5";

  4153.             break;

  4154.         case LV2_UI_COCOA:

  4155.             bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-lv2-cocoa";

  4156.             break;

  4157.         case LV2_UI_WINDOWS:

  4158.             bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-lv2-windows";

  4159.             break;

  4160.         case LV2_UI_X11:

  4161.             bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-lv2-x11";

  4162.             break;

  4163.         case LV2_UI_EXTERNAL:

  4164.         case LV2_UI_OLD_EXTERNAL:

  4165.             bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-lv2-external";

  4166.             break;

  4167.         case LV2_UI_MOD:

  4168.             bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-lv2-modgui";

  4169.             break;

  4170.         default:

  4171.             return nullptr;

  4172.         }

  4173. 

  4174. #ifdef CARLA_OS_WIN

  4175.         bridgeBinary += ".exe";

  4176. #endif

  4177. 

  4178.         if (! File(bridgeBinary.buffer()).existsAsFile())

  4179.             return nullptr;

  4180. 

  4181.         return bridgeBinary.dup();

  4182.     }

  4183. 

  4184.     // -------------------------------------------------------------------

  4185. 

  4186.     void recheckExtensions()

  4187.     {

  4188.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr,);

  4189.         carla_debug("CarlaPluginLV2::recheckExtensions()");

  4190. 

  4191.         fExt.options  = nullptr;

  4192.         fExt.programs = nullptr;

  4193.         fExt.state    = nullptr;

  4194.         fExt.worker   = nullptr;

  4195. 

  4196.         for (uint32_t i=0; i < fRdfDescriptor->ExtensionCount; ++i)

  4197.         {

  4198.             CARLA_SAFE_ASSERT_CONTINUE(fRdfDescriptor->Extensions[i] != nullptr);

  4199. 

  4200.             if (std::strcmp(fRdfDescriptor->Extensions[i], LV2_OPTIONS__interface) == 0)

  4201.                 pData->hints |= PLUGIN_HAS_EXTENSION_OPTIONS;

  4202.             else if (std::strcmp(fRdfDescriptor->Extensions[i], LV2_PROGRAMS__Interface) == 0)

  4203.                 pData->hints |= PLUGIN_HAS_EXTENSION_PROGRAMS;

  4204.             else if (std::strcmp(fRdfDescriptor->Extensions[i], LV2_STATE__interface) == 0)

  4205.                 pData->hints |= PLUGIN_HAS_EXTENSION_STATE;

  4206.             else if (std::strcmp(fRdfDescriptor->Extensions[i], LV2_WORKER__interface) == 0)

  4207.                 pData->hints |= PLUGIN_HAS_EXTENSION_WORKER;

  4208.             else

  4209.                 carla_stdout("Plugin has non-supported extension: '%s'", fRdfDescriptor->Extensions[i]);

  4210.         }

  4211. 

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

  4213.         {

  4214.             if (pData->hints & PLUGIN_HAS_EXTENSION_OPTIONS)

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

  4216. 

  4217.             if (pData->hints & PLUGIN_HAS_EXTENSION_PROGRAMS)

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

  4219. 

  4220.             if (pData->hints & PLUGIN_HAS_EXTENSION_STATE)

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

  4222. 

  4223.             if (pData->hints & PLUGIN_HAS_EXTENSION_WORKER)

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

  4225. 

  4226.             // check if invalid

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

  4228.                 fExt.options = nullptr;

  4229. 

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

  4231.                 fExt.programs = nullptr;

  4232. 

  4233.             if (fExt.state != nullptr && (fExt.state->save == nullptr || fExt.state->restore == nullptr))

  4234.                 fExt.state = nullptr;

  4235. 

  4236.             if (fExt.worker != nullptr && fExt.worker->work == nullptr)

  4237.                 fExt.worker = nullptr;

  4238.         }

  4239. 

  4240.         CARLA_SAFE_ASSERT_RETURN(fLatencyIndex == -1,);

  4241. 

  4242.         int32_t iCtrl=0;

  4243.         for (uint32_t i=0, count=fRdfDescriptor->PortCount; i<count; ++i)

  4244.         {

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

  4246. 

  4247.             if (! LV2_IS_PORT_CONTROL(portTypes))

  4248.                 continue;

  4249. 

  4250.             const ScopedValueSetter<int32_t> svs(iCtrl, iCtrl, iCtrl+1);

  4251. 

  4252.             if (! LV2_IS_PORT_OUTPUT(portTypes))

  4253.                 continue;

  4254. 

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

  4256. 

  4257.             if (! LV2_IS_PORT_DESIGNATION_LATENCY(portDesignation))

  4258.                 continue;

  4259. 

  4260.             fLatencyIndex = iCtrl;

  4261.             break;

  4262.         }

  4263.     }

  4264. 

  4265.     // -------------------------------------------------------------------

  4266. 

  4267.     void updateUi()

  4268.     {

  4269.         CARLA_SAFE_ASSERT_RETURN(fUI.handle != nullptr,);

  4270.         CARLA_SAFE_ASSERT_RETURN(fUI.descriptor != nullptr,);

  4271.         carla_debug("CarlaPluginLV2::updateUi()");

  4272. 

  4273.         // update midi program

  4274.         if (fExt.uiprograms != nullptr && pData->midiprog.count > 0 && pData->midiprog.current >= 0)

  4275.         {

  4276.             const MidiProgramData& curData(pData->midiprog.getCurrent());

  4277.             fExt.uiprograms->select_program(fUI.handle, curData.bank, curData.program);

  4278.         }

  4279. 

  4280.         // update control ports

  4281.         if (fUI.descriptor->port_event != nullptr)

  4282.         {

  4283.             float value;

  4284.             for (uint32_t i=0; i < pData->param.count; ++i)

  4285.             {

  4286.                 value = getParameterValue(i);

  4287.                 fUI.descriptor->port_event(fUI.handle, static_cast<uint32_t>(pData->param.data[i].rindex), sizeof(float), CARLA_URI_MAP_ID_NULL, &value);

  4288.             }

  4289.         }

  4290.     }

  4291. 

  4292.     // -------------------------------------------------------------------

  4293. 

  4294.     LV2_URID getCustomURID(const char* const uri)

  4295.     {

  4296.         CARLA_SAFE_ASSERT_RETURN(uri != nullptr && uri[0] != '\0', CARLA_URI_MAP_ID_NULL);

  4297.         carla_debug("CarlaPluginLV2::getCustomURID(\"%s\")", uri);

  4298. 

  4299.         const std::size_t uriCount(fCustomURIDs.size());

  4300. 

  4301.         const std::string s_uri(uri);

  4302.         const std::size_t s_pos(std::find(fCustomURIDs.begin(), fCustomURIDs.end(), s_uri) - fCustomURIDs.begin());

  4303. 

  4304.         if (s_pos < uriCount)

  4305.             return static_cast<LV2_URID>(s_pos);

  4306. 

  4307.         fCustomURIDs.push_back(uri);

  4308. 

  4309.         if (fUI.type == UI::TYPE_BRIDGE && fPipeServer.isPipeRunning())

  4310.             fPipeServer.writeLv2UridMessage(uriCount, uri);

  4311. 

  4312.         return uriCount;

  4313.     }

  4314. 

  4315.     const char* getCustomURIDString(const LV2_URID urid) const noexcept

  4316.     {

  4317.         static const char* const sFallback = "urn:null";

  4318.         CARLA_SAFE_ASSERT_RETURN(urid != CARLA_URI_MAP_ID_NULL, sFallback);

  4319.         CARLA_SAFE_ASSERT_RETURN(urid < fCustomURIDs.size(), sFallback);

  4320.         carla_debug("CarlaPluginLV2::getCustomURIString(%i)", urid);

  4321. 

  4322.         return fCustomURIDs[urid].c_str();

  4323.     }

  4324. 

  4325.     // -------------------------------------------------------------------

  4326. 

  4327.     void handleProgramChanged(const int32_t index)

  4328.     {

  4329.         CARLA_SAFE_ASSERT_RETURN(index >= -1,);

  4330.         carla_debug("CarlaPluginLV2::handleProgramChanged(%i)", index);

  4331. 

  4332.         if (index == -1)

  4333.         {

  4334.             const ScopedSingleProcessLocker spl(this, true);

  4335.             return reloadPrograms(false);

  4336.         }

  4337. 

  4338.         if (index < static_cast<int32_t>(pData->midiprog.count) && fExt.programs != nullptr && fExt.programs->get_program != nullptr)

  4339.         {

  4340.             if (const LV2_Program_Descriptor* const progDesc = fExt.programs->get_program(fHandle, static_cast<uint32_t>(index)))

  4341.             {

  4342.                 CARLA_SAFE_ASSERT_RETURN(progDesc->name != nullptr,);

  4343. 

  4344.                 if (pData->midiprog.data[index].name != nullptr)

  4345.                     delete[] pData->midiprog.data[index].name;

  4346. 

  4347.                 pData->midiprog.data[index].name = carla_strdup(progDesc->name);

  4348. 

  4349.                 if (index == pData->midiprog.current)

  4350.                     pData->engine->callback(ENGINE_CALLBACK_UPDATE, pData->id, 0, 0, 0.0, nullptr);

  4351.                 else

  4352.                     pData->engine->callback(ENGINE_CALLBACK_RELOAD_PROGRAMS, pData->id, 0, 0, 0.0, nullptr);

  4353.             }

  4354.         }

  4355.     }

  4356. 

  4357.     // -------------------------------------------------------------------

  4358. 

  4359.     LV2_Resize_Port_Status handleResizePort(const uint32_t index, const size_t size)

  4360.     {

  4361.         CARLA_SAFE_ASSERT_RETURN(size > 0, LV2_RESIZE_PORT_ERR_UNKNOWN);

  4362.         carla_debug("CarlaPluginLV2::handleResizePort(%i, " P_SIZE ")", index, size);

  4363. 

  4364.         // TODO

  4365.         return LV2_RESIZE_PORT_ERR_NO_SPACE;

  4366.         (void)index;

  4367.     }

  4368. 

  4369.     // -------------------------------------------------------------------

  4370. 

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

  4372.     {

  4373.         CARLA_SAFE_ASSERT_RETURN(key != CARLA_URI_MAP_ID_NULL, LV2_STATE_ERR_NO_PROPERTY);

  4374.         CARLA_SAFE_ASSERT_RETURN(value != nullptr, LV2_STATE_ERR_NO_PROPERTY);

  4375.         CARLA_SAFE_ASSERT_RETURN(size > 0, LV2_STATE_ERR_NO_PROPERTY);

  4376.         CARLA_SAFE_ASSERT_RETURN(type != CARLA_URI_MAP_ID_NULL, LV2_STATE_ERR_BAD_TYPE);

  4377.         CARLA_SAFE_ASSERT_RETURN(flags & LV2_STATE_IS_POD, LV2_STATE_ERR_BAD_FLAGS);

  4378.         carla_debug("CarlaPluginLV2::handleStateStore(%i:\"%s\", %p, " P_SIZE ", %i:\"%s\", %i)", key, carla_lv2_urid_unmap(this, key), value, size, type, carla_lv2_urid_unmap(this, type), flags);

  4379. 

  4380.         const char* const skey(carla_lv2_urid_unmap(this, key));

  4381.         const char* const stype(carla_lv2_urid_unmap(this, type));

  4382. 

  4383.         CARLA_SAFE_ASSERT_RETURN(skey != nullptr, LV2_STATE_ERR_BAD_TYPE);

  4384.         CARLA_SAFE_ASSERT_RETURN(stype != nullptr, LV2_STATE_ERR_BAD_TYPE);

  4385. 

  4386.         // Check if we already have this key

  4387.         for (LinkedList<CustomData>::Itenerator it = pData->custom.begin2(); it.valid(); it.next())

  4388.         {

  4389.             CustomData& cData(it.getValue(kCustomDataFallbackNC));

  4390.             CARLA_SAFE_ASSERT_CONTINUE(cData.isValid());

  4391. 

  4392.             if (std::strcmp(cData.key, skey) == 0)

  4393.             {

  4394.                 // found it

  4395.                 delete[] cData.value;

  4396. 

  4397.                 if (type == CARLA_URI_MAP_ID_ATOM_STRING || type == CARLA_URI_MAP_ID_ATOM_PATH)

  4398.                     cData.value = carla_strdup((const char*)value);

  4399.                 else

  4400.                     cData.value = CarlaString::asBase64(value, size).dup();

  4401. 

  4402.                 return LV2_STATE_SUCCESS;

  4403.             }

  4404.         }

  4405. 

  4406.         // Otherwise store it

  4407.         CustomData newData;

  4408.         newData.type = carla_strdup(stype);

  4409.         newData.key  = carla_strdup(skey);

  4410. 

  4411.         if (type == CARLA_URI_MAP_ID_ATOM_STRING || type == CARLA_URI_MAP_ID_ATOM_PATH)

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

  4413.         else

  4414.             newData.value = CarlaString::asBase64(value, size).dup();

  4415. 

  4416.         pData->custom.append(newData);

  4417. 

  4418.         return LV2_STATE_SUCCESS;

  4419.     }

  4420. 

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

  4422.     {

  4423.         CARLA_SAFE_ASSERT_RETURN(key != CARLA_URI_MAP_ID_NULL, nullptr);

  4424.         CARLA_SAFE_ASSERT_RETURN(size != nullptr, nullptr);

  4425.         CARLA_SAFE_ASSERT_RETURN(type != nullptr, nullptr);

  4426.         CARLA_SAFE_ASSERT_RETURN(flags != nullptr, nullptr);

  4427.         carla_debug("CarlaPluginLV2::handleStateRetrieve(%i, %p, %p, %p)", key, size, type, flags);

  4428. 

  4429.         const char* const skey(carla_lv2_urid_unmap(this, key));

  4430. 

  4431.         CARLA_SAFE_ASSERT_RETURN(skey != nullptr, nullptr);

  4432. 

  4433.         const char* stype = nullptr;

  4434.         const char* stringData = nullptr;

  4435. 

  4436.         for (LinkedList<CustomData>::Itenerator it = pData->custom.begin2(); it.valid(); it.next())

  4437.         {

  4438.             const CustomData& cData(it.getValue(kCustomDataFallback));

  4439.             CARLA_SAFE_ASSERT_CONTINUE(cData.isValid());

  4440. 

  4441.             if (std::strcmp(cData.key, skey) == 0)

  4442.             {

  4443.                 stype      = cData.type;

  4444.                 stringData = cData.value;

  4445.                 break;

  4446.             }

  4447.         }

  4448. 

  4449.         CARLA_SAFE_ASSERT_RETURN(stype != nullptr, nullptr);

  4450.         CARLA_SAFE_ASSERT_RETURN(stringData != nullptr, nullptr);

  4451. 

  4452.         *type  = carla_lv2_urid_map(this, stype);

  4453.         *flags = LV2_STATE_IS_POD;

  4454. 

  4455.         if (*type == CARLA_URI_MAP_ID_ATOM_STRING || *type == CARLA_URI_MAP_ID_ATOM_PATH)

  4456.         {

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

  4458.             return stringData;

  4459.         }

  4460.         else

  4461.         {

  4462.             if (fLastStateChunk != nullptr)

  4463.             {

  4464.                 std::free(fLastStateChunk);

  4465.                 fLastStateChunk = nullptr;

  4466.             }

  4467. 

  4468.             std::vector<uint8_t> chunk(carla_getChunkFromBase64String(stringData));

  4469.             CARLA_SAFE_ASSERT_RETURN(chunk.size() > 0, nullptr);

  4470. 

  4471.             fLastStateChunk = std::malloc(chunk.size());

  4472.             CARLA_SAFE_ASSERT_RETURN(fLastStateChunk != nullptr, nullptr);

  4473. 

  4474.             std::memcpy(fLastStateChunk, chunk.data(), chunk.size());

  4475. 

  4476.             *size = chunk.size();

  4477.             return fLastStateChunk;

  4478.         }

  4479.     }

  4480. 

  4481.     // -------------------------------------------------------------------

  4482. 

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

  4484.     {

  4485.         CARLA_SAFE_ASSERT_RETURN(fExt.worker != nullptr && fExt.worker->work != nullptr, LV2_WORKER_ERR_UNKNOWN);

  4486.         CARLA_SAFE_ASSERT_RETURN(fEventsIn.ctrl != nullptr, LV2_WORKER_ERR_UNKNOWN);

  4487.         carla_debug("CarlaPluginLV2::handleWorkerSchedule(%i, %p)", size, data);

  4488. 

  4489.         if (pData->engine->isOffline())

  4490.         {

  4491.             fExt.worker->work(fHandle, carla_lv2_worker_respond, this, size, data);

  4492.             return LV2_WORKER_SUCCESS;

  4493.         }

  4494. 

  4495.         LV2_Atom atom;

  4496.         atom.size = size;

  4497.         atom.type = CARLA_URI_MAP_ID_CARLA_ATOM_WORKER;

  4498. 

  4499.         return fAtomBufferOut.putChunk(&atom, data, fEventsOut.ctrlIndex) ? LV2_WORKER_SUCCESS : LV2_WORKER_ERR_NO_SPACE;

  4500.     }

  4501. 

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

  4503.     {

  4504.         carla_debug("CarlaPluginLV2::handleWorkerRespond(%i, %p)", size, data);

  4505. 

  4506.         LV2_Atom atom;

  4507.         atom.size = size;

  4508.         atom.type = CARLA_URI_MAP_ID_CARLA_ATOM_WORKER;

  4509. 

  4510.         return fAtomBufferIn.putChunk(&atom, data, fEventsIn.ctrlIndex) ? LV2_WORKER_SUCCESS : LV2_WORKER_ERR_NO_SPACE;

  4511.     }

  4512. 

  4513.     // -------------------------------------------------------------------

  4514. 

  4515.     void handleExternalUIClosed()

  4516.     {

  4517.         CARLA_SAFE_ASSERT_RETURN(fUI.type == UI::TYPE_EXTERNAL,);

  4518.         carla_debug("CarlaPluginLV2::handleExternalUIClosed()");

  4519. 

  4520.         fNeedsUiClose = true;

  4521.     }

  4522. 

  4523.     void handlePluginUIClosed() override

  4524.     {

  4525.         CARLA_SAFE_ASSERT_RETURN(fUI.type == UI::TYPE_EMBED,);

  4526.         CARLA_SAFE_ASSERT_RETURN(fUI.window != nullptr,);

  4527.         carla_debug("CarlaPluginLV2::handlePluginUIClosed()");

  4528. 

  4529.         fNeedsUiClose = true;

  4530.     }

  4531. 

  4532.     void handlePluginUIResized(const uint width, const uint height) override

  4533.     {

  4534.         CARLA_SAFE_ASSERT_RETURN(fUI.type == UI::TYPE_EMBED,);

  4535.         CARLA_SAFE_ASSERT_RETURN(fUI.window != nullptr,);

  4536.         carla_debug("CarlaPluginLV2::handlePluginUIResized(%u, %u)", width, height);

  4537. 

  4538.         if (fUI.handle != nullptr && fExt.uiresize != nullptr)

  4539.             fExt.uiresize->ui_resize(fUI.handle, static_cast<int>(width), static_cast<int>(height));

  4540.     }

  4541. 

  4542.     // -------------------------------------------------------------------

  4543. 

  4544.     uint32_t handleUIPortMap(const char* const symbol) const noexcept

  4545.     {

  4546.         CARLA_SAFE_ASSERT_RETURN(symbol != nullptr && symbol[0] != '\0', LV2UI_INVALID_PORT_INDEX);

  4547.         carla_debug("CarlaPluginLV2::handleUIPortMap(\"%s\")", symbol);

  4548. 

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

  4550.         {

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

  4552.                 return i;

  4553.         }

  4554. 

  4555.         return LV2UI_INVALID_PORT_INDEX;

  4556.     }

  4557. 

  4558.     int handleUIResize(const int width, const int height)

  4559.     {

  4560.         CARLA_SAFE_ASSERT_RETURN(fUI.window != nullptr, 1);

  4561.         CARLA_SAFE_ASSERT_RETURN(width > 0, 1);

  4562.         CARLA_SAFE_ASSERT_RETURN(height > 0, 1);

  4563.         carla_debug("CarlaPluginLV2::handleUIResize(%i, %i)", width, height);

  4564. 

  4565.         fUI.window->setSize(static_cast<uint>(width), static_cast<uint>(height), true);

  4566. 

  4567.         return 0;

  4568.     }

  4569. 

  4570.     void handleUIWrite(const uint32_t rindex, const uint32_t bufferSize, const uint32_t format, const void* const buffer)

  4571.     {

  4572.         CARLA_SAFE_ASSERT_RETURN(buffer != nullptr,);

  4573.         CARLA_SAFE_ASSERT_RETURN(bufferSize > 0,);

  4574.         carla_debug("CarlaPluginLV2::handleUIWrite(%i, %i, %i, %p)", rindex, bufferSize, format, buffer);

  4575. 

  4576.         uint32_t index = LV2UI_INVALID_PORT_INDEX;

  4577. 

  4578.         switch (format)

  4579.         {

  4580.         case CARLA_URI_MAP_ID_NULL: {

  4581.             CARLA_SAFE_ASSERT_RETURN(bufferSize == sizeof(float),);

  4582. 

  4583.             for (uint32_t i=0; i < pData->param.count; ++i)

  4584.             {

  4585.                 if (pData->param.data[i].rindex != static_cast<int32_t>(rindex))

  4586.                     continue;

  4587.                 index = i;

  4588.                 break;

  4589.             }

  4590. 

  4591.             CARLA_SAFE_ASSERT_RETURN(index != LV2UI_INVALID_PORT_INDEX,);

  4592. 

  4593.             const float value(*(const float*)buffer);

  4594. 

  4595.             //if (carla_isNotEqual(fParamBuffers[index], value))

  4596.             setParameterValue(index, value, false, true, true);

  4597. 

  4598.         } break;

  4599. 

  4600.         case CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM:

  4601.         case CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT: {

  4602.             CARLA_SAFE_ASSERT_RETURN(bufferSize >= sizeof(LV2_Atom),);

  4603. 

  4604.             const LV2_Atom* const atom((const LV2_Atom*)buffer);

  4605. 

  4606.             // plugins sometimes fail on this, not good...

  4607.             CARLA_SAFE_ASSERT_INT2(bufferSize == lv2_atom_total_size(atom), bufferSize, atom->size);

  4608. 

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

  4610.             {

  4611.                 if (fEventsIn.data[i].rindex != rindex)

  4612.                     continue;

  4613.                 index = i;

  4614.                 break;

  4615.             }

  4616. 

  4617.             // for bad plugins

  4618.             if (index == LV2UI_INVALID_PORT_INDEX)

  4619.             {

  4620.                 CARLA_SAFE_ASSERT(index != LV2UI_INVALID_PORT_INDEX); // FIXME

  4621.                 index = fEventsIn.ctrlIndex;

  4622.             }

  4623. 

  4624.             fAtomBufferIn.put(atom, index);

  4625.         } break;

  4626. 

  4627.         default:

  4628.             carla_stdout("CarlaPluginLV2::handleUIWrite(%i, %i, %i:\"%s\", %p) - unknown format", rindex, bufferSize, format, carla_lv2_urid_unmap(this, format), buffer);

  4629.             break;

  4630.         }

  4631.     }

  4632. 

  4633.     // -------------------------------------------------------------------

  4634. 

  4635.     void handleLilvSetPortValue(const char* const portSymbol, const void* const value, const uint32_t size, const uint32_t type)

  4636.     {

  4637.         CARLA_SAFE_ASSERT_RETURN(portSymbol != nullptr && portSymbol[0] != '\0',);

  4638.         CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

  4639.         CARLA_SAFE_ASSERT_RETURN(size > 0,);

  4640.         CARLA_SAFE_ASSERT_RETURN(type != CARLA_URI_MAP_ID_NULL,);

  4641.         carla_debug("CarlaPluginLV2::handleLilvSetPortValue(\"%s\", %p, %i, %i)", portSymbol, value, size, type);

  4642. 

  4643.         int32_t rindex = -1;

  4644. 

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

  4646.         {

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

  4648.             {

  4649.                 rindex = static_cast<int32_t>(i);

  4650.                 break;

  4651.             }

  4652.         }

  4653. 

  4654.         CARLA_SAFE_ASSERT_RETURN(rindex >= 0,);

  4655. 

  4656.         float paramValue;

  4657. 

  4658.         switch (type)

  4659.         {

  4660.         case CARLA_URI_MAP_ID_ATOM_BOOL:

  4661.             CARLA_SAFE_ASSERT_RETURN(size == sizeof(bool),);

  4662.             paramValue = (*(const bool*)value) ? 1.0f : 0.0f;

  4663.             break;

  4664.         case CARLA_URI_MAP_ID_ATOM_DOUBLE:

  4665.             CARLA_SAFE_ASSERT_RETURN(size == sizeof(double),);

  4666.             paramValue = static_cast<float>((*(const double*)value));

  4667.             break;

  4668.         case CARLA_URI_MAP_ID_ATOM_FLOAT:

  4669.             CARLA_SAFE_ASSERT_RETURN(size == sizeof(float),);

  4670.             paramValue = (*(const float*)value);

  4671.             break;

  4672.         case CARLA_URI_MAP_ID_ATOM_INT:

  4673.             CARLA_SAFE_ASSERT_RETURN(size == sizeof(int32_t),);

  4674.             paramValue = static_cast<float>((*(const int32_t*)value));

  4675.             break;

  4676.         case CARLA_URI_MAP_ID_ATOM_LONG:

  4677.             CARLA_SAFE_ASSERT_RETURN(size == sizeof(int64_t),);

  4678.             paramValue = static_cast<float>((*(const int64_t*)value));

  4679.             break;

  4680.         default:

  4681.             carla_stdout("CarlaPluginLV2::handleLilvSetPortValue(\"%s\", %p, %i, %i:\"%s\") - unknown type", portSymbol, value, size, type, carla_lv2_urid_unmap(this, type));

  4682.             return;

  4683.         }

  4684. 

  4685.         for (uint32_t i=0; i < pData->param.count; ++i)

  4686.         {

  4687.             if (pData->param.data[i].rindex == rindex)

  4688.             {

  4689.                 setParameterValue(i, paramValue, true, true, true);

  4690.                 break;

  4691.             }

  4692.         }

  4693.     }

  4694. 

  4695.     // -------------------------------------------------------------------

  4696. 

  4697.     void* getNativeHandle() const noexcept override

  4698.     {

  4699.         return fHandle;

  4700.     }

  4701. 

  4702.     const void* getNativeDescriptor() const noexcept override

  4703.     {

  4704.         return fDescriptor;

  4705.     }

  4706. 

  4707.     uintptr_t getUiBridgeProcessId() const noexcept override

  4708.     {

  4709.         return fPipeServer.isPipeRunning() ? fPipeServer.getPID() : 0;

  4710.     }

  4711. 

  4712.     // -------------------------------------------------------------------

  4713. 

  4714. public:

  4715.     bool init(const char* const name, const char* const uri, const uint options)

  4716.     {

  4717.         CARLA_SAFE_ASSERT_RETURN(pData->engine != nullptr, false);

  4718. 

  4719.         // ---------------------------------------------------------------

  4720.         // first checks

  4721. 

  4722.         if (pData->client != nullptr)

  4723.         {

  4724.             pData->engine->setLastError("Plugin client is already registered");

  4725.             return false;

  4726.         }

  4727. 

  4728.         if (uri == nullptr || uri[0] == '\0')

  4729.         {

  4730.             pData->engine->setLastError("null uri");

  4731.             return false;

  4732.         }

  4733. 

  4734.         // ---------------------------------------------------------------

  4735.         // Init LV2 World if needed, sets LV2_PATH for lilv

  4736. 

  4737.         Lv2WorldClass& lv2World(Lv2WorldClass::getInstance());

  4738. 

  4739.         if (pData->engine->getOptions().pathLV2 != nullptr && pData->engine->getOptions().pathLV2[0] != '\0')

  4740.             lv2World.initIfNeeded(pData->engine->getOptions().pathLV2);

  4741.         else if (const char* const LV2_PATH = std::getenv("LV2_PATH"))

  4742.             lv2World.initIfNeeded(LV2_PATH);

  4743.         else

  4744.             lv2World.initIfNeeded(LILV_DEFAULT_LV2_PATH);

  4745. 

  4746.         // ---------------------------------------------------------------

  4747.         // get plugin from lv2_rdf (lilv)

  4748. 

  4749.         fRdfDescriptor = lv2_rdf_new(uri, true);

  4750. 

  4751.         if (fRdfDescriptor == nullptr)

  4752.         {

  4753.             pData->engine->setLastError("Failed to find the requested plugin");

  4754.             return false;

  4755.         }

  4756. 

  4757.         // ---------------------------------------------------------------

  4758.         // open DLL

  4759. 

  4760.         if (! pData->libOpen(fRdfDescriptor->Binary))

  4761.         {

  4762.             pData->engine->setLastError(pData->libError(fRdfDescriptor->Binary));

  4763.             return false;

  4764.         }

  4765. 

  4766.         // ---------------------------------------------------------------

  4767.         // try to get DLL main entry via new mode

  4768. 

  4769.         if (const LV2_Lib_Descriptor_Function libDescFn = pData->libSymbol<LV2_Lib_Descriptor_Function>("lv2_lib_descriptor"))

  4770.         {

  4771.             // -----------------------------------------------------------

  4772.             // all ok, get lib descriptor

  4773. 

  4774.             const LV2_Lib_Descriptor* const libDesc = libDescFn(fRdfDescriptor->Bundle, nullptr);

  4775. 

  4776.             if (libDesc == nullptr)

  4777.             {

  4778.                 pData->engine->setLastError("Could not find the LV2 Descriptor");

  4779.                 return false;

  4780.             }

  4781. 

  4782.             // -----------------------------------------------------------

  4783.             // get descriptor that matches URI (new mode)

  4784. 

  4785.             uint32_t i = 0;

  4786.             while ((fDescriptor = libDesc->get_plugin(libDesc->handle, i++)))

  4787.             {

  4788.                 if (std::strcmp(fDescriptor->URI, uri) == 0)

  4789.                     break;

  4790.             }

  4791.         }

  4792.         else

  4793.         {

  4794.             // -----------------------------------------------------------

  4795.             // get DLL main entry (old mode)

  4796. 

  4797.             const LV2_Descriptor_Function descFn = pData->libSymbol<LV2_Descriptor_Function>("lv2_descriptor");

  4798. 

  4799.             if (descFn == nullptr)

  4800.             {

  4801.                 pData->engine->setLastError("Could not find the LV2 Descriptor in the plugin library");

  4802.                 return false;

  4803.             }

  4804. 

  4805.             // -----------------------------------------------------------

  4806.             // get descriptor that matches URI (old mode)

  4807. 

  4808.             uint32_t i = 0;

  4809.             while ((fDescriptor = descFn(i++)))

  4810.             {

  4811.                 if (std::strcmp(fDescriptor->URI, uri) == 0)

  4812.                     break;

  4813.             }

  4814.         }

  4815. 

  4816.         if (fDescriptor == nullptr)

  4817.         {

  4818.             pData->engine->setLastError("Could not find the requested plugin URI in the plugin library");

  4819.             return false;

  4820.         }

  4821. 

  4822.         // ---------------------------------------------------------------

  4823.         // check supported port-types and features

  4824. 

  4825.         bool canContinue = true;

  4826. 

  4827.         // Check supported ports

  4828.         for (uint32_t j=0; j < fRdfDescriptor->PortCount; ++j)

  4829.         {

  4830.             const LV2_Property portTypes(fRdfDescriptor->Ports[j].Types);

  4831. 

  4832.             if (! is_lv2_port_supported(portTypes))

  4833.             {

  4834.                 if (! LV2_IS_PORT_OPTIONAL(fRdfDescriptor->Ports[j].Properties))

  4835.                 {

  4836.                     pData->engine->setLastError("Plugin requires a port type that is not currently supported");

  4837.                     canContinue = false;

  4838.                     break;

  4839.                 }

  4840.             }

  4841.         }

  4842. 

  4843.         // Check supported features

  4844.         for (uint32_t j=0; j < fRdfDescriptor->FeatureCount && canContinue; ++j)

  4845.         {

  4846.             const LV2_RDF_Feature& feature(fRdfDescriptor->Features[j]);

  4847. 

  4848.             if (std::strcmp(feature.URI, LV2_DATA_ACCESS_URI) == 0 || std::strcmp(feature.URI, LV2_INSTANCE_ACCESS_URI) == 0)

  4849.             {

  4850.                 carla_stderr("Plugin DSP wants UI feature '%s', ignoring this", feature.URI);

  4851.             }

  4852.             else if (feature.Required && ! is_lv2_feature_supported(feature.URI))

  4853.             {

  4854.                 CarlaString msg("Plugin wants a feature that is not supported:\n");

  4855.                 msg += feature.URI;

  4856. 

  4857.                 canContinue = false;

  4858.                 pData->engine->setLastError(msg);

  4859.                 break;

  4860.             }

  4861.         }

  4862. 

  4863.         if (! canContinue)

  4864.         {

  4865.             // error already set

  4866.             return false;

  4867.         }

  4868. 

  4869.         // ---------------------------------------------------------------

  4870.         // get info

  4871. 

  4872.         if (name != nullptr && name[0] != '\0')

  4873.             pData->name = pData->engine->getUniquePluginName(name);

  4874.         else

  4875.             pData->name = pData->engine->getUniquePluginName(fRdfDescriptor->Name);

  4876. 

  4877.         // ---------------------------------------------------------------

  4878.         // register client

  4879. 

  4880.         pData->client = pData->engine->addClient(this);

  4881. 

  4882.         if (pData->client == nullptr || ! pData->client->isOk())

  4883.         {

  4884.             pData->engine->setLastError("Failed to register plugin client");

  4885.             return false;

  4886.         }

  4887. 

  4888.         // ---------------------------------------------------------------

  4889.         // initialize options

  4890. 

  4891.         fLv2Options.minBufferSize     = 1;

  4892.         fLv2Options.maxBufferSize     = static_cast<int>(pData->engine->getBufferSize());

  4893.         fLv2Options.nominalBufferSize = fLv2Options.maxBufferSize;

  4894.         fLv2Options.sampleRate        = pData->engine->getSampleRate();

  4895.         fLv2Options.frontendWinId     = static_cast<int64_t>(pData->engine->getOptions().frontendWinId);

  4896. 

  4897.         uint32_t eventBufferSize = MAX_DEFAULT_BUFFER_SIZE;

  4898. 

  4899.         for (uint32_t j=0; j < fRdfDescriptor->PortCount; ++j)

  4900.         {

  4901.             const LV2_Property portTypes(fRdfDescriptor->Ports[j].Types);

  4902. 

  4903.             if (LV2_IS_PORT_ATOM_SEQUENCE(portTypes) || LV2_IS_PORT_EVENT(portTypes) || LV2_IS_PORT_MIDI_LL(portTypes))

  4904.             {

  4905.                 if (fRdfDescriptor->Ports[j].MinimumSize > eventBufferSize)

  4906.                     eventBufferSize = fRdfDescriptor->Ports[j].MinimumSize;

  4907.             }

  4908.         }

  4909. 

  4910.         fLv2Options.sequenceSize = static_cast<int>(eventBufferSize);

  4911. 

  4912.         // ---------------------------------------------------------------

  4913.         // initialize features (part 1)

  4914. 

  4915.         LV2_Event_Feature* const eventFt = new LV2_Event_Feature;

  4916.         eventFt->callback_data           = this;

  4917.         eventFt->lv2_event_ref           = carla_lv2_event_ref;

  4918.         eventFt->lv2_event_unref         = carla_lv2_event_unref;

  4919. 

  4920.         LV2_Log_Log* const logFt         = new LV2_Log_Log;

  4921.         logFt->handle                    = this;

  4922.         logFt->printf                    = carla_lv2_log_printf;

  4923.         logFt->vprintf                   = carla_lv2_log_vprintf;

  4924. 

  4925.         LV2_State_Make_Path* const stateMakePathFt = new LV2_State_Make_Path;

  4926.         stateMakePathFt->handle                    = this;

  4927.         stateMakePathFt->path                      = carla_lv2_state_make_path;

  4928. 

  4929.         LV2_State_Map_Path* const stateMapPathFt   = new LV2_State_Map_Path;

  4930.         stateMapPathFt->handle                     = this;

  4931.         stateMapPathFt->abstract_path              = carla_lv2_state_map_abstract_path;

  4932.         stateMapPathFt->absolute_path              = carla_lv2_state_map_absolute_path;

  4933. 

  4934.         LV2_Programs_Host* const programsFt   = new LV2_Programs_Host;

  4935.         programsFt->handle                    = this;

  4936.         programsFt->program_changed           = carla_lv2_program_changed;

  4937. 

  4938.         LV2_Resize_Port_Resize* const rsPortFt = new LV2_Resize_Port_Resize;

  4939.         rsPortFt->data                         = this;

  4940.         rsPortFt->resize                       = carla_lv2_resize_port;

  4941. 

  4942.         LV2_RtMemPool_Pool* const rtMemPoolFt = new LV2_RtMemPool_Pool;

  4943.         lv2_rtmempool_init(rtMemPoolFt);

  4944. 

  4945.         LV2_RtMemPool_Pool_Deprecated* const rtMemPoolOldFt = new LV2_RtMemPool_Pool_Deprecated;

  4946.         lv2_rtmempool_init_deprecated(rtMemPoolOldFt);

  4947. 

  4948.         LV2_URI_Map_Feature* const uriMapFt = new LV2_URI_Map_Feature;

  4949.         uriMapFt->callback_data             = this;

  4950.         uriMapFt->uri_to_id                 = carla_lv2_uri_to_id;

  4951. 

  4952.         LV2_URID_Map* const uridMapFt       = new LV2_URID_Map;

  4953.         uridMapFt->handle                   = this;

  4954.         uridMapFt->map                      = carla_lv2_urid_map;

  4955. 

  4956.         LV2_URID_Unmap* const uridUnmapFt   = new LV2_URID_Unmap;

  4957.         uridUnmapFt->handle                 = this;

  4958.         uridUnmapFt->unmap                  = carla_lv2_urid_unmap;

  4959. 

  4960.         LV2_Worker_Schedule* const workerFt = new LV2_Worker_Schedule;

  4961.         workerFt->handle                    = this;

  4962.         workerFt->schedule_work             = carla_lv2_worker_schedule;

  4963. 

  4964.         // ---------------------------------------------------------------

  4965.         // initialize features (part 2)

  4966. 

  4967.         for (uint32_t j=0; j < kFeatureCountPlugin; ++j)

  4968.             fFeatures[j] = new LV2_Feature;

  4969. 

  4970.         fFeatures[kFeatureIdBufSizeBounded]->URI   = LV2_BUF_SIZE__boundedBlockLength;

  4971.         fFeatures[kFeatureIdBufSizeBounded]->data  = nullptr;

  4972. 

  4973.         fFeatures[kFeatureIdBufSizeFixed]->URI     = LV2_BUF_SIZE__fixedBlockLength;

  4974.         fFeatures[kFeatureIdBufSizeFixed]->data    = nullptr;

  4975. 

  4976.         fFeatures[kFeatureIdBufSizePowerOf2]->URI  = LV2_BUF_SIZE__powerOf2BlockLength;

  4977.         fFeatures[kFeatureIdBufSizePowerOf2]->data = nullptr;

  4978. 

  4979.         fFeatures[kFeatureIdEvent]->URI          = LV2_EVENT_URI;

  4980.         fFeatures[kFeatureIdEvent]->data         = eventFt;

  4981. 

  4982.         fFeatures[kFeatureIdHardRtCapable]->URI  = LV2_CORE__hardRTCapable;

  4983.         fFeatures[kFeatureIdHardRtCapable]->data = nullptr;

  4984. 

  4985.         fFeatures[kFeatureIdInPlaceBroken]->URI  = LV2_CORE__inPlaceBroken;

  4986.         fFeatures[kFeatureIdInPlaceBroken]->data = nullptr;

  4987. 

  4988.         fFeatures[kFeatureIdIsLive]->URI         = LV2_CORE__isLive;

  4989.         fFeatures[kFeatureIdIsLive]->data        = nullptr;

  4990. 

  4991.         fFeatures[kFeatureIdLogs]->URI       = LV2_LOG__log;

  4992.         fFeatures[kFeatureIdLogs]->data      = logFt;

  4993. 

  4994.         fFeatures[kFeatureIdOptions]->URI    = LV2_OPTIONS__options;

  4995.         fFeatures[kFeatureIdOptions]->data   = fLv2Options.opts;

  4996. 

  4997.         fFeatures[kFeatureIdPrograms]->URI   = LV2_PROGRAMS__Host;

  4998.         fFeatures[kFeatureIdPrograms]->data  = programsFt;

  4999. 

  5000.         fFeatures[kFeatureIdResizePort]->URI   = LV2_RESIZE_PORT__resize;

  5001.         fFeatures[kFeatureIdResizePort]->data  = rsPortFt;

  5002. 

  5003.         fFeatures[kFeatureIdRtMemPool]->URI  = LV2_RTSAFE_MEMORY_POOL__Pool;

  5004.         fFeatures[kFeatureIdRtMemPool]->data = rtMemPoolFt;

  5005. 

  5006.         fFeatures[kFeatureIdRtMemPoolOld]->URI  = LV2_RTSAFE_MEMORY_POOL_DEPRECATED_URI;

  5007.         fFeatures[kFeatureIdRtMemPoolOld]->data = rtMemPoolOldFt;

  5008. 

  5009.         fFeatures[kFeatureIdStateMakePath]->URI  = LV2_STATE__makePath;

  5010.         fFeatures[kFeatureIdStateMakePath]->data = stateMakePathFt;

  5011. 

  5012.         fFeatures[kFeatureIdStateMapPath]->URI   = LV2_STATE__mapPath;

  5013.         fFeatures[kFeatureIdStateMapPath]->data  = stateMapPathFt;

  5014. 

  5015.         fFeatures[kFeatureIdStrictBounds]->URI   = LV2_PORT_PROPS__supportsStrictBounds;

  5016.         fFeatures[kFeatureIdStrictBounds]->data  = nullptr;

  5017. 

  5018.         fFeatures[kFeatureIdUriMap]->URI     = LV2_URI_MAP_URI;

  5019.         fFeatures[kFeatureIdUriMap]->data    = uriMapFt;

  5020. 

  5021.         fFeatures[kFeatureIdUridMap]->URI    = LV2_URID__map;

  5022.         fFeatures[kFeatureIdUridMap]->data   = uridMapFt;

  5023. 

  5024.         fFeatures[kFeatureIdUridUnmap]->URI  = LV2_URID__unmap;

  5025.         fFeatures[kFeatureIdUridUnmap]->data = uridUnmapFt;

  5026. 

  5027.         fFeatures[kFeatureIdWorker]->URI     = LV2_WORKER__schedule;

  5028.         fFeatures[kFeatureIdWorker]->data    = workerFt;

  5029. 

  5030.         // if a fixed buffer is not needed, skip its feature

  5031.         if (! needsFixedBuffer())

  5032.             fFeatures[kFeatureIdBufSizeFixed]->URI = LV2_BUF_SIZE__boundedBlockLength;

  5033.         else

  5034.             fLv2Options.minBufferSize = fLv2Options.maxBufferSize;

  5035. 

  5036.         // if power of 2 is not possible, skip its feature FIXME

  5037.         //if (fLv2Options.maxBufferSize)

  5038.         //    fFeatures[kFeatureIdBufSizePowerOf2]->URI = LV2_BUF_SIZE__boundedBlockLength;

  5039. 

  5040.         // ---------------------------------------------------------------

  5041.         // initialize plugin

  5042. 

  5043.         try {

  5044.             fHandle = fDescriptor->instantiate(fDescriptor, pData->engine->getSampleRate(), fRdfDescriptor->Bundle, fFeatures);

  5045.         } catch(...) {}

  5046. 

  5047.         if (fHandle == nullptr)

  5048.         {

  5049.             pData->engine->setLastError("Plugin failed to initialize");

  5050.             return false;

  5051.         }

  5052. 

  5053.         if (std::strcmp(uri, "http://hyperglitch.com/dev/VocProc") == 0)

  5054.             fCanInit2 = false;

  5055. 

  5056.         recheckExtensions();

  5057. 

  5058.         // ---------------------------------------------------------------

  5059.         // set default options

  5060. 

  5061.         pData->options = 0x0;

  5062. 

  5063.         if (fExt.programs != nullptr && getCategory() == PLUGIN_CATEGORY_SYNTH)

  5064.             pData->options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  5065. 

  5066.         if (fLatencyIndex >= 0 || getMidiInCount() > 0 || needsFixedBuffer())

  5067.             pData->options |= PLUGIN_OPTION_FIXED_BUFFERS;

  5068.          else if (options & PLUGIN_OPTION_FIXED_BUFFERS)

  5069.             pData->options |= PLUGIN_OPTION_FIXED_BUFFERS;

  5070. 

  5071.         if (fCanInit2)

  5072.         {

  5073.             if (pData->engine->getOptions().forceStereo)

  5074.                 pData->options |= PLUGIN_OPTION_FORCE_STEREO;

  5075.             else if (options & PLUGIN_OPTION_FORCE_STEREO)

  5076.                 pData->options |= PLUGIN_OPTION_FORCE_STEREO;

  5077.         }

  5078. 

  5079.         if (getMidiInCount() > 0)

  5080.         {

  5081.             pData->options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  5082.             pData->options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

  5083.             pData->options |= PLUGIN_OPTION_SEND_PITCHBEND;

  5084.             pData->options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  5085.         }

  5086. 

  5087.         // ---------------------------------------------------------------

  5088.         // gui stuff

  5089. 

  5090.         if (fRdfDescriptor->UICount != 0)

  5091.             initUi();

  5092. 

  5093.         return true;

  5094.     }

  5095. 

  5096.     // -------------------------------------------------------------------

  5097. 

  5098.     void initUi()

  5099.     {

  5100.         // ---------------------------------------------------------------

  5101.         // find the most appropriate ui

  5102. 

  5103.         int eQt4, eQt5, eGtk2, eGtk3, eCocoa, eWindows, eX11, eExt, eMod, iCocoa, iWindows, iX11, iExt, iFinal;

  5104.         eQt4 = eQt5 = eGtk2 = eGtk3 = eCocoa = eWindows = eX11 = eExt = eMod = iCocoa = iWindows = iX11 = iExt = iFinal = -1;

  5105. 

  5106. #if defined(BUILD_BRIDGE)

  5107.         const bool preferUiBridges(false);

  5108. #elif defined(LV2_UIS_ONLY_BRIDGES)

  5109.         const bool preferUiBridges(true);

  5110. #else

  5111.         const bool preferUiBridges(pData->engine->getOptions().preferUiBridges && (pData->hints & PLUGIN_IS_BRIDGE) == 0);

  5112. #endif

  5113. 

  5114.         for (uint32_t i=0; i < fRdfDescriptor->UICount; ++i)

  5115.         {

  5116.             CARLA_SAFE_ASSERT_CONTINUE(fRdfDescriptor->UIs[i].URI != nullptr);

  5117. 

  5118.             const int ii(static_cast<int>(i));

  5119. 

  5120.             switch (fRdfDescriptor->UIs[i].Type)

  5121.             {

  5122.             case LV2_UI_QT4:

  5123.                 if (isUiBridgeable(i))

  5124.                     eQt4 = ii;

  5125.                 break;

  5126.             case LV2_UI_QT5:

  5127.                 if (isUiBridgeable(i))

  5128.                     eQt5 = ii;

  5129.                 break;

  5130.             case LV2_UI_GTK2:

  5131.                 if (isUiBridgeable(i))

  5132.                     eGtk2 = ii;

  5133.                 break;

  5134.             case LV2_UI_GTK3:

  5135.                 if (isUiBridgeable(i))

  5136.                     eGtk3 = ii;

  5137.                 break;

  5138.             case LV2_UI_COCOA:

  5139.                 if (isUiBridgeable(i) && preferUiBridges)

  5140.                     eCocoa = ii;

  5141.                 iCocoa = ii;

  5142.                 break;

  5143.             case LV2_UI_WINDOWS:

  5144.                 if (isUiBridgeable(i) && preferUiBridges)

  5145.                     eWindows = ii;

  5146.                 iWindows = ii;

  5147.                 break;

  5148.             case LV2_UI_X11:

  5149.                 if (isUiBridgeable(i) && preferUiBridges)

  5150.                     eX11 = ii;

  5151.                 iX11 = ii;

  5152.                 break;

  5153.             case LV2_UI_EXTERNAL:

  5154.             case LV2_UI_OLD_EXTERNAL:

  5155.                 if (isUiBridgeable(i))

  5156.                     eExt = ii;

  5157.                 iExt = ii;

  5158.                 break;

  5159.             case LV2_UI_MOD:

  5160.                 eMod = ii;

  5161.                 break;

  5162.             default:

  5163.                 break;

  5164.             }

  5165.         }

  5166. 

  5167.         if (eQt4 >= 0)

  5168.             iFinal = eQt4;

  5169.         else if (eQt5 >= 0)

  5170.             iFinal = eQt5;

  5171.         else if (eGtk2 >= 0)

  5172.             iFinal = eGtk2;

  5173.         else if (eGtk3 >= 0)

  5174.             iFinal = eGtk3;

  5175. #ifdef CARLA_OS_MAC

  5176.         else if (eCocoa >= 0)

  5177.             iFinal = eCocoa;

  5178. #endif

  5179. #ifdef CARLA_OS_WIN

  5180.         else if (eWindows >= 0)

  5181.             iFinal = eWindows;

  5182. #endif

  5183. #ifdef HAVE_X11

  5184.         else if (eX11 >= 0)

  5185.             iFinal = eX11;

  5186. #endif

  5187.         //else if (eExt >= 0) // TODO

  5188.         //    iFinal = eExt;

  5189. #ifndef LV2_UIS_ONLY_BRIDGES

  5190. # ifdef CARLA_OS_MAC

  5191.         else if (iCocoa >= 0)

  5192.             iFinal = iCocoa;

  5193. # endif

  5194. # ifdef CARLA_OS_WIN

  5195.         else if (iWindows >= 0)

  5196.             iFinal = iWindows;

  5197. # endif

  5198. # ifdef HAVE_X11

  5199.         else if (iX11 >= 0)

  5200.             iFinal = iX11;

  5201. # endif

  5202. #endif

  5203.         else if (iExt >= 0)

  5204.             iFinal = iExt;

  5205. 

  5206.         if (iFinal < 0)

  5207.         {

  5208.             // no suitable UI found, see if there's one which supports ui:showInterface

  5209.             bool hasShowInterface = false;

  5210. 

  5211.             for (uint32_t i=0; i < fRdfDescriptor->UICount && ! hasShowInterface; ++i)

  5212.             {

  5213.                 LV2_RDF_UI* const ui(&fRdfDescriptor->UIs[i]);

  5214. 

  5215.                 for (uint32_t j=0; j < ui->ExtensionCount; ++j)

  5216.                 {

  5217.                     CARLA_SAFE_ASSERT_CONTINUE(ui->Extensions[j] != nullptr);

  5218. 

  5219.                     if (std::strcmp(ui->Extensions[j], LV2_UI__showInterface) != 0)

  5220.                         continue;

  5221. 

  5222.                     iFinal = static_cast<int>(i);

  5223.                     hasShowInterface = true;

  5224.                     break;

  5225.                 }

  5226.             }

  5227. 

  5228.             if (! hasShowInterface)

  5229.             {

  5230.                 if (eMod < 0)

  5231.                 {

  5232.                     carla_stderr("Failed to find an appropriate LV2 UI for this plugin");

  5233.                     return;

  5234.                 }

  5235. 

  5236.                 // use MODGUI as last resort

  5237.                 iFinal = eMod;

  5238.             }

  5239.         }

  5240. 

  5241.         fUI.rdfDescriptor = &fRdfDescriptor->UIs[iFinal];

  5242. 

  5243.         // ---------------------------------------------------------------

  5244.         // check supported ui features

  5245. 

  5246.         bool canContinue = true;

  5247.         bool canDelete = true;

  5248. 

  5249.         for (uint32_t i=0; i < fUI.rdfDescriptor->FeatureCount; ++i)

  5250.         {

  5251.             const char* const uri(fUI.rdfDescriptor->Features[i].URI);

  5252.             CARLA_SAFE_ASSERT_CONTINUE(uri != nullptr && uri[0] != '\0');

  5253. 

  5254.             if (! is_lv2_ui_feature_supported(uri))

  5255.             {

  5256.                 carla_stderr("Plugin UI requires a feature that is not supported:\n%s", uri);

  5257. 

  5258.                 if (fUI.rdfDescriptor->Features[i].Required)

  5259.                 {

  5260.                     canContinue = false;

  5261.                     break;

  5262.                 }

  5263.             }

  5264.             if (std::strcmp(uri, LV2_UI__makeResident) == 0 || std::strcmp(uri, LV2_UI__makeSONameResident) == 0)

  5265.                 canDelete = false;

  5266.         }

  5267. 

  5268.         if (! canContinue)

  5269.         {

  5270.             fUI.rdfDescriptor = nullptr;

  5271.             return;

  5272.         }

  5273. 

  5274.         // ---------------------------------------------------------------

  5275.         // initialize ui according to type

  5276. 

  5277.         const LV2_Property uiType(fUI.rdfDescriptor->Type);

  5278. 

  5279.         if (iFinal == eQt4 || iFinal == eQt5 || iFinal == eGtk2 || iFinal == eGtk3 ||

  5280.             iFinal == eCocoa || iFinal == eWindows || iFinal == eX11 || iFinal == eExt || iFinal == eMod)

  5281.         {

  5282.             // -----------------------------------------------------------

  5283.             // initialize ui-bridge

  5284. 

  5285.             if (const char* const bridgeBinary = getUiBridgeBinary(uiType))

  5286.             {

  5287.                 carla_stdout("Will use UI-Bridge, binary: \"%s\"", bridgeBinary);

  5288. 

  5289.                 CarlaString guiTitle(pData->name);

  5290.                 guiTitle += " (GUI)";

  5291.                 fLv2Options.windowTitle = guiTitle.dup();

  5292. 

  5293.                 fUI.type = UI::TYPE_BRIDGE;

  5294.                 fPipeServer.setData(bridgeBinary, fRdfDescriptor->URI, fUI.rdfDescriptor->URI);

  5295. 

  5296.                 delete[] bridgeBinary;

  5297.                 return;

  5298.             }

  5299. 

  5300.             if (iFinal == eQt4 || iFinal == eQt5 || iFinal == eGtk2 || iFinal == eGtk3)

  5301.             {

  5302.                 carla_stderr2("Failed to find UI bridge binary, cannot use UI");

  5303.                 fUI.rdfDescriptor = nullptr;

  5304.                 return;

  5305.             }

  5306.         }

  5307. 

  5308. #ifdef LV2_UIS_ONLY_BRIDGES

  5309.         carla_stderr2("Failed to get an UI working, canBridge:%s", bool2str(isUiBridgeable(static_cast<uint32_t>(iFinal))));

  5310.         fUI.rdfDescriptor = nullptr;

  5311.         return;

  5312. #endif

  5313. 

  5314.         // ---------------------------------------------------------------

  5315.         // open UI DLL

  5316. 

  5317.         if (! pData->uiLibOpen(fUI.rdfDescriptor->Binary, canDelete))

  5318.         {

  5319.             carla_stderr2("Could not load UI library, error was:\n%s", pData->libError(fUI.rdfDescriptor->Binary));

  5320.             fUI.rdfDescriptor = nullptr;

  5321.             return;

  5322.         }

  5323. 

  5324.         // ---------------------------------------------------------------

  5325.         // get UI DLL main entry

  5326. 

  5327.         LV2UI_DescriptorFunction uiDescFn = pData->uiLibSymbol<LV2UI_DescriptorFunction>("lv2ui_descriptor");

  5328. 

  5329.         if (uiDescFn == nullptr)

  5330.         {

  5331.             carla_stderr2("Could not find the LV2UI Descriptor in the UI library");

  5332.             pData->uiLibClose();

  5333.             fUI.rdfDescriptor = nullptr;

  5334.             return;

  5335.         }

  5336. 

  5337.         // ---------------------------------------------------------------

  5338.         // get UI descriptor that matches UI URI

  5339. 

  5340.         uint32_t i = 0;

  5341.         while ((fUI.descriptor = uiDescFn(i++)))

  5342.         {

  5343.             if (std::strcmp(fUI.descriptor->URI, fUI.rdfDescriptor->URI) == 0)

  5344.                 break;

  5345.         }

  5346. 

  5347.         if (fUI.descriptor == nullptr)

  5348.         {

  5349.             carla_stderr2("Could not find the requested GUI in the plugin UI library");

  5350.             pData->uiLibClose();

  5351.             fUI.rdfDescriptor = nullptr;

  5352.             return;

  5353.         }

  5354. 

  5355.         // ---------------------------------------------------------------

  5356.         // check if ui is usable

  5357. 

  5358.         switch (uiType)

  5359.         {

  5360.         case LV2_UI_QT4:

  5361.             carla_stdout("Will use LV2 Qt4 UI, NOT!");

  5362.             fUI.type = UI::TYPE_EMBED;

  5363.             break;

  5364.         case LV2_UI_QT5:

  5365.             carla_stdout("Will use LV2 Qt5 UI, NOT!");

  5366.             fUI.type = UI::TYPE_EMBED;

  5367.             break;

  5368.         case LV2_UI_GTK2:

  5369.             carla_stdout("Will use LV2 Gtk2 UI, NOT!");

  5370.             fUI.type = UI::TYPE_EMBED;

  5371.             break;

  5372.         case LV2_UI_GTK3:

  5373.             carla_stdout("Will use LV2 Gtk3 UI, NOT!");

  5374.             fUI.type = UI::TYPE_EMBED;

  5375.             break;

  5376. #ifdef CARLA_OS_MAC

  5377.         case LV2_UI_COCOA:

  5378.             carla_stdout("Will use LV2 Cocoa UI");

  5379.             fUI.type = UI::TYPE_EMBED;

  5380.             break;

  5381. #endif

  5382. #ifdef CARLA_OS_WIN

  5383.         case LV2_UI_WINDOWS:

  5384.             carla_stdout("Will use LV2 Windows UI");

  5385.             fUI.type = UI::TYPE_EMBED;

  5386.             break;

  5387. #endif

  5388.         case LV2_UI_X11:

  5389. #ifdef HAVE_X11

  5390.             carla_stdout("Will use LV2 X11 UI");

  5391. #else

  5392.             carla_stdout("Will use LV2 X11 UI, NOT!");

  5393. #endif

  5394.             fUI.type = UI::TYPE_EMBED;

  5395.             break;

  5396.         case LV2_UI_EXTERNAL:

  5397.         case LV2_UI_OLD_EXTERNAL:

  5398.             carla_stdout("Will use LV2 External UI");

  5399.             fUI.type = UI::TYPE_EXTERNAL;

  5400.             break;

  5401.         }

  5402. 

  5403.         if (fUI.type == UI::TYPE_NULL)

  5404.         {

  5405.             pData->uiLibClose();

  5406.             fUI.descriptor = nullptr;

  5407.             fUI.rdfDescriptor = nullptr;

  5408.             return;

  5409.         }

  5410. 

  5411.         // ---------------------------------------------------------------

  5412.         // initialize ui data

  5413. 

  5414.         CarlaString guiTitle(pData->name);

  5415.         guiTitle += " (GUI)";

  5416.         fLv2Options.windowTitle = guiTitle.dup();

  5417. 

  5418.         fLv2Options.opts[CarlaPluginLV2Options::WindowTitle].size  = (uint32_t)std::strlen(fLv2Options.windowTitle);

  5419.         fLv2Options.opts[CarlaPluginLV2Options::WindowTitle].value = fLv2Options.windowTitle;

  5420. 

  5421.         // ---------------------------------------------------------------

  5422.         // initialize ui features (part 1)

  5423. 

  5424.         LV2_Extension_Data_Feature* const uiDataFt = new LV2_Extension_Data_Feature;

  5425.         uiDataFt->data_access                      = fDescriptor->extension_data;

  5426. 

  5427.         LV2UI_Port_Map* const uiPortMapFt = new LV2UI_Port_Map;

  5428.         uiPortMapFt->handle               = this;

  5429.         uiPortMapFt->port_index           = carla_lv2_ui_port_map;

  5430. 

  5431.         LV2UI_Resize* const uiResizeFt    = new LV2UI_Resize;

  5432.         uiResizeFt->handle                = this;

  5433.         uiResizeFt->ui_resize             = carla_lv2_ui_resize;

  5434. 

  5435.         LV2_External_UI_Host* const uiExternalHostFt = new LV2_External_UI_Host;

  5436.         uiExternalHostFt->ui_closed                  = carla_lv2_external_ui_closed;

  5437.         uiExternalHostFt->plugin_human_id            = fLv2Options.windowTitle;

  5438. 

  5439.         // ---------------------------------------------------------------

  5440.         // initialize ui features (part 2)

  5441. 

  5442.         for (uint32_t j=kFeatureCountPlugin; j < kFeatureCountAll; ++j)

  5443.             fFeatures[j] = new LV2_Feature;

  5444. 

  5445.         fFeatures[kFeatureIdUiDataAccess]->URI      = LV2_DATA_ACCESS_URI;

  5446.         fFeatures[kFeatureIdUiDataAccess]->data     = uiDataFt;

  5447. 

  5448.         fFeatures[kFeatureIdUiInstanceAccess]->URI  = LV2_INSTANCE_ACCESS_URI;

  5449.         fFeatures[kFeatureIdUiInstanceAccess]->data = fHandle;

  5450. 

  5451.         fFeatures[kFeatureIdUiIdleInterface]->URI  = LV2_UI__idleInterface;

  5452.         fFeatures[kFeatureIdUiIdleInterface]->data = nullptr;

  5453. 

  5454.         fFeatures[kFeatureIdUiFixedSize]->URI      = LV2_UI__fixedSize;

  5455.         fFeatures[kFeatureIdUiFixedSize]->data     = nullptr;

  5456. 

  5457.         fFeatures[kFeatureIdUiMakeResident]->URI   = LV2_UI__makeResident;

  5458.         fFeatures[kFeatureIdUiMakeResident]->data  = nullptr;

  5459. 

  5460.         fFeatures[kFeatureIdUiMakeResident2]->URI  = LV2_UI__makeSONameResident;

  5461.         fFeatures[kFeatureIdUiMakeResident2]->data = nullptr;

  5462. 

  5463.         fFeatures[kFeatureIdUiNoUserResize]->URI   = LV2_UI__noUserResize;

  5464.         fFeatures[kFeatureIdUiNoUserResize]->data  = nullptr;

  5465. 

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

  5467.         fFeatures[kFeatureIdUiParent]->data        = nullptr;

  5468. 

  5469.         fFeatures[kFeatureIdUiPortMap]->URI        = LV2_UI__portMap;

  5470.         fFeatures[kFeatureIdUiPortMap]->data       = uiPortMapFt;

  5471. 

  5472.         fFeatures[kFeatureIdUiPortSubscribe]->URI  = LV2_UI__portSubscribe;

  5473.         fFeatures[kFeatureIdUiPortSubscribe]->data = nullptr;

  5474. 

  5475.         fFeatures[kFeatureIdUiResize]->URI       = LV2_UI__resize;

  5476.         fFeatures[kFeatureIdUiResize]->data      = uiResizeFt;

  5477. 

  5478.         fFeatures[kFeatureIdUiTouch]->URI        = LV2_UI__touch;

  5479.         fFeatures[kFeatureIdUiTouch]->data       = nullptr;

  5480. 

  5481.         fFeatures[kFeatureIdExternalUi]->URI     = LV2_EXTERNAL_UI__Host;

  5482.         fFeatures[kFeatureIdExternalUi]->data    = uiExternalHostFt;

  5483. 

  5484.         fFeatures[kFeatureIdExternalUiOld]->URI  = LV2_EXTERNAL_UI_DEPRECATED_URI;

  5485.         fFeatures[kFeatureIdExternalUiOld]->data = uiExternalHostFt;

  5486. 

  5487.         // ---------------------------------------------------------------

  5488.         // initialize ui extensions

  5489. 

  5490.         if (fUI.descriptor->extension_data == nullptr)

  5491.             return;

  5492. 

  5493.         fExt.uiidle     = (const LV2UI_Idle_Interface*)fUI.descriptor->extension_data(LV2_UI__idleInterface);

  5494.         fExt.uishow     = (const LV2UI_Show_Interface*)fUI.descriptor->extension_data(LV2_UI__showInterface);

  5495.         fExt.uiresize   = (const LV2UI_Resize*)fUI.descriptor->extension_data(LV2_UI__resize);

  5496.         fExt.uiprograms = (const LV2_Programs_UI_Interface*)fUI.descriptor->extension_data(LV2_PROGRAMS__UIInterface);

  5497. 

  5498.         // check if invalid

  5499.         if (fExt.uiidle != nullptr && fExt.uiidle->idle == nullptr)

  5500.             fExt.uiidle = nullptr;

  5501. 

  5502.         if (fExt.uishow != nullptr && (fExt.uishow->show == nullptr || fExt.uishow->hide == nullptr))

  5503.             fExt.uishow = nullptr;

  5504. 

  5505.         if (fExt.uiresize != nullptr && fExt.uiresize->ui_resize == nullptr)

  5506.             fExt.uiresize = nullptr;

  5507. 

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

  5509.             fExt.uiprograms = nullptr;

  5510. 

  5511.         // don't use uiidle if external

  5512.         if (fUI.type == UI::TYPE_EXTERNAL)

  5513.             fExt.uiidle = nullptr;

  5514.     }

  5515. 

  5516.     // -------------------------------------------------------------------

  5517. 

  5518.     void handleTransferAtom(const uint32_t portIndex, const LV2_Atom* const atom)

  5519.     {

  5520.         CARLA_SAFE_ASSERT_RETURN(atom != nullptr,);

  5521.         carla_debug("CarlaPluginLV2::handleTransferAtom(%i, %p)", portIndex, atom);

  5522. 

  5523.         fAtomBufferIn.put(atom, portIndex);

  5524.     }

  5525. 

  5526.     void handleUridMap(const LV2_URID urid, const char* const uri)

  5527.     {

  5528.         CARLA_SAFE_ASSERT_RETURN(urid != CARLA_URI_MAP_ID_NULL,);

  5529.         CARLA_SAFE_ASSERT_RETURN(uri != nullptr && uri[0] != '\0',);

  5530.         carla_debug("CarlaPluginLV2::handleUridMap(%i v " P_SIZE ", \"%s\")", urid, fCustomURIDs.size()-1, uri);

  5531. 

  5532.         const std::size_t uriCount(fCustomURIDs.size());

  5533. 

  5534.         if (urid < uriCount)

  5535.         {

  5536.             const char* const ourURI(carla_lv2_urid_unmap(this, urid));

  5537.             CARLA_SAFE_ASSERT_RETURN(ourURI != nullptr,);

  5538. 

  5539.             if (std::strcmp(ourURI, uri) != 0)

  5540.             {

  5541.                 carla_stderr2("PLUGIN :: wrong URI '%s' vs '%s'", ourURI,  uri);

  5542.             }

  5543.         }

  5544.         else

  5545.         {

  5546.             CARLA_SAFE_ASSERT_RETURN(urid == uriCount,);

  5547.             fCustomURIDs.push_back(uri);

  5548.         }

  5549.     }

  5550. 

  5551.     // -------------------------------------------------------------------

  5552. 

  5553. private:

  5554.     LV2_Handle   fHandle;

  5555.     LV2_Handle   fHandle2;

  5556.     LV2_Feature* fFeatures[kFeatureCountAll+1];

  5557.     const LV2_Descriptor*     fDescriptor;

  5558.     const LV2_RDF_Descriptor* fRdfDescriptor;

  5559. 

  5560.     float** fAudioInBuffers;

  5561.     float** fAudioOutBuffers;

  5562.     float** fCvInBuffers;

  5563.     float** fCvOutBuffers;

  5564.     float*  fParamBuffers;

  5565. 

  5566.     bool    fCanInit2; // some plugins don't like 2 instances

  5567.     bool    fNeedsUiClose;

  5568.     //bool    fLatencyChanged;

  5569.     int32_t fLatencyIndex; // -1 if invalid

  5570. 

  5571.     Lv2AtomRingBuffer fAtomBufferIn;

  5572.     Lv2AtomRingBuffer fAtomBufferOut;

  5573.     LV2_Atom_Forge    fAtomForge;

  5574.     uint8_t*          fTmpAtomBuffer;

  5575. 

  5576.     CarlaPluginLV2EventData fEventsIn;

  5577.     CarlaPluginLV2EventData fEventsOut;

  5578.     CarlaPluginLV2Options   fLv2Options;

  5579.     CarlaPipeServerLV2      fPipeServer;

  5580. 

  5581.     std::vector<std::string> fCustomURIDs;

  5582. 

  5583.     bool fFirstActive; // first process() call after activate()

  5584.     void* fLastStateChunk;

  5585.     EngineTimeInfo fLastTimeInfo;

  5586. 

  5587.     struct Extensions {

  5588.         const LV2_Options_Interface* options;

  5589.         const LV2_State_Interface* state;

  5590.         const LV2_Worker_Interface* worker;

  5591.         const LV2_Programs_Interface* programs;

  5592.         const LV2UI_Idle_Interface* uiidle;

  5593.         const LV2UI_Show_Interface* uishow;

  5594.         const LV2UI_Resize* uiresize;

  5595.         const LV2_Programs_UI_Interface* uiprograms;

  5596. 

  5597.         Extensions()

  5598.             : options(nullptr),

  5599.               state(nullptr),

  5600.               worker(nullptr),

  5601.               programs(nullptr),

  5602.               uiidle(nullptr),

  5603.               uishow(nullptr),

  5604.               uiresize(nullptr),

  5605.               uiprograms(nullptr) {}

  5606. 

  5607.         CARLA_DECLARE_NON_COPY_STRUCT(Extensions);

  5608.     } fExt;

  5609. 

  5610.     struct UI {

  5611.         enum Type {

  5612.             TYPE_NULL = 0,

  5613.             TYPE_BRIDGE,

  5614.             TYPE_EMBED,

  5615.             TYPE_EXTERNAL

  5616.         };

  5617. 

  5618.         Type type;

  5619.         LV2UI_Handle handle;

  5620.         LV2UI_Widget widget;

  5621.         const LV2UI_Descriptor* descriptor;

  5622.         const LV2_RDF_UI*       rdfDescriptor;

  5623. 

  5624.         CarlaPluginUI* window;

  5625. 

  5626.         UI()

  5627.             : type(TYPE_NULL),

  5628.               handle(nullptr),

  5629.               widget(nullptr),

  5630.               descriptor(nullptr),

  5631.               rdfDescriptor(nullptr),

  5632.               window(nullptr) {}

  5633. 

  5634.         ~UI()

  5635.         {

  5636.             CARLA_ASSERT(handle == nullptr);

  5637.             CARLA_ASSERT(widget == nullptr);

  5638.             CARLA_ASSERT(descriptor == nullptr);

  5639.             CARLA_ASSERT(rdfDescriptor == nullptr);

  5640.             CARLA_ASSERT(window == nullptr);

  5641.         }

  5642. 

  5643.         CARLA_DECLARE_NON_COPY_STRUCT(UI);

  5644.     } fUI;

  5645. 

  5646.     // -------------------------------------------------------------------

  5647.     // Event Feature

  5648. 

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

  5650.     {

  5651.         CARLA_SAFE_ASSERT_RETURN(callback_data != nullptr, 0);

  5652.         CARLA_SAFE_ASSERT_RETURN(event != nullptr, 0);

  5653.         carla_debug("carla_lv2_event_ref(%p, %p)", callback_data, event);

  5654. 

  5655.         return 0;

  5656.     }

  5657. 

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

  5659.     {

  5660.         CARLA_SAFE_ASSERT_RETURN(callback_data != nullptr, 0);

  5661.         CARLA_SAFE_ASSERT_RETURN(event != nullptr, 0);

  5662.         carla_debug("carla_lv2_event_unref(%p, %p)", callback_data, event);

  5663. 

  5664.         return 0;

  5665.     }

  5666. 

  5667.     // -------------------------------------------------------------------

  5668.     // Logs Feature

  5669. 

  5670.     static int carla_lv2_log_printf(LV2_Log_Handle handle, LV2_URID type, const char* fmt, ...)

  5671.     {

  5672.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr, 0);

  5673.         CARLA_SAFE_ASSERT_RETURN(type != CARLA_URI_MAP_ID_NULL, 0);

  5674.         CARLA_SAFE_ASSERT_RETURN(fmt != nullptr, 0);

  5675. 

  5676. #ifndef DEBUG

  5677.         if (type == CARLA_URI_MAP_ID_LOG_TRACE)

  5678.             return 0;

  5679. #endif

  5680. 

  5681.         va_list args;

  5682.         va_start(args, fmt);

  5683.         const int ret(carla_lv2_log_vprintf(handle, type, fmt, args));

  5684.         va_end(args);

  5685. 

  5686.         return ret;

  5687.     }

  5688. 

  5689.     static int carla_lv2_log_vprintf(LV2_Log_Handle handle, LV2_URID type, const char* fmt, va_list ap)

  5690.     {

  5691.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr, 0);

  5692.         CARLA_SAFE_ASSERT_RETURN(type != CARLA_URI_MAP_ID_NULL, 0);

  5693.         CARLA_SAFE_ASSERT_RETURN(fmt != nullptr, 0);

  5694. 

  5695. #ifndef DEBUG

  5696.         if (type == CARLA_URI_MAP_ID_LOG_TRACE)

  5697.             return 0;

  5698. #endif

  5699. 

  5700.         int ret = 0;

  5701. 

  5702.         switch (type)

  5703.         {

  5704.         case CARLA_URI_MAP_ID_LOG_ERROR:

  5705.             std::fprintf(stderr, "\x1b[31m");

  5706.             ret = std::vfprintf(stderr, fmt, ap);

  5707.             std::fprintf(stderr, "\x1b[0m");

  5708.             break;

  5709. 

  5710.         case CARLA_URI_MAP_ID_LOG_NOTE:

  5711.             ret = std::vfprintf(stdout, fmt, ap);

  5712.             break;

  5713. 

  5714.         case CARLA_URI_MAP_ID_LOG_TRACE:

  5715. #ifdef DEBUG

  5716.             std::fprintf(stdout, "\x1b[30;1m");

  5717.             ret = std::vfprintf(stdout, fmt, ap);

  5718.             std::fprintf(stdout, "\x1b[0m");

  5719. #endif

  5720.             break;

  5721. 

  5722.         case CARLA_URI_MAP_ID_LOG_WARNING:

  5723.             ret = std::vfprintf(stderr, fmt, ap);

  5724.             break;

  5725. 

  5726.         default:

  5727.             break;

  5728.         }

  5729. 

  5730.         return ret;

  5731.     }

  5732. 

  5733.     // -------------------------------------------------------------------

  5734.     // Programs Feature

  5735. 

  5736.     static void carla_lv2_program_changed(LV2_Programs_Handle handle, int32_t index)

  5737.     {

  5738.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

  5739.         carla_debug("carla_lv2_program_changed(%p, %i)", handle, index);

  5740. 

  5741.         ((CarlaPluginLV2*)handle)->handleProgramChanged(index);

  5742.     }

  5743. 

  5744.     // -------------------------------------------------------------------

  5745.     // Resize Port Feature

  5746. 

  5747.     static LV2_Resize_Port_Status carla_lv2_resize_port(LV2_Resize_Port_Feature_Data data, uint32_t index, size_t size)

  5748.     {

  5749.         CARLA_SAFE_ASSERT_RETURN(data != nullptr, LV2_RESIZE_PORT_ERR_UNKNOWN);

  5750.         carla_debug("carla_lv2_program_changed(%p, %i, " P_SIZE ")", data, index, size);

  5751. 

  5752.         return ((CarlaPluginLV2*)data)->handleResizePort(index, size);

  5753.     }

  5754. 

  5755.     // -------------------------------------------------------------------

  5756.     // State Feature

  5757. 

  5758.     static char* carla_lv2_state_make_path(LV2_State_Make_Path_Handle handle, const char* path)

  5759.     {

  5760.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr, nullptr);

  5761.         CARLA_SAFE_ASSERT_RETURN(path != nullptr && path[0] != '\0', nullptr);

  5762.         carla_debug("carla_lv2_state_make_path(%p, \"%s\")", handle, path);

  5763. 

  5764.         File file;

  5765. 

  5766.         if (File::isAbsolutePath(path))

  5767.             file = File(path);

  5768.         else

  5769.             file = File::getCurrentWorkingDirectory().getChildFile(path);

  5770. 

  5771.         file.getParentDirectory().createDirectory();

  5772. 

  5773.         return strdup(file.getFullPathName().toRawUTF8());

  5774.     }

  5775. 

  5776.     static char* carla_lv2_state_map_abstract_path(LV2_State_Map_Path_Handle handle, const char* absolute_path)

  5777.     {

  5778.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr, strdup(""));

  5779.         CARLA_SAFE_ASSERT_RETURN(absolute_path != nullptr && absolute_path[0] != '\0', strdup(""));

  5780.         carla_debug("carla_lv2_state_map_abstract_path(%p, \"%s\")", handle, absolute_path);

  5781. 

  5782.         // may already be an abstract path

  5783.         if (! File::isAbsolutePath(absolute_path))

  5784.             return strdup(absolute_path);

  5785. 

  5786.         return strdup(File(absolute_path).getRelativePathFrom(File::getCurrentWorkingDirectory()).toRawUTF8());

  5787.     }

  5788. 

  5789.     static char* carla_lv2_state_map_absolute_path(LV2_State_Map_Path_Handle handle, const char* abstract_path)

  5790.     {

  5791.         const char* const cwd(File::getCurrentWorkingDirectory().getFullPathName().toRawUTF8());

  5792.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr, strdup(cwd));

  5793.         CARLA_SAFE_ASSERT_RETURN(abstract_path != nullptr && abstract_path[0] != '\0', strdup(cwd));

  5794.         carla_debug("carla_lv2_state_map_absolute_path(%p, \"%s\")", handle, abstract_path);

  5795. 

  5796.         // may already be an absolute path

  5797.         if (File::isAbsolutePath(abstract_path))

  5798.             return strdup(abstract_path);

  5799. 

  5800.         return strdup(File::getCurrentWorkingDirectory().getChildFile(abstract_path).getFullPathName().toRawUTF8());

  5801.     }

  5802. 

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

  5804.     {

  5805.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr, LV2_STATE_ERR_UNKNOWN);

  5806.         carla_debug("carla_lv2_state_store(%p, %i, %p, " P_SIZE ", %i, %i)", handle, key, value, size, type, flags);

  5807. 

  5808.         return ((CarlaPluginLV2*)handle)->handleStateStore(key, value, size, type, flags);

  5809.     }

  5810. 

  5811.     static const void* carla_lv2_state_retrieve(LV2_State_Handle handle, uint32_t key, size_t* size, uint32_t* type, uint32_t* flags)

  5812.     {

  5813.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr, nullptr);

  5814.         carla_debug("carla_lv2_state_retrieve(%p, %i, %p, %p, %p)", handle, key, size, type, flags);

  5815. 

  5816.         return ((CarlaPluginLV2*)handle)->handleStateRetrieve(key, size, type, flags);

  5817.     }

  5818. 

  5819.     // -------------------------------------------------------------------

  5820.     // URI-Map Feature

  5821. 

  5822.     static uint32_t carla_lv2_uri_to_id(LV2_URI_Map_Callback_Data data, const char* map, const char* uri)

  5823.     {

  5824.         carla_debug("carla_lv2_uri_to_id(%p, \"%s\", \"%s\")", data, map, uri);

  5825.         return carla_lv2_urid_map((LV2_URID_Map_Handle*)data, uri);

  5826. 

  5827.         // unused

  5828.         (void)map;

  5829.     }

  5830. 

  5831.     // -------------------------------------------------------------------

  5832.     // URID Feature

  5833. 

  5834.     static LV2_URID carla_lv2_urid_map(LV2_URID_Map_Handle handle, const char* uri)

  5835.     {

  5836.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr, CARLA_URI_MAP_ID_NULL);

  5837.         CARLA_SAFE_ASSERT_RETURN(uri != nullptr && uri[0] != '\0', CARLA_URI_MAP_ID_NULL);

  5838.         carla_debug("carla_lv2_urid_map(%p, \"%s\")", handle, uri);

  5839. 

  5840.         // Atom types

  5841.         if (std::strcmp(uri, LV2_ATOM__Blank) == 0)

  5842.             return CARLA_URI_MAP_ID_ATOM_BLANK;

  5843.         if (std::strcmp(uri, LV2_ATOM__Bool) == 0)

  5844.             return CARLA_URI_MAP_ID_ATOM_BOOL;

  5845.         if (std::strcmp(uri, LV2_ATOM__Chunk) == 0)

  5846.             return CARLA_URI_MAP_ID_ATOM_CHUNK;

  5847.         if (std::strcmp(uri, LV2_ATOM__Double) == 0)

  5848.             return CARLA_URI_MAP_ID_ATOM_DOUBLE;

  5849.         if (std::strcmp(uri, LV2_ATOM__Event) == 0)

  5850.             return CARLA_URI_MAP_ID_ATOM_EVENT;

  5851.         if (std::strcmp(uri, LV2_ATOM__Float) == 0)

  5852.             return CARLA_URI_MAP_ID_ATOM_FLOAT;

  5853.         if (std::strcmp(uri, LV2_ATOM__Int) == 0)

  5854.             return CARLA_URI_MAP_ID_ATOM_INT;

  5855.         if (std::strcmp(uri, LV2_ATOM__Literal) == 0)

  5856.             return CARLA_URI_MAP_ID_ATOM_LITERAL;

  5857.         if (std::strcmp(uri, LV2_ATOM__Long) == 0)

  5858.             return CARLA_URI_MAP_ID_ATOM_LONG;

  5859.         if (std::strcmp(uri, LV2_ATOM__Number) == 0)

  5860.             return CARLA_URI_MAP_ID_ATOM_NUMBER;

  5861.         if (std::strcmp(uri, LV2_ATOM__Object) == 0)

  5862.             return CARLA_URI_MAP_ID_ATOM_OBJECT;

  5863.         if (std::strcmp(uri, LV2_ATOM__Path) == 0)

  5864.             return CARLA_URI_MAP_ID_ATOM_PATH;

  5865.         if (std::strcmp(uri, LV2_ATOM__Property) == 0)

  5866.             return CARLA_URI_MAP_ID_ATOM_PROPERTY;

  5867.         if (std::strcmp(uri, LV2_ATOM__Resource) == 0)

  5868.             return CARLA_URI_MAP_ID_ATOM_RESOURCE;

  5869.         if (std::strcmp(uri, LV2_ATOM__Sequence) == 0)

  5870.             return CARLA_URI_MAP_ID_ATOM_SEQUENCE;

  5871.         if (std::strcmp(uri, LV2_ATOM__Sound) == 0)

  5872.             return CARLA_URI_MAP_ID_ATOM_SOUND;

  5873.         if (std::strcmp(uri, LV2_ATOM__String) == 0)

  5874.             return CARLA_URI_MAP_ID_ATOM_STRING;

  5875.         if (std::strcmp(uri, LV2_ATOM__Tuple) == 0)

  5876.             return CARLA_URI_MAP_ID_ATOM_TUPLE;

  5877.         if (std::strcmp(uri, LV2_ATOM__URI) == 0)

  5878.             return CARLA_URI_MAP_ID_ATOM_URI;

  5879.         if (std::strcmp(uri, LV2_ATOM__URID) == 0)

  5880.             return CARLA_URI_MAP_ID_ATOM_URID;

  5881.         if (std::strcmp(uri, LV2_ATOM__Vector) == 0)

  5882.             return CARLA_URI_MAP_ID_ATOM_VECTOR;

  5883.         if (std::strcmp(uri, LV2_ATOM__atomTransfer) == 0)

  5884.             return CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM;

  5885.         if (std::strcmp(uri, LV2_ATOM__eventTransfer) == 0)

  5886.             return CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT;

  5887. 

  5888.         // BufSize types

  5889.         if (std::strcmp(uri, LV2_BUF_SIZE__maxBlockLength) == 0)

  5890.             return CARLA_URI_MAP_ID_BUF_MAX_LENGTH;

  5891.         if (std::strcmp(uri, LV2_BUF_SIZE__minBlockLength) == 0)

  5892.             return CARLA_URI_MAP_ID_BUF_MIN_LENGTH;

  5893.         if (std::strcmp(uri, LV2_BUF_SIZE__nominalBlockLength) == 0)

  5894.             return CARLA_URI_MAP_ID_BUF_NOMINAL_LENGTH;

  5895.         if (std::strcmp(uri, LV2_BUF_SIZE__sequenceSize) == 0)

  5896.             return CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE;

  5897. 

  5898.         // Log types

  5899.         if (std::strcmp(uri, LV2_LOG__Error) == 0)

  5900.             return CARLA_URI_MAP_ID_LOG_ERROR;

  5901.         if (std::strcmp(uri, LV2_LOG__Note) == 0)

  5902.             return CARLA_URI_MAP_ID_LOG_NOTE;

  5903.         if (std::strcmp(uri, LV2_LOG__Trace) == 0)

  5904.             return CARLA_URI_MAP_ID_LOG_TRACE;

  5905.         if (std::strcmp(uri, LV2_LOG__Warning) == 0)

  5906.             return CARLA_URI_MAP_ID_LOG_WARNING;

  5907. 

  5908.         // Time types

  5909.         if (std::strcmp(uri, LV2_TIME__Position) == 0)

  5910.             return CARLA_URI_MAP_ID_TIME_POSITION;

  5911.         if (std::strcmp(uri, LV2_TIME__bar) == 0)

  5912.             return CARLA_URI_MAP_ID_TIME_BAR;

  5913.         if (std::strcmp(uri, LV2_TIME__barBeat) == 0)

  5914.             return CARLA_URI_MAP_ID_TIME_BAR_BEAT;

  5915.         if (std::strcmp(uri, LV2_TIME__beat) == 0)

  5916.             return CARLA_URI_MAP_ID_TIME_BEAT;

  5917.         if (std::strcmp(uri, LV2_TIME__beatUnit) == 0)

  5918.             return CARLA_URI_MAP_ID_TIME_BEAT_UNIT;

  5919.         if (std::strcmp(uri, LV2_TIME__beatsPerBar) == 0)

  5920.             return CARLA_URI_MAP_ID_TIME_BEATS_PER_BAR;

  5921.         if (std::strcmp(uri, LV2_TIME__beatsPerMinute) == 0)

  5922.             return CARLA_URI_MAP_ID_TIME_BEATS_PER_MINUTE;

  5923.         if (std::strcmp(uri, LV2_TIME__frame) == 0)

  5924.             return CARLA_URI_MAP_ID_TIME_FRAME;

  5925.         if (std::strcmp(uri, LV2_TIME__framesPerSecond) == 0)

  5926.             return CARLA_URI_MAP_ID_TIME_FRAMES_PER_SECOND;

  5927.         if (std::strcmp(uri, LV2_TIME__speed) == 0)

  5928.             return CARLA_URI_MAP_ID_TIME_SPEED;

  5929.         if (std::strcmp(uri, LV2_KXSTUDIO_PROPERTIES__TimePositionTicksPerBeat) == 0)

  5930.             return CARLA_URI_MAP_ID_TIME_TICKS_PER_BEAT;

  5931. 

  5932.         // Others

  5933.         if (std::strcmp(uri, LV2_MIDI__MidiEvent) == 0)

  5934.             return CARLA_URI_MAP_ID_MIDI_EVENT;

  5935.         if (std::strcmp(uri, LV2_PARAMETERS__sampleRate) == 0)

  5936.             return CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE;

  5937.         if (std::strcmp(uri, LV2_UI__windowTitle) == 0)

  5938.             return CARLA_URI_MAP_ID_UI_WINDOW_TITLE;

  5939. 

  5940.         // Custom

  5941.         if (std::strcmp(uri, LV2_KXSTUDIO_PROPERTIES__TransientWindowId) == 0)

  5942.             return CARLA_URI_MAP_ID_CARLA_TRANSIENT_WIN_ID;

  5943.         if (std::strcmp(uri, URI_CARLA_ATOM_WORKER) == 0)

  5944.             return CARLA_URI_MAP_ID_CARLA_ATOM_WORKER;

  5945. 

  5946.         // Custom types

  5947.         return ((CarlaPluginLV2*)handle)->getCustomURID(uri);

  5948.     }

  5949. 

  5950.     static const char* carla_lv2_urid_unmap(LV2_URID_Map_Handle handle, LV2_URID urid)

  5951.     {

  5952.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr, nullptr);

  5953.         CARLA_SAFE_ASSERT_RETURN(urid != CARLA_URI_MAP_ID_NULL, nullptr);

  5954.         carla_debug("carla_lv2_urid_unmap(%p, %i)", handle, urid);

  5955. 

  5956.         // Atom types

  5957.         if (urid == CARLA_URI_MAP_ID_ATOM_BLANK)

  5958.             return LV2_ATOM__Blank;

  5959.         if (urid == CARLA_URI_MAP_ID_ATOM_BOOL)

  5960.             return LV2_ATOM__Bool;

  5961.         if (urid == CARLA_URI_MAP_ID_ATOM_CHUNK)

  5962.             return LV2_ATOM__Chunk;

  5963.         if (urid == CARLA_URI_MAP_ID_ATOM_DOUBLE)

  5964.             return LV2_ATOM__Double;

  5965.         if (urid == CARLA_URI_MAP_ID_ATOM_EVENT)

  5966.             return LV2_ATOM__Event;

  5967.         if (urid == CARLA_URI_MAP_ID_ATOM_FLOAT)

  5968.             return LV2_ATOM__Float;

  5969.         if (urid == CARLA_URI_MAP_ID_ATOM_INT)

  5970.             return LV2_ATOM__Int;

  5971.         if (urid == CARLA_URI_MAP_ID_ATOM_LITERAL)

  5972.             return LV2_ATOM__Literal;

  5973.         if (urid == CARLA_URI_MAP_ID_ATOM_LONG)

  5974.             return LV2_ATOM__Long;

  5975.         if (urid == CARLA_URI_MAP_ID_ATOM_NUMBER)

  5976.             return LV2_ATOM__Number;

  5977.         if (urid == CARLA_URI_MAP_ID_ATOM_OBJECT)

  5978.             return LV2_ATOM__Object;

  5979.         if (urid == CARLA_URI_MAP_ID_ATOM_PATH)

  5980.             return LV2_ATOM__Path;

  5981.         if (urid == CARLA_URI_MAP_ID_ATOM_PROPERTY)

  5982.             return LV2_ATOM__Property;

  5983.         if (urid == CARLA_URI_MAP_ID_ATOM_RESOURCE)

  5984.             return LV2_ATOM__Resource;

  5985.         if (urid == CARLA_URI_MAP_ID_ATOM_SEQUENCE)

  5986.             return LV2_ATOM__Sequence;

  5987.         if (urid == CARLA_URI_MAP_ID_ATOM_SOUND)

  5988.             return LV2_ATOM__Sound;

  5989.         if (urid == CARLA_URI_MAP_ID_ATOM_STRING)

  5990.             return LV2_ATOM__String;

  5991.         if (urid == CARLA_URI_MAP_ID_ATOM_TUPLE)

  5992.             return LV2_ATOM__Tuple;

  5993.         if (urid == CARLA_URI_MAP_ID_ATOM_URI)

  5994.             return LV2_ATOM__URI;

  5995.         if (urid == CARLA_URI_MAP_ID_ATOM_URID)

  5996.             return LV2_ATOM__URID;

  5997.         if (urid == CARLA_URI_MAP_ID_ATOM_VECTOR)

  5998.             return LV2_ATOM__Vector;

  5999.         if (urid == CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM)

  6000.             return LV2_ATOM__atomTransfer;

  6001.         if (urid == CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT)

  6002.             return LV2_ATOM__eventTransfer;

  6003. 

  6004.         // BufSize types

  6005.         if (urid == CARLA_URI_MAP_ID_BUF_MAX_LENGTH)

  6006.             return LV2_BUF_SIZE__maxBlockLength;

  6007.         if (urid == CARLA_URI_MAP_ID_BUF_MIN_LENGTH)

  6008.             return LV2_BUF_SIZE__minBlockLength;

  6009.         if (urid == CARLA_URI_MAP_ID_BUF_NOMINAL_LENGTH)

  6010.             return LV2_BUF_SIZE__nominalBlockLength;

  6011.         if (urid == CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE)

  6012.             return LV2_BUF_SIZE__sequenceSize;

  6013. 

  6014.         // Log types

  6015.         if (urid == CARLA_URI_MAP_ID_LOG_ERROR)

  6016.             return LV2_LOG__Error;

  6017.         if (urid == CARLA_URI_MAP_ID_LOG_NOTE)

  6018.             return LV2_LOG__Note;

  6019.         if (urid == CARLA_URI_MAP_ID_LOG_TRACE)

  6020.             return LV2_LOG__Trace;

  6021.         if (urid == CARLA_URI_MAP_ID_LOG_WARNING)

  6022.             return LV2_LOG__Warning;

  6023. 

  6024.         // Time types

  6025.         if (urid == CARLA_URI_MAP_ID_TIME_POSITION)

  6026.             return LV2_TIME__Position;

  6027.         if (urid == CARLA_URI_MAP_ID_TIME_BAR)

  6028.             return LV2_TIME__bar;

  6029.         if (urid == CARLA_URI_MAP_ID_TIME_BAR_BEAT)

  6030.             return LV2_TIME__barBeat;

  6031.         if (urid == CARLA_URI_MAP_ID_TIME_BEAT)

  6032.             return LV2_TIME__beat;

  6033.         if (urid == CARLA_URI_MAP_ID_TIME_BEAT_UNIT)

  6034.             return LV2_TIME__beatUnit;

  6035.         if (urid == CARLA_URI_MAP_ID_TIME_BEATS_PER_BAR)

  6036.             return LV2_TIME__beatsPerBar;

  6037.         if (urid == CARLA_URI_MAP_ID_TIME_BEATS_PER_MINUTE)

  6038.             return LV2_TIME__beatsPerMinute;

  6039.         if (urid == CARLA_URI_MAP_ID_TIME_FRAME)

  6040.             return LV2_TIME__frame;

  6041.         if (urid == CARLA_URI_MAP_ID_TIME_FRAMES_PER_SECOND)

  6042.             return LV2_TIME__framesPerSecond;

  6043.         if (urid == CARLA_URI_MAP_ID_TIME_SPEED)

  6044.             return LV2_TIME__speed;

  6045.         if (urid == CARLA_URI_MAP_ID_TIME_TICKS_PER_BEAT)

  6046.             return LV2_KXSTUDIO_PROPERTIES__TimePositionTicksPerBeat;

  6047. 

  6048.         // Others

  6049.         if (urid == CARLA_URI_MAP_ID_MIDI_EVENT)

  6050.             return LV2_MIDI__MidiEvent;

  6051.         if (urid == CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE)

  6052.             return LV2_PARAMETERS__sampleRate;

  6053.         if (urid == CARLA_URI_MAP_ID_UI_WINDOW_TITLE)

  6054.             return LV2_UI__windowTitle;

  6055. 

  6056.         // Custom

  6057.         if (urid == CARLA_URI_MAP_ID_CARLA_ATOM_WORKER)

  6058.             return URI_CARLA_ATOM_WORKER;

  6059.         if (urid == CARLA_URI_MAP_ID_CARLA_TRANSIENT_WIN_ID)

  6060.             return LV2_KXSTUDIO_PROPERTIES__TransientWindowId;

  6061. 

  6062.         // Custom types

  6063.         return ((CarlaPluginLV2*)handle)->getCustomURIDString(urid);

  6064.     }

  6065. 

  6066.     // -------------------------------------------------------------------

  6067.     // Worker Feature

  6068. 

  6069.     static LV2_Worker_Status carla_lv2_worker_schedule(LV2_Worker_Schedule_Handle handle, uint32_t size, const void* data)

  6070.     {

  6071.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr, LV2_WORKER_ERR_UNKNOWN);

  6072.         carla_debug("carla_lv2_worker_schedule(%p, %i, %p)", handle, size, data);

  6073. 

  6074.         return ((CarlaPluginLV2*)handle)->handleWorkerSchedule(size, data);

  6075.     }

  6076. 

  6077.     static LV2_Worker_Status carla_lv2_worker_respond(LV2_Worker_Respond_Handle handle, uint32_t size, const void* data)

  6078.     {

  6079.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr, LV2_WORKER_ERR_UNKNOWN);

  6080.         carla_debug("carla_lv2_worker_respond(%p, %i, %p)", handle, size, data);

  6081. 

  6082.         return ((CarlaPluginLV2*)handle)->handleWorkerRespond(size, data);

  6083.     }

  6084. 

  6085.     // -------------------------------------------------------------------

  6086.     // External UI Feature

  6087. 

  6088.     static void carla_lv2_external_ui_closed(LV2UI_Controller controller)

  6089.     {

  6090.         CARLA_SAFE_ASSERT_RETURN(controller != nullptr,);

  6091.         carla_debug("carla_lv2_external_ui_closed(%p)", controller);

  6092. 

  6093.         ((CarlaPluginLV2*)controller)->handleExternalUIClosed();

  6094.     }

  6095. 

  6096.     // -------------------------------------------------------------------

  6097.     // UI Port-Map Feature

  6098. 

  6099.     static uint32_t carla_lv2_ui_port_map(LV2UI_Feature_Handle handle, const char* symbol)

  6100.     {

  6101.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr, LV2UI_INVALID_PORT_INDEX);

  6102.         carla_debug("carla_lv2_ui_port_map(%p, \"%s\")", handle, symbol);

  6103. 

  6104.         return ((CarlaPluginLV2*)handle)->handleUIPortMap(symbol);

  6105.     }

  6106. 

  6107.     // -------------------------------------------------------------------

  6108.     // UI Resize Feature

  6109. 

  6110.     static int carla_lv2_ui_resize(LV2UI_Feature_Handle handle, int width, int height)

  6111.     {

  6112.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr, 1);

  6113.         carla_debug("carla_lv2_ui_resize(%p, %i, %i)", handle, width, height);

  6114. 

  6115.         return ((CarlaPluginLV2*)handle)->handleUIResize(width, height);

  6116.     }

  6117. 

  6118.     // -------------------------------------------------------------------

  6119.     // UI Extension

  6120. 

  6121.     static void carla_lv2_ui_write_function(LV2UI_Controller controller, uint32_t port_index, uint32_t buffer_size, uint32_t format, const void* buffer)

  6122.     {

  6123.         CARLA_SAFE_ASSERT_RETURN(controller != nullptr,);

  6124.         carla_debug("carla_lv2_ui_write_function(%p, %i, %i, %i, %p)", controller, port_index, buffer_size, format, buffer);

  6125. 

  6126.         ((CarlaPluginLV2*)controller)->handleUIWrite(port_index, buffer_size, format, buffer);

  6127.     }

  6128. 

  6129.     // -------------------------------------------------------------------

  6130.     // Lilv State

  6131. 

  6132.     static void carla_lilv_set_port_value(const char* port_symbol, void* user_data, const void* value, uint32_t size, uint32_t type)

  6133.     {

  6134.         CARLA_SAFE_ASSERT_RETURN(user_data != nullptr,);

  6135.         carla_debug("carla_lilv_set_port_value(\"%s\", %p, %p, %i, %i", port_symbol, user_data, value, size, type);

  6136. 

  6137.         ((CarlaPluginLV2*)user_data)->handleLilvSetPortValue(port_symbol, value, size, type);

  6138.     }

  6139. 

  6140.     // -------------------------------------------------------------------

  6141. 

  6142.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaPluginLV2)

  6143. };

  6144. 

  6145. // -------------------------------------------------------------------------------------------------------------------

  6146. 

  6147. bool CarlaPipeServerLV2::msgReceived(const char* const msg) noexcept

  6148. {

  6149.     if (std::strcmp(msg, "exiting") == 0)

  6150.     {

  6151.         closePipeServer();

  6152.         fUiState = UiHide;

  6153.         return true;

  6154.     }

  6155. 

  6156.     if (std::strcmp(msg, "control") == 0)

  6157.     {

  6158.         uint32_t index;

  6159.         float value;

  6160. 

  6161.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(index), true);

  6162.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsFloat(value), true);

  6163. 

  6164.         try {

  6165.             kPlugin->handleUIWrite(index, sizeof(float), CARLA_URI_MAP_ID_NULL, &value);

  6166.         } CARLA_SAFE_EXCEPTION("magReceived control");

  6167. 

  6168.         return true;

  6169.     }

  6170. 

  6171.     if (std::strcmp(msg, "atom") == 0)

  6172.     {

  6173.         uint32_t index, size;

  6174.         const char* base64atom;

  6175. 

  6176.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(index), true);

  6177.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(size), true);

  6178.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(base64atom), true);

  6179. 

  6180.         std::vector<uint8_t> chunk(carla_getChunkFromBase64String(base64atom));

  6181.         delete[] base64atom;

  6182.         CARLA_SAFE_ASSERT_RETURN(chunk.size() >= sizeof(LV2_Atom), true);

  6183. 

  6184.         const LV2_Atom* const atom((const LV2_Atom*)chunk.data());

  6185.         CARLA_SAFE_ASSERT_RETURN(lv2_atom_total_size(atom) == chunk.size(), true);

  6186. 

  6187.         try {

  6188.             kPlugin->handleUIWrite(index, lv2_atom_total_size(atom), CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT, atom);

  6189.         } CARLA_SAFE_EXCEPTION("magReceived atom");

  6190. 

  6191.         return true;

  6192.     }

  6193. 

  6194.     if (std::strcmp(msg, "program") == 0)

  6195.     {

  6196.         uint32_t index;

  6197. 

  6198.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(index), true);

  6199. 

  6200.         try {

  6201.             kPlugin->setMidiProgram(static_cast<int32_t>(index), false, true, true);

  6202.         } CARLA_SAFE_EXCEPTION("msgReceived program");

  6203. 

  6204.         return true;

  6205.     }

  6206. 

  6207.     if (std::strcmp(msg, "urid") == 0)

  6208.     {

  6209.         uint32_t urid;

  6210.         const char* uri;

  6211. 

  6212.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(urid), true);

  6213.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(uri), true);

  6214. 

  6215.         if (urid != 0)

  6216.         {

  6217.             try {

  6218.                 kPlugin->handleUridMap(urid, uri);

  6219.             } CARLA_SAFE_EXCEPTION("msgReceived urid");

  6220.         }

  6221. 

  6222.         delete[] uri;

  6223.         return true;

  6224.     }

  6225. 

  6226.     return false;

  6227. }

  6228. 

  6229. // -------------------------------------------------------------------------------------------------------------------

  6230. 

  6231. CarlaPlugin* CarlaPlugin::newLV2(const Initializer& init)

  6232. {

  6233.     carla_debug("CarlaPlugin::newLV2({%p, \"%s\", \"%s\", " P_INT64 "})", init.engine, init.name, init.label, init.uniqueId);

  6234. 

  6235.     CarlaPluginLV2* const plugin(new CarlaPluginLV2(init.engine, init.id));

  6236. 

  6237.     if (! plugin->init(init.name, init.label, init.options))

  6238.     {

  6239.         delete plugin;

  6240.         return nullptr;

  6241.     }

  6242. 

  6243.     return plugin;

  6244. }

  6245. 

  6246. // -------------------------------------------------------------------------------------------------------------------

  6247. 

  6248. CARLA_BACKEND_END_NAMESPACE