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.
2843 Commits
16 Branches
16GB
Tree: eafdc0362d
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'eafdc0362d'
${ noResults }
Carla/source/backend/plugin/CarlaPluginLV2.cpp

6190 lines
232KB
Raw Blame History 

  1. /*

  2.  * Carla LV2 Plugin

  3.  * Copyright (C) 2011-2014 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. 

  35. extern "C" {

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

  37. }

  38. 

  39. #include "juce_core.h"

  40. 

  41. using juce::File;

  42. 

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

  44. 

  45. CARLA_BACKEND_START_NAMESPACE

  46. 

  47. // -----------------------------------------------------

  48. 

  49. // Maximum default buffer size

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

  51. 

  52. // Extra Plugin Hints

  53. const uint PLUGIN_HAS_EXTENSION_OPTIONS  = 0x1000;

  54. const uint PLUGIN_HAS_EXTENSION_PROGRAMS = 0x2000;

  55. const uint PLUGIN_HAS_EXTENSION_STATE    = 0x4000;

  56. const uint PLUGIN_HAS_EXTENSION_WORKER   = 0x8000;

  57. 

  58. // Extra Parameter Hints

  59. const uint PARAMETER_IS_STRICT_BOUNDS = 0x1000;

  60. const uint PARAMETER_IS_TRIGGER       = 0x2000;

  61. 

  62. // LV2 Event Data/Types

  63. const uint CARLA_EVENT_DATA_ATOM    = 0x01;

  64. const uint CARLA_EVENT_DATA_EVENT   = 0x02;

  65. const uint CARLA_EVENT_DATA_MIDI_LL = 0x04;

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

  67. const uint CARLA_EVENT_TYPE_MIDI    = 0x20;

  68. const uint CARLA_EVENT_TYPE_TIME    = 0x40;

  69. 

  70. // LV2 URI Map Ids

  71. const uint32_t CARLA_URI_MAP_ID_NULL                   =  0;

  72. const uint32_t CARLA_URI_MAP_ID_ATOM_BLANK             =  1;

  73. const uint32_t CARLA_URI_MAP_ID_ATOM_BOOL              =  2;

  74. const uint32_t CARLA_URI_MAP_ID_ATOM_CHUNK             =  3;

  75. const uint32_t CARLA_URI_MAP_ID_ATOM_DOUBLE            =  4;

  76. const uint32_t CARLA_URI_MAP_ID_ATOM_EVENT             =  5;

  77. const uint32_t CARLA_URI_MAP_ID_ATOM_FLOAT             =  6;

  78. const uint32_t CARLA_URI_MAP_ID_ATOM_INT               =  7;

  79. const uint32_t CARLA_URI_MAP_ID_ATOM_LITERAL           =  8;

  80. const uint32_t CARLA_URI_MAP_ID_ATOM_LONG              =  9;

  81. const uint32_t CARLA_URI_MAP_ID_ATOM_NUMBER            = 10;

  82. const uint32_t CARLA_URI_MAP_ID_ATOM_OBJECT            = 11;

  83. const uint32_t CARLA_URI_MAP_ID_ATOM_PATH              = 12;

  84. const uint32_t CARLA_URI_MAP_ID_ATOM_PROPERTY          = 13;

  85. const uint32_t CARLA_URI_MAP_ID_ATOM_RESOURCE          = 14;

  86. const uint32_t CARLA_URI_MAP_ID_ATOM_SEQUENCE          = 15;

  87. const uint32_t CARLA_URI_MAP_ID_ATOM_SOUND             = 16;

  88. const uint32_t CARLA_URI_MAP_ID_ATOM_STRING            = 17;

  89. const uint32_t CARLA_URI_MAP_ID_ATOM_TUPLE             = 18;

  90. const uint32_t CARLA_URI_MAP_ID_ATOM_URI               = 19;

  91. const uint32_t CARLA_URI_MAP_ID_ATOM_URID              = 20;

  92. const uint32_t CARLA_URI_MAP_ID_ATOM_VECTOR            = 21;

  93. const uint32_t CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM     = 22;

  94. const uint32_t CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT    = 23;

  95. const uint32_t CARLA_URI_MAP_ID_BUF_MAX_LENGTH         = 24;

  96. const uint32_t CARLA_URI_MAP_ID_BUF_MIN_LENGTH         = 25;

  97. const uint32_t CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE      = 26;

  98. const uint32_t CARLA_URI_MAP_ID_LOG_ERROR              = 27;

  99. const uint32_t CARLA_URI_MAP_ID_LOG_NOTE               = 28;

  100. const uint32_t CARLA_URI_MAP_ID_LOG_TRACE              = 29;

  101. const uint32_t CARLA_URI_MAP_ID_LOG_WARNING            = 30;

  102. const uint32_t CARLA_URI_MAP_ID_TIME_POSITION          = 31; // base type

  103. const uint32_t CARLA_URI_MAP_ID_TIME_BAR               = 32; // values

  104. const uint32_t CARLA_URI_MAP_ID_TIME_BAR_BEAT          = 33;

  105. const uint32_t CARLA_URI_MAP_ID_TIME_BEAT              = 34;

  106. const uint32_t CARLA_URI_MAP_ID_TIME_BEAT_UNIT         = 35;

  107. const uint32_t CARLA_URI_MAP_ID_TIME_BEATS_PER_BAR     = 36;

  108. const uint32_t CARLA_URI_MAP_ID_TIME_BEATS_PER_MINUTE  = 37;

  109. const uint32_t CARLA_URI_MAP_ID_TIME_FRAME             = 38;

  110. const uint32_t CARLA_URI_MAP_ID_TIME_FRAMES_PER_SECOND = 39;

  111. const uint32_t CARLA_URI_MAP_ID_TIME_SPEED             = 40;

  112. const uint32_t CARLA_URI_MAP_ID_TIME_TICKS_PER_BEAT    = 41;

  113. const uint32_t CARLA_URI_MAP_ID_MIDI_EVENT             = 42;

  114. const uint32_t CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE      = 43;

  115. const uint32_t CARLA_URI_MAP_ID_UI_WINDOW_TITLE        = 44;

  116. const uint32_t CARLA_URI_MAP_ID_CARLA_ATOM_WORKER      = 45;

  117. const uint32_t CARLA_URI_MAP_ID_CARLA_TRANSIENT_WIN_ID = 46;

  118. const uint32_t CARLA_URI_MAP_ID_COUNT                  = 47;

  119. 

  120. // LV2 Feature Ids

  121. const uint32_t kFeatureIdBufSizeBounded   =  0;

  122. const uint32_t kFeatureIdBufSizeFixed     =  1;

  123. const uint32_t kFeatureIdBufSizePowerOf2  =  2;

  124. const uint32_t kFeatureIdEvent            =  3;

  125. const uint32_t kFeatureIdHardRtCapable    =  4;

  126. const uint32_t kFeatureIdInPlaceBroken    =  5;

  127. const uint32_t kFeatureIdIsLive           =  6;

  128. const uint32_t kFeatureIdLogs             =  7;

  129. const uint32_t kFeatureIdOptions          =  8;

  130. const uint32_t kFeatureIdPrograms         =  9;

  131. const uint32_t kFeatureIdResizePort       = 10;

  132. const uint32_t kFeatureIdRtMemPool        = 11;

  133. const uint32_t kFeatureIdRtMemPoolOld     = 12;

  134. const uint32_t kFeatureIdStateMakePath    = 13;

  135. const uint32_t kFeatureIdStateMapPath     = 14;

  136. const uint32_t kFeatureIdStrictBounds     = 15;

  137. const uint32_t kFeatureIdUriMap           = 16;

  138. const uint32_t kFeatureIdUridMap          = 17;

  139. const uint32_t kFeatureIdUridUnmap        = 18;

  140. const uint32_t kFeatureIdWorker           = 19;

  141. const uint32_t kFeatureCountPlugin        = 20;

  142. const uint32_t kFeatureIdUiDataAccess     = 20;

  143. const uint32_t kFeatureIdUiInstanceAccess = 21;

  144. const uint32_t kFeatureIdUiIdleInterface  = 22;

  145. const uint32_t kFeatureIdUiFixedSize      = 23;

  146. const uint32_t kFeatureIdUiMakeResident   = 24;

  147. const uint32_t kFeatureIdUiNoUserResize   = 25;

  148. const uint32_t kFeatureIdUiParent         = 26;

  149. const uint32_t kFeatureIdUiPortMap        = 27;

  150. const uint32_t kFeatureIdUiPortSubscribe  = 28;

  151. const uint32_t kFeatureIdUiResize         = 29;

  152. const uint32_t kFeatureIdUiTouch          = 30;

  153. const uint32_t kFeatureIdExternalUi       = 31;

  154. const uint32_t kFeatureIdExternalUiOld    = 32;

  155. const uint32_t kFeatureCountAll           = 33;

  156. 

  157. // -----------------------------------------------------

  158. 

  159. struct Lv2EventData {

  160.     uint32_t type;

  161.     uint32_t rindex;

  162.     CarlaEngineEventPort* port;

  163. 

  164.     union {

  165.         LV2_Atom_Buffer* atom;

  166.         LV2_Event_Buffer* event;

  167.         LV2_MIDI midi;

  168.     };

  169. 

  170.     Lv2EventData() noexcept

  171.         : type(0x0),

  172.           rindex(0),

  173.           port(nullptr) {}

  174. 

  175.     ~Lv2EventData() noexcept

  176.     {

  177.         if (port != nullptr)

  178.         {

  179.             delete port;

  180.             port = nullptr;

  181.         }

  182. 

  183.         const uint32_t rtype(type);

  184.         type = 0x0;

  185. 

  186.         if (rtype & CARLA_EVENT_DATA_ATOM)

  187.         {

  188.             CARLA_SAFE_ASSERT_RETURN(atom != nullptr,);

  189. 

  190.             std::free(atom);

  191.             atom = nullptr;

  192.         }

  193.         else if (rtype & CARLA_EVENT_DATA_EVENT)

  194.         {

  195.             CARLA_SAFE_ASSERT_RETURN(event != nullptr,);

  196. 

  197.             std::free(event);

  198.             event = nullptr;

  199.         }

  200.         else if (rtype & CARLA_EVENT_DATA_MIDI_LL)

  201.         {

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

  203. 

  204.             delete[] midi.data;

  205.             midi.data = nullptr;

  206.         }

  207.     }

  208. 

  209.     CARLA_DECLARE_NON_COPY_STRUCT(Lv2EventData)

  210. };

  211. 

  212. struct CarlaPluginLV2EventData {

  213.     uint32_t count;

  214.     Lv2EventData* data;

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

  216.     uint32_t ctrlIndex;

  217. 

  218.     CarlaPluginLV2EventData() noexcept

  219.         : count(0),

  220.           data(nullptr),

  221.           ctrl(nullptr),

  222.           ctrlIndex(0) {}

  223. 

  224.     ~CarlaPluginLV2EventData() noexcept

  225.     {

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

  227.         CARLA_SAFE_ASSERT(data == nullptr);

  228.         CARLA_SAFE_ASSERT(ctrl == nullptr);

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

  230.     }

  231. 

  232.     void createNew(const uint32_t newCount)

  233.     {

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

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

  236.         CARLA_SAFE_ASSERT_RETURN(data == nullptr,);

  237.         CARLA_SAFE_ASSERT_RETURN(ctrl == nullptr,);

  238.         CARLA_SAFE_ASSERT_RETURN(newCount > 0,);

  239. 

  240.         data  = new Lv2EventData[newCount];

  241.         count = newCount;

  242. 

  243.         ctrl      = nullptr;

  244.         ctrlIndex = 0;

  245.     }

  246. 

  247.     void clear() noexcept

  248.     {

  249.         if (data != nullptr)

  250.         {

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

  252.             {

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

  254.                     data[i].port = nullptr;

  255.             }

  256. 

  257.             delete[] data;

  258.             data = nullptr;

  259.         }

  260. 

  261.         count = 0;

  262. 

  263.         ctrl      = nullptr;

  264.         ctrlIndex = 0;

  265.     }

  266. 

  267.     void initBuffers() const noexcept

  268.     {

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

  270.         {

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

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

  273.         }

  274.     }

  275. 

  276.     CARLA_DECLARE_NON_COPY_STRUCT(CarlaPluginLV2EventData)

  277. };

  278. 

  279. // -----------------------------------------------------

  280. 

  281. struct CarlaPluginLV2Options {

  282.     enum OptIndex {

  283.         MaxBlockLenth = 0,

  284.         MinBlockLenth,

  285.         SequenceSize,

  286.         SampleRate,

  287.         FrontendWinId,

  288.         WindowTitle,

  289.         Null,

  290.         Count

  291.     };

  292. 

  293.     int maxBufferSize;

  294.     int minBufferSize;

  295.     int sequenceSize;

  296.     double sampleRate;

  297.     int64_t frontendWinId;

  298.     const char* windowTitle;

  299.     LV2_Options_Option opts[Count];

  300. 

  301.     CarlaPluginLV2Options() noexcept

  302.         : maxBufferSize(0),

  303.           minBufferSize(0),

  304.           sequenceSize(MAX_DEFAULT_BUFFER_SIZE),

  305.           sampleRate(0.0),

  306.           frontendWinId(0),

  307.           windowTitle(nullptr)

  308.     {

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

  310.         optMaxBlockLenth.context = LV2_OPTIONS_INSTANCE;

  311.         optMaxBlockLenth.subject = 0;

  312.         optMaxBlockLenth.key     = CARLA_URI_MAP_ID_BUF_MAX_LENGTH;

  313.         optMaxBlockLenth.size    = sizeof(int);

  314.         optMaxBlockLenth.type    = CARLA_URI_MAP_ID_ATOM_INT;

  315.         optMaxBlockLenth.value   = &maxBufferSize;

  316. 

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

  318.         optMinBlockLenth.context = LV2_OPTIONS_INSTANCE;

  319.         optMinBlockLenth.subject = 0;

  320.         optMinBlockLenth.key     = CARLA_URI_MAP_ID_BUF_MIN_LENGTH;

  321.         optMinBlockLenth.size    = sizeof(int);

  322.         optMinBlockLenth.type    = CARLA_URI_MAP_ID_ATOM_INT;

  323.         optMinBlockLenth.value   = &minBufferSize;

  324. 

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

  326.         optSequenceSize.context = LV2_OPTIONS_INSTANCE;

  327.         optSequenceSize.subject = 0;

  328.         optSequenceSize.key     = CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE;

  329.         optSequenceSize.size    = sizeof(int);

  330.         optSequenceSize.type    = CARLA_URI_MAP_ID_ATOM_INT;

  331.         optSequenceSize.value   = &sequenceSize;

  332. 

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

  334.         optSampleRate.context = LV2_OPTIONS_INSTANCE;

  335.         optSampleRate.subject = 0;

  336.         optSampleRate.key     = CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE;

  337.         optSampleRate.size    = sizeof(double);

  338.         optSampleRate.type    = CARLA_URI_MAP_ID_ATOM_DOUBLE;

  339.         optSampleRate.value   = &sampleRate;

  340. 

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

  342.         optFrontendWinId.context = LV2_OPTIONS_INSTANCE;

  343.         optFrontendWinId.subject = 0;

  344.         optFrontendWinId.key     = CARLA_URI_MAP_ID_CARLA_TRANSIENT_WIN_ID;

  345.         optFrontendWinId.size    = sizeof(int64_t);

  346.         optFrontendWinId.type    = CARLA_URI_MAP_ID_ATOM_LONG;

  347.         optFrontendWinId.value   = &frontendWinId;

  348. 

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

  350.         optWindowTitle.context = LV2_OPTIONS_INSTANCE;

  351.         optWindowTitle.subject = 0;

  352.         optWindowTitle.key     = CARLA_URI_MAP_ID_UI_WINDOW_TITLE;

  353.         optWindowTitle.size    = 0;

  354.         optWindowTitle.type    = CARLA_URI_MAP_ID_ATOM_STRING;

  355.         optWindowTitle.value   = nullptr;

  356. 

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

  358.         optNull.context = LV2_OPTIONS_INSTANCE;

  359.         optNull.subject = 0;

  360.         optNull.key     = CARLA_URI_MAP_ID_NULL;

  361.         optNull.size    = 0;

  362.         optNull.type    = CARLA_URI_MAP_ID_NULL;

  363.         optNull.value   = nullptr;

  364.     }

  365. 

  366.     ~CarlaPluginLV2Options() noexcept

  367.     {

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

  369. 

  370.         optWindowTitle.size  = 0;

  371.         optWindowTitle.value = nullptr;

  372. 

  373.         if (windowTitle != nullptr)

  374.         {

  375.             delete[] windowTitle;

  376.             windowTitle = nullptr;

  377.         }

  378.     }

  379. 

  380.     CARLA_DECLARE_NON_COPY_STRUCT(CarlaPluginLV2Options);

  381. };

  382. 

  383. // -----------------------------------------------------------------------

  384. 

  385. class CarlaPluginLV2;

  386. 

  387. class CarlaPipeServerLV2 : public CarlaPipeServer

  388. {

  389. public:

  390.     enum UiState {

  391.         UiNone = 0,

  392.         UiHide,

  393.         UiShow,

  394.         UiCrashed

  395.     };

  396. 

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

  398.         : kEngine(engine),

  399.           kPlugin(plugin),

  400.           fFilename(),

  401.           fPluginURI(),

  402.           fUiURI(),

  403.           fUiState(UiNone),

  404.           leakDetector_CarlaPipeServerLV2() {}

  405. 

  406.     ~CarlaPipeServerLV2() noexcept override

  407.     {

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

  409.     }

  410. 

  411.     UiState getAndResetUiState() noexcept

  412.     {

  413.         const UiState uiState(fUiState);

  414.         fUiState = UiNone;

  415.         return uiState;

  416.     }

  417. 

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

  419.     {

  420.         fFilename  = filename;

  421.         fPluginURI = pluginURI;

  422.         fUiURI     = uiURI;

  423.     }

  424. 

  425.     bool startPipeServer() noexcept

  426.     {

  427.         const ScopedEngineEnvironmentLocker _seel(kEngine);

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

  429. #ifdef CARLA_OS_LINUX

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

  431. #endif

  432. 

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

  434.     }

  435. 

  436.     void writeUiOptionsMessage(const double sampleRate, const bool useTheme, const bool useThemeColors, const char* const windowTitle, uintptr_t transientWindowId) const noexcept

  437.     {

  438.         char tmpBuf[0xff+1];

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

  440. 

  441.         const CarlaMutexLocker cml(getPipeLock());

  442.         const ScopedLocale csl;

  443. 

  444.         _writeMsgBuffer("uiOptions\n", 10);

  445. 

  446.         {

  447.             std::snprintf(tmpBuf, 0xff, "%g\n", sampleRate);

  448.             _writeMsgBuffer(tmpBuf, std::strlen(tmpBuf));

  449. 

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

  451.             _writeMsgBuffer(tmpBuf, std::strlen(tmpBuf));

  452. 

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

  454.             _writeMsgBuffer(tmpBuf, std::strlen(tmpBuf));

  455. 

  456.             writeAndFixMessage(windowTitle != nullptr ? windowTitle : "");

  457. 

  458.             std::snprintf(tmpBuf, 0xff, P_INTPTR "\n", transientWindowId);

  459.             _writeMsgBuffer(tmpBuf, std::strlen(tmpBuf));

  460.         }

  461. 

  462.         flushMessages();

  463.     }

  464. 

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

  466.     {

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

  468. 

  469.         const CarlaMutexLocker cml(getPipeLock());

  470. 

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

  472.         writeAndFixMessage(title);

  473.         flushMessages();

  474.     }

  475. 

  476. protected:

  477.     // returns true if msg was handled

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

  479. 

  480. private:

  481.     CarlaEngine*    const kEngine;

  482.     CarlaPluginLV2* const kPlugin;

  483. 

  484.     CarlaString fFilename;

  485.     CarlaString fPluginURI;

  486.     CarlaString fUiURI;

  487.     UiState     fUiState;

  488. 

  489.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaPipeServerLV2)

  490. };

  491. 

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

  493. 

  494. class CarlaPluginLV2 : public CarlaPlugin,

  495.                        private CarlaPluginUI::CloseCallback

  496. {

  497. public:

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

  499.         : CarlaPlugin(engine, id),

  500.           fHandle(nullptr),

  501.           fHandle2(nullptr),

  502.           fDescriptor(nullptr),

  503.           fRdfDescriptor(nullptr),

  504.           fAudioInBuffers(nullptr),

  505.           fAudioOutBuffers(nullptr),

  506.           fCvInBuffers(nullptr),

  507.           fCvOutBuffers(nullptr),

  508.           fParamBuffers(nullptr),

  509.           fCanInit2(true),

  510.           fNeedsUiClose(false),

  511.           fLatencyChanged(false),

  512.           fLatencyIndex(-1),

  513.           fAtomBufferIn(),

  514.           fAtomBufferOut(),

  515.           fAtomForge(),

  516.           fEventsIn(),

  517.           fEventsOut(),

  518.           fLv2Options(),

  519.           fPipeServer(engine, this),

  520.           fCustomURIDs(),

  521.           fFirstActive(true),

  522.           fLastStateChunk(nullptr),

  523.           fLastTimeInfo(),

  524.           fExt(),

  525.           fUI(),

  526.           leakDetector_CarlaPluginLV2()

  527.     {

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

  529. 

  530.         carla_zeroPointers(fFeatures, kFeatureCountAll+1);

  531. 

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

  533.             fCustomURIDs.append(nullptr);

  534. 

  535. #if defined(__clang__)

  536. # pragma clang diagnostic push

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

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

  539. # pragma GCC diagnostic push

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

  541. #endif

  542.         fAtomForge.Blank    = CARLA_URI_MAP_ID_ATOM_BLANK;

  543.         fAtomForge.Bool     = CARLA_URI_MAP_ID_ATOM_BOOL;

  544.         fAtomForge.Chunk    = CARLA_URI_MAP_ID_ATOM_CHUNK;

  545.         fAtomForge.Double   = CARLA_URI_MAP_ID_ATOM_DOUBLE;

  546.         fAtomForge.Float    = CARLA_URI_MAP_ID_ATOM_FLOAT;

  547.         fAtomForge.Int      = CARLA_URI_MAP_ID_ATOM_INT;

  548.         fAtomForge.Literal  = CARLA_URI_MAP_ID_ATOM_LITERAL;

  549.         fAtomForge.Long     = CARLA_URI_MAP_ID_ATOM_LONG;

  550.         fAtomForge.Object   = CARLA_URI_MAP_ID_ATOM_OBJECT;

  551.         fAtomForge.Path     = CARLA_URI_MAP_ID_ATOM_PATH;

  552.         fAtomForge.Property = CARLA_URI_MAP_ID_ATOM_PROPERTY;

  553.         fAtomForge.Resource = CARLA_URI_MAP_ID_ATOM_RESOURCE;

  554.         fAtomForge.Sequence = CARLA_URI_MAP_ID_ATOM_SEQUENCE;

  555.         fAtomForge.String   = CARLA_URI_MAP_ID_ATOM_STRING;

  556.         fAtomForge.Tuple    = CARLA_URI_MAP_ID_ATOM_TUPLE;

  557.         fAtomForge.URI      = CARLA_URI_MAP_ID_ATOM_URI;

  558.         fAtomForge.URID     = CARLA_URI_MAP_ID_ATOM_URID;

  559.         fAtomForge.Vector   = CARLA_URI_MAP_ID_ATOM_VECTOR;

  560. #if defined(__clang__)

  561. # pragma clang diagnostic pop

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

  563. # pragma GCC diagnostic pop

  564. #endif

  565.     }

  566. 

  567.     ~CarlaPluginLV2() override

  568.     {

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

  570. 

  571.         // close UI

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

  573.         {

  574.             showCustomUI(false);

  575. 

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

  577.             {

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

  579.             }

  580.             else

  581.             {

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

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

  584. 

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

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

  587. 

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

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

  590. 

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

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

  593. 

  594.                 fUI.descriptor = nullptr;

  595.                 pData->uiLibClose();

  596.             }

  597. 

  598. #ifndef LV2_UIS_ONLY_BRIDGES

  599.             if (fUI.window != nullptr)

  600.             {

  601.                 delete fUI.window;

  602.                 fUI.window = nullptr;

  603.             }

  604. #endif

  605. 

  606.             fUI.rdfDescriptor = nullptr;

  607.         }

  608. 

  609.         pData->singleMutex.lock();

  610.         pData->masterMutex.lock();

  611. 

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

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

  614. 

  615.         if (pData->active)

  616.         {

  617.             deactivate();

  618.             pData->active = false;

  619.         }

  620. 

  621.         if (fDescriptor != nullptr)

  622.         {

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

  624.             {

  625.                 if (fHandle != nullptr)

  626.                     fDescriptor->cleanup(fHandle);

  627.                 if (fHandle2 != nullptr)

  628.                     fDescriptor->cleanup(fHandle2);

  629.             }

  630. 

  631.             fHandle  = nullptr;

  632.             fHandle2 = nullptr;

  633.             fDescriptor = nullptr;

  634.         }

  635. 

  636.         if (fRdfDescriptor != nullptr)

  637.         {

  638.             delete fRdfDescriptor;

  639.             fRdfDescriptor = nullptr;

  640.         }

  641. 

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

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

  644. 

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

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

  647. 

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

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

  650. 

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

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

  653. 

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

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

  656. 

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

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

  659. 

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

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

  662. 

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

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

  665. 

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

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

  668. 

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

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

  671. 

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

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

  674. 

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

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

  677. 

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

  679.         {

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

  681.             {

  682.                 delete fFeatures[i];

  683.                 fFeatures[i] = nullptr;

  684.             }

  685.         }

  686. 

  687.         for (LinkedList<const char*>::Itenerator it = fCustomURIDs.begin(); it.valid(); it.next())

  688.         {

  689.             const char* const uri(it.getValue());

  690. 

  691.             if (uri != nullptr)

  692.                 delete[] uri;

  693.         }

  694. 

  695.         fCustomURIDs.clear();

  696. 

  697.         if (fLastStateChunk != nullptr)

  698.         {

  699.             std::free(fLastStateChunk);

  700.             fLastStateChunk = nullptr;

  701.         }

  702. 

  703.         clearBuffers();

  704.     }

  705. 

  706.     // -------------------------------------------------------------------

  707.     // Information (base)

  708. 

  709.     PluginType getType() const noexcept override

  710.     {

  711.         return PLUGIN_LV2;

  712.     }

  713. 

  714.     PluginCategory getCategory() const noexcept override

  715.     {

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

  717. 

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

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

  720. 

  721.         if (LV2_IS_DELAY(cat1, cat2))

  722.             return PLUGIN_CATEGORY_DELAY;

  723.         if (LV2_IS_DISTORTION(cat1, cat2))

  724.             return PLUGIN_CATEGORY_OTHER;

  725.         if (LV2_IS_DYNAMICS(cat1, cat2))

  726.             return PLUGIN_CATEGORY_DYNAMICS;

  727.         if (LV2_IS_EQ(cat1, cat2))

  728.             return PLUGIN_CATEGORY_EQ;

  729.         if (LV2_IS_FILTER(cat1, cat2))

  730.             return PLUGIN_CATEGORY_FILTER;

  731.         if (LV2_IS_GENERATOR(cat1, cat2))

  732.             return PLUGIN_CATEGORY_SYNTH;

  733.         if (LV2_IS_MODULATOR(cat1, cat2))

  734.             return PLUGIN_CATEGORY_MODULATOR;

  735.         if (LV2_IS_REVERB(cat1, cat2))

  736.             return PLUGIN_CATEGORY_DELAY;

  737.         if (LV2_IS_SIMULATOR(cat1, cat2))

  738.             return PLUGIN_CATEGORY_OTHER;

  739.         if (LV2_IS_SPATIAL(cat1, cat2))

  740.             return PLUGIN_CATEGORY_OTHER;

  741.         if (LV2_IS_SPECTRAL(cat1, cat2))

  742.             return PLUGIN_CATEGORY_UTILITY;

  743.         if (LV2_IS_UTILITY(cat1, cat2))

  744.             return PLUGIN_CATEGORY_UTILITY;

  745. 

  746.         return CarlaPlugin::getCategory();

  747.     }

  748. 

  749.     int64_t getUniqueId() const noexcept override

  750.     {

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

  752. 

  753.         return static_cast<int64_t>(fRdfDescriptor->UniqueID);

  754.     }

  755. 

  756.     // -------------------------------------------------------------------

  757.     // Information (count)

  758. 

  759.     uint32_t getMidiInCount() const noexcept override

  760.     {

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

  762. 

  763.         uint32_t count = 0;

  764. 

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

  766.         {

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

  768. 

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

  770.                 ++count;

  771.         }

  772. 

  773.         return count;

  774.     }

  775. 

  776.     uint32_t getMidiOutCount() const noexcept override

  777.     {

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

  779. 

  780.         uint32_t count = 0;

  781. 

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

  783.         {

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

  785. 

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

  787.                 ++count;

  788.         }

  789. 

  790.         return count;

  791.     }

  792. 

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

  794.     {

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

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

  797. 

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

  799. 

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

  801.         {

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

  803.             return port->ScalePointCount;

  804.         }

  805. 

  806.         return 0;

  807.     }

  808. 

  809.     // -------------------------------------------------------------------

  810.     // Information (current data)

  811. 

  812.     // nothing

  813. 

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

  815.     // Information (per-plugin data)

  816. 

  817.     uint getOptionsAvailable() const noexcept override

  818.     {

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

  820. 

  821.         uint options = 0x0;

  822. 

  823.         if (fExt.programs != nullptr)

  824.             options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  825. 

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

  827.             options |= PLUGIN_OPTION_FIXED_BUFFERS;

  828. 

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

  830.         {

  831.             if (pData->options & PLUGIN_OPTION_FORCE_STEREO)

  832.                 options |= PLUGIN_OPTION_FORCE_STEREO;

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

  834.                 options |= PLUGIN_OPTION_FORCE_STEREO;

  835.         }

  836. 

  837.         if (hasMidiIn)

  838.         {

  839.             options |= PLUGIN_OPTION_SEND_PROGRAM_CHANGES;

  840.             options |= PLUGIN_OPTION_SEND_CONTROL_CHANGES;

  841.             options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  842.             options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

  843.             options |= PLUGIN_OPTION_SEND_PITCHBEND;

  844.             options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  845.         }

  846. 

  847.         return options;

  848.     }

  849. 

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

  851.     {

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

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

  854. 

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

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

  857. 

  858.         return fParamBuffers[parameterId];

  859.     }

  860. 

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

  862.     {

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

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

  865. 

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

  867. 

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

  869.         {

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

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

  872. 

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

  874.             return portScalePoint->Value;

  875.         }

  876. 

  877.         return 0.0f;

  878.     }

  879. 

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

  881.     {

  882.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr,);

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

  884. 

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

  886.     }

  887. 

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

  889.     {

  890.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr,);

  891. 

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

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

  894.         else

  895.             CarlaPlugin::getMaker(strBuf);

  896.     }

  897. 

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

  899.     {

  900.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr,);

  901. 

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

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

  904.         else

  905.             CarlaPlugin::getCopyright(strBuf);

  906.     }

  907. 

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

  909.     {

  910.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr,);

  911. 

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

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

  914.         else

  915.             CarlaPlugin::getRealName(strBuf);

  916.     }

  917. 

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

  919.     {

  920.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr,);

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

  922. 

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

  924. 

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

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

  927.         else

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

  929.     }

  930. 

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

  932.     {

  933.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr,);

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

  935. 

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

  937. 

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

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

  940.         else

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

  942.     }

  943. 

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

  945.     {

  946.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr,);

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

  948. 

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

  950. 

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

  952.         {

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

  954. 

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

  956.             {

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

  958.                 return;

  959.             }

  960. 

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

  962.             {

  963.                 switch (port->Unit.Unit)

  964.                 {

  965.                 case LV2_PORT_UNIT_BAR:

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

  967.                     return;

  968.                 case LV2_PORT_UNIT_BEAT:

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

  970.                     return;

  971.                 case LV2_PORT_UNIT_BPM:

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

  973.                     return;

  974.                 case LV2_PORT_UNIT_CENT:

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

  976.                     return;

  977.                 case LV2_PORT_UNIT_CM:

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

  979.                     return;

  980.                 case LV2_PORT_UNIT_COEF:

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

  982.                     return;

  983.                 case LV2_PORT_UNIT_DB:

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

  985.                     return;

  986.                 case LV2_PORT_UNIT_DEGREE:

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

  988.                     return;

  989.                 case LV2_PORT_UNIT_FRAME:

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

  991.                     return;

  992.                 case LV2_PORT_UNIT_HZ:

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

  994.                     return;

  995.                 case LV2_PORT_UNIT_INCH:

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

  997.                     return;

  998.                 case LV2_PORT_UNIT_KHZ:

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

  1000.                     return;

  1001.                 case LV2_PORT_UNIT_KM:

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

  1003.                     return;

  1004.                 case LV2_PORT_UNIT_M:

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

  1006.                     return;

  1007.                 case LV2_PORT_UNIT_MHZ:

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

  1009.                     return;

  1010.                 case LV2_PORT_UNIT_MIDINOTE:

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

  1012.                     return;

  1013.                 case LV2_PORT_UNIT_MILE:

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

  1015.                     return;

  1016.                 case LV2_PORT_UNIT_MIN:

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

  1018.                     return;

  1019.                 case LV2_PORT_UNIT_MM:

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

  1021.                     return;

  1022.                 case LV2_PORT_UNIT_MS:

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

  1024.                     return;

  1025.                 case LV2_PORT_UNIT_OCT:

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

  1027.                     return;

  1028.                 case LV2_PORT_UNIT_PC:

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

  1030.                     return;

  1031.                 case LV2_PORT_UNIT_S:

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

  1033.                     return;

  1034.                 case LV2_PORT_UNIT_SEMITONE:

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

  1036.                     return;

  1037.                 }

  1038.             }

  1039.         }

  1040. 

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

  1042.     }

  1043. 

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

  1045.     {

  1046.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr,);

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

  1048. 

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

  1050. 

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

  1052.         {

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

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

  1055. 

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

  1057. 

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

  1059.             {

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

  1061.                 return;

  1062.             }

  1063.         }

  1064. 

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

  1066.     }

  1067. 

  1068.     // -------------------------------------------------------------------

  1069.     // Set data (state)

  1070. 

  1071.     void prepareForSave() override

  1072.     {

  1073.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  1074. 

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

  1076.         {

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

  1078. 

  1079.             if (fHandle2 != nullptr)

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

  1081.         }

  1082.     }

  1083. 

  1084.     // -------------------------------------------------------------------

  1085.     // Set data (internal stuff)

  1086. 

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

  1088.     {

  1089.         CarlaPlugin::setName(newName);

  1090. 

  1091.         if (fLv2Options.windowTitle == nullptr)

  1092.             return;

  1093. 

  1094.         CarlaString guiTitle(pData->name);

  1095.         guiTitle += " (GUI)";

  1096. 

  1097.         delete[] fLv2Options.windowTitle;

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

  1099. 

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

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

  1102. 

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

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

  1105. 

  1106.         if (fPipeServer.isPipeRunning())

  1107.             fPipeServer.writeUiTitleMessage(fLv2Options.windowTitle);

  1108. 

  1109. #ifndef LV2_UIS_ONLY_BRIDGES

  1110.         if (fUI.window != nullptr)

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

  1112. #endif

  1113.     }

  1114. 

  1115.     // -------------------------------------------------------------------

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

  1117. 

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

  1119.     {

  1120.         CARLA_SAFE_ASSERT_RETURN(fParamBuffers != nullptr,);

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

  1122. 

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

  1124.         fParamBuffers[parameterId] = fixedValue;

  1125. 

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

  1127.     }

  1128. 

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

  1130.     {

  1131.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  1132.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

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

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

  1135.         CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

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

  1137. 

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

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

  1140. 

  1141.         // we should only call state restore once

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

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

  1144.         {

  1145.             if (fExt.state == nullptr)

  1146.                 return;

  1147. 

  1148.             LV2_State_Status status = LV2_STATE_ERR_UNKNOWN;

  1149. 

  1150.             {

  1151.                 const ScopedSingleProcessLocker spl(this, true);

  1152. 

  1153.                 try {

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

  1155.                 } catch(...) {}

  1156. 

  1157.                 if (fHandle2 != nullptr)

  1158.                 {

  1159.                     try {

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

  1161.                     } catch(...) {}

  1162.                 }

  1163.             }

  1164. 

  1165.             switch (status)

  1166.             {

  1167.             case LV2_STATE_SUCCESS:

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

  1169.                 break;

  1170.             case LV2_STATE_ERR_UNKNOWN:

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

  1172.                 break;

  1173.             case LV2_STATE_ERR_BAD_TYPE:

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

  1175.                 break;

  1176.             case LV2_STATE_ERR_BAD_FLAGS:

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

  1178.                 break;

  1179.             case LV2_STATE_ERR_NO_FEATURE:

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

  1181.                 break;

  1182.             case LV2_STATE_ERR_NO_PROPERTY:

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

  1184.                 break;

  1185.             }

  1186.             return;

  1187.         }

  1188. 

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

  1190.     }

  1191. 

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

  1193.     {

  1194.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

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

  1196. 

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

  1198.         {

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

  1200.             {

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

  1202. 

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

  1204. 

  1205.                 if (fHandle2 != nullptr)

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

  1207. 

  1208.                 lilv_state_free(state);

  1209.             }

  1210.         }

  1211. 

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

  1213.     }

  1214. 

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

  1216.     {

  1217.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

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

  1219. 

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

  1221.         {

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

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

  1224. 

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

  1226. 

  1227.             try {

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

  1229.             } catch(...) {}

  1230. 

  1231.             if (fHandle2 != nullptr)

  1232.             {

  1233.                 try {

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

  1235.                 } catch(...) {}

  1236.             }

  1237.         }

  1238. 

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

  1240.     }

  1241. 

  1242.     // -------------------------------------------------------------------

  1243.     // Set ui stuff

  1244. 

  1245.     void showCustomUI(const bool yesNo) override

  1246.     {

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

  1248. 

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

  1250. 

  1251.         if (! yesNo)

  1252.             pData->transientTryCounter = 0;

  1253. 

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

  1255.         {

  1256.             if (yesNo)

  1257.             {

  1258.                 if (fPipeServer.isPipeRunning())

  1259.                 {

  1260.                     fPipeServer.writeFocusMessage();

  1261.                     return;

  1262.                 }

  1263. 

  1264.                 if (! fPipeServer.startPipeServer())

  1265.                 {

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

  1267.                     return;

  1268.                 }

  1269. 

  1270.                 for (std::size_t i=CARLA_URI_MAP_ID_COUNT, count=fCustomURIDs.count(); i < count; ++i)

  1271.                     fPipeServer.writeLv2UridMessage(static_cast<uint32_t>(i), fCustomURIDs.getAt(i, nullptr));

  1272. 

  1273.                 fPipeServer.writeUiOptionsMessage(pData->engine->getSampleRate(), true, true, fLv2Options.windowTitle, frontendWinId);

  1274. 

  1275.                 // send control ports

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

  1277.                     fPipeServer.writeControlMessage(static_cast<uint32_t>(pData->param.data[i].rindex), getParameterValue(i));

  1278. 

  1279.                 fPipeServer.writeShowMessage();

  1280. #ifndef BUILD_BRIDGE

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

  1282.                     pData->tryTransient();

  1283. #endif

  1284.             }

  1285.             else

  1286.             {

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

  1288.             }

  1289.             return;

  1290.         }

  1291. 

  1292.         // take some precautions

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

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

  1295. 

  1296.         if (yesNo)

  1297.         {

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

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

  1300.         }

  1301.         else

  1302.         {

  1303.             if (fUI.handle == nullptr)

  1304.                 return;

  1305.         }

  1306. 

  1307.         if (yesNo)

  1308.         {

  1309.             if (fUI.handle == nullptr)

  1310.             {

  1311. #ifndef LV2_UIS_ONLY_BRIDGES

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

  1313.                 {

  1314.                     const char* msg = nullptr;

  1315. 

  1316.                     switch (fUI.rdfDescriptor->Type)

  1317.                     {

  1318.                     case LV2_UI_GTK2:

  1319.                     case LV2_UI_GTK3:

  1320.                     case LV2_UI_QT4:

  1321.                     case LV2_UI_QT5:

  1322.                     case LV2_UI_EXTERNAL:

  1323.                     case LV2_UI_OLD_EXTERNAL:

  1324.                         msg = "Invalid UI type";

  1325.                         break;

  1326. 

  1327.                     case LV2_UI_COCOA:

  1328. # ifdef CARLA_OS_MAC

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

  1330. # else

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

  1332. # endif

  1333.                         break;

  1334. 

  1335.                     case LV2_UI_WINDOWS:

  1336. # ifdef CARLA_OS_WIN

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

  1338. # else

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

  1340. # endif

  1341.                         break;

  1342. 

  1343.                     case LV2_UI_X11:

  1344. # ifdef HAVE_X11

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

  1346. # else

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

  1348. # endif

  1349.                         break;

  1350. 

  1351.                     default:

  1352.                         msg = "Unknown UI type";

  1353.                         break;

  1354.                     }

  1355. 

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

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

  1358. 

  1359.                     if (fUI.window != nullptr)

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

  1361.                 }

  1362. #endif

  1363.                 if (fUI.window != nullptr)

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

  1365. 

  1366.                 fUI.widget = nullptr;

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

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

  1369.             }

  1370. 

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

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

  1373. 

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

  1375.             {

  1376.                 fUI.widget = nullptr;

  1377. 

  1378.                 if (fUI.handle != nullptr)

  1379.                 {

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

  1381.                     fUI.handle = nullptr;

  1382.                 }

  1383. 

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

  1385.             }

  1386. 

  1387.             updateUi();

  1388. 

  1389. #ifndef LV2_UIS_ONLY_BRIDGES

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

  1391.             {

  1392.                 if (fUI.window != nullptr)

  1393.                 {

  1394.                     fUI.window->show();

  1395.                 }

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

  1397.                 {

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

  1399. # ifndef BUILD_BRIDGE

  1400.                     pData->tryTransient();

  1401. # endif

  1402.                 }

  1403.             }

  1404.             else

  1405. #endif

  1406.             {

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

  1408. #ifndef BUILD_BRIDGE

  1409.                 pData->tryTransient();

  1410. #endif

  1411.             }

  1412.         }

  1413.         else

  1414.         {

  1415. #ifndef LV2_UIS_ONLY_BRIDGES

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

  1417.             {

  1418.                 if (fUI.window != nullptr)

  1419.                     fUI.window->hide();

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

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

  1422.             }

  1423.             else

  1424. #endif

  1425.             {

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

  1427. 

  1428.                 if (fUI.widget != nullptr)

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

  1430.             }

  1431. 

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

  1433.             fUI.handle = nullptr;

  1434.             fUI.widget = nullptr;

  1435.         }

  1436.     }

  1437. 

  1438. #if 0 // TODO

  1439.     void idle() override

  1440.     {

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

  1442.         {

  1443.             fLatencyChanged = false;

  1444. 

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

  1446. 

  1447.             if (latency >= 0)

  1448.             {

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

  1450. 

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

  1452.                 {

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

  1454. 

  1455.                     const ScopedSingleProcessLocker sspl(this, true);

  1456. 

  1457.                     pData->latency = ulatency;

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

  1459. #ifndef BUILD_BRIDGE

  1460.                     pData->recreateLatencyBuffers();

  1461. #endif

  1462.                 }

  1463.             }

  1464.             else

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

  1466.         }

  1467. 

  1468.         CarlaPlugin::idle();

  1469.     }

  1470. #endif

  1471. 

  1472.     void uiIdle() override

  1473.     {

  1474.         if (fAtomBufferOut.isDataAvailableForReading())

  1475.         {

  1476.             uint8_t dumpBuf[fAtomBufferOut.getSize()];

  1477. 

  1478.             Lv2AtomRingBuffer tmpRingBuffer(fAtomBufferOut, dumpBuf);

  1479.             CARLA_SAFE_ASSERT(tmpRingBuffer.isDataAvailableForReading());

  1480. 

  1481.             uint32_t portIndex;

  1482.             const LV2_Atom* atom;

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

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

  1485. 

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

  1487.             {

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

  1489.                 {

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

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

  1492.                 }

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

  1494.                 {

  1495.                     if (fPipeServer.isPipeRunning())

  1496.                         fPipeServer.writeLv2AtomMessage(portIndex, atom);

  1497.                 }

  1498.                 else

  1499.                 {

  1500.                     if (hasPortEvent)

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

  1502.                 }

  1503.             }

  1504.         }

  1505. 

  1506.         if (fPipeServer.isPipeRunning())

  1507.         {

  1508.             fPipeServer.idlePipe();

  1509. 

  1510.             switch (fPipeServer.getAndResetUiState())

  1511.             {

  1512.             case CarlaPipeServerLV2::UiNone:

  1513.             case CarlaPipeServerLV2::UiShow:

  1514.                 break;

  1515.             case CarlaPipeServerLV2::UiHide:

  1516.                 fPipeServer.stopPipeServer(2000);

  1517.                 // nobreak

  1518.             case CarlaPipeServerLV2::UiCrashed:

  1519.                 pData->transientTryCounter = 0;

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

  1521.                 break;

  1522.             }

  1523.         }

  1524.         else

  1525.         {

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

  1527.         }

  1528. 

  1529.         if (fNeedsUiClose)

  1530.         {

  1531.             fNeedsUiClose = false;

  1532.             showCustomUI(false);

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

  1534.         }

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

  1536.         {

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

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

  1539. #ifndef LV2_UIS_ONLY_BRIDGES

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

  1541.                 fUI.window->idle();

  1542. 

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

  1544.             if (fNeedsUiClose)

  1545.                 pass();

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

  1547.             {

  1548.                 showCustomUI(false);

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

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

  1551.             }

  1552. #endif

  1553.         }

  1554. 

  1555.         CarlaPlugin::uiIdle();

  1556.     }

  1557. 

  1558.     // -------------------------------------------------------------------

  1559.     // Plugin state

  1560. 

  1561.     void reload() override

  1562.     {

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

  1564.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  1565.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  1566.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr,);

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

  1568. 

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

  1570. 

  1571.         // Safely disable plugin for reload

  1572.         const ScopedDisabler sd(this);

  1573. 

  1574.         if (pData->active)

  1575.             deactivate();

  1576. 

  1577.         clearBuffers();

  1578. 

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

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

  1581. 

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

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

  1584.         LinkedList<uint> evIns, evOuts;

  1585. 

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

  1587. 

  1588.         bool forcedStereoIn, forcedStereoOut;

  1589.         forcedStereoIn = forcedStereoOut = false;

  1590. 

  1591.         bool needsCtrlIn, needsCtrlOut;

  1592.         needsCtrlIn = needsCtrlOut = false;

  1593. 

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

  1595.         {

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

  1597. 

  1598.             if (LV2_IS_PORT_AUDIO(portTypes))

  1599.             {

  1600.                 if (LV2_IS_PORT_INPUT(portTypes))

  1601.                     aIns += 1;

  1602.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  1603.                     aOuts += 1;

  1604.             }

  1605.             else if (LV2_IS_PORT_CV(portTypes))

  1606.             {

  1607.                 if (LV2_IS_PORT_INPUT(portTypes))

  1608.                     cvIns += 1;

  1609.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  1610.                     cvOuts += 1;

  1611.             }

  1612.             else if (LV2_IS_PORT_ATOM_SEQUENCE(portTypes))

  1613.             {

  1614.                 if (LV2_IS_PORT_INPUT(portTypes))

  1615.                     evIns.append(CARLA_EVENT_DATA_ATOM);

  1616.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  1617.                     evOuts.append(CARLA_EVENT_DATA_ATOM);

  1618.             }

  1619.             else if (LV2_IS_PORT_EVENT(portTypes))

  1620.             {

  1621.                 if (LV2_IS_PORT_INPUT(portTypes))

  1622.                     evIns.append(CARLA_EVENT_DATA_EVENT);

  1623.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  1624.                     evOuts.append(CARLA_EVENT_DATA_EVENT);

  1625.             }

  1626.             else if (LV2_IS_PORT_MIDI_LL(portTypes))

  1627.             {

  1628.                 if (LV2_IS_PORT_INPUT(portTypes))

  1629.                     evIns.append(CARLA_EVENT_DATA_MIDI_LL);

  1630.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  1631.                     evOuts.append(CARLA_EVENT_DATA_MIDI_LL);

  1632.             }

  1633.             else if (LV2_IS_PORT_CONTROL(portTypes))

  1634.                 params += 1;

  1635.         }

  1636. 

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

  1638.         {

  1639.             if (fHandle2 == nullptr)

  1640.             {

  1641.                 try {

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

  1643.                 } catch(...) {}

  1644.             }

  1645. 

  1646.             if (fHandle2 != nullptr)

  1647.             {

  1648.                 if (aIns == 1)

  1649.                 {

  1650.                     aIns = 2;

  1651.                     forcedStereoIn = true;

  1652.                 }

  1653. 

  1654.                 if (aOuts == 1)

  1655.                 {

  1656.                     aOuts = 2;

  1657.                     forcedStereoOut = true;

  1658.                 }

  1659.             }

  1660.         }

  1661. 

  1662.         if (aIns > 0)

  1663.         {

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

  1665.             fAudioInBuffers = new float*[aIns];

  1666. 

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

  1668.                 fAudioInBuffers[i] = nullptr;

  1669.         }

  1670. 

  1671.         if (aOuts > 0)

  1672.         {

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

  1674.             fAudioOutBuffers = new float*[aOuts];

  1675.             needsCtrlIn = true;

  1676. 

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

  1678.                 fAudioOutBuffers[i] = nullptr;

  1679.         }

  1680. 

  1681.         if (cvIns > 0)

  1682.         {

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

  1684.             fCvInBuffers = new float*[cvIns];

  1685. 

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

  1687.                 fCvInBuffers[i] = nullptr;

  1688.         }

  1689. 

  1690.         if (cvOuts > 0)

  1691.         {

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

  1693.             fCvOutBuffers = new float*[cvOuts];

  1694. 

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

  1696.                 fCvOutBuffers[i] = nullptr;

  1697.         }

  1698. 

  1699.         if (params > 0)

  1700.         {

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

  1702.             fParamBuffers = new float[params];

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

  1704.         }

  1705. 

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

  1707.         {

  1708.             fEventsIn.createNew(count);

  1709. 

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

  1711.             {

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

  1713. 

  1714.                 if (type == CARLA_EVENT_DATA_ATOM)

  1715.                 {

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

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

  1718.                 }

  1719.                 else if (type == CARLA_EVENT_DATA_EVENT)

  1720.                 {

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

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

  1723.                 }

  1724.                 else if (type == CARLA_EVENT_DATA_MIDI_LL)

  1725.                 {

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

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

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

  1729.                 }

  1730.             }

  1731.         }

  1732.         else

  1733.         {

  1734.             fEventsIn.createNew(1);

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

  1736.         }

  1737. 

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

  1739.         {

  1740.             fEventsOut.createNew(count);

  1741. 

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

  1743.             {

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

  1745. 

  1746.                 if (type == CARLA_EVENT_DATA_ATOM)

  1747.                 {

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

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

  1750.                 }

  1751.                 else if (type == CARLA_EVENT_DATA_EVENT)

  1752.                 {

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

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

  1755.                 }

  1756.                 else if (type == CARLA_EVENT_DATA_MIDI_LL)

  1757.                 {

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

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

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

  1761.                 }

  1762.             }

  1763.         }

  1764. 

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

  1766.         CarlaString portName;

  1767. 

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

  1769.         {

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

  1771. 

  1772.             portName.clear();

  1773. 

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

  1775.             {

  1776.                 if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  1777.                 {

  1778.                     portName  = pData->name;

  1779.                     portName += ":";

  1780.                 }

  1781. 

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

  1783.                 portName.truncate(portNameSize);

  1784.             }

  1785. 

  1786.             if (LV2_IS_PORT_AUDIO(portTypes))

  1787.             {

  1788.                 if (LV2_IS_PORT_INPUT(portTypes))

  1789.                 {

  1790.                     const uint32_t j = iAudioIn++;

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

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

  1793. 

  1794.                     if (forcedStereoIn)

  1795.                     {

  1796.                         portName += "_2";

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

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

  1799.                     }

  1800.                 }

  1801.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  1802.                 {

  1803.                     const uint32_t j = iAudioOut++;

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

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

  1806. 

  1807.                     if (forcedStereoOut)

  1808.                     {

  1809.                         portName += "_2";

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

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

  1812.                     }

  1813.                 }

  1814.                 else

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

  1816.             }

  1817.             else if (LV2_IS_PORT_CV(portTypes))

  1818.             {

  1819.                 if (LV2_IS_PORT_INPUT(portTypes))

  1820.                 {

  1821.                     const uint32_t j = iCvIn++;

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

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

  1824.                 }

  1825.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  1826.                 {

  1827.                     const uint32_t j = iCvOut++;

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

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

  1830.                 }

  1831.                 else

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

  1833.             }

  1834.             else if (LV2_IS_PORT_ATOM_SEQUENCE(portTypes))

  1835.             {

  1836.                 if (LV2_IS_PORT_INPUT(portTypes))

  1837.                 {

  1838.                     const uint32_t j = iEvIn++;

  1839. 

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

  1841. 

  1842.                     if (fHandle2 != nullptr)

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

  1844. 

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

  1846. 

  1847.                     if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

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

  1849.                     if (portTypes & LV2_PORT_DATA_PATCH_MESSAGE)

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

  1851.                     if (portTypes & LV2_PORT_DATA_TIME_POSITION)

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

  1853. 

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

  1855.                     {

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

  1857.                         fEventsIn.ctrlIndex = j;

  1858. 

  1859.                         if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

  1860.                             needsCtrlIn = true;

  1861.                     }

  1862.                     else

  1863.                     {

  1864.                         if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

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

  1866. 

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

  1868.                         {

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

  1870.                             fEventsIn.ctrlIndex = j;

  1871.                         }

  1872.                     }

  1873.                 }

  1874.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  1875.                 {

  1876.                     const uint32_t j = iEvOut++;

  1877. 

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

  1879. 

  1880.                     if (fHandle2 != nullptr)

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

  1882. 

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

  1884. 

  1885.                     if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

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

  1887.                     if (portTypes & LV2_PORT_DATA_PATCH_MESSAGE)

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

  1889.                     if (portTypes & LV2_PORT_DATA_TIME_POSITION)

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

  1891. 

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

  1893.                     {

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

  1895.                         fEventsOut.ctrlIndex = j;

  1896. 

  1897.                         if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

  1898.                             needsCtrlOut = true;

  1899.                     }

  1900.                     else

  1901.                     {

  1902.                         if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

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

  1904. 

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

  1906.                         {

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

  1908.                             fEventsOut.ctrlIndex = j;

  1909.                         }

  1910.                     }

  1911.                 }

  1912.                 else

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

  1914.             }

  1915.             else if (LV2_IS_PORT_EVENT(portTypes))

  1916.             {

  1917.                 if (LV2_IS_PORT_INPUT(portTypes))

  1918.                 {

  1919.                     const uint32_t j = iEvIn++;

  1920. 

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

  1922. 

  1923.                     if (fHandle2 != nullptr)

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

  1925. 

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

  1927. 

  1928.                     if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

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

  1930.                     if (portTypes & LV2_PORT_DATA_PATCH_MESSAGE)

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

  1932.                     if (portTypes & LV2_PORT_DATA_TIME_POSITION)

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

  1934. 

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

  1936.                     {

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

  1938.                         fEventsIn.ctrlIndex = j;

  1939. 

  1940.                         if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

  1941.                             needsCtrlIn = true;

  1942.                     }

  1943.                     else

  1944.                     {

  1945.                         if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

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

  1947. 

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

  1949.                         {

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

  1951.                             fEventsIn.ctrlIndex = j;

  1952.                         }

  1953.                     }

  1954.                 }

  1955.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  1956.                 {

  1957.                     const uint32_t j = iEvOut++;

  1958. 

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

  1960. 

  1961.                     if (fHandle2 != nullptr)

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

  1963. 

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

  1965. 

  1966.                     if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

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

  1968.                     if (portTypes & LV2_PORT_DATA_PATCH_MESSAGE)

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

  1970.                     if (portTypes & LV2_PORT_DATA_TIME_POSITION)

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

  1972. 

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

  1974.                     {

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

  1976.                         fEventsOut.ctrlIndex = j;

  1977. 

  1978.                         if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

  1979.                             needsCtrlOut = true;

  1980.                     }

  1981.                     else

  1982.                     {

  1983.                         if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

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

  1985. 

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

  1987.                         {

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

  1989.                             fEventsOut.ctrlIndex = j;

  1990.                         }

  1991.                     }

  1992.                 }

  1993.                 else

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

  1995.             }

  1996.             else if (LV2_IS_PORT_MIDI_LL(portTypes))

  1997.             {

  1998.                 if (LV2_IS_PORT_INPUT(portTypes))

  1999.                 {

  2000.                     const uint32_t j = iEvIn++;

  2001. 

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

  2003. 

  2004.                     if (fHandle2 != nullptr)

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

  2006. 

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

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

  2009. 

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

  2011.                     {

  2012.                         needsCtrlIn = true;

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

  2014.                         fEventsIn.ctrlIndex = j;

  2015.                     }

  2016.                     else

  2017.                     {

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

  2019. 

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

  2021.                         {

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

  2023.                             fEventsIn.ctrlIndex = j;

  2024.                         }

  2025.                     }

  2026.                 }

  2027.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  2028.                 {

  2029.                     const uint32_t j = iEvOut++;

  2030. 

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

  2032. 

  2033.                     if (fHandle2 != nullptr)

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

  2035. 

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

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

  2038. 

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

  2040.                     {

  2041.                         needsCtrlOut = true;

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

  2043.                         fEventsOut.ctrlIndex = j;

  2044.                     }

  2045.                     else

  2046.                     {

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

  2048. 

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

  2050.                         {

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

  2052.                             fEventsOut.ctrlIndex = j;

  2053.                         }

  2054.                     }

  2055.                 }

  2056.                 else

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

  2058.             }

  2059.             else if (LV2_IS_PORT_CONTROL(portTypes))

  2060.             {

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

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

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

  2064. 

  2065.                 const uint32_t j = iCtrl++;

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

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

  2068. 

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

  2070. 

  2071.                 // min value

  2072.                 if (LV2_HAVE_MINIMUM_PORT_POINT(portPoints.Hints))

  2073.                     min = portPoints.Minimum;

  2074.                 else

  2075.                     min = 0.0f;

  2076. 

  2077.                 // max value

  2078.                 if (LV2_HAVE_MAXIMUM_PORT_POINT(portPoints.Hints))

  2079.                     max = portPoints.Maximum;

  2080.                 else

  2081.                     max = 1.0f;

  2082. 

  2083.                 if (min > max)

  2084.                     max = min;

  2085. 

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

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

  2088.                 {

  2089.                     min = 0.0f;

  2090.                     max = (float)0xffffff;

  2091.                 }

  2092. 

  2093.                 if (carla_compareFloats(min, max))

  2094.                 {

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

  2096.                     max = min + 0.1f;

  2097.                 }

  2098. 

  2099.                 // default value

  2100.                 if (LV2_HAVE_DEFAULT_PORT_POINT(portPoints.Hints))

  2101.                 {

  2102.                     def = portPoints.Default;

  2103.                 }

  2104.                 else

  2105.                 {

  2106.                     // no default value

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

  2108.                         def = 0.0f;

  2109.                     else

  2110.                         def = min;

  2111.                 }

  2112. 

  2113.                 if (def < min)

  2114.                     def = min;

  2115.                 else if (def > max)

  2116.                     def = max;

  2117. 

  2118.                 if (LV2_IS_PORT_SAMPLE_RATE(portProps))

  2119.                 {

  2120.                     min *= sampleRate;

  2121.                     max *= sampleRate;

  2122.                     def *= sampleRate;

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

  2124.                 }

  2125. 

  2126.                 if (LV2_IS_PORT_TOGGLED(portProps))

  2127.                 {

  2128.                     step = max - min;

  2129.                     stepSmall = step;

  2130.                     stepLarge = step;

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

  2132.                 }

  2133.                 else if (LV2_IS_PORT_INTEGER(portProps))

  2134.                 {

  2135.                     step = 1.0f;

  2136.                     stepSmall = 1.0f;

  2137.                     stepLarge = 10.0f;

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

  2139.                 }

  2140.                 else

  2141.                 {

  2142.                     float range = max - min;

  2143.                     step = range/100.0f;

  2144.                     stepSmall = range/1000.0f;

  2145.                     stepLarge = range/10.0f;

  2146.                 }

  2147. 

  2148.                 if (LV2_IS_PORT_INPUT(portTypes))

  2149.                 {

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

  2151. 

  2152.                     if (LV2_IS_PORT_DESIGNATION_LATENCY(portDesignation))

  2153.                     {

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

  2155.                     }

  2156.                     else if (LV2_IS_PORT_DESIGNATION_SAMPLE_RATE(portDesignation))

  2157.                     {

  2158.                         def = sampleRate;

  2159.                         step = 1.0f;

  2160.                         stepSmall = 1.0f;

  2161.                         stepLarge = 1.0f;

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

  2163.                     }

  2164.                     else if (LV2_IS_PORT_DESIGNATION_FREEWHEELING(portDesignation))

  2165.                     {

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

  2167.                     }

  2168.                     else if (LV2_IS_PORT_DESIGNATION_TIME(portDesignation))

  2169.                     {

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

  2171.                     }

  2172.                     else

  2173.                     {

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

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

  2176.                         needsCtrlIn = true;

  2177.                     }

  2178. 

  2179.                     // MIDI CC value

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

  2181. 

  2182.                     if (LV2_IS_PORT_MIDI_MAP_CC(portMidiMap.Type))

  2183.                     {

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

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

  2186.                     }

  2187.                 }

  2188.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  2189.                 {

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

  2191. 

  2192.                     if (LV2_IS_PORT_DESIGNATION_LATENCY(portDesignation))

  2193.                     {

  2194.                         min = 0.0f;

  2195.                         max = sampleRate;

  2196.                         def = 0.0f;

  2197.                         step = 1.0f;

  2198.                         stepSmall = 1.0f;

  2199.                         stepLarge = 1.0f;

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

  2201.                         CARLA_SAFE_ASSERT(fLatencyIndex == static_cast<int32_t>(j));

  2202.                     }

  2203.                     else if (LV2_IS_PORT_DESIGNATION_SAMPLE_RATE(portDesignation))

  2204.                     {

  2205.                         def = sampleRate;

  2206.                         step = 1.0f;

  2207.                         stepSmall = 1.0f;

  2208.                         stepLarge = 1.0f;

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

  2210.                     }

  2211.                     else if (LV2_IS_PORT_DESIGNATION_FREEWHEELING(portDesignation))

  2212.                     {

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

  2214.                     }

  2215.                     else if (LV2_IS_PORT_DESIGNATION_TIME(portDesignation))

  2216.                     {

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

  2218.                     }

  2219.                     else

  2220.                     {

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

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

  2223.                         needsCtrlOut = true;

  2224.                     }

  2225.                 }

  2226.                 else

  2227.                 {

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

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

  2230.                 }

  2231. 

  2232.                 // extra parameter hints

  2233.                 if (LV2_IS_PORT_LOGARITHMIC(portProps))

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

  2235. 

  2236.                 if (LV2_IS_PORT_TRIGGER(portProps))

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

  2238. 

  2239.                 if (LV2_IS_PORT_STRICT_BOUNDS(portProps))

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

  2241. 

  2242.                 if (LV2_IS_PORT_ENUMERATION(portProps))

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

  2244. 

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

  2246.                 if (LV2_IS_PORT_NOT_ON_GUI(portProps))

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

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

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

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

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

  2252. 

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

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

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

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

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

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

  2259. 

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

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

  2262.                     fParamBuffers[j] = min;

  2263.                 else

  2264.                     fParamBuffers[j] = def;

  2265. 

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

  2267. 

  2268.                 if (fHandle2 != nullptr)

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

  2270.             }

  2271.             else

  2272.             {

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

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

  2275. 

  2276.                 if (fHandle2 != nullptr)

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

  2278.             }

  2279.         }

  2280. 

  2281.         if (needsCtrlIn)

  2282.         {

  2283.             portName.clear();

  2284. 

  2285.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  2286.             {

  2287.                 portName  = pData->name;

  2288.                 portName += ":";

  2289.             }

  2290. 

  2291.             portName += "events-in";

  2292.             portName.truncate(portNameSize);

  2293. 

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

  2295.         }

  2296. 

  2297.         if (needsCtrlOut)

  2298.         {

  2299.             portName.clear();

  2300. 

  2301.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  2302.             {

  2303.                 portName  = pData->name;

  2304.                 portName += ":";

  2305.             }

  2306. 

  2307.             portName += "events-out";

  2308.             portName.truncate(portNameSize);

  2309. 

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

  2311.         }

  2312. 

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

  2314.             fAtomBufferIn.createBuffer(eventBufferSize);

  2315. 

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

  2317.             fAtomBufferOut.createBuffer(eventBufferSize);

  2318. 

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

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

  2321. 

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

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

  2324. 

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

  2326.             pData->options |= PLUGIN_OPTION_FORCE_STEREO;

  2327.         else

  2328.             pData->options &= ~PLUGIN_OPTION_FORCE_STEREO;

  2329. 

  2330.         // plugin hints

  2331.         pData->hints = 0x0;

  2332. 

  2333.         if (isRealtimeSafe())

  2334.             pData->hints |= PLUGIN_IS_RTSAFE;

  2335. 

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

  2337.         {

  2338.             pData->hints |= PLUGIN_HAS_CUSTOM_UI;

  2339. 

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

  2341.                 pData->hints |= PLUGIN_NEEDS_UI_MAIN_THREAD;

  2342.         }

  2343. 

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

  2345.             pData->hints |= PLUGIN_IS_SYNTH;

  2346. 

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

  2348.             pData->hints |= PLUGIN_CAN_DRYWET;

  2349. 

  2350.         if (aOuts > 0)

  2351.             pData->hints |= PLUGIN_CAN_VOLUME;

  2352. 

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

  2354.             pData->hints |= PLUGIN_CAN_BALANCE;

  2355. 

  2356.         // extra plugin hints

  2357.         pData->extraHints = 0x0;

  2358. 

  2359.         if (! fCanInit2)

  2360.         {

  2361.             // can't run in rack

  2362.         }

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

  2364.         {

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

  2366.                 pData->extraHints |= PLUGIN_EXTRA_HINT_CAN_RUN_RACK;

  2367.         }

  2368.         else

  2369.         {

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

  2371.                 pData->extraHints |= PLUGIN_EXTRA_HINT_CAN_RUN_RACK;

  2372.         }

  2373. 

  2374. #if 0 // TODO

  2375.         // check latency

  2376.         if (fLatencyIndex >= 0)

  2377.         {

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

  2379. 

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

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

  2382. 

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

  2384.             {

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

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

  2387. 

  2388.                 try {

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

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

  2391.             }

  2392. 

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

  2394.             {

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

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

  2397. 

  2398.                 try {

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

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

  2401.             }

  2402. 

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

  2404.             {

  2405.                 try {

  2406.                     fDescriptor->activate(fHandle);

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

  2408.             }

  2409. 

  2410.             try {

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

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

  2413. 

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

  2415.             {

  2416.                 try {

  2417.                     fDescriptor->deactivate(fHandle);

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

  2419.             }

  2420. 

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

  2422. 

  2423.             if (latency >= 0)

  2424.             {

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

  2426. 

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

  2428.                 {

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

  2430. 

  2431.                     pData->latency = ulatency;

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

  2433. #ifndef BUILD_BRIDGE

  2434.                     pData->recreateLatencyBuffers();

  2435. #endif

  2436.                 }

  2437.             }

  2438.             else

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

  2440. 

  2441.             fLatencyChanged = false;

  2442.         }

  2443. #endif

  2444. 

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

  2446.         reloadPrograms(true);

  2447. 

  2448.         evIns.clear();

  2449.         evOuts.clear();

  2450. 

  2451.         if (pData->active)

  2452.             activate();

  2453. 

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

  2455.     }

  2456. 

  2457.     void reloadPrograms(const bool doInit) override

  2458.     {

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

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

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

  2462. 

  2463.         // special LV2 programs handling

  2464.         if (doInit)

  2465.         {

  2466.             pData->prog.clear();

  2467. 

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

  2469. 

  2470.             if (presetCount > 0)

  2471.             {

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

  2473. 

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

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

  2476.             }

  2477.         }

  2478. 

  2479.         // Delete old programs

  2480.         pData->midiprog.clear();

  2481. 

  2482.         // Query new programs

  2483.         uint32_t newCount = 0;

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

  2485.         {

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

  2487.                 ++newCount;

  2488.         }

  2489. 

  2490.         if (newCount > 0)

  2491.         {

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

  2493. 

  2494.             // Update data

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

  2496.             {

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

  2498.                 CARLA_SAFE_ASSERT_CONTINUE(pdesc != nullptr);

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

  2500. 

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

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

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

  2504.             }

  2505.         }

  2506. 

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

  2508.         // Update OSC Names

  2509.         if (pData->engine->isOscControlRegistered())

  2510.         {

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

  2512. 

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

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

  2515.         }

  2516. #endif

  2517. 

  2518.         if (doInit)

  2519.         {

  2520.             if (newCount > 0)

  2521.             {

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

  2523.             }

  2524.             else

  2525.             {

  2526.                 // load default state

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

  2528.                 {

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

  2530. 

  2531.                     if (fHandle2 != nullptr)

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

  2533. 

  2534.                     lilv_state_free(state);

  2535.                 }

  2536.             }

  2537.         }

  2538.         else

  2539.         {

  2540.             // Check if current program is invalid

  2541.             bool programChanged = false;

  2542. 

  2543.             if (newCount == oldCount+1)

  2544.             {

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

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

  2547.                 programChanged = true;

  2548.             }

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

  2550.             {

  2551.                 // programs exist now, but not before

  2552.                 pData->midiprog.current = 0;

  2553.                 programChanged = true;

  2554.             }

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

  2556.             {

  2557.                 // programs existed before, but not anymore

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

  2559.                 programChanged = true;

  2560.             }

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

  2562.             {

  2563.                 // current midi program > count

  2564.                 pData->midiprog.current = 0;

  2565.                 programChanged = true;

  2566.             }

  2567.             else

  2568.             {

  2569.                 // no change

  2570.                 pData->midiprog.current = current;

  2571.             }

  2572. 

  2573.             if (programChanged)

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

  2575. 

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

  2577.         }

  2578.     }

  2579. 

  2580.     // -------------------------------------------------------------------

  2581.     // Plugin processing

  2582. 

  2583.     void activate() noexcept override

  2584.     {

  2585.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  2586.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  2587. 

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

  2589.         {

  2590.             try {

  2591.                 fDescriptor->activate(fHandle);

  2592.             } CARLA_SAFE_EXCEPTION("LV2 activate");

  2593. 

  2594.             if (fHandle2 != nullptr)

  2595.             {

  2596.                 try {

  2597.                     fDescriptor->activate(fHandle2);

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

  2599.             }

  2600.         }

  2601. 

  2602.         fFirstActive = true;

  2603.     }

  2604. 

  2605.     void deactivate() noexcept override

  2606.     {

  2607.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  2608.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  2609. 

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

  2611.         {

  2612.             try {

  2613.                 fDescriptor->deactivate(fHandle);

  2614.             } CARLA_SAFE_EXCEPTION("LV2 deactivate");

  2615. 

  2616.             if (fHandle2 != nullptr)

  2617.             {

  2618.                 try {

  2619.                     fDescriptor->deactivate(fHandle2);

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

  2621.             }

  2622.         }

  2623.     }

  2624. 

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

  2626.     {

  2627.         // --------------------------------------------------------------------------------------------------------

  2628.         // Check if active

  2629. 

  2630.         if (! pData->active)

  2631.         {

  2632.             // disable any output sound

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

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

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

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

  2637.             return;

  2638.         }

  2639. 

  2640.         // --------------------------------------------------------------------------------------------------------

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

  2642. 

  2643.         LV2_Atom_Buffer_Iterator evInAtomIters[fEventsIn.count];

  2644.         LV2_Event_Iterator       evInEventIters[fEventsIn.count];

  2645.         LV2_MIDIState            evInMidiStates[fEventsIn.count];

  2646. 

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

  2648.         {

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

  2650.             {

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

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

  2653.             }

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

  2655.             {

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

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

  2658.             }

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

  2660.             {

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

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

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

  2664.                 evInMidiStates[i].frame_count = frames;

  2665.                 evInMidiStates[i].position    = 0;

  2666.             }

  2667.         }

  2668. 

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

  2670.         {

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

  2672.             {

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

  2674.             }

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

  2676.             {

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

  2678.             }

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

  2680.             {

  2681.                 // not needed

  2682.             }

  2683.         }

  2684. 

  2685.         // --------------------------------------------------------------------------------------------------------

  2686.         // Check if needs reset

  2687. 

  2688.         if (pData->needsReset)

  2689.         {

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

  2691. 

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

  2693.             {

  2694.                 const uint32_t j = fEventsIn.ctrlIndex;

  2695. 

  2696.                 if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  2697.                 {

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

  2699.                     {

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

  2701.                         midiData[1] = MIDI_CONTROL_ALL_NOTES_OFF;

  2702. 

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

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

  2705. 

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

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

  2708. 

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

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

  2711. 

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

  2713.                         midiData[1] = MIDI_CONTROL_ALL_SOUND_OFF;

  2714. 

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

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

  2717. 

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

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

  2720. 

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

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

  2723.                     }

  2724.                 }

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

  2726.                 {

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

  2728.                     {

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

  2730.                         midiData[1] = k;

  2731. 

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

  2733.                             lv2_atom_buffer_write(&evInAtomIters[k], 0, 0, CARLA_URI_MAP_ID_MIDI_EVENT, 3, midiData);

  2734. 

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

  2736.                             lv2_event_write(&evInEventIters[k], 0, 0, CARLA_URI_MAP_ID_MIDI_EVENT, 3, midiData);

  2737. 

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

  2739.                             lv2midi_put_event(&evInMidiStates[k], 0.0, 3, midiData);

  2740.                     }

  2741.                 }

  2742.             }

  2743. 

  2744. #ifndef BUILD_BRIDGE

  2745. #if 0 // TODO

  2746.             if (pData->latency > 0)

  2747.             {

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

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

  2750.             }

  2751. #endif

  2752. #endif

  2753. 

  2754.             pData->needsReset = false;

  2755.         }

  2756. 

  2757.         // --------------------------------------------------------------------------------------------------------

  2758.         // TimeInfo

  2759. 

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

  2761. 

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

  2763.         {

  2764.             bool doPostRt;

  2765.             int32_t rindex;

  2766. 

  2767.             // update input ports

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

  2769.             {

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

  2771.                     continue;

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

  2773.                     continue;

  2774. 

  2775.                 doPostRt = false;

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

  2777. 

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

  2779. 

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

  2781.                 {

  2782.                 // Non-BBT

  2783.                 case LV2_PORT_DESIGNATION_TIME_SPEED:

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

  2785.                     {

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

  2787.                         doPostRt = true;

  2788.                     }

  2789.                     break;

  2790.                 case LV2_PORT_DESIGNATION_TIME_FRAME:

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

  2792.                     {

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

  2794.                         doPostRt = true;

  2795.                     }

  2796.                     break;

  2797.                 case LV2_PORT_DESIGNATION_TIME_FRAMES_PER_SECOND:

  2798.                     break;

  2799. 

  2800.                 // BBT

  2801.                 case LV2_PORT_DESIGNATION_TIME_BAR:

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

  2803.                     {

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

  2805.                         doPostRt = true;

  2806.                     }

  2807.                     break;

  2808.                 case LV2_PORT_DESIGNATION_TIME_BAR_BEAT:

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

  2810.                                                                               !carla_compareFloats(fLastTimeInfo.bbt.ticksPerBeat, timeInfo.bbt.ticksPerBeat)))

  2811.                     {

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

  2813.                         doPostRt = true;

  2814.                     }

  2815.                     break;

  2816.                 case LV2_PORT_DESIGNATION_TIME_BEAT:

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

  2818.                     {

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

  2820.                         doPostRt = true;

  2821.                     }

  2822.                     break;

  2823.                 case LV2_PORT_DESIGNATION_TIME_BEAT_UNIT:

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

  2825.                     {

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

  2827.                         doPostRt = true;

  2828.                     }

  2829.                     break;

  2830.                 case LV2_PORT_DESIGNATION_TIME_BEATS_PER_BAR:

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

  2832.                     {

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

  2834.                         doPostRt = true;

  2835.                     }

  2836.                     break;

  2837.                 case LV2_PORT_DESIGNATION_TIME_BEATS_PER_MINUTE:

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

  2839.                     {

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

  2841.                         doPostRt = true;

  2842.                     }

  2843.                     break;

  2844.                 case LV2_PORT_DESIGNATION_TIME_TICKS_PER_BEAT:

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

  2846.                     {

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

  2848.                         doPostRt = true;

  2849.                     }

  2850.                     break;

  2851.                 }

  2852. 

  2853.                 if (doPostRt)

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

  2855.             }

  2856. 

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

  2858.             {

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

  2860.                     continue;

  2861. 

  2862.                 uint8_t timeInfoBuf[256];

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

  2864. 

  2865.                 LV2_Atom_Forge_Frame forgeFrame;

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

  2867. 

  2868.                 lv2_atom_forge_key(&fAtomForge, CARLA_URI_MAP_ID_TIME_SPEED);

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

  2870. 

  2871.                 lv2_atom_forge_key(&fAtomForge, CARLA_URI_MAP_ID_TIME_FRAME);

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

  2873. 

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

  2875.                 {

  2876.                     lv2_atom_forge_key(&fAtomForge, CARLA_URI_MAP_ID_TIME_BAR);

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

  2878. 

  2879.                     lv2_atom_forge_key(&fAtomForge, CARLA_URI_MAP_ID_TIME_BAR_BEAT);

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

  2881. 

  2882.                     lv2_atom_forge_key(&fAtomForge, CARLA_URI_MAP_ID_TIME_BEAT);

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

  2884. 

  2885.                     lv2_atom_forge_key(&fAtomForge, CARLA_URI_MAP_ID_TIME_BEAT_UNIT);

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

  2887. 

  2888.                     lv2_atom_forge_key(&fAtomForge, CARLA_URI_MAP_ID_TIME_BEATS_PER_BAR);

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

  2890. 

  2891.                     lv2_atom_forge_key(&fAtomForge, CARLA_URI_MAP_ID_TIME_BEATS_PER_MINUTE);

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

  2893. 

  2894.                     lv2_atom_forge_key(&fAtomForge, CARLA_URI_MAP_ID_TIME_TICKS_PER_BEAT);

  2895.                     lv2_atom_forge_double(&fAtomForge, static_cast<float>(timeInfo.bbt.ticksPerBeat));

  2896.                 }

  2897. 

  2898.                 lv2_atom_forge_pop(&fAtomForge, &forgeFrame);

  2899. 

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

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

  2902. 

  2903.                 // send only deprecated blank object for now

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

  2905. 

  2906.                 // for atom:object

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

  2908.             }

  2909. 

  2910.             pData->postRtEvents.trySplice();

  2911. 

  2912.             carla_copyStruct<EngineTimeInfo>(fLastTimeInfo, timeInfo);

  2913.         }

  2914. 

  2915.         // --------------------------------------------------------------------------------------------------------

  2916.         // Event Input and Processing

  2917. 

  2918.         if (fEventsIn.ctrl != nullptr)

  2919.         {

  2920.             // ----------------------------------------------------------------------------------------------------

  2921.             // Message Input

  2922. 

  2923.             if (fAtomBufferIn.tryLock())

  2924.             {

  2925.                 if (fAtomBufferIn.isDataAvailableForReading())

  2926.                 {

  2927.                     const LV2_Atom* atom;

  2928.                     uint32_t j, portIndex;

  2929. 

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

  2931.                     {

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

  2933. 

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

  2935.                         {

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

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

  2938.                         }

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

  2940.                         {

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

  2942.                             continue;

  2943.                         }

  2944.                     }

  2945.                 }

  2946. 

  2947.                 fAtomBufferIn.unlock();

  2948.             }

  2949. 

  2950.             // ----------------------------------------------------------------------------------------------------

  2951.             // MIDI Input (External)

  2952. 

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

  2954.             {

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

  2956.                 {

  2957.                     // does not handle MIDI

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

  2959.                 }

  2960.                 else

  2961.                 {

  2962.                     const uint32_t j = fEventsIn.ctrlIndex;

  2963. 

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

  2965.                     {

  2966.                         const ExternalMidiNote& note(it.getValue());

  2967. 

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

  2969. 

  2970.                         uint8_t midiEvent[3];

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

  2972.                         midiEvent[1] = note.note;

  2973.                         midiEvent[2] = note.velo;

  2974. 

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

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

  2977. 

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

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

  2980. 

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

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

  2983.                     }

  2984. 

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

  2986.                 }

  2987. 

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

  2989. 

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

  2991. 

  2992.             // ----------------------------------------------------------------------------------------------------

  2993.             // Event Input (System)

  2994. 

  2995. #ifndef BUILD_BRIDGE

  2996.             bool allNotesOffSent  = false;

  2997. #endif

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

  2999. 

  3000.             uint32_t startTime  = 0;

  3001.             uint32_t timeOffset = 0;

  3002.             uint32_t nextBankId;

  3003. 

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

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

  3006.             else

  3007.                 nextBankId = 0;

  3008. 

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

  3010. 

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

  3012.             {

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

  3014. 

  3015.                 if (event.time >= frames)

  3016.                     continue;

  3017. 

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

  3019. 

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

  3021.                 {

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

  3023.                     {

  3024.                         startTime  = 0;

  3025.                         timeOffset = event.time;

  3026. 

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

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

  3029.                         else

  3030.                             nextBankId = 0;

  3031. 

  3032.                         // reset iters

  3033.                         const uint32_t j = fEventsIn.ctrlIndex;

  3034. 

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

  3036.                         {

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

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

  3039.                         }

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

  3041.                         {

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

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

  3044.                         }

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

  3046.                         {

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

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

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

  3050.                         }

  3051.                     }

  3052.                     else

  3053.                         startTime += timeOffset;

  3054.                 }

  3055. 

  3056.                 switch (event.type)

  3057.                 {

  3058.                 case kEngineEventTypeNull:

  3059.                     break;

  3060. 

  3061.                 case kEngineEventTypeControl: {

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

  3063. 

  3064.                     switch (ctrlEvent.type)

  3065.                     {

  3066.                     case kEngineControlEventTypeNull:

  3067.                         break;

  3068. 

  3069.                     case kEngineControlEventTypeParameter: {

  3070. #ifndef BUILD_BRIDGE

  3071.                         // Control backend stuff

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

  3073.                         {

  3074.                             float value;

  3075. 

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

  3077.                             {

  3078.                                 value = ctrlEvent.value;

  3079.                                 setDryWet(value, false, false);

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

  3081.                                 break;

  3082.                             }

  3083. 

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

  3085.                             {

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

  3087.                                 setVolume(value, false, false);

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

  3089.                                 break;

  3090.                             }

  3091. 

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

  3093.                             {

  3094.                                 float left, right;

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

  3096. 

  3097.                                 if (value < 0.0f)

  3098.                                 {

  3099.                                     left  = -1.0f;

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

  3101.                                 }

  3102.                                 else if (value > 0.0f)

  3103.                                 {

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

  3105.                                     right = 1.0f;

  3106.                                 }

  3107.                                 else

  3108.                                 {

  3109.                                     left  = -1.0f;

  3110.                                     right = 1.0f;

  3111.                                 }

  3112. 

  3113.                                 setBalanceLeft(left, false, false);

  3114.                                 setBalanceRight(right, false, false);

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

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

  3117.                                 break;

  3118.                             }

  3119.                         }

  3120. #endif

  3121.                         // Control plugin parameters

  3122.                         uint32_t k;

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

  3124.                         {

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

  3126.                                 continue;

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

  3128.                                 continue;

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

  3130.                                 continue;

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

  3132.                                 continue;

  3133. 

  3134.                             float value;

  3135. 

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

  3137.                             {

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

  3139.                             }

  3140.                             else

  3141.                             {

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

  3143. 

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

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

  3146.                             }

  3147. 

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

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

  3150.                             break;

  3151.                         }

  3152. 

  3153.                         // check if event is already handled

  3154.                         if (k != pData->param.count)

  3155.                             break;

  3156. 

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

  3158.                         {

  3159.                             uint8_t midiData[3];

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

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

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

  3163. 

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

  3165. 

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

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

  3168. 

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

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

  3171. 

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

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

  3174.                         }

  3175.                         break;

  3176.                     } // case kEngineControlEventTypeParameter

  3177. 

  3178.                     case kEngineControlEventTypeMidiBank:

  3179.                         if (pData->options & PLUGIN_OPTION_MAP_PROGRAM_CHANGES)

  3180.                         {

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

  3182.                                 nextBankId = ctrlEvent.param;

  3183.                         }

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

  3185.                         {

  3186.                             uint8_t midiData[3];

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

  3188.                             midiData[1] = MIDI_CONTROL_BANK_SELECT;

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

  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.                         break;

  3203. 

  3204.                     case kEngineControlEventTypeMidiProgram:

  3205.                         if (pData->options & PLUGIN_OPTION_MAP_PROGRAM_CHANGES)

  3206.                         {

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

  3208.                             {

  3209.                                 const uint32_t nextProgramId = ctrlEvent.param;

  3210. 

  3211.                                 for (uint32_t k=0; k < pData->midiprog.count; ++k)

  3212.                                 {

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

  3214.                                     {

  3215.                                         const int32_t index(static_cast<int32_t>(k));

  3216.                                         setMidiProgram(index, false, false, false);

  3217.                                         pData->postponeRtEvent(kPluginPostRtEventMidiProgramChange, index, 0, 0.0f);

  3218.                                         break;

  3219.                                     }

  3220.                                 }

  3221.                             }

  3222.                         }

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

  3224.                         {

  3225.                             uint8_t midiData[2];

  3226.                             midiData[0] = uint8_t(MIDI_STATUS_PROGRAM_CHANGE | (event.channel & MIDI_CHANNEL_BIT));

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

  3228. 

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

  3230. 

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

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

  3233. 

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

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

  3236. 

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

  3238.                                 lv2midi_put_event(&evInMidiStates[fEventsIn.ctrlIndex], mtime, 2, midiData);

  3239.                         }

  3240.                         break;

  3241. 

  3242.                     case kEngineControlEventTypeAllSoundOff:

  3243.                         if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  3244.                         {

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

  3246. 

  3247.                             uint8_t midiData[3];

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

  3249.                             midiData[1] = MIDI_CONTROL_ALL_SOUND_OFF;

  3250.                             midiData[2] = 0;

  3251. 

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

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

  3254. 

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

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

  3257. 

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

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

  3260.                         }

  3261.                         break;

  3262. 

  3263.                     case kEngineControlEventTypeAllNotesOff:

  3264.                         if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  3265.                         {

  3266. #ifndef BUILD_BRIDGE

  3267.                             if (event.channel == pData->ctrlChannel && ! allNotesOffSent)

  3268.                             {

  3269.                                 allNotesOffSent = true;

  3270.                                 sendMidiAllNotesOffToCallback();

  3271.                             }

  3272. #endif

  3273. 

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

  3275. 

  3276.                             uint8_t midiData[3];

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

  3278.                             midiData[1] = MIDI_CONTROL_ALL_NOTES_OFF;

  3279.                             midiData[2] = 0;

  3280. 

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

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

  3283. 

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

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

  3286. 

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

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

  3289.                         }

  3290.                         break;

  3291.                     } // switch (ctrlEvent.type)

  3292.                     break;

  3293.                 } // case kEngineEventTypeControl

  3294. 

  3295.                 case kEngineEventTypeMidi: {

  3296.                     const EngineMidiEvent& midiEvent(event.midi);

  3297. 

  3298.                     const uint8_t* const midiData(midiEvent.size > EngineMidiEvent::kDataSize ? midiEvent.dataExt : midiEvent.data);

  3299. 

  3300.                     uint8_t status = uint8_t(MIDI_GET_STATUS_FROM_DATA(midiData));

  3301. 

  3302.                     if (status == MIDI_STATUS_CHANNEL_PRESSURE && (pData->options & PLUGIN_OPTION_SEND_CHANNEL_PRESSURE) == 0)

  3303.                         continue;

  3304.                     if (status == MIDI_STATUS_CONTROL_CHANGE && (pData->options & PLUGIN_OPTION_SEND_CONTROL_CHANGES) == 0)

  3305.                         continue;

  3306.                     if (status == MIDI_STATUS_POLYPHONIC_AFTERTOUCH && (pData->options & PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH) == 0)

  3307.                         continue;

  3308.                     if (status == MIDI_STATUS_PITCH_WHEEL_CONTROL && (pData->options & PLUGIN_OPTION_SEND_PITCHBEND) == 0)

  3309.                         continue;

  3310. 

  3311.                     // Fix bad note-off (per LV2 spec)

  3312.                     if (status == MIDI_STATUS_NOTE_ON && midiData[2] == 0)

  3313.                         status = MIDI_STATUS_NOTE_OFF;

  3314. 

  3315.                     const uint32_t j     = fEventsIn.ctrlIndex;

  3316.                     const uint32_t mtime = isSampleAccurate ? startTime : event.time;

  3317. 

  3318.                     // put back channel in data

  3319.                     uint8_t midiData2[midiEvent.size];

  3320.                     midiData2[0] = uint8_t(status | (event.channel & MIDI_CHANNEL_BIT));

  3321.                     std::memcpy(midiData2+1, midiData+1, static_cast<std::size_t>(midiEvent.size-1));

  3322. 

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

  3324.                         lv2_atom_buffer_write(&evInAtomIters[j], mtime, 0, CARLA_URI_MAP_ID_MIDI_EVENT, midiEvent.size, midiData2);

  3325. 

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

  3327.                         lv2_event_write(&evInEventIters[j], mtime, 0, CARLA_URI_MAP_ID_MIDI_EVENT, midiEvent.size, midiData2);

  3328. 

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

  3330.                         lv2midi_put_event(&evInMidiStates[j], mtime, midiEvent.size, midiData2);

  3331. 

  3332.                     if (status == MIDI_STATUS_NOTE_ON)

  3333.                         pData->postponeRtEvent(kPluginPostRtEventNoteOn, event.channel, midiData[1], midiData[2]);

  3334.                     else if (status == MIDI_STATUS_NOTE_OFF)

  3335.                         pData->postponeRtEvent(kPluginPostRtEventNoteOff, event.channel, midiData[1], 0.0f);

  3336.                 } break;

  3337.                 } // switch (event.type)

  3338.             }

  3339. 

  3340.             pData->postRtEvents.trySplice();

  3341. 

  3342.             if (frames > timeOffset)

  3343.                 processSingle(audioIn, audioOut, cvIn, cvOut, frames - timeOffset, timeOffset);

  3344. 

  3345.         } // End of Event Input and Processing

  3346. 

  3347.         // --------------------------------------------------------------------------------------------------------

  3348.         // Plugin processing (no events)

  3349. 

  3350.         else

  3351.         {

  3352.             processSingle(audioIn, audioOut, cvIn, cvOut, frames, 0);

  3353. 

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

  3355. 

  3356. #ifndef BUILD_BRIDGE

  3357. #if 0 // TODO

  3358.         // --------------------------------------------------------------------------------------------------------

  3359.         // Latency, save values for next callback

  3360. 

  3361.         if (fLatencyIndex != -1)

  3362.         {

  3363.             if (pData->latency != static_cast<uint32_t>(fParamBuffers[fLatencyIndex]))

  3364.             {

  3365.                 fLatencyChanged = true;

  3366.             }

  3367.             else if (pData->latency > 0)

  3368.             {

  3369.                 if (pData->latency <= frames)

  3370.                 {

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

  3372.                         FloatVectorOperations::copy(pData->latencyBuffers[i], audioIn[i]+(frames-pData->latency), static_cast<int>(pData->latency));

  3373.                 }

  3374.                 else

  3375.                 {

  3376.                     for (uint32_t i=0, j, k; i < pData->audioIn.count; ++i)

  3377.                     {

  3378.                         for (k=0; k < pData->latency-frames; ++k)

  3379.                             pData->latencyBuffers[i][k] = pData->latencyBuffers[i][k+frames];

  3380.                         for (j=0; k < pData->latency; ++j, ++k)

  3381.                             pData->latencyBuffers[i][k] = audioIn[i][j];

  3382.                     }

  3383.                 }

  3384.             }

  3385.         }

  3386. #endif

  3387. #endif

  3388. 

  3389.         // --------------------------------------------------------------------------------------------------------

  3390.         // MIDI Output

  3391. 

  3392.         if (fEventsOut.ctrl != nullptr)

  3393.         {

  3394.             if (fEventsOut.ctrl->type & CARLA_EVENT_DATA_ATOM)

  3395.             {

  3396.                 const LV2_Atom_Event* ev;

  3397.                 LV2_Atom_Buffer_Iterator iter;

  3398. 

  3399.                 uint8_t* data;

  3400.                 lv2_atom_buffer_begin(&iter, fEventsOut.ctrl->atom);

  3401. 

  3402.                 for (;;)

  3403.                 {

  3404.                     data = nullptr;

  3405.                     ev = lv2_atom_buffer_get(&iter, &data);

  3406. 

  3407.                     if (ev == nullptr || ev->body.size == 0 || data == nullptr)

  3408.                         break;

  3409. 

  3410.                     if (ev->body.type == CARLA_URI_MAP_ID_MIDI_EVENT)

  3411.                     {

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

  3413.                         {

  3414.                             CARLA_SAFE_ASSERT_CONTINUE(ev->time.frames >= 0);

  3415.                             CARLA_SAFE_ASSERT_CONTINUE(ev->body.size < 0xFF);

  3416.                             fEventsOut.ctrl->port->writeMidiEvent(static_cast<uint32_t>(ev->time.frames), static_cast<uint8_t>(ev->body.size), data);

  3417.                         }

  3418.                     }

  3419.                     else //if (ev->body.type == CARLA_URI_MAP_ID_ATOM_BLANK)

  3420.                     {

  3421.                         //carla_stdout("Got out event, %s", carla_lv2_urid_unmap(this, ev->body.type));

  3422.                         fAtomBufferOut.put(&ev->body, fEventsOut.ctrl->rindex);

  3423.                     }

  3424. 

  3425.                     lv2_atom_buffer_increment(&iter);

  3426.                 }

  3427.             }

  3428.             else if ((fEventsOut.ctrl->type & CARLA_EVENT_DATA_EVENT) != 0 && fEventsOut.ctrl->port != nullptr)

  3429.             {

  3430.                 const LV2_Event* ev;

  3431.                 LV2_Event_Iterator iter;

  3432. 

  3433.                 uint8_t* data;

  3434.                 lv2_event_begin(&iter, fEventsOut.ctrl->event);

  3435. 

  3436.                 for (;;)

  3437.                 {

  3438.                     data = nullptr;

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

  3440. 

  3441.                     if (ev == nullptr || data == nullptr)

  3442.                         break;

  3443. 

  3444.                     if (ev->type == CARLA_URI_MAP_ID_MIDI_EVENT)

  3445.                     {

  3446.                         CARLA_SAFE_ASSERT_CONTINUE(ev->size < 0xFF);

  3447.                         fEventsOut.ctrl->port->writeMidiEvent(ev->frames, static_cast<uint8_t>(ev->size), data);

  3448.                     }

  3449. 

  3450.                     lv2_event_increment(&iter);

  3451.                 }

  3452.             }

  3453.             else if ((fEventsOut.ctrl->type & CARLA_EVENT_DATA_MIDI_LL) != 0 && fEventsOut.ctrl->port != nullptr)

  3454.             {

  3455.                 LV2_MIDIState state = { &fEventsOut.ctrl->midi, frames, 0 };

  3456. 

  3457.                 uint32_t eventSize;

  3458.                 double   eventTime;

  3459.                 uchar* eventData;

  3460. 

  3461.                 for (;;)

  3462.                 {

  3463.                     eventSize = 0;

  3464.                     eventTime = 0.0;

  3465.                     eventData = nullptr;

  3466.                     lv2midi_get_event(&state, &eventTime, &eventSize, &eventData);

  3467. 

  3468.                     if (eventData == nullptr || eventSize == 0)

  3469.                         break;

  3470. 

  3471.                     CARLA_SAFE_ASSERT_CONTINUE(eventSize < 0xFF);

  3472.                     CARLA_SAFE_ASSERT_CONTINUE(eventTime >= 0.0);

  3473. 

  3474.                     fEventsOut.ctrl->port->writeMidiEvent(static_cast<uint32_t>(eventTime), static_cast<uint8_t>(eventSize), eventData);

  3475.                     lv2midi_step(&state);

  3476.                 }

  3477.             }

  3478.         }

  3479. 

  3480. #ifndef BUILD_BRIDGE

  3481.         // --------------------------------------------------------------------------------------------------------

  3482.         // Control Output

  3483. 

  3484.         if (pData->event.portOut != nullptr)

  3485.         {

  3486.             uint8_t  channel;

  3487.             uint16_t param;

  3488.             float    value;

  3489. 

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

  3491.             {

  3492.                 if (pData->param.data[k].type != PARAMETER_OUTPUT)

  3493.                     continue;

  3494. 

  3495.                 pData->param.ranges[k].fixValue(fParamBuffers[k]);

  3496. 

  3497.                 if (pData->param.data[k].midiCC > 0)

  3498.                 {

  3499.                     channel = pData->param.data[k].midiChannel;

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

  3501.                     value   = pData->param.ranges[k].getNormalizedValue(fParamBuffers[k]);

  3502.                     pData->event.portOut->writeControlEvent(0, channel, kEngineControlEventTypeParameter, param, value);

  3503.                 }

  3504.             }

  3505.         } // End of Control Output

  3506. #endif

  3507. 

  3508.         // --------------------------------------------------------------------------------------------------------

  3509.         // Final work

  3510. 

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

  3512.         {

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

  3514. 

  3515.             if (fHandle2 != nullptr)

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

  3517.         }

  3518. 

  3519.         fFirstActive = false;

  3520. 

  3521.         // --------------------------------------------------------------------------------------------------------

  3522.     }

  3523. 

  3524.     bool processSingle(const float** const audioIn, float** const audioOut, const float** const cvIn, float** const cvOut, const uint32_t frames, const uint32_t timeOffset)

  3525.     {

  3526.         CARLA_SAFE_ASSERT_RETURN(frames > 0, false);

  3527. 

  3528.         if (pData->audioIn.count > 0)

  3529.         {

  3530.             CARLA_SAFE_ASSERT_RETURN(audioIn != nullptr, false);

  3531.         }

  3532.         if (pData->audioOut.count > 0)

  3533.         {

  3534.             CARLA_SAFE_ASSERT_RETURN(audioOut != nullptr, false);

  3535.         }

  3536.         if (pData->cvIn.count > 0)

  3537.         {

  3538.             CARLA_SAFE_ASSERT_RETURN(cvIn != nullptr, false);

  3539.         }

  3540.         if (pData->cvOut.count > 0)

  3541.         {

  3542.             CARLA_SAFE_ASSERT_RETURN(cvOut != nullptr, false);

  3543.         }

  3544. 

  3545.         // --------------------------------------------------------------------------------------------------------

  3546.         // Try lock, silence otherwise

  3547. 

  3548.         if (pData->engine->isOffline())

  3549.         {

  3550.             pData->singleMutex.lock();

  3551.         }

  3552.         else if (! pData->singleMutex.tryLock())

  3553.         {

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

  3555.             {

  3556.                 for (uint32_t k=0; k < frames; ++k)

  3557.                     audioOut[i][k+timeOffset] = 0.0f;

  3558.             }

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

  3560.             {

  3561.                 for (uint32_t k=0; k < frames; ++k)

  3562.                     cvOut[i][k+timeOffset] = 0.0f;

  3563.             }

  3564. 

  3565.             return false;

  3566.         }

  3567. 

  3568.         // --------------------------------------------------------------------------------------------------------

  3569.         // Set audio buffers

  3570. 

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

  3572.             FloatVectorOperations::copy(fAudioInBuffers[i], audioIn[i]+timeOffset, static_cast<int>(frames));

  3573. 

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

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

  3576. 

  3577.         // --------------------------------------------------------------------------------------------------------

  3578.         // Set CV buffers

  3579. 

  3580.         for (uint32_t i=0; i < pData->cvIn.count; ++i)

  3581.             FloatVectorOperations::copy(fCvInBuffers[i], cvIn[i]+timeOffset, static_cast<int>(frames));

  3582. 

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

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

  3585. 

  3586.         // --------------------------------------------------------------------------------------------------------

  3587.         // Run plugin

  3588. 

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

  3590. 

  3591.         if (fHandle2 != nullptr)

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

  3593. 

  3594.         // --------------------------------------------------------------------------------------------------------

  3595.         // Handle trigger parameters

  3596. 

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

  3598.         {

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

  3600.                 continue;

  3601. 

  3602.             if (pData->param.data[k].hints & PARAMETER_IS_TRIGGER)

  3603.             {

  3604.                 if (! carla_compareFloats(fParamBuffers[k], pData->param.ranges[k].def))

  3605.                 {

  3606.                     fParamBuffers[k] = pData->param.ranges[k].def;

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

  3608.                 }

  3609.             }

  3610.         }

  3611. 

  3612.         pData->postRtEvents.trySplice();

  3613. 

  3614. #ifndef BUILD_BRIDGE

  3615.         // --------------------------------------------------------------------------------------------------------

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

  3617. 

  3618.         {

  3619.             const bool doDryWet  = (pData->hints & PLUGIN_CAN_DRYWET) != 0 && ! carla_compareFloats(pData->postProc.dryWet, 1.0f);

  3620.             const bool doBalance = (pData->hints & PLUGIN_CAN_BALANCE) != 0 && ! (carla_compareFloats(pData->postProc.balanceLeft, -1.0f) && carla_compareFloats(pData->postProc.balanceRight, 1.0f));

  3621.             const bool isMono    = (pData->audioIn.count == 1);

  3622. 

  3623.             bool isPair;

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

  3625. 

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

  3627.             {

  3628.                 // Dry/Wet

  3629.                 if (doDryWet)

  3630.                 {

  3631.                     for (uint32_t k=0; k < frames; ++k)

  3632.                     {

  3633. #if 0 // TODO

  3634.                         if (k < pData->latency)

  3635.                             bufValue = pData->latencyBuffers[isMono ? 0 : i][k];

  3636.                         else if (pData->latency < frames)

  3637.                             bufValue = fAudioInBuffers[isMono ? 0 : i][k-pData->latency];

  3638.                         else

  3639. #endif

  3640.                             bufValue = fAudioInBuffers[isMono ? 0 : i][k];

  3641. 

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

  3643.                     }

  3644.                 }

  3645. 

  3646.                 // Balance

  3647.                 if (doBalance)

  3648.                 {

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

  3650. 

  3651.                     if (isPair)

  3652.                     {

  3653.                         CARLA_ASSERT(i+1 < pData->audioOut.count);

  3654.                         FloatVectorOperations::copy(oldBufLeft, fAudioOutBuffers[i], static_cast<int>(frames));

  3655.                     }

  3656. 

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

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

  3659. 

  3660.                     for (uint32_t k=0; k < frames; ++k)

  3661.                     {

  3662.                         if (isPair)

  3663.                         {

  3664.                             // left

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

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

  3667.                         }

  3668.                         else

  3669.                         {

  3670.                             // right

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

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

  3673.                         }

  3674.                     }

  3675.                 }

  3676. 

  3677.                 // Volume (and buffer copy)

  3678.                 {

  3679.                     for (uint32_t k=0; k < frames; ++k)

  3680.                         audioOut[i][k+timeOffset] = fAudioOutBuffers[i][k] * pData->postProc.volume;

  3681.                 }

  3682.             }

  3683.         } // End of Post-processing

  3684. 

  3685. #else // BUILD_BRIDGE

  3686.         for (uint32_t i=0; i < pData->audioOut.count; ++i)

  3687.         {

  3688.             for (uint32_t k=0; k < frames; ++k)

  3689.                 audioOut[i][k+timeOffset] = fAudioOutBuffers[i][k];

  3690.         }

  3691. #endif

  3692. 

  3693.         for (uint32_t i=0; i < pData->cvOut.count; ++i)

  3694.         {

  3695.             for (uint32_t k=0; k < frames; ++k)

  3696.                 cvOut[i][k+timeOffset] = fCvOutBuffers[i][k];

  3697.         }

  3698. 

  3699.         // --------------------------------------------------------------------------------------------------------

  3700. 

  3701.         pData->singleMutex.unlock();

  3702.         return true;

  3703.     }

  3704. 

  3705.     void bufferSizeChanged(const uint32_t newBufferSize) override

  3706.     {

  3707.         CARLA_ASSERT_INT(newBufferSize > 0, newBufferSize);

  3708.         carla_debug("CarlaPluginLV2::bufferSizeChanged(%i) - start", newBufferSize);

  3709. 

  3710.         for (uint32_t i=0; i < pData->audioIn.count; ++i)

  3711.         {

  3712.             if (fAudioInBuffers[i] != nullptr)

  3713.                 delete[] fAudioInBuffers[i];

  3714.             fAudioInBuffers[i] = new float[newBufferSize];

  3715.         }

  3716. 

  3717.         for (uint32_t i=0; i < pData->audioOut.count; ++i)

  3718.         {

  3719.             if (fAudioOutBuffers[i] != nullptr)

  3720.                 delete[] fAudioOutBuffers[i];

  3721.             fAudioOutBuffers[i] = new float[newBufferSize];

  3722.         }

  3723. 

  3724.         if (fHandle2 == nullptr)

  3725.         {

  3726.             for (uint32_t i=0; i < pData->audioIn.count; ++i)

  3727.             {

  3728.                 CARLA_ASSERT(fAudioInBuffers[i] != nullptr);

  3729.                 fDescriptor->connect_port(fHandle, pData->audioIn.ports[i].rindex, fAudioInBuffers[i]);

  3730.             }

  3731. 

  3732.             for (uint32_t i=0; i < pData->audioOut.count; ++i)

  3733.             {

  3734.                 CARLA_ASSERT(fAudioOutBuffers[i] != nullptr);

  3735.                 fDescriptor->connect_port(fHandle, pData->audioOut.ports[i].rindex, fAudioOutBuffers[i]);

  3736.             }

  3737.         }

  3738.         else

  3739.         {

  3740.             if (pData->audioIn.count > 0)

  3741.             {

  3742.                 CARLA_ASSERT(pData->audioIn.count == 2);

  3743.                 CARLA_ASSERT(fAudioInBuffers[0] != nullptr);

  3744.                 CARLA_ASSERT(fAudioInBuffers[1] != nullptr);

  3745. 

  3746.                 fDescriptor->connect_port(fHandle,  pData->audioIn.ports[0].rindex, fAudioInBuffers[0]);

  3747.                 fDescriptor->connect_port(fHandle2, pData->audioIn.ports[1].rindex, fAudioInBuffers[1]);

  3748.             }

  3749. 

  3750.             if (pData->audioOut.count > 0)

  3751.             {

  3752.                 CARLA_ASSERT(pData->audioOut.count == 2);

  3753.                 CARLA_ASSERT(fAudioOutBuffers[0] != nullptr);

  3754.                 CARLA_ASSERT(fAudioOutBuffers[1] != nullptr);

  3755. 

  3756.                 fDescriptor->connect_port(fHandle,  pData->audioOut.ports[0].rindex, fAudioOutBuffers[0]);

  3757.                 fDescriptor->connect_port(fHandle2, pData->audioOut.ports[1].rindex, fAudioOutBuffers[1]);

  3758.             }

  3759.         }

  3760. 

  3761.         for (uint32_t i=0; i < pData->cvIn.count; ++i)

  3762.         {

  3763.             if (fCvInBuffers[i] != nullptr)

  3764.                 delete[] fCvInBuffers[i];

  3765.             fCvInBuffers[i] = new float[newBufferSize];

  3766. 

  3767.             fDescriptor->connect_port(fHandle, pData->cvIn.ports[i].rindex, fCvInBuffers[i]);

  3768. 

  3769.             if (fHandle2 != nullptr)

  3770.                 fDescriptor->connect_port(fHandle2, pData->cvIn.ports[i].rindex, fCvInBuffers[i]);

  3771.         }

  3772. 

  3773.         for (uint32_t i=0; i < pData->cvOut.count; ++i)

  3774.         {

  3775.             if (fCvOutBuffers[i] != nullptr)

  3776.                 delete[] fCvOutBuffers[i];

  3777.             fCvOutBuffers[i] = new float[newBufferSize];

  3778. 

  3779.             fDescriptor->connect_port(fHandle, pData->cvOut.ports[i].rindex, fCvOutBuffers[i]);

  3780. 

  3781.             if (fHandle2 != nullptr)

  3782.                 fDescriptor->connect_port(fHandle2, pData->cvOut.ports[i].rindex, fCvOutBuffers[i]);

  3783.         }

  3784. 

  3785.         const int newBufferSizeInt(static_cast<int>(newBufferSize));

  3786. 

  3787.         if (fLv2Options.maxBufferSize != newBufferSizeInt || (fLv2Options.minBufferSize != 1 && fLv2Options.minBufferSize != newBufferSizeInt))

  3788.         {

  3789.             fLv2Options.maxBufferSize = newBufferSizeInt;

  3790. 

  3791.             if (fLv2Options.minBufferSize != 1)

  3792.                 fLv2Options.minBufferSize = newBufferSizeInt;

  3793. 

  3794.             if (fExt.options != nullptr && fExt.options->set != nullptr)

  3795.             {

  3796.                 fExt.options->set(fHandle, &fLv2Options.opts[CarlaPluginLV2Options::MaxBlockLenth]);

  3797.                 fExt.options->set(fHandle, &fLv2Options.opts[CarlaPluginLV2Options::MinBlockLenth]);

  3798.             }

  3799.         }

  3800. 

  3801.         carla_debug("CarlaPluginLV2::bufferSizeChanged(%i) - end", newBufferSize);

  3802.     }

  3803. 

  3804.     void sampleRateChanged(const double newSampleRate) override

  3805.     {

  3806.         CARLA_ASSERT_INT(newSampleRate > 0.0, newSampleRate);

  3807.         carla_debug("CarlaPluginLV2::sampleRateChanged(%g) - start", newSampleRate);

  3808. 

  3809.         if (! carla_compareFloats(fLv2Options.sampleRate, newSampleRate))

  3810.         {

  3811.             fLv2Options.sampleRate = newSampleRate;

  3812. 

  3813.             if (fExt.options != nullptr && fExt.options->set != nullptr)

  3814.                 fExt.options->set(fHandle, &fLv2Options.opts[CarlaPluginLV2Options::SampleRate]);

  3815.         }

  3816. 

  3817.         for (uint32_t k=0; k < pData->param.count; ++k)

  3818.         {

  3819.             if (pData->param.data[k].type == PARAMETER_INPUT && pData->param.special[k] == PARAMETER_SPECIAL_SAMPLE_RATE)

  3820.             {

  3821.                 fParamBuffers[k] = static_cast<float>(newSampleRate);

  3822.                 pData->postponeRtEvent(kPluginPostRtEventParameterChange, static_cast<int32_t>(k), 1, fParamBuffers[k]);

  3823.                 break;

  3824.             }

  3825.         }

  3826. 

  3827.         carla_debug("CarlaPluginLV2::sampleRateChanged(%g) - end", newSampleRate);

  3828.     }

  3829. 

  3830.     void offlineModeChanged(const bool isOffline) override

  3831.     {

  3832.         for (uint32_t k=0; k < pData->param.count; ++k)

  3833.         {

  3834.             if (pData->param.data[k].type == PARAMETER_INPUT && pData->param.special[k] == PARAMETER_SPECIAL_FREEWHEEL)

  3835.             {

  3836.                 fParamBuffers[k] = isOffline ? pData->param.ranges[k].max : pData->param.ranges[k].min;

  3837.                 pData->postponeRtEvent(kPluginPostRtEventParameterChange, static_cast<int32_t>(k), 1, fParamBuffers[k]);

  3838.                 break;

  3839.             }

  3840.         }

  3841.     }

  3842. 

  3843.     // -------------------------------------------------------------------

  3844.     // Plugin buffers

  3845. 

  3846.     void initBuffers() const noexcept override

  3847.     {

  3848.         fEventsIn.initBuffers();

  3849.         fEventsOut.initBuffers();

  3850. 

  3851.         CarlaPlugin::initBuffers();

  3852.     }

  3853. 

  3854.     void clearBuffers() noexcept override

  3855.     {

  3856.         carla_debug("CarlaPluginLV2::clearBuffers() - start");

  3857. 

  3858.         if (fAudioInBuffers != nullptr)

  3859.         {

  3860.             for (uint32_t i=0; i < pData->audioIn.count; ++i)

  3861.             {

  3862.                 if (fAudioInBuffers[i] != nullptr)

  3863.                 {

  3864.                     delete[] fAudioInBuffers[i];

  3865.                     fAudioInBuffers[i] = nullptr;

  3866.                 }

  3867.             }

  3868. 

  3869.             delete[] fAudioInBuffers;

  3870.             fAudioInBuffers = nullptr;

  3871.         }

  3872. 

  3873.         if (fAudioOutBuffers != nullptr)

  3874.         {

  3875.             for (uint32_t i=0; i < pData->audioOut.count; ++i)

  3876.             {

  3877.                 if (fAudioOutBuffers[i] != nullptr)

  3878.                 {

  3879.                     delete[] fAudioOutBuffers[i];

  3880.                     fAudioOutBuffers[i] = nullptr;

  3881.                 }

  3882.             }

  3883. 

  3884.             delete[] fAudioOutBuffers;

  3885.             fAudioOutBuffers = nullptr;

  3886.         }

  3887. 

  3888.         if (fCvInBuffers != nullptr)

  3889.         {

  3890.             for (uint32_t i=0; i < pData->cvIn.count; ++i)

  3891.             {

  3892.                 if (fCvInBuffers[i] != nullptr)

  3893.                 {

  3894.                     delete[] fCvInBuffers[i];

  3895.                     fCvInBuffers[i] = nullptr;

  3896.                 }

  3897.             }

  3898. 

  3899.             delete[] fCvInBuffers;

  3900.             fCvInBuffers = nullptr;

  3901.         }

  3902. 

  3903.         if (fCvOutBuffers != nullptr)

  3904.         {

  3905.             for (uint32_t i=0; i < pData->cvOut.count; ++i)

  3906.             {

  3907.                 if (fCvOutBuffers[i] != nullptr)

  3908.                 {

  3909.                     delete[] fCvOutBuffers[i];

  3910.                     fCvOutBuffers[i] = nullptr;

  3911.                 }

  3912.             }

  3913. 

  3914.             delete[] fCvOutBuffers;

  3915.             fCvOutBuffers = nullptr;

  3916.         }

  3917. 

  3918.         if (fParamBuffers != nullptr)

  3919.         {

  3920.             delete[] fParamBuffers;

  3921.             fParamBuffers = nullptr;

  3922.         }

  3923. 

  3924.         fEventsIn.clear();

  3925.         fEventsOut.clear();

  3926. 

  3927.         CarlaPlugin::clearBuffers();

  3928. 

  3929.         carla_debug("CarlaPluginLV2::clearBuffers() - end");

  3930.     }

  3931. 

  3932.     // -------------------------------------------------------------------

  3933.     // Post-poned UI Stuff

  3934. 

  3935.     void uiParameterChange(const uint32_t index, const float value) noexcept override

  3936.     {

  3937.         CARLA_SAFE_ASSERT_RETURN(fUI.type != UI::TYPE_NULL,);

  3938.         CARLA_SAFE_ASSERT_RETURN(index < pData->param.count,);

  3939. 

  3940.         if (fUI.type == UI::TYPE_BRIDGE)

  3941.         {

  3942.             if (fPipeServer.isPipeRunning())

  3943.                 fPipeServer.writeControlMessage(static_cast<uint32_t>(pData->param.data[index].rindex), value);

  3944.         }

  3945.         else

  3946.         {

  3947.             if (fUI.handle != nullptr && fUI.descriptor != nullptr && fUI.descriptor->port_event != nullptr && ! fNeedsUiClose)

  3948.             {

  3949.                 CARLA_SAFE_ASSERT_RETURN(pData->param.data[index].rindex >= 0,);

  3950.                 fUI.descriptor->port_event(fUI.handle, static_cast<uint32_t>(pData->param.data[index].rindex), sizeof(float), CARLA_URI_MAP_ID_NULL, &value);

  3951.             }

  3952.         }

  3953.     }

  3954. 

  3955.     void uiMidiProgramChange(const uint32_t index) noexcept override

  3956.     {

  3957.         CARLA_SAFE_ASSERT_RETURN(fUI.type != UI::TYPE_NULL,);

  3958.         CARLA_SAFE_ASSERT_RETURN(index < pData->midiprog.count,);

  3959. 

  3960.         if (fUI.type == UI::TYPE_BRIDGE)

  3961.         {

  3962.             if (fPipeServer.isPipeRunning())

  3963.                 fPipeServer.writeProgramMessage(index);

  3964.         }

  3965.         else

  3966.         {

  3967.             if (fExt.uiprograms != nullptr && fExt.uiprograms->select_program != nullptr && ! fNeedsUiClose)

  3968.                 fExt.uiprograms->select_program(fUI.handle, pData->midiprog.data[index].bank, pData->midiprog.data[index].program);

  3969.         }

  3970.     }

  3971. 

  3972.     void uiNoteOn(const uint8_t channel, const uint8_t note, const uint8_t velo) noexcept override

  3973.     {

  3974.         CARLA_SAFE_ASSERT_RETURN(fUI.type != UI::TYPE_NULL,);

  3975.         CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  3976.         CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

  3977.         CARLA_SAFE_ASSERT_RETURN(velo > 0 && velo < MAX_MIDI_VALUE,);

  3978. 

  3979.         if (fUI.type == UI::TYPE_BRIDGE)

  3980.         {

  3981.             if (fPipeServer.isPipeRunning())

  3982.                 fPipeServer.writeMidiNoteMessage(false, channel, note, velo);

  3983.         }

  3984.         else

  3985.         {

  3986.             if (fUI.handle != nullptr && fUI.descriptor != nullptr && fUI.descriptor->port_event != nullptr && fEventsIn.ctrl != nullptr && ! fNeedsUiClose)

  3987.             {

  3988.                 LV2_Atom_MidiEvent midiEv;

  3989.                 midiEv.atom.type = CARLA_URI_MAP_ID_MIDI_EVENT;

  3990.                 midiEv.atom.size = 3;

  3991.                 midiEv.data[0] = uint8_t(MIDI_STATUS_NOTE_ON | (channel & MIDI_CHANNEL_BIT));

  3992.                 midiEv.data[1] = note;

  3993.                 midiEv.data[2] = velo;

  3994. 

  3995.                 fUI.descriptor->port_event(fUI.handle, fEventsIn.ctrl->rindex, lv2_atom_total_size(midiEv), CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT, &midiEv);

  3996.             }

  3997.         }

  3998.     }

  3999. 

  4000.     void uiNoteOff(const uint8_t channel, const uint8_t note) noexcept override

  4001.     {

  4002.         CARLA_SAFE_ASSERT_RETURN(fUI.type != UI::TYPE_NULL,);

  4003.         CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  4004.         CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

  4005. 

  4006.         if (fUI.type == UI::TYPE_BRIDGE)

  4007.         {

  4008.             if (fPipeServer.isPipeRunning())

  4009.                 fPipeServer.writeMidiNoteMessage(false, channel, note, 0);

  4010.         }

  4011.         else

  4012.         {

  4013.             if (fUI.handle != nullptr && fUI.descriptor != nullptr && fUI.descriptor->port_event != nullptr && fEventsIn.ctrl != nullptr && ! fNeedsUiClose)

  4014.             {

  4015.                 LV2_Atom_MidiEvent midiEv;

  4016.                 midiEv.atom.type = CARLA_URI_MAP_ID_MIDI_EVENT;

  4017.                 midiEv.atom.size = 3;

  4018.                 midiEv.data[0] = uint8_t(MIDI_STATUS_NOTE_OFF | (channel & MIDI_CHANNEL_BIT));

  4019.                 midiEv.data[1] = note;

  4020.                 midiEv.data[2] = 0;

  4021. 

  4022.                 fUI.descriptor->port_event(fUI.handle, fEventsIn.ctrl->rindex, lv2_atom_total_size(midiEv), CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT, &midiEv);

  4023.             }

  4024.         }

  4025.     }

  4026. 

  4027.     // -------------------------------------------------------------------

  4028. 

  4029.     bool isRealtimeSafe() const noexcept

  4030.     {

  4031.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr, false);

  4032. 

  4033.         for (uint32_t i=0; i < fRdfDescriptor->FeatureCount; ++i)

  4034.         {

  4035.             if (std::strcmp(fRdfDescriptor->Features[i].URI, LV2_CORE__hardRTCapable) == 0)

  4036.                 return true;

  4037.         }

  4038. 

  4039.         return false;

  4040.     }

  4041. 

  4042.     bool needsFixedBuffer() const noexcept

  4043.     {

  4044.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr, false);

  4045. 

  4046.         for (uint32_t i=0; i < fRdfDescriptor->FeatureCount; ++i)

  4047.         {

  4048.             if (std::strcmp(fRdfDescriptor->Features[i].URI, LV2_BUF_SIZE__fixedBlockLength) == 0)

  4049.                 return true;

  4050.         }

  4051. 

  4052.         return false;

  4053.     }

  4054. 

  4055.     // -------------------------------------------------------------------

  4056. 

  4057.     bool isUiBridgeable(const uint32_t uiId) const noexcept

  4058.     {

  4059.         CARLA_SAFE_ASSERT_RETURN(uiId < fRdfDescriptor->UICount, false);

  4060. 

  4061. #ifndef LV2_UIS_ONLY_INPROCESS

  4062.         const LV2_RDF_UI* const rdfUI(&fRdfDescriptor->UIs[uiId]);

  4063. 

  4064.         if (std::strstr(rdfUI->URI, "http://calf.sourceforge.net/plugins/gui/") != nullptr)

  4065.             return false;

  4066. 

  4067.         for (uint32_t i=0; i < rdfUI->FeatureCount; ++i)

  4068.         {

  4069.             if (std::strcmp(rdfUI->Features[i].URI, LV2_INSTANCE_ACCESS_URI) == 0)

  4070.                 return false;

  4071.             if (std::strcmp(rdfUI->Features[i].URI, LV2_DATA_ACCESS_URI) == 0)

  4072.                 return false;

  4073.         }

  4074. 

  4075.         return true;

  4076. #else

  4077.         return false;

  4078. #endif

  4079.     }

  4080. 

  4081.     bool isUiResizable() const noexcept

  4082.     {

  4083.         CARLA_SAFE_ASSERT_RETURN(fUI.rdfDescriptor != nullptr, false);

  4084. 

  4085.         for (uint32_t i=0; i < fUI.rdfDescriptor->FeatureCount; ++i)

  4086.         {

  4087.             if (std::strcmp(fUI.rdfDescriptor->Features[i].URI, LV2_UI__fixedSize) == 0)

  4088.                 return false;

  4089.             if (std::strcmp(fUI.rdfDescriptor->Features[i].URI, LV2_UI__noUserResize) == 0)

  4090.                 return false;

  4091.         }

  4092. 

  4093.         return true;

  4094.     }

  4095. 

  4096.     const char* getUiBridgeBinary(const LV2_Property type) const

  4097.     {

  4098.         CarlaString bridgeBinary(pData->engine->getOptions().binaryDir);

  4099. 

  4100.         if (bridgeBinary.isEmpty())

  4101.             return nullptr;

  4102. 

  4103.         switch (type)

  4104.         {

  4105.         case LV2_UI_GTK2:

  4106.             bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-lv2-gtk2";

  4107.             break;

  4108.         case LV2_UI_GTK3:

  4109.             bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-lv2-gtk3";

  4110.             break;

  4111.         case LV2_UI_QT4:

  4112.             bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-lv2-qt4";

  4113.             break;

  4114.         case LV2_UI_QT5:

  4115.             bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-lv2-qt5";

  4116.             break;

  4117.         case LV2_UI_COCOA:

  4118.             bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-lv2-cocoa";

  4119.             break;

  4120.         case LV2_UI_WINDOWS:

  4121.             bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-lv2-windows";

  4122.             break;

  4123.         case LV2_UI_X11:

  4124.             bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-lv2-x11";

  4125.             break;

  4126.         case LV2_UI_EXTERNAL:

  4127.         case LV2_UI_OLD_EXTERNAL:

  4128.             bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-lv2-external";

  4129.             break;

  4130.         case LV2_UI_MOD:

  4131.             bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-lv2-modgui";

  4132.             break;

  4133.         default:

  4134.             return nullptr;

  4135.         }

  4136. 

  4137. #ifdef CARLA_OS_WIN

  4138.         bridgeBinary += ".exe";

  4139. #endif

  4140. 

  4141.         if (! File(bridgeBinary.buffer()).existsAsFile())

  4142.             return nullptr;

  4143. 

  4144.         return bridgeBinary.dup();

  4145.     }

  4146. 

  4147.     // -------------------------------------------------------------------

  4148. 

  4149.     void recheckExtensions()

  4150.     {

  4151.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr,);

  4152.         carla_debug("CarlaPluginLV2::recheckExtensions()");

  4153. 

  4154.         fExt.options  = nullptr;

  4155.         fExt.programs = nullptr;

  4156.         fExt.state    = nullptr;

  4157.         fExt.worker   = nullptr;

  4158. 

  4159.         if (fRdfDescriptor->ExtensionCount == 0 || fDescriptor->extension_data == nullptr)

  4160.             return;

  4161. 

  4162.         for (uint32_t i=0; i < fRdfDescriptor->ExtensionCount; ++i)

  4163.         {

  4164.             CARLA_SAFE_ASSERT_CONTINUE(fRdfDescriptor->Extensions[i] != nullptr);

  4165. 

  4166.             if (std::strcmp(fRdfDescriptor->Extensions[i], LV2_OPTIONS__interface) == 0)

  4167.                 pData->hints |= PLUGIN_HAS_EXTENSION_OPTIONS;

  4168.             else if (std::strcmp(fRdfDescriptor->Extensions[i], LV2_PROGRAMS__Interface) == 0)

  4169.                 pData->hints |= PLUGIN_HAS_EXTENSION_PROGRAMS;

  4170.             else if (std::strcmp(fRdfDescriptor->Extensions[i], LV2_STATE__interface) == 0)

  4171.                 pData->hints |= PLUGIN_HAS_EXTENSION_STATE;

  4172.             else if (std::strcmp(fRdfDescriptor->Extensions[i], LV2_WORKER__interface) == 0)

  4173.                 pData->hints |= PLUGIN_HAS_EXTENSION_WORKER;

  4174.             else

  4175.                 carla_stdout("Plugin has non-supported extension: '%s'", fRdfDescriptor->Extensions[i]);

  4176.         }

  4177. 

  4178.         if (fDescriptor->extension_data != nullptr)

  4179.         {

  4180.             if (pData->hints & PLUGIN_HAS_EXTENSION_OPTIONS)

  4181.                 fExt.options = (const LV2_Options_Interface*)fDescriptor->extension_data(LV2_OPTIONS__interface);

  4182. 

  4183.             if (pData->hints & PLUGIN_HAS_EXTENSION_PROGRAMS)

  4184.                 fExt.programs = (const LV2_Programs_Interface*)fDescriptor->extension_data(LV2_PROGRAMS__Interface);

  4185. 

  4186.             if (pData->hints & PLUGIN_HAS_EXTENSION_STATE)

  4187.                 fExt.state = (const LV2_State_Interface*)fDescriptor->extension_data(LV2_STATE__interface);

  4188. 

  4189.             if (pData->hints & PLUGIN_HAS_EXTENSION_WORKER)

  4190.                 fExt.worker = (const LV2_Worker_Interface*)fDescriptor->extension_data(LV2_WORKER__interface);

  4191. 

  4192.             // check if invalid

  4193.             if (fExt.options != nullptr && fExt.options->get == nullptr  && fExt.options->set == nullptr)

  4194.                 fExt.options = nullptr;

  4195. 

  4196.             if (fExt.programs != nullptr && (fExt.programs->get_program == nullptr || fExt.programs->select_program == nullptr))

  4197.                 fExt.programs = nullptr;

  4198. 

  4199.             if (fExt.state != nullptr && (fExt.state->save == nullptr || fExt.state->restore == nullptr))

  4200.                 fExt.state = nullptr;

  4201. 

  4202.             if (fExt.worker != nullptr && fExt.worker->work == nullptr)

  4203.                 fExt.worker = nullptr;

  4204.         }

  4205. 

  4206.         CARLA_SAFE_ASSERT_RETURN(fLatencyIndex == -1,);

  4207. 

  4208.         for (uint32_t i=0, count=fRdfDescriptor->PortCount, iCtrl=0; i<count; ++i)

  4209.         {

  4210.             const LV2_Property portTypes(fRdfDescriptor->Ports[i].Types);

  4211. 

  4212.             if (! LV2_IS_PORT_CONTROL(portTypes))

  4213.                 continue;

  4214. 

  4215.             iCtrl++;

  4216. 

  4217.             if (! LV2_IS_PORT_OUTPUT(portTypes))

  4218.                 continue;

  4219. 

  4220.             const LV2_Property portDesignation(fRdfDescriptor->Ports[i].Designation);

  4221. 

  4222.             if (! LV2_IS_PORT_DESIGNATION_LATENCY(portDesignation))

  4223.                 continue;

  4224. 

  4225.             fLatencyIndex = static_cast<int32_t>(iCtrl);

  4226.             break;

  4227.         }

  4228.     }

  4229. 

  4230.     // -------------------------------------------------------------------

  4231. 

  4232.     void updateUi()

  4233.     {

  4234.         CARLA_SAFE_ASSERT_RETURN(fUI.handle != nullptr,);

  4235.         CARLA_SAFE_ASSERT_RETURN(fUI.descriptor != nullptr,);

  4236.         carla_debug("CarlaPluginLV2::updateUi()");

  4237. 

  4238.         // update midi program

  4239.         if (fExt.uiprograms != nullptr && pData->midiprog.count > 0 && pData->midiprog.current >= 0)

  4240.         {

  4241.             const MidiProgramData& curData(pData->midiprog.getCurrent());

  4242.             fExt.uiprograms->select_program(fUI.handle, curData.bank, curData.program);

  4243.         }

  4244. 

  4245.         // update control ports

  4246.         if (fUI.descriptor->port_event != nullptr)

  4247.         {

  4248.             float value;

  4249.             for (uint32_t i=0; i < pData->param.count; ++i)

  4250.             {

  4251.                 value = getParameterValue(i);

  4252.                 fUI.descriptor->port_event(fUI.handle, static_cast<uint32_t>(pData->param.data[i].rindex), sizeof(float), CARLA_URI_MAP_ID_NULL, &value);

  4253.             }

  4254.         }

  4255.     }

  4256. 

  4257.     // -------------------------------------------------------------------

  4258. 

  4259.     LV2_URID getCustomURID(const char* const uri)

  4260.     {

  4261.         CARLA_SAFE_ASSERT_RETURN(uri != nullptr && uri[0] != '\0', CARLA_URI_MAP_ID_NULL);

  4262.         carla_debug("CarlaPluginLV2::getCustomURID(\"%s\")", uri);

  4263. 

  4264.         for (size_t i=0; i < fCustomURIDs.count(); ++i)

  4265.         {

  4266.             const char* const thisUri(fCustomURIDs.getAt(i, nullptr));

  4267.             if (thisUri != nullptr && std::strcmp(thisUri, uri) == 0)

  4268.                 return static_cast<LV2_URID>(i);

  4269.         }

  4270. 

  4271.         const LV2_URID urid(static_cast<LV2_URID>(fCustomURIDs.count()));

  4272. 

  4273.         fCustomURIDs.append(carla_strdup(uri));

  4274. 

  4275.         if (fUI.type == UI::TYPE_BRIDGE && fPipeServer.isPipeRunning())

  4276.             fPipeServer.writeLv2UridMessage(urid, uri);

  4277. 

  4278.         return urid;

  4279.     }

  4280. 

  4281.     const char* getCustomURIDString(const LV2_URID urid) const noexcept

  4282.     {

  4283.         CARLA_SAFE_ASSERT_RETURN(urid != CARLA_URI_MAP_ID_NULL, nullptr);

  4284.         CARLA_SAFE_ASSERT_RETURN(urid < fCustomURIDs.count(), nullptr);

  4285.         carla_debug("CarlaPluginLV2::getCustomURIString(%i)", urid);

  4286. 

  4287.         return fCustomURIDs.getAt(urid, nullptr);

  4288.     }

  4289. 

  4290.     // -------------------------------------------------------------------

  4291. 

  4292.     void handleProgramChanged(const int32_t index)

  4293.     {

  4294.         CARLA_SAFE_ASSERT_RETURN(index >= -1,);

  4295.         carla_debug("CarlaPluginLV2::handleProgramChanged(%i)", index);

  4296. 

  4297.         if (index == -1)

  4298.         {

  4299.             const ScopedSingleProcessLocker spl(this, true);

  4300.             return reloadPrograms(false);

  4301.         }

  4302. 

  4303.         if (index < static_cast<int32_t>(pData->midiprog.count) && fExt.programs != nullptr && fExt.programs->get_program != nullptr)

  4304.         {

  4305.             if (const LV2_Program_Descriptor* const progDesc = fExt.programs->get_program(fHandle, static_cast<uint32_t>(index)))

  4306.             {

  4307.                 CARLA_SAFE_ASSERT_RETURN(progDesc->name != nullptr,);

  4308. 

  4309.                 if (pData->midiprog.data[index].name != nullptr)

  4310.                     delete[] pData->midiprog.data[index].name;

  4311. 

  4312.                 pData->midiprog.data[index].name = carla_strdup(progDesc->name);

  4313. 

  4314.                 if (index == pData->midiprog.current)

  4315.                     pData->engine->callback(ENGINE_CALLBACK_UPDATE, pData->id, 0, 0, 0.0, nullptr);

  4316.                 else

  4317.                     pData->engine->callback(ENGINE_CALLBACK_RELOAD_PROGRAMS, pData->id, 0, 0, 0.0, nullptr);

  4318.             }

  4319.         }

  4320.     }

  4321. 

  4322.     // -------------------------------------------------------------------

  4323. 

  4324.     LV2_Resize_Port_Status handleResizePort(const uint32_t index, const size_t size)

  4325.     {

  4326.         CARLA_SAFE_ASSERT_RETURN(size > 0, LV2_RESIZE_PORT_ERR_UNKNOWN);

  4327.         carla_debug("CarlaPluginLV2::handleResizePort(%i, " P_SIZE ")", index, size);

  4328. 

  4329.         // TODO

  4330.         return LV2_RESIZE_PORT_ERR_NO_SPACE;

  4331.         (void)index;

  4332.     }

  4333. 

  4334.     // -------------------------------------------------------------------

  4335. 

  4336.     LV2_State_Status handleStateStore(const uint32_t key, const void* const value, const size_t size, const uint32_t type, const uint32_t flags)

  4337.     {

  4338.         CARLA_SAFE_ASSERT_RETURN(key != CARLA_URI_MAP_ID_NULL, LV2_STATE_ERR_NO_PROPERTY);

  4339.         CARLA_SAFE_ASSERT_RETURN(value != nullptr, LV2_STATE_ERR_NO_PROPERTY);

  4340.         CARLA_SAFE_ASSERT_RETURN(size > 0, LV2_STATE_ERR_NO_PROPERTY);

  4341.         CARLA_SAFE_ASSERT_RETURN(type != CARLA_URI_MAP_ID_NULL, LV2_STATE_ERR_BAD_TYPE);

  4342.         CARLA_SAFE_ASSERT_RETURN(flags & LV2_STATE_IS_POD, LV2_STATE_ERR_BAD_FLAGS);

  4343.         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);

  4344. 

  4345.         const char* const skey(carla_lv2_urid_unmap(this, key));

  4346.         const char* const stype(carla_lv2_urid_unmap(this, type));

  4347. 

  4348.         CARLA_SAFE_ASSERT_RETURN(skey != nullptr, LV2_STATE_ERR_BAD_TYPE);

  4349.         CARLA_SAFE_ASSERT_RETURN(stype != nullptr, LV2_STATE_ERR_BAD_TYPE);

  4350. 

  4351.         // Check if we already have this key

  4352.         for (LinkedList<CustomData>::Itenerator it = pData->custom.begin(); it.valid(); it.next())

  4353.         {

  4354.             CustomData& data(it.getValue());

  4355. 

  4356.             if (std::strcmp(data.key, skey) == 0)

  4357.             {

  4358.                 // found it

  4359.                 if (data.value != nullptr)

  4360.                     delete[] data.value;

  4361. 

  4362.                 if (type == CARLA_URI_MAP_ID_ATOM_STRING || type == CARLA_URI_MAP_ID_ATOM_PATH)

  4363.                     data.value = carla_strdup((const char*)value);

  4364.                 else

  4365.                     data.value = CarlaString::asBase64(value, size).dup();

  4366. 

  4367.                 return LV2_STATE_SUCCESS;

  4368.             }

  4369.         }

  4370. 

  4371.         // Otherwise store it

  4372.         CustomData newData;

  4373.         newData.type = carla_strdup(stype);

  4374.         newData.key  = carla_strdup(skey);

  4375. 

  4376.         if (type == CARLA_URI_MAP_ID_ATOM_STRING || type == CARLA_URI_MAP_ID_ATOM_PATH)

  4377.             newData.value = carla_strdup((const char*)value);

  4378.         else

  4379.             newData.value = CarlaString::asBase64(value, size).dup();

  4380. 

  4381.         pData->custom.append(newData);

  4382. 

  4383.         return LV2_STATE_SUCCESS;

  4384.     }

  4385. 

  4386.     const void* handleStateRetrieve(const uint32_t key, size_t* const size, uint32_t* const type, uint32_t* const flags)

  4387.     {

  4388.         CARLA_SAFE_ASSERT_RETURN(key != CARLA_URI_MAP_ID_NULL, nullptr);

  4389.         CARLA_SAFE_ASSERT_RETURN(size != nullptr, nullptr);

  4390.         CARLA_SAFE_ASSERT_RETURN(type != nullptr, nullptr);

  4391.         CARLA_SAFE_ASSERT_RETURN(flags != nullptr, nullptr);

  4392.         carla_debug("CarlaPluginLV2::handleStateRetrieve(%i, %p, %p, %p)", key, size, type, flags);

  4393. 

  4394.         const char* const skey(carla_lv2_urid_unmap(this, key));

  4395. 

  4396.         CARLA_SAFE_ASSERT_RETURN(skey != nullptr, nullptr);

  4397. 

  4398.         const char* stype = nullptr;

  4399.         const char* stringData = nullptr;

  4400. 

  4401.         for (LinkedList<CustomData>::Itenerator it = pData->custom.begin(); it.valid(); it.next())

  4402.         {

  4403.             const CustomData& data(it.getValue());

  4404. 

  4405.             if (std::strcmp(data.key, skey) == 0)

  4406.             {

  4407.                 stype      = data.type;

  4408.                 stringData = data.value;

  4409.                 break;

  4410.             }

  4411.         }

  4412. 

  4413.         CARLA_SAFE_ASSERT_RETURN(stype != nullptr, nullptr);

  4414.         CARLA_SAFE_ASSERT_RETURN(stringData != nullptr, nullptr);

  4415. 

  4416.         *type  = carla_lv2_urid_map(this, stype);

  4417.         *flags = LV2_STATE_IS_POD;

  4418. 

  4419.         if (*type == CARLA_URI_MAP_ID_ATOM_STRING || *type == CARLA_URI_MAP_ID_ATOM_PATH)

  4420.         {

  4421.             *size = std::strlen(stringData);

  4422.             return stringData;

  4423.         }

  4424.         else

  4425.         {

  4426.             if (fLastStateChunk != nullptr)

  4427.             {

  4428.                 std::free(fLastStateChunk);

  4429.                 fLastStateChunk = nullptr;

  4430.             }

  4431. 

  4432.             std::vector<uint8_t> chunk(carla_getChunkFromBase64String(stringData));

  4433.             CARLA_SAFE_ASSERT_RETURN(chunk.size() > 0, nullptr);

  4434. 

  4435.             fLastStateChunk = std::malloc(chunk.size());

  4436.             CARLA_SAFE_ASSERT_RETURN(fLastStateChunk != nullptr, nullptr);

  4437. 

  4438.             std::memcpy(fLastStateChunk, chunk.data(), chunk.size());

  4439. 

  4440.             *size = chunk.size();

  4441.             return fLastStateChunk;

  4442.         }

  4443.     }

  4444. 

  4445.     // -------------------------------------------------------------------

  4446. 

  4447.     LV2_Worker_Status handleWorkerSchedule(const uint32_t size, const void* const data)

  4448.     {

  4449.         CARLA_SAFE_ASSERT_RETURN(fExt.worker != nullptr && fExt.worker->work != nullptr, LV2_WORKER_ERR_UNKNOWN);

  4450.         CARLA_SAFE_ASSERT_RETURN(fEventsIn.ctrl != nullptr, LV2_WORKER_ERR_UNKNOWN);

  4451.         carla_debug("CarlaPluginLV2::handleWorkerSchedule(%i, %p)", size, data);

  4452. 

  4453.         if (pData->engine->isOffline())

  4454.         {

  4455.             fExt.worker->work(fHandle, carla_lv2_worker_respond, this, size, data);

  4456.             return LV2_WORKER_SUCCESS;

  4457.         }

  4458. 

  4459.         LV2_Atom atom;

  4460.         atom.size = size;

  4461.         atom.type = CARLA_URI_MAP_ID_CARLA_ATOM_WORKER;

  4462. 

  4463.         return fAtomBufferOut.putChunk(&atom, data, fEventsOut.ctrlIndex) ? LV2_WORKER_SUCCESS : LV2_WORKER_ERR_NO_SPACE;

  4464.     }

  4465. 

  4466.     LV2_Worker_Status handleWorkerRespond(const uint32_t size, const void* const data)

  4467.     {

  4468.         carla_debug("CarlaPluginLV2::handleWorkerRespond(%i, %p)", size, data);

  4469. 

  4470.         LV2_Atom atom;

  4471.         atom.size = size;

  4472.         atom.type = CARLA_URI_MAP_ID_CARLA_ATOM_WORKER;

  4473. 

  4474.         return fAtomBufferIn.putChunk(&atom, data, fEventsIn.ctrlIndex) ? LV2_WORKER_SUCCESS : LV2_WORKER_ERR_NO_SPACE;

  4475.     }

  4476. 

  4477.     // -------------------------------------------------------------------

  4478. 

  4479.     void handleExternalUIClosed()

  4480.     {

  4481.         CARLA_SAFE_ASSERT_RETURN(fUI.type == UI::TYPE_EXTERNAL,);

  4482.         carla_debug("CarlaPluginLV2::handleExternalUIClosed()");

  4483. 

  4484.         fNeedsUiClose = true;

  4485.     }

  4486. 

  4487.     void handlePluginUIClosed() override

  4488.     {

  4489.         CARLA_SAFE_ASSERT_RETURN(fUI.type == UI::TYPE_EMBED,);

  4490.         CARLA_SAFE_ASSERT_RETURN(fUI.window != nullptr,);

  4491.         carla_debug("CarlaPluginLV2::handlePluginUIClosed()");

  4492. 

  4493.         fNeedsUiClose = true;

  4494.     }

  4495. 

  4496.     void handlePluginUIResized(const uint width, const uint height) override

  4497.     {

  4498.         CARLA_SAFE_ASSERT_RETURN(fUI.type == UI::TYPE_EMBED,);

  4499.         CARLA_SAFE_ASSERT_RETURN(fUI.window != nullptr,);

  4500.         carla_debug("CarlaPluginLV2::handlePluginUIResized(%u, %u)", width, height);

  4501. 

  4502.         if (fUI.handle != nullptr && fExt.uiresize != nullptr)

  4503.             fExt.uiresize->ui_resize(fUI.handle, static_cast<int>(width), static_cast<int>(height));

  4504.     }

  4505. 

  4506.     // -------------------------------------------------------------------

  4507. 

  4508.     uint32_t handleUIPortMap(const char* const symbol) const noexcept

  4509.     {

  4510.         CARLA_SAFE_ASSERT_RETURN(symbol != nullptr && symbol[0] != '\0', LV2UI_INVALID_PORT_INDEX);

  4511.         carla_debug("CarlaPluginLV2::handleUIPortMap(\"%s\")", symbol);

  4512. 

  4513.         for (uint32_t i=0; i < fRdfDescriptor->PortCount; ++i)

  4514.         {

  4515.             if (std::strcmp(fRdfDescriptor->Ports[i].Symbol, symbol) == 0)

  4516.                 return i;

  4517.         }

  4518. 

  4519.         return LV2UI_INVALID_PORT_INDEX;

  4520.     }

  4521. 

  4522.     int handleUIResize(const int width, const int height)

  4523.     {

  4524.         CARLA_SAFE_ASSERT_RETURN(fUI.window != nullptr, 1);

  4525.         CARLA_SAFE_ASSERT_RETURN(width > 0, 1);

  4526.         CARLA_SAFE_ASSERT_RETURN(height > 0, 1);

  4527.         carla_debug("CarlaPluginLV2::handleUIResize(%i, %i)", width, height);

  4528. 

  4529.         fUI.window->setSize(static_cast<uint>(width), static_cast<uint>(height), true);

  4530. 

  4531.         return 0;

  4532.     }

  4533. 

  4534.     void handleUIWrite(const uint32_t rindex, const uint32_t bufferSize, const uint32_t format, const void* const buffer)

  4535.     {

  4536.         CARLA_SAFE_ASSERT_RETURN(buffer != nullptr,);

  4537.         CARLA_SAFE_ASSERT_RETURN(bufferSize > 0,);

  4538.         carla_debug("CarlaPluginLV2::handleUIWrite(%i, %i, %i, %p)", rindex, bufferSize, format, buffer);

  4539. 

  4540.         uint32_t index = LV2UI_INVALID_PORT_INDEX;

  4541. 

  4542.         switch (format)

  4543.         {

  4544.         case CARLA_URI_MAP_ID_NULL: {

  4545.             CARLA_SAFE_ASSERT_RETURN(bufferSize == sizeof(float),);

  4546. 

  4547.             for (uint32_t i=0; i < pData->param.count; ++i)

  4548.             {

  4549.                 if (pData->param.data[i].rindex != static_cast<int32_t>(rindex))

  4550.                     continue;

  4551.                 index = i;

  4552.                 break;

  4553.             }

  4554. 

  4555.             CARLA_SAFE_ASSERT_RETURN(index != LV2UI_INVALID_PORT_INDEX,);

  4556. 

  4557.             const float value(*(const float*)buffer);

  4558. 

  4559.             //if (! carla_compareFloats(fParamBuffers[index], value))

  4560.             setParameterValue(index, value, false, true, true);

  4561. 

  4562.         } break;

  4563. 

  4564.         case CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM:

  4565.         case CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT: {

  4566.             CARLA_SAFE_ASSERT_RETURN(bufferSize >= sizeof(LV2_Atom),);

  4567. 

  4568.             const LV2_Atom* const atom((const LV2_Atom*)buffer);

  4569. 

  4570.             // plugins sometimes fail on this, not good...

  4571.             CARLA_SAFE_ASSERT_INT2(bufferSize == lv2_atom_total_size(atom), bufferSize, atom->size);

  4572. 

  4573.             for (uint32_t i=0; i < fEventsIn.count; ++i)

  4574.             {

  4575.                 if (fEventsIn.data[i].rindex != rindex)

  4576.                     continue;

  4577.                 index = i;

  4578.                 break;

  4579.             }

  4580. 

  4581.             // for bad plugins

  4582.             if (index == LV2UI_INVALID_PORT_INDEX)

  4583.             {

  4584.                 CARLA_SAFE_ASSERT(index != LV2UI_INVALID_PORT_INDEX); // FIXME

  4585.                 index = fEventsIn.ctrlIndex;

  4586.             }

  4587. 

  4588.             fAtomBufferIn.put(atom, index);

  4589.         } break;

  4590. 

  4591.         default:

  4592.             carla_stdout("CarlaPluginLV2::handleUIWrite(%i, %i, %i:\"%s\", %p) - unknown format", rindex, bufferSize, format, carla_lv2_urid_unmap(this, format), buffer);

  4593.             break;

  4594.         }

  4595.     }

  4596. 

  4597.     // -------------------------------------------------------------------

  4598. 

  4599.     void handleLilvSetPortValue(const char* const portSymbol, const void* const value, const uint32_t size, const uint32_t type)

  4600.     {

  4601.         CARLA_SAFE_ASSERT_RETURN(portSymbol != nullptr && portSymbol[0] != '\0',);

  4602.         CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

  4603.         CARLA_SAFE_ASSERT_RETURN(size > 0,);

  4604.         CARLA_SAFE_ASSERT_RETURN(type != CARLA_URI_MAP_ID_NULL,);

  4605.         carla_debug("CarlaPluginLV2::handleLilvSetPortValue(\"%s\", %p, %i, %i)", portSymbol, value, size, type);

  4606. 

  4607.         int32_t rindex = -1;

  4608. 

  4609.         for (uint32_t i=0; i < fRdfDescriptor->PortCount; ++i)

  4610.         {

  4611.             if (std::strcmp(fRdfDescriptor->Ports[i].Symbol, portSymbol) == 0)

  4612.             {

  4613.                 rindex = static_cast<int32_t>(i);

  4614.                 break;

  4615.             }

  4616.         }

  4617. 

  4618.         CARLA_SAFE_ASSERT_RETURN(rindex >= 0,);

  4619. 

  4620.         float paramValue;

  4621. 

  4622.         switch (type)

  4623.         {

  4624.         case CARLA_URI_MAP_ID_ATOM_BOOL:

  4625.             CARLA_SAFE_ASSERT_RETURN(size == sizeof(bool),);

  4626.             paramValue = (*(const bool*)value) ? 1.0f : 0.0f;

  4627.             break;

  4628.         case CARLA_URI_MAP_ID_ATOM_DOUBLE:

  4629.             CARLA_SAFE_ASSERT_RETURN(size == sizeof(double),);

  4630.             paramValue = static_cast<float>((*(const double*)value));

  4631.             break;

  4632.         case CARLA_URI_MAP_ID_ATOM_FLOAT:

  4633.             CARLA_SAFE_ASSERT_RETURN(size == sizeof(float),);

  4634.             paramValue = (*(const float*)value);

  4635.             break;

  4636.         case CARLA_URI_MAP_ID_ATOM_INT:

  4637.             CARLA_SAFE_ASSERT_RETURN(size == sizeof(int32_t),);

  4638.             paramValue = static_cast<float>((*(const int32_t*)value));

  4639.             break;

  4640.         case CARLA_URI_MAP_ID_ATOM_LONG:

  4641.             CARLA_SAFE_ASSERT_RETURN(size == sizeof(int64_t),);

  4642.             paramValue = static_cast<float>((*(const int64_t*)value));

  4643.             break;

  4644.         default:

  4645.             carla_stdout("CarlaPluginLV2::handleLilvSetPortValue(\"%s\", %p, %i, %i:\"%s\") - unknown type", portSymbol, value, size, type, carla_lv2_urid_unmap(this, type));

  4646.             return;

  4647.         }

  4648. 

  4649.         for (uint32_t i=0; i < pData->param.count; ++i)

  4650.         {

  4651.             if (pData->param.data[i].rindex == rindex)

  4652.             {

  4653.                 setParameterValue(i, paramValue, true, true, true);

  4654.                 break;

  4655.             }

  4656.         }

  4657.     }

  4658. 

  4659.     // -------------------------------------------------------------------

  4660. 

  4661.     void* getNativeHandle() const noexcept override

  4662.     {

  4663.         return fHandle;

  4664.     }

  4665. 

  4666.     const void* getNativeDescriptor() const noexcept override

  4667.     {

  4668.         return fDescriptor;

  4669.     }

  4670. 

  4671.     uintptr_t getUiBridgeProcessId() const noexcept override

  4672.     {

  4673.         return fPipeServer.isPipeRunning() ? fPipeServer.getPID() : 0;

  4674.     }

  4675. 

  4676.     // -------------------------------------------------------------------

  4677. 

  4678. public:

  4679.     bool init(const char* const name, const char* const uri)

  4680.     {

  4681.         CARLA_SAFE_ASSERT_RETURN(pData->engine != nullptr, false);

  4682. 

  4683.         // ---------------------------------------------------------------

  4684.         // first checks

  4685. 

  4686.         if (pData->client != nullptr)

  4687.         {

  4688.             pData->engine->setLastError("Plugin client is already registered");

  4689.             return false;

  4690.         }

  4691. 

  4692.         if (uri == nullptr || uri[0] == '\0')

  4693.         {

  4694.             pData->engine->setLastError("null uri");

  4695.             return false;

  4696.         }

  4697. 

  4698.         // ---------------------------------------------------------------

  4699.         // Init LV2 World if needed, sets LV2_PATH for lilv

  4700. 

  4701.         Lv2WorldClass& lv2World(Lv2WorldClass::getInstance());

  4702. 

  4703.         if (pData->engine->getOptions().pathLV2 != nullptr && pData->engine->getOptions().pathLV2[0] != '\0')

  4704.             lv2World.initIfNeeded(pData->engine->getOptions().pathLV2);

  4705.         else

  4706.             lv2World.initIfNeeded(std::getenv("LV2_PATH"));

  4707. 

  4708.         // ---------------------------------------------------------------

  4709.         // get plugin from lv2_rdf (lilv)

  4710. 

  4711.         fRdfDescriptor = lv2_rdf_new(uri, true);

  4712. 

  4713.         if (fRdfDescriptor == nullptr)

  4714.         {

  4715.             pData->engine->setLastError("Failed to find the requested plugin");

  4716.             return false;

  4717.         }

  4718. 

  4719.         // ---------------------------------------------------------------

  4720.         // open DLL

  4721. 

  4722.         if (! pData->libOpen(fRdfDescriptor->Binary))

  4723.         {

  4724.             pData->engine->setLastError(pData->libError(fRdfDescriptor->Binary));

  4725.             return false;

  4726.         }

  4727. 

  4728.         // ---------------------------------------------------------------

  4729.         // try to get DLL main entry via new mode

  4730. 

  4731.         if (const LV2_Lib_Descriptor_Function libDescFn = pData->libSymbol<LV2_Lib_Descriptor_Function>("lv2_lib_descriptor"))

  4732.         {

  4733.             // -----------------------------------------------------------

  4734.             // all ok, get lib descriptor

  4735. 

  4736.             const LV2_Lib_Descriptor* const libDesc = libDescFn(fRdfDescriptor->Bundle, nullptr);

  4737. 

  4738.             if (libDesc == nullptr)

  4739.             {

  4740.                 pData->engine->setLastError("Could not find the LV2 Descriptor");

  4741.                 return false;

  4742.             }

  4743. 

  4744.             // -----------------------------------------------------------

  4745.             // get descriptor that matches URI (new mode)

  4746. 

  4747.             uint32_t i = 0;

  4748.             while ((fDescriptor = libDesc->get_plugin(libDesc->handle, i++)))

  4749.             {

  4750.                 if (std::strcmp(fDescriptor->URI, uri) == 0)

  4751.                     break;

  4752.             }

  4753.         }

  4754.         else

  4755.         {

  4756.             // -----------------------------------------------------------

  4757.             // get DLL main entry (old mode)

  4758. 

  4759.             const LV2_Descriptor_Function descFn = pData->libSymbol<LV2_Descriptor_Function>("lv2_descriptor");

  4760. 

  4761.             if (descFn == nullptr)

  4762.             {

  4763.                 pData->engine->setLastError("Could not find the LV2 Descriptor in the plugin library");

  4764.                 return false;

  4765.             }

  4766. 

  4767.             // -----------------------------------------------------------

  4768.             // get descriptor that matches URI (old mode)

  4769. 

  4770.             uint32_t i = 0;

  4771.             while ((fDescriptor = descFn(i++)))

  4772.             {

  4773.                 if (std::strcmp(fDescriptor->URI, uri) == 0)

  4774.                     break;

  4775.             }

  4776.         }

  4777. 

  4778.         if (fDescriptor == nullptr)

  4779.         {

  4780.             pData->engine->setLastError("Could not find the requested plugin URI in the plugin library");

  4781.             return false;

  4782.         }

  4783. 

  4784.         // ---------------------------------------------------------------

  4785.         // check supported port-types and features

  4786. 

  4787.         bool canContinue = true;

  4788. 

  4789.         // Check supported ports

  4790.         for (uint32_t j=0; j < fRdfDescriptor->PortCount; ++j)

  4791.         {

  4792.             const LV2_Property portTypes(fRdfDescriptor->Ports[j].Types);

  4793. 

  4794.             if (! is_lv2_port_supported(portTypes))

  4795.             {

  4796.                 if (! LV2_IS_PORT_OPTIONAL(fRdfDescriptor->Ports[j].Properties))

  4797.                 {

  4798.                     pData->engine->setLastError("Plugin requires a port type that is not currently supported");

  4799.                     canContinue = false;

  4800.                     break;

  4801.                 }

  4802.             }

  4803.         }

  4804. 

  4805.         // Check supported features

  4806.         for (uint32_t j=0; j < fRdfDescriptor->FeatureCount && canContinue; ++j)

  4807.         {

  4808.             const LV2_RDF_Feature& feature(fRdfDescriptor->Features[j]);

  4809. 

  4810.             if (std::strcmp(feature.URI, LV2_DATA_ACCESS_URI) == 0 || std::strcmp(feature.URI, LV2_INSTANCE_ACCESS_URI) == 0)

  4811.             {

  4812.                 carla_stderr("Plugin DSP wants UI feature '%s', ignoring this", feature.URI);

  4813.             }

  4814.             else if (LV2_IS_FEATURE_REQUIRED(feature.Type) && ! is_lv2_feature_supported(feature.URI))

  4815.             {

  4816.                 CarlaString msg("Plugin wants a feature that is not supported:\n");

  4817.                 msg += feature.URI;

  4818. 

  4819.                 canContinue = false;

  4820.                 pData->engine->setLastError(msg);

  4821.                 break;

  4822.             }

  4823.         }

  4824. 

  4825.         if (! canContinue)

  4826.         {

  4827.             // error already set

  4828.             return false;

  4829.         }

  4830. 

  4831.         // ---------------------------------------------------------------

  4832.         // get info

  4833. 

  4834.         if (name != nullptr && name[0] != '\0')

  4835.             pData->name = pData->engine->getUniquePluginName(name);

  4836.         else

  4837.             pData->name = pData->engine->getUniquePluginName(fRdfDescriptor->Name);

  4838. 

  4839.         // ---------------------------------------------------------------

  4840.         // register client

  4841. 

  4842.         pData->client = pData->engine->addClient(this);

  4843. 

  4844.         if (pData->client == nullptr || ! pData->client->isOk())

  4845.         {

  4846.             pData->engine->setLastError("Failed to register plugin client");

  4847.             return false;

  4848.         }

  4849. 

  4850.         // ---------------------------------------------------------------

  4851.         // initialize options

  4852. 

  4853.         fLv2Options.minBufferSize = 1;

  4854.         fLv2Options.maxBufferSize = static_cast<int>(pData->engine->getBufferSize());

  4855.         fLv2Options.sampleRate    = pData->engine->getSampleRate();

  4856.         fLv2Options.frontendWinId = static_cast<int64_t>(pData->engine->getOptions().frontendWinId);

  4857. 

  4858.         uint32_t eventBufferSize = MAX_DEFAULT_BUFFER_SIZE;

  4859. 

  4860.         for (uint32_t j=0; j < fRdfDescriptor->PortCount; ++j)

  4861.         {

  4862.             const LV2_Property portTypes(fRdfDescriptor->Ports[j].Types);

  4863. 

  4864.             if (LV2_IS_PORT_ATOM_SEQUENCE(portTypes) || LV2_IS_PORT_EVENT(portTypes) || LV2_IS_PORT_MIDI_LL(portTypes))

  4865.             {

  4866.                 if (fRdfDescriptor->Ports[j].MinimumSize > eventBufferSize)

  4867.                     eventBufferSize = fRdfDescriptor->Ports[j].MinimumSize;

  4868.             }

  4869.         }

  4870. 

  4871.         fLv2Options.sequenceSize = static_cast<int>(eventBufferSize);

  4872. 

  4873.         // ---------------------------------------------------------------

  4874.         // initialize features (part 1)

  4875. 

  4876.         LV2_Event_Feature* const eventFt = new LV2_Event_Feature;

  4877.         eventFt->callback_data           = this;

  4878.         eventFt->lv2_event_ref           = carla_lv2_event_ref;

  4879.         eventFt->lv2_event_unref         = carla_lv2_event_unref;

  4880. 

  4881.         LV2_Log_Log* const logFt         = new LV2_Log_Log;

  4882.         logFt->handle                    = this;

  4883.         logFt->printf                    = carla_lv2_log_printf;

  4884.         logFt->vprintf                   = carla_lv2_log_vprintf;

  4885. 

  4886.         LV2_State_Make_Path* const stateMakePathFt = new LV2_State_Make_Path;

  4887.         stateMakePathFt->handle                    = this;

  4888.         stateMakePathFt->path                      = carla_lv2_state_make_path;

  4889. 

  4890.         LV2_State_Map_Path* const stateMapPathFt   = new LV2_State_Map_Path;

  4891.         stateMapPathFt->handle                     = this;

  4892.         stateMapPathFt->abstract_path              = carla_lv2_state_map_abstract_path;

  4893.         stateMapPathFt->absolute_path              = carla_lv2_state_map_absolute_path;

  4894. 

  4895.         LV2_Programs_Host* const programsFt   = new LV2_Programs_Host;

  4896.         programsFt->handle                    = this;

  4897.         programsFt->program_changed           = carla_lv2_program_changed;

  4898. 

  4899.         LV2_Resize_Port_Resize* const rsPortFt = new LV2_Resize_Port_Resize;

  4900.         rsPortFt->data                         = this;

  4901.         rsPortFt->resize                       = carla_lv2_resize_port;

  4902. 

  4903.         LV2_RtMemPool_Pool* const rtMemPoolFt = new LV2_RtMemPool_Pool;

  4904.         lv2_rtmempool_init(rtMemPoolFt);

  4905. 

  4906.         LV2_RtMemPool_Pool_Deprecated* const rtMemPoolOldFt = new LV2_RtMemPool_Pool_Deprecated;

  4907.         lv2_rtmempool_init_deprecated(rtMemPoolOldFt);

  4908. 

  4909.         LV2_URI_Map_Feature* const uriMapFt = new LV2_URI_Map_Feature;

  4910.         uriMapFt->callback_data             = this;

  4911.         uriMapFt->uri_to_id                 = carla_lv2_uri_to_id;

  4912. 

  4913.         LV2_URID_Map* const uridMapFt       = new LV2_URID_Map;

  4914.         uridMapFt->handle                   = this;

  4915.         uridMapFt->map                      = carla_lv2_urid_map;

  4916. 

  4917.         LV2_URID_Unmap* const uridUnmapFt   = new LV2_URID_Unmap;

  4918.         uridUnmapFt->handle                 = this;

  4919.         uridUnmapFt->unmap                  = carla_lv2_urid_unmap;

  4920. 

  4921.         LV2_Worker_Schedule* const workerFt = new LV2_Worker_Schedule;

  4922.         workerFt->handle                    = this;

  4923.         workerFt->schedule_work             = carla_lv2_worker_schedule;

  4924. 

  4925.         // ---------------------------------------------------------------

  4926.         // initialize features (part 2)

  4927. 

  4928.         for (uint32_t j=0; j < kFeatureCountPlugin; ++j)

  4929.             fFeatures[j] = new LV2_Feature;

  4930. 

  4931.         fFeatures[kFeatureIdBufSizeBounded]->URI   = LV2_BUF_SIZE__boundedBlockLength;

  4932.         fFeatures[kFeatureIdBufSizeBounded]->data  = nullptr;

  4933. 

  4934.         fFeatures[kFeatureIdBufSizeFixed]->URI     = LV2_BUF_SIZE__fixedBlockLength;

  4935.         fFeatures[kFeatureIdBufSizeFixed]->data    = nullptr;

  4936. 

  4937.         fFeatures[kFeatureIdBufSizePowerOf2]->URI  = LV2_BUF_SIZE__powerOf2BlockLength;

  4938.         fFeatures[kFeatureIdBufSizePowerOf2]->data = nullptr;

  4939. 

  4940.         fFeatures[kFeatureIdEvent]->URI          = LV2_EVENT_URI;

  4941.         fFeatures[kFeatureIdEvent]->data         = eventFt;

  4942. 

  4943.         fFeatures[kFeatureIdHardRtCapable]->URI  = LV2_CORE__hardRTCapable;

  4944.         fFeatures[kFeatureIdHardRtCapable]->data = nullptr;

  4945. 

  4946.         fFeatures[kFeatureIdInPlaceBroken]->URI  = LV2_CORE__inPlaceBroken;

  4947.         fFeatures[kFeatureIdInPlaceBroken]->data = nullptr;

  4948. 

  4949.         fFeatures[kFeatureIdIsLive]->URI         = LV2_CORE__isLive;

  4950.         fFeatures[kFeatureIdIsLive]->data        = nullptr;

  4951. 

  4952.         fFeatures[kFeatureIdLogs]->URI       = LV2_LOG__log;

  4953.         fFeatures[kFeatureIdLogs]->data      = logFt;

  4954. 

  4955.         fFeatures[kFeatureIdOptions]->URI    = LV2_OPTIONS__options;

  4956.         fFeatures[kFeatureIdOptions]->data   = fLv2Options.opts;

  4957. 

  4958.         fFeatures[kFeatureIdPrograms]->URI   = LV2_PROGRAMS__Host;

  4959.         fFeatures[kFeatureIdPrograms]->data  = programsFt;

  4960. 

  4961.         fFeatures[kFeatureIdResizePort]->URI   = LV2_RESIZE_PORT__resize;

  4962.         fFeatures[kFeatureIdResizePort]->data  = rsPortFt;

  4963. 

  4964.         fFeatures[kFeatureIdRtMemPool]->URI  = LV2_RTSAFE_MEMORY_POOL__Pool;

  4965.         fFeatures[kFeatureIdRtMemPool]->data = rtMemPoolFt;

  4966. 

  4967.         fFeatures[kFeatureIdRtMemPoolOld]->URI  = LV2_RTSAFE_MEMORY_POOL_DEPRECATED_URI;

  4968.         fFeatures[kFeatureIdRtMemPoolOld]->data = rtMemPoolOldFt;

  4969. 

  4970.         fFeatures[kFeatureIdStateMakePath]->URI  = LV2_STATE__makePath;

  4971.         fFeatures[kFeatureIdStateMakePath]->data = stateMakePathFt;

  4972. 

  4973.         fFeatures[kFeatureIdStateMapPath]->URI   = LV2_STATE__mapPath;

  4974.         fFeatures[kFeatureIdStateMapPath]->data  = stateMapPathFt;

  4975. 

  4976.         fFeatures[kFeatureIdStrictBounds]->URI   = LV2_PORT_PROPS__supportsStrictBounds;

  4977.         fFeatures[kFeatureIdStrictBounds]->data  = nullptr;

  4978. 

  4979.         fFeatures[kFeatureIdUriMap]->URI     = LV2_URI_MAP_URI;

  4980.         fFeatures[kFeatureIdUriMap]->data    = uriMapFt;

  4981. 

  4982.         fFeatures[kFeatureIdUridMap]->URI    = LV2_URID__map;

  4983.         fFeatures[kFeatureIdUridMap]->data   = uridMapFt;

  4984. 

  4985.         fFeatures[kFeatureIdUridUnmap]->URI  = LV2_URID__unmap;

  4986.         fFeatures[kFeatureIdUridUnmap]->data = uridUnmapFt;

  4987. 

  4988.         fFeatures[kFeatureIdWorker]->URI     = LV2_WORKER__schedule;

  4989.         fFeatures[kFeatureIdWorker]->data    = workerFt;

  4990. 

  4991.         // if a fixed buffer is not needed, skip its feature

  4992.         if (! needsFixedBuffer())

  4993.             fFeatures[kFeatureIdBufSizeFixed]->URI = LV2_BUF_SIZE__boundedBlockLength;

  4994. 

  4995.         // if power of 2 is not possible, skip its feature FIXME

  4996.         //if (fLv2Options.maxBufferSize)

  4997.         //    fFeatures[kFeatureIdBufSizePowerOf2]->URI = LV2_BUF_SIZE__boundedBlockLength;

  4998. 

  4999.         // ---------------------------------------------------------------

  5000.         // initialize plugin

  5001. 

  5002.         try {

  5003.             fHandle = fDescriptor->instantiate(fDescriptor, pData->engine->getSampleRate(), fRdfDescriptor->Bundle, fFeatures);

  5004.         } catch(...) {}

  5005. 

  5006.         if (fHandle == nullptr)

  5007.         {

  5008.             pData->engine->setLastError("Plugin failed to initialize");

  5009.             return false;

  5010.         }

  5011. 

  5012.         if (std::strcmp(uri, "http://hyperglitch.com/dev/VocProc") == 0)

  5013.             fCanInit2 = false;

  5014. 

  5015.         recheckExtensions();

  5016. 

  5017.         // ---------------------------------------------------------------

  5018.         // set default options

  5019. 

  5020.         pData->options  = 0x0;

  5021. 

  5022.         if (fExt.programs != nullptr)

  5023.             pData->options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  5024. 

  5025.         if (fLatencyIndex >= 0 || getMidiInCount() > 0 || needsFixedBuffer())

  5026.             pData->options |= PLUGIN_OPTION_FIXED_BUFFERS;

  5027. 

  5028.         if (fCanInit2 && pData->engine->getOptions().forceStereo)

  5029.             pData->options |= PLUGIN_OPTION_FORCE_STEREO;

  5030. 

  5031.         if (getMidiInCount() > 0)

  5032.         {

  5033.             pData->options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  5034.             pData->options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

  5035.             pData->options |= PLUGIN_OPTION_SEND_PITCHBEND;

  5036.             pData->options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  5037.         }

  5038. 

  5039.         // ---------------------------------------------------------------

  5040.         // gui stuff

  5041. 

  5042.         if (fRdfDescriptor->UICount != 0)

  5043.             initUi();

  5044. 

  5045.         return true;

  5046.     }

  5047. 

  5048.     // -------------------------------------------------------------------

  5049. 

  5050.     void initUi()

  5051.     {

  5052.         // ---------------------------------------------------------------

  5053.         // find the most appropriate ui

  5054. 

  5055.         int eQt4, eQt5, eGtk2, eGtk3, eCocoa, eWindows, eX11, eExt, eMod, iCocoa, iWindows, iX11, iExt, iFinal;

  5056.         eQt4 = eQt5 = eGtk2 = eGtk3 = eCocoa = eWindows = eX11 = eExt = eMod = iCocoa = iWindows = iX11 = iExt = iFinal = -1;

  5057. 

  5058. #if defined(BUILD_BRIDGE)

  5059.         const bool preferUiBridges(false);

  5060. #elif defined(LV2_UIS_ONLY_BRIDGES)

  5061.         const bool preferUiBridges(true);

  5062. #else

  5063.         const bool preferUiBridges(pData->engine->getOptions().preferUiBridges && (pData->hints & PLUGIN_IS_BRIDGE) == 0);

  5064. #endif

  5065. 

  5066.         for (uint32_t i=0; i < fRdfDescriptor->UICount; ++i)

  5067.         {

  5068.             CARLA_SAFE_ASSERT_CONTINUE(fRdfDescriptor->UIs[i].URI != nullptr);

  5069. 

  5070.             const int ii(static_cast<int>(i));

  5071. 

  5072.             switch (fRdfDescriptor->UIs[i].Type)

  5073.             {

  5074.             case LV2_UI_QT4:

  5075.                 if (isUiBridgeable(i))

  5076.                     eQt4 = ii;

  5077.                 break;

  5078.             case LV2_UI_QT5:

  5079.                 if (isUiBridgeable(i))

  5080.                     eQt5 = ii;

  5081.                 break;

  5082.             case LV2_UI_GTK2:

  5083.                 if (isUiBridgeable(i))

  5084.                     eGtk2 = ii;

  5085.                 break;

  5086.             case LV2_UI_GTK3:

  5087.                 if (isUiBridgeable(i))

  5088.                     eGtk3 = ii;

  5089.                 break;

  5090.             case LV2_UI_COCOA:

  5091.                 if (isUiBridgeable(i) && preferUiBridges)

  5092.                     eCocoa = ii;

  5093.                 iCocoa = ii;

  5094.                 break;

  5095.             case LV2_UI_WINDOWS:

  5096.                 if (isUiBridgeable(i) && preferUiBridges)

  5097.                     eWindows = ii;

  5098.                 iWindows = ii;

  5099.                 break;

  5100.             case LV2_UI_X11:

  5101.                 if (isUiBridgeable(i) && preferUiBridges)

  5102.                     eX11 = ii;

  5103.                 iX11 = ii;

  5104.                 break;

  5105.             case LV2_UI_EXTERNAL:

  5106.             case LV2_UI_OLD_EXTERNAL:

  5107.                 if (isUiBridgeable(i))

  5108.                     eExt = ii;

  5109.                 iExt = ii;

  5110.                 break;

  5111.             case LV2_UI_MOD:

  5112.                 eMod = ii;

  5113.                 break;

  5114.             default:

  5115.                 break;

  5116.             }

  5117.         }

  5118. 

  5119.         if (eQt4 >= 0)

  5120.             iFinal = eQt4;

  5121.         else if (eQt5 >= 0)

  5122.             iFinal = eQt5;

  5123.         else if (eGtk2 >= 0)

  5124.             iFinal = eGtk2;

  5125.         else if (eGtk3 >= 0)

  5126.             iFinal = eGtk3;

  5127. #ifdef CARLA_OS_MAC

  5128.         else if (eCocoa >= 0)

  5129.             iFinal = eCocoa;

  5130. #endif

  5131. #ifdef CARLA_OS_WIN

  5132.         else if (eWindows >= 0)

  5133.             iFinal = eWindows;

  5134. #endif

  5135. #ifdef HAVE_X11

  5136.         else if (eX11 >= 0)

  5137.             iFinal = eX11;

  5138. #endif

  5139.         //else if (eExt >= 0) // TODO

  5140.         //    iFinal = eExt;

  5141. #ifndef LV2_UIS_ONLY_BRIDGES

  5142. # ifdef CARLA_OS_MAC

  5143.         else if (iCocoa >= 0)

  5144.             iFinal = iCocoa;

  5145. # endif

  5146. # ifdef CARLA_OS_WIN

  5147.         else if (iWindows >= 0)

  5148.             iFinal = iWindows;

  5149. # endif

  5150. # ifdef HAVE_X11

  5151.         else if (iX11 >= 0)

  5152.             iFinal = iX11;

  5153. # endif

  5154. #endif

  5155.         else if (iExt >= 0)

  5156.             iFinal = iExt;

  5157. 

  5158.         if (iFinal < 0)

  5159.         {

  5160.             // no suitable UI found, see if there's one which supports ui:showInterface

  5161.             bool hasShowInterface = false;

  5162. 

  5163.             for (uint32_t i=0; i < fRdfDescriptor->UICount && ! hasShowInterface; ++i)

  5164.             {

  5165.                 LV2_RDF_UI* const ui(&fRdfDescriptor->UIs[i]);

  5166. 

  5167.                 for (uint32_t j=0; j < ui->ExtensionCount; ++j)

  5168.                 {

  5169.                     CARLA_SAFE_ASSERT_CONTINUE(ui->Extensions[j] != nullptr);

  5170. 

  5171.                     if (std::strcmp(ui->Extensions[j], LV2_UI__showInterface) != 0)

  5172.                         continue;

  5173. 

  5174.                     iFinal = static_cast<int>(i);

  5175.                     hasShowInterface = true;

  5176.                     break;

  5177.                 }

  5178.             }

  5179. 

  5180.             if (! hasShowInterface)

  5181.             {

  5182.                 if (eMod < 0)

  5183.                 {

  5184.                     carla_stderr("Failed to find an appropriate LV2 UI for this plugin");

  5185.                     return;

  5186.                 }

  5187. 

  5188.                 // use MODGUI as last resort

  5189.                 iFinal = eMod;

  5190.             }

  5191.         }

  5192. 

  5193.         fUI.rdfDescriptor = &fRdfDescriptor->UIs[iFinal];

  5194. 

  5195.         // ---------------------------------------------------------------

  5196.         // check supported ui features

  5197. 

  5198.         bool canContinue = true;

  5199.         bool canDelete = true;

  5200. 

  5201.         for (uint32_t i=0; i < fUI.rdfDescriptor->FeatureCount; ++i)

  5202.         {

  5203.             const char* const uri(fUI.rdfDescriptor->Features[i].URI);

  5204.             CARLA_SAFE_ASSERT_CONTINUE(uri != nullptr && uri[0] != '\0');

  5205. 

  5206.             if (! is_lv2_ui_feature_supported(uri))

  5207.             {

  5208.                 carla_stderr("Plugin UI requires a feature that is not supported:\n%s", uri);

  5209. 

  5210.                 if (LV2_IS_FEATURE_REQUIRED(fUI.rdfDescriptor->Features[i].Type))

  5211.                 {

  5212.                     canContinue = false;

  5213.                     break;

  5214.                 }

  5215.             }

  5216.             if (std::strcmp(uri, LV2_UI__makeResident) == 0)

  5217.                 canDelete = false;

  5218.         }

  5219. 

  5220.         if (! canContinue)

  5221.         {

  5222.             fUI.rdfDescriptor = nullptr;

  5223.             return;

  5224.         }

  5225. 

  5226.         // ---------------------------------------------------------------

  5227.         // initialize ui according to type

  5228. 

  5229.         const LV2_Property uiType(fUI.rdfDescriptor->Type);

  5230. 

  5231.         if (iFinal == eQt4 || iFinal == eQt5 || iFinal == eGtk2 || iFinal == eGtk3 ||

  5232.             iFinal == eCocoa || iFinal == eWindows || iFinal == eX11 || iFinal == eExt || iFinal == eMod)

  5233.         {

  5234.             // -----------------------------------------------------------

  5235.             // initialize ui-bridge

  5236. 

  5237.             if (const char* const bridgeBinary = getUiBridgeBinary(uiType))

  5238.             {

  5239.                 carla_stdout("Will use UI-Bridge, binary: \"%s\"", bridgeBinary);

  5240. 

  5241.                 CarlaString guiTitle(pData->name);

  5242.                 guiTitle += " (GUI)";

  5243.                 fLv2Options.windowTitle = guiTitle.dup();

  5244. 

  5245.                 fUI.type = UI::TYPE_BRIDGE;

  5246.                 fPipeServer.setData(bridgeBinary, fRdfDescriptor->URI, fUI.rdfDescriptor->URI);

  5247. 

  5248.                 delete[] bridgeBinary;

  5249.                 return;

  5250.             }

  5251. 

  5252.             if (iFinal == eQt4 || iFinal == eQt5 || iFinal == eGtk2 || iFinal == eGtk3)

  5253.             {

  5254.                 carla_stderr2("Failed to find UI bridge binary, cannot use UI");

  5255.                 fUI.rdfDescriptor = nullptr;

  5256.                 return;

  5257.             }

  5258.         }

  5259. 

  5260. #ifdef LV2_UIS_ONLY_BRIDGES

  5261.         carla_stderr2("Failed to get an UI working, canBridge:%s", bool2str(isUiBridgeable(static_cast<uint32_t>(iFinal))));

  5262.         fUI.rdfDescriptor = nullptr;

  5263.         return;

  5264. #endif

  5265. 

  5266.         // ---------------------------------------------------------------

  5267.         // open UI DLL

  5268. 

  5269.         if (! pData->uiLibOpen(fUI.rdfDescriptor->Binary, canDelete))

  5270.         {

  5271.             carla_stderr2("Could not load UI library, error was:\n%s", pData->libError(fUI.rdfDescriptor->Binary));

  5272.             fUI.rdfDescriptor = nullptr;

  5273.             return;

  5274.         }

  5275. 

  5276.         // ---------------------------------------------------------------

  5277.         // get UI DLL main entry

  5278. 

  5279.         LV2UI_DescriptorFunction uiDescFn = pData->uiLibSymbol<LV2UI_DescriptorFunction>("lv2ui_descriptor");

  5280. 

  5281.         if (uiDescFn == nullptr)

  5282.         {

  5283.             carla_stderr2("Could not find the LV2UI Descriptor in the UI library");

  5284.             pData->uiLibClose();

  5285.             fUI.rdfDescriptor = nullptr;

  5286.             return;

  5287.         }

  5288. 

  5289.         // ---------------------------------------------------------------

  5290.         // get UI descriptor that matches UI URI

  5291. 

  5292.         uint32_t i = 0;

  5293.         while ((fUI.descriptor = uiDescFn(i++)))

  5294.         {

  5295.             if (std::strcmp(fUI.descriptor->URI, fUI.rdfDescriptor->URI) == 0)

  5296.                 break;

  5297.         }

  5298. 

  5299.         if (fUI.descriptor == nullptr)

  5300.         {

  5301.             carla_stderr2("Could not find the requested GUI in the plugin UI library");

  5302.             pData->uiLibClose();

  5303.             fUI.rdfDescriptor = nullptr;

  5304.             return;

  5305.         }

  5306. 

  5307.         // ---------------------------------------------------------------

  5308.         // check if ui is usable

  5309. 

  5310.         switch (uiType)

  5311.         {

  5312.         case LV2_UI_QT4:

  5313.             carla_stdout("Will use LV2 Qt4 UI, NOT!");

  5314.             fUI.type = UI::TYPE_EMBED;

  5315.             break;

  5316.         case LV2_UI_QT5:

  5317.             carla_stdout("Will use LV2 Qt5 UI, NOT!");

  5318.             fUI.type = UI::TYPE_EMBED;

  5319.             break;

  5320.         case LV2_UI_GTK2:

  5321.             carla_stdout("Will use LV2 Gtk2 UI, NOT!");

  5322.             fUI.type = UI::TYPE_EMBED;

  5323.             break;

  5324.         case LV2_UI_GTK3:

  5325.             carla_stdout("Will use LV2 Gtk3 UI, NOT!");

  5326.             fUI.type = UI::TYPE_EMBED;

  5327.             break;

  5328. #ifdef CARLA_OS_MAC

  5329.         case LV2_UI_COCOA:

  5330.             carla_stdout("Will use LV2 Cocoa UI");

  5331.             fUI.type = UI::TYPE_EMBED;

  5332.             break;

  5333. #endif

  5334. #ifdef CARLA_OS_WIN

  5335.         case LV2_UI_WINDOWS:

  5336.             carla_stdout("Will use LV2 Windows UI");

  5337.             fUI.type = UI::TYPE_EMBED;

  5338.             break;

  5339. #endif

  5340.         case LV2_UI_X11:

  5341. #ifdef HAVE_X11

  5342.             carla_stdout("Will use LV2 X11 UI");

  5343. #else

  5344.             carla_stdout("Will use LV2 X11 UI, NOT!");

  5345. #endif

  5346.             fUI.type = UI::TYPE_EMBED;

  5347.             break;

  5348.         case LV2_UI_EXTERNAL:

  5349.         case LV2_UI_OLD_EXTERNAL:

  5350.             carla_stdout("Will use LV2 External UI");

  5351.             fUI.type = UI::TYPE_EXTERNAL;

  5352.             break;

  5353.         }

  5354. 

  5355.         if (fUI.type == UI::TYPE_NULL)

  5356.         {

  5357.             pData->uiLibClose();

  5358.             fUI.descriptor = nullptr;

  5359.             fUI.rdfDescriptor = nullptr;

  5360.             return;

  5361.         }

  5362. 

  5363.         // ---------------------------------------------------------------

  5364.         // initialize ui data

  5365. 

  5366.         CarlaString guiTitle(pData->name);

  5367.         guiTitle += " (GUI)";

  5368.         fLv2Options.windowTitle = guiTitle.dup();

  5369. 

  5370.         fLv2Options.opts[CarlaPluginLV2Options::WindowTitle].size  = (uint32_t)std::strlen(fLv2Options.windowTitle);

  5371.         fLv2Options.opts[CarlaPluginLV2Options::WindowTitle].value = fLv2Options.windowTitle;

  5372. 

  5373.         // ---------------------------------------------------------------

  5374.         // initialize ui features (part 1)

  5375. 

  5376.         LV2_Extension_Data_Feature* const uiDataFt = new LV2_Extension_Data_Feature;

  5377.         uiDataFt->data_access                      = fDescriptor->extension_data;

  5378. 

  5379.         LV2UI_Port_Map* const uiPortMapFt = new LV2UI_Port_Map;

  5380.         uiPortMapFt->handle               = this;

  5381.         uiPortMapFt->port_index           = carla_lv2_ui_port_map;

  5382. 

  5383.         LV2UI_Resize* const uiResizeFt    = new LV2UI_Resize;

  5384.         uiResizeFt->handle                = this;

  5385.         uiResizeFt->ui_resize             = carla_lv2_ui_resize;

  5386. 

  5387.         LV2_External_UI_Host* const uiExternalHostFt = new LV2_External_UI_Host;

  5388.         uiExternalHostFt->ui_closed                  = carla_lv2_external_ui_closed;

  5389.         uiExternalHostFt->plugin_human_id            = fLv2Options.windowTitle;

  5390. 

  5391.         // ---------------------------------------------------------------

  5392.         // initialize ui features (part 2)

  5393. 

  5394.         for (uint32_t j=kFeatureCountPlugin; j < kFeatureCountAll; ++j)

  5395.             fFeatures[j] = new LV2_Feature;

  5396. 

  5397.         fFeatures[kFeatureIdUiDataAccess]->URI      = LV2_DATA_ACCESS_URI;

  5398.         fFeatures[kFeatureIdUiDataAccess]->data     = uiDataFt;

  5399. 

  5400.         fFeatures[kFeatureIdUiInstanceAccess]->URI  = LV2_INSTANCE_ACCESS_URI;

  5401.         fFeatures[kFeatureIdUiInstanceAccess]->data = fHandle;

  5402. 

  5403.         fFeatures[kFeatureIdUiIdleInterface]->URI  = LV2_UI__idleInterface;

  5404.         fFeatures[kFeatureIdUiIdleInterface]->data = nullptr;

  5405. 

  5406.         fFeatures[kFeatureIdUiFixedSize]->URI      = LV2_UI__fixedSize;

  5407.         fFeatures[kFeatureIdUiFixedSize]->data     = nullptr;

  5408. 

  5409.         fFeatures[kFeatureIdUiMakeResident]->URI   = LV2_UI__makeResident;

  5410.         fFeatures[kFeatureIdUiMakeResident]->data  = nullptr;

  5411. 

  5412.         fFeatures[kFeatureIdUiNoUserResize]->URI   = LV2_UI__noUserResize;

  5413.         fFeatures[kFeatureIdUiNoUserResize]->data  = nullptr;

  5414. 

  5415.         fFeatures[kFeatureIdUiParent]->URI         = LV2_UI__parent;

  5416.         fFeatures[kFeatureIdUiParent]->data        = nullptr;

  5417. 

  5418.         fFeatures[kFeatureIdUiPortMap]->URI        = LV2_UI__portMap;

  5419.         fFeatures[kFeatureIdUiPortMap]->data       = uiPortMapFt;

  5420. 

  5421.         fFeatures[kFeatureIdUiPortSubscribe]->URI  = LV2_UI__portSubscribe;

  5422.         fFeatures[kFeatureIdUiPortSubscribe]->data = nullptr;

  5423. 

  5424.         fFeatures[kFeatureIdUiResize]->URI       = LV2_UI__resize;

  5425.         fFeatures[kFeatureIdUiResize]->data      = uiResizeFt;

  5426. 

  5427.         fFeatures[kFeatureIdUiTouch]->URI        = LV2_UI__touch;

  5428.         fFeatures[kFeatureIdUiTouch]->data       = nullptr;

  5429. 

  5430.         fFeatures[kFeatureIdExternalUi]->URI     = LV2_EXTERNAL_UI__Host;

  5431.         fFeatures[kFeatureIdExternalUi]->data    = uiExternalHostFt;

  5432. 

  5433.         fFeatures[kFeatureIdExternalUiOld]->URI  = LV2_EXTERNAL_UI_DEPRECATED_URI;

  5434.         fFeatures[kFeatureIdExternalUiOld]->data = uiExternalHostFt;

  5435. 

  5436.         // ---------------------------------------------------------------

  5437.         // initialize ui extensions

  5438. 

  5439.         if (fUI.descriptor->extension_data == nullptr)

  5440.             return;

  5441. 

  5442.         fExt.uiidle     = (const LV2UI_Idle_Interface*)fUI.descriptor->extension_data(LV2_UI__idleInterface);

  5443.         fExt.uishow     = (const LV2UI_Show_Interface*)fUI.descriptor->extension_data(LV2_UI__showInterface);

  5444.         fExt.uiresize   = (const LV2UI_Resize*)fUI.descriptor->extension_data(LV2_UI__resize);

  5445.         fExt.uiprograms = (const LV2_Programs_UI_Interface*)fUI.descriptor->extension_data(LV2_PROGRAMS__UIInterface);

  5446. 

  5447.         // check if invalid

  5448.         if (fExt.uiidle != nullptr && fExt.uiidle->idle == nullptr)

  5449.             fExt.uiidle = nullptr;

  5450. 

  5451.         if (fExt.uishow != nullptr && (fExt.uishow->show == nullptr || fExt.uishow->hide == nullptr))

  5452.             fExt.uishow = nullptr;

  5453. 

  5454.         if (fExt.uiresize != nullptr && fExt.uiresize->ui_resize == nullptr)

  5455.             fExt.uiresize = nullptr;

  5456. 

  5457.         if (fExt.uiprograms != nullptr && fExt.uiprograms->select_program == nullptr)

  5458.             fExt.uiprograms = nullptr;

  5459. 

  5460.         // don't use uiidle if external

  5461.         if (fUI.type == UI::TYPE_EXTERNAL)

  5462.             fExt.uiidle = nullptr;

  5463.     }

  5464. 

  5465.     // -------------------------------------------------------------------

  5466. 

  5467.     void handleTransferAtom(const uint32_t portIndex, const LV2_Atom* const atom)

  5468.     {

  5469.         CARLA_SAFE_ASSERT_RETURN(atom != nullptr,);

  5470.         carla_debug("CarlaPluginLV2::handleTransferAtom(%i, %p)", portIndex, atom);

  5471. 

  5472.         fAtomBufferIn.put(atom, portIndex);

  5473.     }

  5474. 

  5475.     void handleUridMap(const LV2_URID urid, const char* const uri)

  5476.     {

  5477.         CARLA_SAFE_ASSERT_RETURN(urid != CARLA_URI_MAP_ID_NULL,);

  5478.         CARLA_SAFE_ASSERT_RETURN(uri != nullptr && uri[0] != '\0',);

  5479.         carla_debug("CarlaPluginLV2::handleUridMap(%i v " P_SIZE ", \"%s\")", urid, fCustomURIDs.count()-1, uri);

  5480. 

  5481.         if (urid < fCustomURIDs.count())

  5482.         {

  5483.             const char* const ourURI(carla_lv2_urid_unmap(this, urid));

  5484.             CARLA_SAFE_ASSERT_RETURN(ourURI != nullptr,);

  5485. 

  5486.             if (std::strcmp(ourURI, uri) != 0)

  5487.             {

  5488.                 carla_stderr2("PLUGIN :: wrong URI '%s' vs '%s'", ourURI,  uri);

  5489.             }

  5490.         }

  5491.         else

  5492.         {

  5493.             CARLA_SAFE_ASSERT_RETURN(urid == fCustomURIDs.count(),);

  5494.             fCustomURIDs.append(carla_strdup(uri));

  5495.         }

  5496.     }

  5497. 

  5498.     // -------------------------------------------------------------------

  5499. 

  5500. private:

  5501.     LV2_Handle   fHandle;

  5502.     LV2_Handle   fHandle2;

  5503.     LV2_Feature* fFeatures[kFeatureCountAll+1];

  5504.     const LV2_Descriptor*     fDescriptor;

  5505.     const LV2_RDF_Descriptor* fRdfDescriptor;

  5506. 

  5507.     float** fAudioInBuffers;

  5508.     float** fAudioOutBuffers;

  5509.     float** fCvInBuffers;

  5510.     float** fCvOutBuffers;

  5511.     float*  fParamBuffers;

  5512. 

  5513.     bool    fCanInit2; // some plugins don't like 2 instances

  5514.     bool    fNeedsUiClose;

  5515.     bool    fLatencyChanged;

  5516.     int32_t fLatencyIndex; // -1 if invalid

  5517. 

  5518.     Lv2AtomRingBuffer fAtomBufferIn;

  5519.     Lv2AtomRingBuffer fAtomBufferOut;

  5520.     LV2_Atom_Forge    fAtomForge;

  5521. 

  5522.     CarlaPluginLV2EventData fEventsIn;

  5523.     CarlaPluginLV2EventData fEventsOut;

  5524.     CarlaPluginLV2Options   fLv2Options;

  5525.     CarlaPipeServerLV2      fPipeServer;

  5526. 

  5527.     LinkedList<const char*> fCustomURIDs;

  5528. 

  5529.     bool fFirstActive; // first process() call after activate()

  5530.     void* fLastStateChunk;

  5531.     EngineTimeInfo fLastTimeInfo;

  5532. 

  5533.     struct Extensions {

  5534.         const LV2_Options_Interface* options;

  5535.         const LV2_State_Interface* state;

  5536.         const LV2_Worker_Interface* worker;

  5537.         const LV2_Programs_Interface* programs;

  5538.         const LV2UI_Idle_Interface* uiidle;

  5539.         const LV2UI_Show_Interface* uishow;

  5540.         const LV2UI_Resize* uiresize;

  5541.         const LV2_Programs_UI_Interface* uiprograms;

  5542. 

  5543.         Extensions()

  5544.             : options(nullptr),

  5545.               state(nullptr),

  5546.               worker(nullptr),

  5547.               programs(nullptr),

  5548.               uiidle(nullptr),

  5549.               uishow(nullptr),

  5550.               uiresize(nullptr),

  5551.               uiprograms(nullptr) {}

  5552. 

  5553.         CARLA_DECLARE_NON_COPY_STRUCT(Extensions);

  5554.     } fExt;

  5555. 

  5556.     struct UI {

  5557.         enum Type {

  5558.             TYPE_NULL = 0,

  5559.             TYPE_BRIDGE,

  5560.             TYPE_EMBED,

  5561.             TYPE_EXTERNAL

  5562.         };

  5563. 

  5564.         Type type;

  5565.         LV2UI_Handle handle;

  5566.         LV2UI_Widget widget;

  5567.         const LV2UI_Descriptor* descriptor;

  5568.         const LV2_RDF_UI*       rdfDescriptor;

  5569. 

  5570.         CarlaPluginUI* window;

  5571. 

  5572.         UI()

  5573.             : type(TYPE_NULL),

  5574.               handle(nullptr),

  5575.               widget(nullptr),

  5576.               descriptor(nullptr),

  5577.               rdfDescriptor(nullptr),

  5578.               window(nullptr) {}

  5579. 

  5580.         ~UI()

  5581.         {

  5582.             CARLA_ASSERT(handle == nullptr);

  5583.             CARLA_ASSERT(widget == nullptr);

  5584.             CARLA_ASSERT(descriptor == nullptr);

  5585.             CARLA_ASSERT(rdfDescriptor == nullptr);

  5586.             CARLA_ASSERT(window == nullptr);

  5587.         }

  5588. 

  5589.         CARLA_DECLARE_NON_COPY_STRUCT(UI);

  5590.     } fUI;

  5591. 

  5592.     // -------------------------------------------------------------------

  5593.     // Event Feature

  5594. 

  5595.     static uint32_t carla_lv2_event_ref(LV2_Event_Callback_Data callback_data, LV2_Event* event)

  5596.     {

  5597.         CARLA_SAFE_ASSERT_RETURN(callback_data != nullptr, 0);

  5598.         CARLA_SAFE_ASSERT_RETURN(event != nullptr, 0);

  5599.         carla_debug("carla_lv2_event_ref(%p, %p)", callback_data, event);

  5600. 

  5601.         return 0;

  5602.     }

  5603. 

  5604.     static uint32_t carla_lv2_event_unref(LV2_Event_Callback_Data callback_data, LV2_Event* event)

  5605.     {

  5606.         CARLA_SAFE_ASSERT_RETURN(callback_data != nullptr, 0);

  5607.         CARLA_SAFE_ASSERT_RETURN(event != nullptr, 0);

  5608.         carla_debug("carla_lv2_event_unref(%p, %p)", callback_data, event);

  5609. 

  5610.         return 0;

  5611.     }

  5612. 

  5613.     // -------------------------------------------------------------------

  5614.     // Logs Feature

  5615. 

  5616.     static int carla_lv2_log_printf(LV2_Log_Handle handle, LV2_URID type, const char* fmt, ...)

  5617.     {

  5618.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr, 0);

  5619.         CARLA_SAFE_ASSERT_RETURN(type != CARLA_URI_MAP_ID_NULL, 0);

  5620.         CARLA_SAFE_ASSERT_RETURN(fmt != nullptr, 0);

  5621. 

  5622. #ifndef DEBUG

  5623.         if (type == CARLA_URI_MAP_ID_LOG_TRACE)

  5624.             return 0;

  5625. #endif

  5626. 

  5627.         va_list args;

  5628.         va_start(args, fmt);

  5629.         const int ret(carla_lv2_log_vprintf(handle, type, fmt, args));

  5630.         va_end(args);

  5631. 

  5632.         return ret;

  5633.     }

  5634. 

  5635.     static int carla_lv2_log_vprintf(LV2_Log_Handle handle, LV2_URID type, const char* fmt, va_list ap)

  5636.     {

  5637.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr, 0);

  5638.         CARLA_SAFE_ASSERT_RETURN(type != CARLA_URI_MAP_ID_NULL, 0);

  5639.         CARLA_SAFE_ASSERT_RETURN(fmt != nullptr, 0);

  5640. 

  5641. #ifndef DEBUG

  5642.         if (type == CARLA_URI_MAP_ID_LOG_TRACE)

  5643.             return 0;

  5644. #endif

  5645. 

  5646.         int ret = 0;

  5647. 

  5648.         switch (type)

  5649.         {

  5650.         case CARLA_URI_MAP_ID_LOG_ERROR:

  5651.             std::fprintf(stderr, "\x1b[31m");

  5652.             ret = std::vfprintf(stderr, fmt, ap);

  5653.             std::fprintf(stderr, "\x1b[0m");

  5654.             break;

  5655. 

  5656.         case CARLA_URI_MAP_ID_LOG_NOTE:

  5657.             ret = std::vfprintf(stdout, fmt, ap);

  5658.             break;

  5659. 

  5660.         case CARLA_URI_MAP_ID_LOG_TRACE:

  5661. #ifdef DEBUG

  5662.             std::fprintf(stdout, "\x1b[30;1m");

  5663.             ret = std::vfprintf(stdout, fmt, ap);

  5664.             std::fprintf(stdout, "\x1b[0m");

  5665. #endif

  5666.             break;

  5667. 

  5668.         case CARLA_URI_MAP_ID_LOG_WARNING:

  5669.             ret = std::vfprintf(stderr, fmt, ap);

  5670.             break;

  5671. 

  5672.         default:

  5673.             break;

  5674.         }

  5675. 

  5676.         return ret;

  5677.     }

  5678. 

  5679.     // -------------------------------------------------------------------

  5680.     // Programs Feature

  5681. 

  5682.     static void carla_lv2_program_changed(LV2_Programs_Handle handle, int32_t index)

  5683.     {

  5684.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

  5685.         carla_debug("carla_lv2_program_changed(%p, %i)", handle, index);

  5686. 

  5687.         ((CarlaPluginLV2*)handle)->handleProgramChanged(index);

  5688.     }

  5689. 

  5690.     // -------------------------------------------------------------------

  5691.     // Resize Port Feature

  5692. 

  5693.     static LV2_Resize_Port_Status carla_lv2_resize_port(LV2_Resize_Port_Feature_Data data, uint32_t index, size_t size)

  5694.     {

  5695.         CARLA_SAFE_ASSERT_RETURN(data != nullptr, LV2_RESIZE_PORT_ERR_UNKNOWN);

  5696.         carla_debug("carla_lv2_program_changed(%p, %i, " P_SIZE ")", data, index, size);

  5697. 

  5698.         return ((CarlaPluginLV2*)data)->handleResizePort(index, size);

  5699.     }

  5700. 

  5701.     // -------------------------------------------------------------------

  5702.     // State Feature

  5703. 

  5704.     static char* carla_lv2_state_make_path(LV2_State_Make_Path_Handle handle, const char* path)

  5705.     {

  5706.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr, nullptr);

  5707.         CARLA_SAFE_ASSERT_RETURN(path != nullptr && path[0] != '\0', nullptr);

  5708.         carla_debug("carla_lv2_state_make_path(%p, \"%s\")", handle, path);

  5709. 

  5710.         File file;

  5711. 

  5712.         if (File::isAbsolutePath(path))

  5713.             file = File(path);

  5714.         else

  5715.             file = File::getCurrentWorkingDirectory().getChildFile(path);

  5716. 

  5717.         file.getParentDirectory().createDirectory();

  5718. 

  5719.         return strdup(file.getFullPathName().toRawUTF8());

  5720.     }

  5721. 

  5722.     static char* carla_lv2_state_map_abstract_path(LV2_State_Map_Path_Handle handle, const char* absolute_path)

  5723.     {

  5724.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr, nullptr);

  5725.         CARLA_SAFE_ASSERT_RETURN(absolute_path != nullptr && absolute_path[0] != '\0', nullptr);

  5726.         carla_debug("carla_lv2_state_map_abstract_path(%p, \"%s\")", handle, absolute_path);

  5727. 

  5728.         // may already be an abstract path

  5729.         if (! File::isAbsolutePath(absolute_path))

  5730.             return strdup(absolute_path);

  5731. 

  5732.         return strdup(File(absolute_path).getRelativePathFrom(File::getCurrentWorkingDirectory()).toRawUTF8());

  5733.     }

  5734. 

  5735.     static char* carla_lv2_state_map_absolute_path(LV2_State_Map_Path_Handle handle, const char* abstract_path)

  5736.     {

  5737.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr, nullptr);

  5738.         CARLA_SAFE_ASSERT_RETURN(abstract_path != nullptr && abstract_path[0] != '\0', nullptr);

  5739.         carla_debug("carla_lv2_state_map_absolute_path(%p, \"%s\")", handle, abstract_path);

  5740. 

  5741.         // may already be an absolute path

  5742.         if (File::isAbsolutePath(abstract_path))

  5743.             return strdup(abstract_path);

  5744. 

  5745.         return strdup(File::getCurrentWorkingDirectory().getChildFile(abstract_path).getFullPathName().toRawUTF8());

  5746.     }

  5747. 

  5748.     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)

  5749.     {

  5750.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr, LV2_STATE_ERR_UNKNOWN);

  5751.         carla_debug("carla_lv2_state_store(%p, %i, %p, " P_SIZE ", %i, %i)", handle, key, value, size, type, flags);

  5752. 

  5753.         return ((CarlaPluginLV2*)handle)->handleStateStore(key, value, size, type, flags);

  5754.     }

  5755. 

  5756.     static const void* carla_lv2_state_retrieve(LV2_State_Handle handle, uint32_t key, size_t* size, uint32_t* type, uint32_t* flags)

  5757.     {

  5758.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr, nullptr);

  5759.         carla_debug("carla_lv2_state_retrieve(%p, %i, %p, %p, %p)", handle, key, size, type, flags);

  5760. 

  5761.         return ((CarlaPluginLV2*)handle)->handleStateRetrieve(key, size, type, flags);

  5762.     }

  5763. 

  5764.     // -------------------------------------------------------------------

  5765.     // URI-Map Feature

  5766. 

  5767.     static uint32_t carla_lv2_uri_to_id(LV2_URI_Map_Callback_Data data, const char* map, const char* uri)

  5768.     {

  5769.         carla_debug("carla_lv2_uri_to_id(%p, \"%s\", \"%s\")", data, map, uri);

  5770.         return carla_lv2_urid_map((LV2_URID_Map_Handle*)data, uri);

  5771. 

  5772.         // unused

  5773.         (void)map;

  5774.     }

  5775. 

  5776.     // -------------------------------------------------------------------

  5777.     // URID Feature

  5778. 

  5779.     static LV2_URID carla_lv2_urid_map(LV2_URID_Map_Handle handle, const char* uri)

  5780.     {

  5781.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr, CARLA_URI_MAP_ID_NULL);

  5782.         CARLA_SAFE_ASSERT_RETURN(uri != nullptr && uri[0] != '\0', CARLA_URI_MAP_ID_NULL);

  5783.         carla_debug("carla_lv2_urid_map(%p, \"%s\")", handle, uri);

  5784. 

  5785.         // Atom types

  5786.         if (std::strcmp(uri, LV2_ATOM__Blank) == 0)

  5787.             return CARLA_URI_MAP_ID_ATOM_BLANK;

  5788.         if (std::strcmp(uri, LV2_ATOM__Bool) == 0)

  5789.             return CARLA_URI_MAP_ID_ATOM_BOOL;

  5790.         if (std::strcmp(uri, LV2_ATOM__Chunk) == 0)

  5791.             return CARLA_URI_MAP_ID_ATOM_CHUNK;

  5792.         if (std::strcmp(uri, LV2_ATOM__Double) == 0)

  5793.             return CARLA_URI_MAP_ID_ATOM_DOUBLE;

  5794.         if (std::strcmp(uri, LV2_ATOM__Event) == 0)

  5795.             return CARLA_URI_MAP_ID_ATOM_EVENT;

  5796.         if (std::strcmp(uri, LV2_ATOM__Float) == 0)

  5797.             return CARLA_URI_MAP_ID_ATOM_FLOAT;

  5798.         if (std::strcmp(uri, LV2_ATOM__Int) == 0)

  5799.             return CARLA_URI_MAP_ID_ATOM_INT;

  5800.         if (std::strcmp(uri, LV2_ATOM__Literal) == 0)

  5801.             return CARLA_URI_MAP_ID_ATOM_LITERAL;

  5802.         if (std::strcmp(uri, LV2_ATOM__Long) == 0)

  5803.             return CARLA_URI_MAP_ID_ATOM_LONG;

  5804.         if (std::strcmp(uri, LV2_ATOM__Number) == 0)

  5805.             return CARLA_URI_MAP_ID_ATOM_NUMBER;

  5806.         if (std::strcmp(uri, LV2_ATOM__Object) == 0)

  5807.             return CARLA_URI_MAP_ID_ATOM_OBJECT;

  5808.         if (std::strcmp(uri, LV2_ATOM__Path) == 0)

  5809.             return CARLA_URI_MAP_ID_ATOM_PATH;

  5810.         if (std::strcmp(uri, LV2_ATOM__Property) == 0)

  5811.             return CARLA_URI_MAP_ID_ATOM_PROPERTY;

  5812.         if (std::strcmp(uri, LV2_ATOM__Resource) == 0)

  5813.             return CARLA_URI_MAP_ID_ATOM_RESOURCE;

  5814.         if (std::strcmp(uri, LV2_ATOM__Sequence) == 0)

  5815.             return CARLA_URI_MAP_ID_ATOM_SEQUENCE;

  5816.         if (std::strcmp(uri, LV2_ATOM__Sound) == 0)

  5817.             return CARLA_URI_MAP_ID_ATOM_SOUND;

  5818.         if (std::strcmp(uri, LV2_ATOM__String) == 0)

  5819.             return CARLA_URI_MAP_ID_ATOM_STRING;

  5820.         if (std::strcmp(uri, LV2_ATOM__Tuple) == 0)

  5821.             return CARLA_URI_MAP_ID_ATOM_TUPLE;

  5822.         if (std::strcmp(uri, LV2_ATOM__URI) == 0)

  5823.             return CARLA_URI_MAP_ID_ATOM_URI;

  5824.         if (std::strcmp(uri, LV2_ATOM__URID) == 0)

  5825.             return CARLA_URI_MAP_ID_ATOM_URID;

  5826.         if (std::strcmp(uri, LV2_ATOM__Vector) == 0)

  5827.             return CARLA_URI_MAP_ID_ATOM_VECTOR;

  5828.         if (std::strcmp(uri, LV2_ATOM__atomTransfer) == 0)

  5829.             return CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM;

  5830.         if (std::strcmp(uri, LV2_ATOM__eventTransfer) == 0)

  5831.             return CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT;

  5832. 

  5833.         // BufSize types

  5834.         if (std::strcmp(uri, LV2_BUF_SIZE__maxBlockLength) == 0)

  5835.             return CARLA_URI_MAP_ID_BUF_MAX_LENGTH;

  5836.         if (std::strcmp(uri, LV2_BUF_SIZE__minBlockLength) == 0)

  5837.             return CARLA_URI_MAP_ID_BUF_MIN_LENGTH;

  5838.         if (std::strcmp(uri, LV2_BUF_SIZE__sequenceSize) == 0)

  5839.             return CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE;

  5840. 

  5841.         // Log types

  5842.         if (std::strcmp(uri, LV2_LOG__Error) == 0)

  5843.             return CARLA_URI_MAP_ID_LOG_ERROR;

  5844.         if (std::strcmp(uri, LV2_LOG__Note) == 0)

  5845.             return CARLA_URI_MAP_ID_LOG_NOTE;

  5846.         if (std::strcmp(uri, LV2_LOG__Trace) == 0)

  5847.             return CARLA_URI_MAP_ID_LOG_TRACE;

  5848.         if (std::strcmp(uri, LV2_LOG__Warning) == 0)

  5849.             return CARLA_URI_MAP_ID_LOG_WARNING;

  5850. 

  5851.         // Time types

  5852.         if (std::strcmp(uri, LV2_TIME__Position) == 0)

  5853.             return CARLA_URI_MAP_ID_TIME_POSITION;

  5854.         if (std::strcmp(uri, LV2_TIME__bar) == 0)

  5855.             return CARLA_URI_MAP_ID_TIME_BAR;

  5856.         if (std::strcmp(uri, LV2_TIME__barBeat) == 0)

  5857.             return CARLA_URI_MAP_ID_TIME_BAR_BEAT;

  5858.         if (std::strcmp(uri, LV2_TIME__beat) == 0)

  5859.             return CARLA_URI_MAP_ID_TIME_BEAT;

  5860.         if (std::strcmp(uri, LV2_TIME__beatUnit) == 0)

  5861.             return CARLA_URI_MAP_ID_TIME_BEAT_UNIT;

  5862.         if (std::strcmp(uri, LV2_TIME__beatsPerBar) == 0)

  5863.             return CARLA_URI_MAP_ID_TIME_BEATS_PER_BAR;

  5864.         if (std::strcmp(uri, LV2_TIME__beatsPerMinute) == 0)

  5865.             return CARLA_URI_MAP_ID_TIME_BEATS_PER_MINUTE;

  5866.         if (std::strcmp(uri, LV2_TIME__frame) == 0)

  5867.             return CARLA_URI_MAP_ID_TIME_FRAME;

  5868.         if (std::strcmp(uri, LV2_TIME__framesPerSecond) == 0)

  5869.             return CARLA_URI_MAP_ID_TIME_FRAMES_PER_SECOND;

  5870.         if (std::strcmp(uri, LV2_TIME__speed) == 0)

  5871.             return CARLA_URI_MAP_ID_TIME_SPEED;

  5872.         if (std::strcmp(uri, LV2_KXSTUDIO_PROPERTIES__TimePositionTicksPerBeat) == 0)

  5873.             return CARLA_URI_MAP_ID_TIME_TICKS_PER_BEAT;

  5874. 

  5875.         // Others

  5876.         if (std::strcmp(uri, LV2_MIDI__MidiEvent) == 0)

  5877.             return CARLA_URI_MAP_ID_MIDI_EVENT;

  5878.         if (std::strcmp(uri, LV2_PARAMETERS__sampleRate) == 0)

  5879.             return CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE;

  5880.         if (std::strcmp(uri, LV2_UI__windowTitle) == 0)

  5881.             return CARLA_URI_MAP_ID_UI_WINDOW_TITLE;

  5882. 

  5883.         // Custom

  5884.         if (std::strcmp(uri, LV2_KXSTUDIO_PROPERTIES__TransientWindowId) == 0)

  5885.             return CARLA_URI_MAP_ID_CARLA_TRANSIENT_WIN_ID;

  5886.         if (std::strcmp(uri, URI_CARLA_ATOM_WORKER) == 0)

  5887.             return CARLA_URI_MAP_ID_CARLA_ATOM_WORKER;

  5888. 

  5889.         // Custom types

  5890.         return ((CarlaPluginLV2*)handle)->getCustomURID(uri);

  5891.     }

  5892. 

  5893.     static const char* carla_lv2_urid_unmap(LV2_URID_Map_Handle handle, LV2_URID urid)

  5894.     {

  5895.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr, nullptr);

  5896.         CARLA_SAFE_ASSERT_RETURN(urid != CARLA_URI_MAP_ID_NULL, nullptr);

  5897.         carla_debug("carla_lv2_urid_unmap(%p, %i)", handle, urid);

  5898. 

  5899.         // Atom types

  5900.         if (urid == CARLA_URI_MAP_ID_ATOM_BLANK)

  5901.             return LV2_ATOM__Blank;

  5902.         if (urid == CARLA_URI_MAP_ID_ATOM_BOOL)

  5903.             return LV2_ATOM__Bool;

  5904.         if (urid == CARLA_URI_MAP_ID_ATOM_CHUNK)

  5905.             return LV2_ATOM__Chunk;

  5906.         if (urid == CARLA_URI_MAP_ID_ATOM_DOUBLE)

  5907.             return LV2_ATOM__Double;

  5908.         if (urid == CARLA_URI_MAP_ID_ATOM_EVENT)

  5909.             return LV2_ATOM__Event;

  5910.         if (urid == CARLA_URI_MAP_ID_ATOM_FLOAT)

  5911.             return LV2_ATOM__Float;

  5912.         if (urid == CARLA_URI_MAP_ID_ATOM_INT)

  5913.             return LV2_ATOM__Int;

  5914.         if (urid == CARLA_URI_MAP_ID_ATOM_LITERAL)

  5915.             return LV2_ATOM__Literal;

  5916.         if (urid == CARLA_URI_MAP_ID_ATOM_LONG)

  5917.             return LV2_ATOM__Long;

  5918.         if (urid == CARLA_URI_MAP_ID_ATOM_NUMBER)

  5919.             return LV2_ATOM__Number;

  5920.         if (urid == CARLA_URI_MAP_ID_ATOM_OBJECT)

  5921.             return LV2_ATOM__Object;

  5922.         if (urid == CARLA_URI_MAP_ID_ATOM_PATH)

  5923.             return LV2_ATOM__Path;

  5924.         if (urid == CARLA_URI_MAP_ID_ATOM_PROPERTY)

  5925.             return LV2_ATOM__Property;

  5926.         if (urid == CARLA_URI_MAP_ID_ATOM_RESOURCE)

  5927.             return LV2_ATOM__Resource;

  5928.         if (urid == CARLA_URI_MAP_ID_ATOM_SEQUENCE)

  5929.             return LV2_ATOM__Sequence;

  5930.         if (urid == CARLA_URI_MAP_ID_ATOM_SOUND)

  5931.             return LV2_ATOM__Sound;

  5932.         if (urid == CARLA_URI_MAP_ID_ATOM_STRING)

  5933.             return LV2_ATOM__String;

  5934.         if (urid == CARLA_URI_MAP_ID_ATOM_TUPLE)

  5935.             return LV2_ATOM__Tuple;

  5936.         if (urid == CARLA_URI_MAP_ID_ATOM_URI)

  5937.             return LV2_ATOM__URI;

  5938.         if (urid == CARLA_URI_MAP_ID_ATOM_URID)

  5939.             return LV2_ATOM__URID;

  5940.         if (urid == CARLA_URI_MAP_ID_ATOM_VECTOR)

  5941.             return LV2_ATOM__Vector;

  5942.         if (urid == CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM)

  5943.             return LV2_ATOM__atomTransfer;

  5944.         if (urid == CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT)

  5945.             return LV2_ATOM__eventTransfer;

  5946. 

  5947.         // BufSize types

  5948.         if (urid == CARLA_URI_MAP_ID_BUF_MAX_LENGTH)

  5949.             return LV2_BUF_SIZE__maxBlockLength;

  5950.         if (urid == CARLA_URI_MAP_ID_BUF_MIN_LENGTH)

  5951.             return LV2_BUF_SIZE__minBlockLength;

  5952.         if (urid == CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE)

  5953.             return LV2_BUF_SIZE__sequenceSize;

  5954. 

  5955.         // Log types

  5956.         if (urid == CARLA_URI_MAP_ID_LOG_ERROR)

  5957.             return LV2_LOG__Error;

  5958.         if (urid == CARLA_URI_MAP_ID_LOG_NOTE)

  5959.             return LV2_LOG__Note;

  5960.         if (urid == CARLA_URI_MAP_ID_LOG_TRACE)

  5961.             return LV2_LOG__Trace;

  5962.         if (urid == CARLA_URI_MAP_ID_LOG_WARNING)

  5963.             return LV2_LOG__Warning;

  5964. 

  5965.         // Time types

  5966.         if (urid == CARLA_URI_MAP_ID_TIME_POSITION)

  5967.             return LV2_TIME__Position;

  5968.         if (urid == CARLA_URI_MAP_ID_TIME_BAR)

  5969.             return LV2_TIME__bar;

  5970.         if (urid == CARLA_URI_MAP_ID_TIME_BAR_BEAT)

  5971.             return LV2_TIME__barBeat;

  5972.         if (urid == CARLA_URI_MAP_ID_TIME_BEAT)

  5973.             return LV2_TIME__beat;

  5974.         if (urid == CARLA_URI_MAP_ID_TIME_BEAT_UNIT)

  5975.             return LV2_TIME__beatUnit;

  5976.         if (urid == CARLA_URI_MAP_ID_TIME_BEATS_PER_BAR)

  5977.             return LV2_TIME__beatsPerBar;

  5978.         if (urid == CARLA_URI_MAP_ID_TIME_BEATS_PER_MINUTE)

  5979.             return LV2_TIME__beatsPerMinute;

  5980.         if (urid == CARLA_URI_MAP_ID_TIME_FRAME)

  5981.             return LV2_TIME__frame;

  5982.         if (urid == CARLA_URI_MAP_ID_TIME_FRAMES_PER_SECOND)

  5983.             return LV2_TIME__framesPerSecond;

  5984.         if (urid == CARLA_URI_MAP_ID_TIME_SPEED)

  5985.             return LV2_TIME__speed;

  5986.         if (urid == CARLA_URI_MAP_ID_TIME_TICKS_PER_BEAT)

  5987.             return LV2_KXSTUDIO_PROPERTIES__TimePositionTicksPerBeat;

  5988. 

  5989.         // Others

  5990.         if (urid == CARLA_URI_MAP_ID_MIDI_EVENT)

  5991.             return LV2_MIDI__MidiEvent;

  5992.         if (urid == CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE)

  5993.             return LV2_PARAMETERS__sampleRate;

  5994.         if (urid == CARLA_URI_MAP_ID_UI_WINDOW_TITLE)

  5995.             return LV2_UI__windowTitle;

  5996. 

  5997.         // Custom

  5998.         if (urid == CARLA_URI_MAP_ID_CARLA_ATOM_WORKER)

  5999.             return URI_CARLA_ATOM_WORKER;

  6000.         if (urid == CARLA_URI_MAP_ID_CARLA_TRANSIENT_WIN_ID)

  6001.             return LV2_KXSTUDIO_PROPERTIES__TransientWindowId;

  6002. 

  6003.         // Custom types

  6004.         return ((CarlaPluginLV2*)handle)->getCustomURIDString(urid);

  6005.     }

  6006. 

  6007.     // -------------------------------------------------------------------

  6008.     // Worker Feature

  6009. 

  6010.     static LV2_Worker_Status carla_lv2_worker_schedule(LV2_Worker_Schedule_Handle handle, uint32_t size, const void* data)

  6011.     {

  6012.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr, LV2_WORKER_ERR_UNKNOWN);

  6013.         carla_debug("carla_lv2_worker_schedule(%p, %i, %p)", handle, size, data);

  6014. 

  6015.         return ((CarlaPluginLV2*)handle)->handleWorkerSchedule(size, data);

  6016.     }

  6017. 

  6018.     static LV2_Worker_Status carla_lv2_worker_respond(LV2_Worker_Respond_Handle handle, uint32_t size, const void* data)

  6019.     {

  6020.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr, LV2_WORKER_ERR_UNKNOWN);

  6021.         carla_debug("carla_lv2_worker_respond(%p, %i, %p)", handle, size, data);

  6022. 

  6023.         return ((CarlaPluginLV2*)handle)->handleWorkerRespond(size, data);

  6024.     }

  6025. 

  6026.     // -------------------------------------------------------------------

  6027.     // External UI Feature

  6028. 

  6029.     static void carla_lv2_external_ui_closed(LV2UI_Controller controller)

  6030.     {

  6031.         CARLA_SAFE_ASSERT_RETURN(controller != nullptr,);

  6032.         carla_debug("carla_lv2_external_ui_closed(%p)", controller);

  6033. 

  6034.         ((CarlaPluginLV2*)controller)->handleExternalUIClosed();

  6035.     }

  6036. 

  6037.     // -------------------------------------------------------------------

  6038.     // UI Port-Map Feature

  6039. 

  6040.     static uint32_t carla_lv2_ui_port_map(LV2UI_Feature_Handle handle, const char* symbol)

  6041.     {

  6042.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr, LV2UI_INVALID_PORT_INDEX);

  6043.         carla_debug("carla_lv2_ui_port_map(%p, \"%s\")", handle, symbol);

  6044. 

  6045.         return ((CarlaPluginLV2*)handle)->handleUIPortMap(symbol);

  6046.     }

  6047. 

  6048.     // -------------------------------------------------------------------

  6049.     // UI Resize Feature

  6050. 

  6051.     static int carla_lv2_ui_resize(LV2UI_Feature_Handle handle, int width, int height)

  6052.     {

  6053.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr, 1);

  6054.         carla_debug("carla_lv2_ui_resize(%p, %i, %i)", handle, width, height);

  6055. 

  6056.         return ((CarlaPluginLV2*)handle)->handleUIResize(width, height);

  6057.     }

  6058. 

  6059.     // -------------------------------------------------------------------

  6060.     // UI Extension

  6061. 

  6062.     static void carla_lv2_ui_write_function(LV2UI_Controller controller, uint32_t port_index, uint32_t buffer_size, uint32_t format, const void* buffer)

  6063.     {

  6064.         CARLA_SAFE_ASSERT_RETURN(controller != nullptr,);

  6065.         carla_debug("carla_lv2_ui_write_function(%p, %i, %i, %i, %p)", controller, port_index, buffer_size, format, buffer);

  6066. 

  6067.         ((CarlaPluginLV2*)controller)->handleUIWrite(port_index, buffer_size, format, buffer);

  6068.     }

  6069. 

  6070.     // -------------------------------------------------------------------

  6071.     // Lilv State

  6072. 

  6073.     static void carla_lilv_set_port_value(const char* port_symbol, void* user_data, const void* value, uint32_t size, uint32_t type)

  6074.     {

  6075.         CARLA_SAFE_ASSERT_RETURN(user_data != nullptr,);

  6076.         carla_debug("carla_lilv_set_port_value(\"%s\", %p, %p, %i, %i", port_symbol, user_data, value, size, type);

  6077. 

  6078.         ((CarlaPluginLV2*)user_data)->handleLilvSetPortValue(port_symbol, value, size, type);

  6079.     }

  6080. 

  6081.     // -------------------------------------------------------------------

  6082. 

  6083.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaPluginLV2)

  6084. };

  6085. 

  6086. // -------------------------------------------------------------------------------------------------------------------

  6087. 

  6088. bool CarlaPipeServerLV2::msgReceived(const char* const msg) noexcept

  6089. {

  6090.     if (std::strcmp(msg, "exiting") == 0)

  6091.     {

  6092.         closePipeServer();

  6093.         fUiState = UiHide;

  6094.         return true;

  6095.     }

  6096. 

  6097.     if (std::strcmp(msg, "control") == 0)

  6098.     {

  6099.         uint32_t index;

  6100.         float value;

  6101. 

  6102.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(index), true);

  6103.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsFloat(value), true);

  6104. 

  6105.         try {

  6106.             kPlugin->handleUIWrite(index, sizeof(float), CARLA_URI_MAP_ID_NULL, &value);

  6107.         } CARLA_SAFE_EXCEPTION("magReceived control");

  6108. 

  6109.         return true;

  6110.     }

  6111. 

  6112.     if (std::strcmp(msg, "atom") == 0)

  6113.     {

  6114.         uint32_t index, size;

  6115.         const char* base64atom;

  6116. 

  6117.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(index), true);

  6118.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(size), true);

  6119.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(base64atom), true);

  6120. 

  6121.         std::vector<uint8_t> chunk(carla_getChunkFromBase64String(base64atom));

  6122.         delete[] base64atom;

  6123.         CARLA_SAFE_ASSERT_RETURN(chunk.size() >= sizeof(LV2_Atom), true);

  6124. 

  6125.         const LV2_Atom* const atom((const LV2_Atom*)chunk.data());

  6126.         CARLA_SAFE_ASSERT_RETURN(lv2_atom_total_size(atom) == chunk.size(), true);

  6127. 

  6128.         try {

  6129.             kPlugin->handleUIWrite(index, lv2_atom_total_size(atom), CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT, atom);

  6130.         } CARLA_SAFE_EXCEPTION("magReceived atom");

  6131. 

  6132.         return true;

  6133.     }

  6134. 

  6135.     if (std::strcmp(msg, "program") == 0)

  6136.     {

  6137.         uint32_t index;

  6138. 

  6139.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(index), true);

  6140. 

  6141.         try {

  6142.             kPlugin->setMidiProgram(static_cast<int32_t>(index), false, true, true);

  6143.         } CARLA_SAFE_EXCEPTION("msgReceived program");

  6144. 

  6145.         return true;

  6146.     }

  6147. 

  6148.     if (std::strcmp(msg, "urid") == 0)

  6149.     {

  6150.         uint32_t urid;

  6151.         const char* uri;

  6152. 

  6153.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(urid), true);

  6154.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(uri), true);

  6155. 

  6156.         if (urid != 0)

  6157.         {

  6158.             try {

  6159.                 kPlugin->handleUridMap(urid, uri);

  6160.             } CARLA_SAFE_EXCEPTION("msgReceived urid");

  6161.         }

  6162. 

  6163.         delete[] uri;

  6164.         return true;

  6165.     }

  6166. 

  6167.     return false;

  6168. }

  6169. 

  6170. // -------------------------------------------------------------------------------------------------------------------

  6171. 

  6172. CarlaPlugin* CarlaPlugin::newLV2(const Initializer& init)

  6173. {

  6174.     carla_debug("CarlaPlugin::newLV2({%p, \"%s\", \"%s\", " P_INT64 "})", init.engine, init.name, init.label, init.uniqueId);

  6175. 

  6176.     CarlaPluginLV2* const plugin(new CarlaPluginLV2(init.engine, init.id));

  6177. 

  6178.     if (! plugin->init(init.name, init.label))

  6179.     {

  6180.         delete plugin;

  6181.         return nullptr;

  6182.     }

  6183. 

  6184.     return plugin;

  6185. }

  6186. 

  6187. // -------------------------------------------------------------------------------------------------------------------

  6188. 

  6189. CARLA_BACKEND_END_NAMESPACE