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

7502 lines
274KB
Raw Blame History 

  1. /*

  2.  * Carla LV2 Plugin

  3.  * Copyright (C) 2011-2020 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 "CarlaBackendUtils.hpp"

  28. #include "CarlaBase64Utils.hpp"

  29. #include "CarlaEngineUtils.hpp"

  30. #include "CarlaPipeUtils.hpp"

  31. #include "CarlaPluginUI.hpp"

  32. #include "CarlaScopeUtils.hpp"

  33. #include "Lv2AtomRingBuffer.hpp"

  34. 

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

  36. 

  37. extern "C" {

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

  39. }

  40. 

  41. #include "water/files/File.h"

  42. #include "water/misc/Time.h"

  43. 

  44. #include <string>

  45. #include <vector>

  46. 

  47. using water::File;

  48. 

  49. #define URI_CARLA_ATOM_WORKER_IN   "http://kxstudio.sf.net/ns/carla/atomWorkerIn"

  50. #define URI_CARLA_ATOM_WORKER_RESP "http://kxstudio.sf.net/ns/carla/atomWorkerResp"

  51. 

  52. CARLA_BACKEND_START_NAMESPACE

  53. 

  54. // -------------------------------------------------------------------------------------------------------------------

  55. // Fallback data

  56. 

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

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

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

  60. static const char* const      kUnmapFallback            = "urn:null";

  61. 

  62. // -------------------------------------------------------------------------------------------------------------------

  63. 

  64. // Maximum default buffer size

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

  66. 

  67. // Extra Plugin Hints

  68. const uint PLUGIN_HAS_EXTENSION_OPTIONS        = 0x01000;

  69. const uint PLUGIN_HAS_EXTENSION_PROGRAMS       = 0x02000;

  70. const uint PLUGIN_HAS_EXTENSION_STATE          = 0x04000;

  71. const uint PLUGIN_HAS_EXTENSION_WORKER         = 0x08000;

  72. const uint PLUGIN_HAS_EXTENSION_INLINE_DISPLAY = 0x10000;

  73. const uint PLUGIN_HAS_EXTENSION_MIDNAM         = 0x20000;

  74. 

  75. // LV2 Event Data/Types

  76. const uint CARLA_EVENT_DATA_ATOM    = 0x01;

  77. const uint CARLA_EVENT_DATA_EVENT   = 0x02;

  78. const uint CARLA_EVENT_DATA_MIDI_LL = 0x04;

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

  80. const uint CARLA_EVENT_TYPE_MIDI    = 0x20;

  81. const uint CARLA_EVENT_TYPE_TIME    = 0x40;

  82. 

  83. // LV2 URI Map Ids

  84. enum CarlaLv2URIDs {

  85.     kUridNull = 0,

  86.     kUridAtomBlank,

  87.     kUridAtomBool,

  88.     kUridAtomChunk,

  89.     kUridAtomDouble,

  90.     kUridAtomEvent,

  91.     kUridAtomFloat,

  92.     kUridAtomInt,

  93.     kUridAtomLiteral,

  94.     kUridAtomLong,

  95.     kUridAtomNumber,

  96.     kUridAtomObject,

  97.     kUridAtomPath,

  98.     kUridAtomProperty,

  99.     kUridAtomResource,

  100.     kUridAtomSequence,

  101.     kUridAtomSound,

  102.     kUridAtomString,

  103.     kUridAtomTuple,

  104.     kUridAtomURI,

  105.     kUridAtomURID,

  106.     kUridAtomVector,

  107.     kUridAtomTransferAtom,

  108.     kUridAtomTransferEvent,

  109.     kUridBufMaxLength,

  110.     kUridBufMinLength,

  111.     kUridBufNominalLength,

  112.     kUridBufSequenceSize,

  113.     kUridLogError,

  114.     kUridLogNote,

  115.     kUridLogTrace,

  116.     kUridLogWarning,

  117.     kUridPatchSet,

  118.     kUridPatchPoperty,

  119.     kUridPatchValue,

  120.     // time base type

  121.     kUridTimePosition,

  122.      // time values

  123.     kUridTimeBar,

  124.     kUridTimeBarBeat,

  125.     kUridTimeBeat,

  126.     kUridTimeBeatUnit,

  127.     kUridTimeBeatsPerBar,

  128.     kUridTimeBeatsPerMinute,

  129.     kUridTimeFrame,

  130.     kUridTimeFramesPerSecond,

  131.     kUridTimeSpeed,

  132.     kUridTimeTicksPerBeat,

  133.     kUridMidiEvent,

  134.     kUridParamSampleRate,

  135.     // ui stuff

  136.     kUridBackgroundColor,

  137.     kUridForegroundColor,

  138.     kUridScaleFactor,

  139.     kUridWindowTitle,

  140.     // custom carla props

  141.     kUridCarlaAtomWorkerIn,

  142.     kUridCarlaAtomWorkerResp,

  143.     kUridCarlaTransientWindowId,

  144.     // count

  145.     kUridCount

  146. };

  147. 

  148. // LV2 Feature Ids

  149. enum CarlaLv2Features {

  150.     // DSP features

  151.     kFeatureIdBufSizeBounded = 0,

  152.     kFeatureIdBufSizeFixed,

  153.     kFeatureIdBufSizePowerOf2,

  154.     kFeatureIdEvent,

  155.     kFeatureIdHardRtCapable,

  156.     kFeatureIdInPlaceBroken,

  157.     kFeatureIdIsLive,

  158.     kFeatureIdLogs,

  159.     kFeatureIdOptions,

  160.     kFeatureIdPrograms,

  161.     kFeatureIdResizePort,

  162.     kFeatureIdRtMemPool,

  163.     kFeatureIdRtMemPoolOld,

  164.     kFeatureIdStateFreePath,

  165.     kFeatureIdStateMakePath,

  166.     kFeatureIdStateMapPath,

  167.     kFeatureIdStrictBounds,

  168.     kFeatureIdUriMap,

  169.     kFeatureIdUridMap,

  170.     kFeatureIdUridUnmap,

  171.     kFeatureIdWorker,

  172.     kFeatureIdInlineDisplay,

  173.     kFeatureIdMidnam,

  174.     kFeatureCountPlugin,

  175.     // UI features

  176.     kFeatureIdUiDataAccess = kFeatureCountPlugin,

  177.     kFeatureIdUiInstanceAccess,

  178.     kFeatureIdUiIdleInterface,

  179.     kFeatureIdUiFixedSize,

  180.     kFeatureIdUiMakeResident,

  181.     kFeatureIdUiMakeResident2,

  182.     kFeatureIdUiNoUserResize,

  183.     kFeatureIdUiParent,

  184.     kFeatureIdUiPortMap,

  185.     kFeatureIdUiPortSubscribe,

  186.     kFeatureIdUiResize,

  187.     kFeatureIdUiRequestValue,

  188.     kFeatureIdUiTouch,

  189.     kFeatureIdExternalUi,

  190.     kFeatureIdExternalUiOld,

  191.     kFeatureCountAll

  192. };

  193. 

  194. // -------------------------------------------------------------------------------------------------------------------

  195. 

  196. struct Lv2EventData {

  197.     uint32_t type;

  198.     uint32_t rindex;

  199.     CarlaEngineEventPort* port;

  200. 

  201.     union {

  202.         LV2_Atom_Buffer* atom;

  203.         LV2_Event_Buffer* event;

  204.         LV2_MIDI midi;

  205.     };

  206. 

  207.     Lv2EventData() noexcept

  208.         : type(0x0),

  209.           rindex(0),

  210.           port(nullptr) {}

  211. 

  212.     ~Lv2EventData() noexcept

  213.     {

  214.         if (port != nullptr)

  215.         {

  216.             delete port;

  217.             port = nullptr;

  218.         }

  219. 

  220.         const uint32_t rtype(type);

  221.         type = 0x0;

  222. 

  223.         if (rtype & CARLA_EVENT_DATA_ATOM)

  224.         {

  225.             CARLA_SAFE_ASSERT_RETURN(atom != nullptr,);

  226. 

  227.             std::free(atom);

  228.             atom = nullptr;

  229.         }

  230.         else if (rtype & CARLA_EVENT_DATA_EVENT)

  231.         {

  232.             CARLA_SAFE_ASSERT_RETURN(event != nullptr,);

  233. 

  234.             std::free(event);

  235.             event = nullptr;

  236.         }

  237.         else if (rtype & CARLA_EVENT_DATA_MIDI_LL)

  238.         {

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

  240. 

  241.             delete[] midi.data;

  242.             midi.data = nullptr;

  243.         }

  244.     }

  245. 

  246.     CARLA_DECLARE_NON_COPY_STRUCT(Lv2EventData)

  247. };

  248. 

  249. struct CarlaPluginLV2EventData {

  250.     uint32_t count;

  251.     Lv2EventData* data;

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

  253.     uint32_t ctrlIndex;

  254. 

  255.     CarlaPluginLV2EventData() noexcept

  256.         : count(0),

  257.           data(nullptr),

  258.           ctrl(nullptr),

  259.           ctrlIndex(0) {}

  260. 

  261.     ~CarlaPluginLV2EventData() noexcept

  262.     {

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

  264.         CARLA_SAFE_ASSERT(data == nullptr);

  265.         CARLA_SAFE_ASSERT(ctrl == nullptr);

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

  267.     }

  268. 

  269.     void createNew(const uint32_t newCount)

  270.     {

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

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

  273.         CARLA_SAFE_ASSERT_RETURN(data == nullptr,);

  274.         CARLA_SAFE_ASSERT_RETURN(ctrl == nullptr,);

  275.         CARLA_SAFE_ASSERT_RETURN(newCount > 0,);

  276. 

  277.         data  = new Lv2EventData[newCount];

  278.         count = newCount;

  279. 

  280.         ctrl      = nullptr;

  281.         ctrlIndex = 0;

  282.     }

  283. 

  284.     void clear() noexcept

  285.     {

  286.         if (data != nullptr)

  287.         {

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

  289.             {

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

  291.                     data[i].port = nullptr;

  292.             }

  293. 

  294.             delete[] data;

  295.             data = nullptr;

  296.         }

  297. 

  298.         count = 0;

  299. 

  300.         ctrl      = nullptr;

  301.         ctrlIndex = 0;

  302.     }

  303. 

  304.     void initBuffers() const noexcept

  305.     {

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

  307.         {

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

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

  310.         }

  311.     }

  312. 

  313.     CARLA_DECLARE_NON_COPY_STRUCT(CarlaPluginLV2EventData)

  314. };

  315. 

  316. // -------------------------------------------------------------------------------------------------------------------

  317. 

  318. struct CarlaPluginLV2Options {

  319.     enum OptIndex {

  320.         MaxBlockLenth = 0,

  321.         MinBlockLenth,

  322.         NominalBlockLenth,

  323.         SequenceSize,

  324.         SampleRate,

  325.         TransientWinId,

  326.         BackgroundColor,

  327.         ForegroundColor,

  328.         ScaleFactor,

  329.         WindowTitle,

  330.         Null,

  331.         Count

  332.     };

  333. 

  334.     int maxBufferSize;

  335.     int minBufferSize;

  336.     int nominalBufferSize;

  337.     int sequenceSize;

  338.     float sampleRate;

  339.     int64_t transientWinId;

  340.     uint32_t bgColor;

  341.     uint32_t fgColor;

  342.     float uiScale;

  343.     const char* windowTitle;

  344.     LV2_Options_Option opts[Count];

  345. 

  346.     CarlaPluginLV2Options() noexcept

  347.         : maxBufferSize(0),

  348.           minBufferSize(0),

  349.           nominalBufferSize(0),

  350.           sequenceSize(MAX_DEFAULT_BUFFER_SIZE),

  351.           sampleRate(0.0),

  352.           transientWinId(0),

  353.           bgColor(0x000000ff),

  354.           fgColor(0xffffffff),

  355.           uiScale(1.0f),

  356.           windowTitle(nullptr)

  357.     {

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

  359.         optMaxBlockLenth.context = LV2_OPTIONS_INSTANCE;

  360.         optMaxBlockLenth.subject = 0;

  361.         optMaxBlockLenth.key     = kUridBufMaxLength;

  362.         optMaxBlockLenth.size    = sizeof(int);

  363.         optMaxBlockLenth.type    = kUridAtomInt;

  364.         optMaxBlockLenth.value   = &maxBufferSize;

  365. 

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

  367.         optMinBlockLenth.context = LV2_OPTIONS_INSTANCE;

  368.         optMinBlockLenth.subject = 0;

  369.         optMinBlockLenth.key     = kUridBufMinLength;

  370.         optMinBlockLenth.size    = sizeof(int);

  371.         optMinBlockLenth.type    = kUridAtomInt;

  372.         optMinBlockLenth.value   = &minBufferSize;

  373. 

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

  375.         optNominalBlockLenth.context = LV2_OPTIONS_INSTANCE;

  376.         optNominalBlockLenth.subject = 0;

  377.         optNominalBlockLenth.key     = kUridBufNominalLength;

  378.         optNominalBlockLenth.size    = sizeof(int);

  379.         optNominalBlockLenth.type    = kUridAtomInt;

  380.         optNominalBlockLenth.value   = &nominalBufferSize;

  381. 

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

  383.         optSequenceSize.context = LV2_OPTIONS_INSTANCE;

  384.         optSequenceSize.subject = 0;

  385.         optSequenceSize.key     = kUridBufSequenceSize;

  386.         optSequenceSize.size    = sizeof(int);

  387.         optSequenceSize.type    = kUridAtomInt;

  388.         optSequenceSize.value   = &sequenceSize;

  389. 

  390.         LV2_Options_Option& optBackgroundColor(opts[BackgroundColor]);

  391.         optBackgroundColor.context = LV2_OPTIONS_INSTANCE;

  392.         optBackgroundColor.subject = 0;

  393.         optBackgroundColor.key     = kUridBackgroundColor;

  394.         optBackgroundColor.size    = sizeof(int32_t);

  395.         optBackgroundColor.type    = kUridAtomInt;

  396.         optBackgroundColor.value   = &bgColor;

  397. 

  398.         LV2_Options_Option& optForegroundColor(opts[ForegroundColor]);

  399.         optForegroundColor.context = LV2_OPTIONS_INSTANCE;

  400.         optForegroundColor.subject = 0;

  401.         optForegroundColor.key     = kUridForegroundColor;

  402.         optForegroundColor.size    = sizeof(int32_t);

  403.         optForegroundColor.type    = kUridAtomInt;

  404.         optForegroundColor.value   = &fgColor;

  405. 

  406.         LV2_Options_Option& optScaleFactor(opts[ScaleFactor]);

  407.         optScaleFactor.context = LV2_OPTIONS_INSTANCE;

  408.         optScaleFactor.subject = 0;

  409.         optScaleFactor.key     = kUridScaleFactor;

  410.         optScaleFactor.size    = sizeof(float);

  411.         optScaleFactor.type    = kUridAtomFloat;

  412.         optScaleFactor.value   = &uiScale;

  413. 

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

  415.         optSampleRate.context = LV2_OPTIONS_INSTANCE;

  416.         optSampleRate.subject = 0;

  417.         optSampleRate.key     = kUridParamSampleRate;

  418.         optSampleRate.size    = sizeof(float);

  419.         optSampleRate.type    = kUridAtomFloat;

  420.         optSampleRate.value   = &sampleRate;

  421. 

  422.         LV2_Options_Option& optTransientWinId(opts[TransientWinId]);

  423.         optTransientWinId.context = LV2_OPTIONS_INSTANCE;

  424.         optTransientWinId.subject = 0;

  425.         optTransientWinId.key     = kUridCarlaTransientWindowId;

  426.         optTransientWinId.size    = sizeof(int64_t);

  427.         optTransientWinId.type    = kUridAtomLong;

  428.         optTransientWinId.value   = &transientWinId;

  429. 

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

  431.         optWindowTitle.context = LV2_OPTIONS_INSTANCE;

  432.         optWindowTitle.subject = 0;

  433.         optWindowTitle.key     = kUridWindowTitle;

  434.         optWindowTitle.size    = 0;

  435.         optWindowTitle.type    = kUridAtomString;

  436.         optWindowTitle.value   = nullptr;

  437. 

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

  439.         optNull.context = LV2_OPTIONS_INSTANCE;

  440.         optNull.subject = 0;

  441.         optNull.key     = kUridNull;

  442.         optNull.size    = 0;

  443.         optNull.type    = kUridNull;

  444.         optNull.value   = nullptr;

  445.     }

  446. 

  447.     ~CarlaPluginLV2Options() noexcept

  448.     {

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

  450. 

  451.         optWindowTitle.size  = 0;

  452.         optWindowTitle.value = nullptr;

  453. 

  454.         if (windowTitle != nullptr)

  455.         {

  456.             std::free(const_cast<char*>(windowTitle));

  457.             windowTitle = nullptr;

  458.         }

  459.     }

  460. 

  461.     CARLA_DECLARE_NON_COPY_STRUCT(CarlaPluginLV2Options);

  462. };

  463. 

  464. // -------------------------------------------------------------------------------------------------------------------

  465. 

  466. class CarlaPluginLV2;

  467. 

  468. class CarlaPipeServerLV2 : public CarlaPipeServer

  469. {

  470. public:

  471.     enum UiState {

  472.         UiNone = 0,

  473.         UiHide,

  474.         UiShow,

  475.         UiCrashed

  476.     };

  477. 

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

  479.         : kEngine(engine),

  480.           kPlugin(plugin),

  481.           fFilename(),

  482.           fPluginURI(),

  483.           fUiURI(),

  484.           fUiState(UiNone) {}

  485. 

  486.     ~CarlaPipeServerLV2() noexcept override

  487.     {

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

  489.     }

  490. 

  491.     UiState getAndResetUiState() noexcept

  492.     {

  493.         const UiState uiState(fUiState);

  494.         fUiState = UiNone;

  495.         return uiState;

  496.     }

  497. 

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

  499.     {

  500.         fFilename  = filename;

  501.         fPluginURI = pluginURI;

  502.         fUiURI     = uiURI;

  503.     }

  504. 

  505.     bool startPipeServer(const int size) noexcept

  506.     {

  507.         char sampleRateStr[32];

  508.         {

  509.             const CarlaScopedLocale csl;

  510.             std::snprintf(sampleRateStr, 31, "%.12g", kEngine->getSampleRate());

  511.         }

  512.         sampleRateStr[31] = '\0';

  513. 

  514.         const ScopedEngineEnvironmentLocker _seel(kEngine);

  515.         const CarlaScopedEnvVar _sev1("LV2_PATH", kEngine->getOptions().pathLV2);

  516. #ifdef CARLA_OS_LINUX

  517.         const CarlaScopedEnvVar _sev2("LD_PRELOAD", nullptr);

  518. #endif

  519.         carla_setenv("CARLA_SAMPLE_RATE", sampleRateStr);

  520. 

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

  522.     }

  523. 

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

  525.     {

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

  527. 

  528.         const CarlaMutexLocker cml(getPipeLock());

  529. 

  530.         if (! _writeMsgBuffer("uiTitle\n", 8))

  531.             return;

  532.         if (! writeAndFixMessage(title))

  533.             return;

  534. 

  535.         flushMessages();

  536.     }

  537. 

  538. protected:

  539.     // returns true if msg was handled

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

  541. 

  542. private:

  543.     CarlaEngine*    const kEngine;

  544.     CarlaPluginLV2* const kPlugin;

  545. 

  546.     CarlaString fFilename;

  547.     CarlaString fPluginURI;

  548.     CarlaString fUiURI;

  549.     UiState     fUiState;

  550. 

  551.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaPipeServerLV2)

  552. };

  553. 

  554. // -------------------------------------------------------------------------------------------------------------------

  555. 

  556. class CarlaPluginLV2 : public CarlaPlugin,

  557.                        private CarlaPluginUI::Callback

  558. {

  559. public:

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

  561.         : CarlaPlugin(engine, id),

  562.           fHandle(nullptr),

  563.           fHandle2(nullptr),

  564.           fDescriptor(nullptr),

  565.           fRdfDescriptor(nullptr),

  566.           fAudioInBuffers(nullptr),

  567.           fAudioOutBuffers(nullptr),

  568.           fCvInBuffers(nullptr),

  569.           fCvOutBuffers(nullptr),

  570.           fParamBuffers(nullptr),

  571.           fNeedsFixedBuffers(false),

  572.           fNeedsUiClose(false),

  573.           fInlineDisplayNeedsRedraw(false),

  574.           fInlineDisplayLastRedrawTime(0),

  575.           fLatencyIndex(-1),

  576.           fStrictBounds(-1),

  577.           fAtomBufferEvIn(),

  578.           fAtomBufferUiOut(),

  579.           fAtomBufferWorkerIn(),

  580.           fAtomBufferWorkerResp(),

  581.           fAtomForge(),

  582.           fAtomBufferUiOutTmpData(nullptr),

  583.           fAtomBufferWorkerInTmpData(nullptr),

  584.           fEventsIn(),

  585.           fEventsOut(),

  586.           fLv2Options(),

  587.           fPipeServer(engine, this),

  588.           fCustomURIDs(kUridCount, std::string("urn:null")),

  589.           fFirstActive(true),

  590.           fLastStateChunk(nullptr),

  591.           fLastTimeInfo(),

  592.           fFilePathURI(),

  593.           fExt(),

  594.           fUI()

  595.     {

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

  597.         CARLA_SAFE_ASSERT(fCustomURIDs.size() == kUridCount);

  598. 

  599.         carla_zeroPointers(fFeatures, kFeatureCountAll+1);

  600. 

  601. #if defined(__clang__)

  602. # pragma clang diagnostic push

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

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

  605. # pragma GCC diagnostic push

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

  607. #endif

  608.         fAtomForge.Blank    = kUridAtomBlank;

  609.         fAtomForge.Bool     = kUridAtomBool;

  610.         fAtomForge.Chunk    = kUridAtomChunk;

  611.         fAtomForge.Double   = kUridAtomDouble;

  612.         fAtomForge.Float    = kUridAtomFloat;

  613.         fAtomForge.Int      = kUridAtomInt;

  614.         fAtomForge.Literal  = kUridAtomLiteral;

  615.         fAtomForge.Long     = kUridAtomLong;

  616.         fAtomForge.Object   = kUridAtomObject;

  617.         fAtomForge.Path     = kUridAtomPath;

  618.         fAtomForge.Property = kUridAtomProperty;

  619.         fAtomForge.Resource = kUridAtomResource;

  620.         fAtomForge.Sequence = kUridAtomSequence;

  621.         fAtomForge.String   = kUridAtomString;

  622.         fAtomForge.Tuple    = kUridAtomTuple;

  623.         fAtomForge.URI      = kUridAtomURI;

  624.         fAtomForge.URID     = kUridAtomURID;

  625.         fAtomForge.Vector   = kUridAtomVector;

  626. #if defined(__clang__)

  627. # pragma clang diagnostic pop

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

  629. # pragma GCC diagnostic pop

  630. #endif

  631.     }

  632. 

  633.     ~CarlaPluginLV2() override

  634.     {

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

  636. 

  637.         fInlineDisplayNeedsRedraw = false;

  638. 

  639.         // close UI

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

  641.         {

  642.             showCustomUI(false);

  643. 

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

  645.             {

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

  647.             }

  648.             else

  649.             {

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

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

  652. 

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

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

  655. 

  656.                 if (fFeatures[kFeatureIdUiRequestValue] != nullptr && fFeatures[kFeatureIdUiRequestValue]->data != nullptr)

  657.                     delete (LV2UI_Request_Value*)fFeatures[kFeatureIdUiRequestValue]->data;

  658. 

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

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

  661. 

  662.                 if (fFeatures[kFeatureIdUiTouch] != nullptr && fFeatures[kFeatureIdUiTouch]->data != nullptr)

  663.                     delete (LV2UI_Touch*)fFeatures[kFeatureIdUiTouch]->data;

  664. 

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

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

  667. 

  668.                 fUI.descriptor = nullptr;

  669.                 pData->uiLibClose();

  670.             }

  671. 

  672. #ifndef LV2_UIS_ONLY_BRIDGES

  673.             if (fUI.window != nullptr)

  674.             {

  675.                 delete fUI.window;

  676.                 fUI.window = nullptr;

  677.             }

  678. #endif

  679. 

  680.             fUI.rdfDescriptor = nullptr;

  681.         }

  682. 

  683.         pData->singleMutex.lock();

  684.         pData->masterMutex.lock();

  685. 

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

  687.             pData->client->deactivate(true);

  688. 

  689.         if (pData->active)

  690.         {

  691.             deactivate();

  692.             pData->active = false;

  693.         }

  694. 

  695.         if (fDescriptor != nullptr)

  696.         {

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

  698.             {

  699.                 if (fHandle != nullptr)

  700.                     fDescriptor->cleanup(fHandle);

  701.                 if (fHandle2 != nullptr)

  702.                     fDescriptor->cleanup(fHandle2);

  703.             }

  704. 

  705.             fHandle  = nullptr;

  706.             fHandle2 = nullptr;

  707.             fDescriptor = nullptr;

  708.         }

  709. 

  710.         if (fRdfDescriptor != nullptr)

  711.         {

  712.             delete fRdfDescriptor;

  713.             fRdfDescriptor = nullptr;

  714.         }

  715. 

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

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

  718. 

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

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

  721. 

  722.         if (fFeatures[kFeatureIdStateFreePath] != nullptr && fFeatures[kFeatureIdStateFreePath]->data != nullptr)

  723.             delete (LV2_State_Free_Path*)fFeatures[kFeatureIdStateFreePath]->data;

  724. 

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

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

  727. 

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

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

  730. 

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

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

  733. 

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

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

  736. 

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

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

  739. 

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

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

  742. 

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

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

  745. 

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

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

  748. 

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

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

  751. 

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

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

  754. 

  755.         if (fFeatures[kFeatureIdInlineDisplay] != nullptr && fFeatures[kFeatureIdInlineDisplay]->data != nullptr)

  756.             delete (LV2_Inline_Display*)fFeatures[kFeatureIdInlineDisplay]->data;

  757. 

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

  759.         {

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

  761.             {

  762.                 delete fFeatures[i];

  763.                 fFeatures[i] = nullptr;

  764.             }

  765.         }

  766. 

  767.         if (fLastStateChunk != nullptr)

  768.         {

  769.             std::free(fLastStateChunk);

  770.             fLastStateChunk = nullptr;

  771.         }

  772. 

  773.         if (fAtomBufferUiOutTmpData != nullptr)

  774.         {

  775.             delete[] fAtomBufferUiOutTmpData;

  776.             fAtomBufferUiOutTmpData = nullptr;

  777.         }

  778. 

  779.         if (fAtomBufferWorkerInTmpData != nullptr)

  780.         {

  781.             delete[] fAtomBufferWorkerInTmpData;

  782.             fAtomBufferWorkerInTmpData = nullptr;

  783.         }

  784. 

  785.         clearBuffers();

  786.     }

  787. 

  788.     // -------------------------------------------------------------------

  789.     // Information (base)

  790. 

  791.     PluginType getType() const noexcept override

  792.     {

  793.         return PLUGIN_LV2;

  794.     }

  795. 

  796.     PluginCategory getCategory() const noexcept override

  797.     {

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

  799. 

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

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

  802. 

  803.         if (LV2_IS_DELAY(cat1, cat2))

  804.             return PLUGIN_CATEGORY_DELAY;

  805.         if (LV2_IS_DISTORTION(cat1, cat2))

  806.             return PLUGIN_CATEGORY_OTHER;

  807.         if (LV2_IS_DYNAMICS(cat1, cat2))

  808.             return PLUGIN_CATEGORY_DYNAMICS;

  809.         if (LV2_IS_EQ(cat1, cat2))

  810.             return PLUGIN_CATEGORY_EQ;

  811.         if (LV2_IS_FILTER(cat1, cat2))

  812.             return PLUGIN_CATEGORY_FILTER;

  813.         if (LV2_IS_GENERATOR(cat1, cat2))

  814.             return PLUGIN_CATEGORY_SYNTH;

  815.         if (LV2_IS_MODULATOR(cat1, cat2))

  816.             return PLUGIN_CATEGORY_MODULATOR;

  817.         if (LV2_IS_REVERB(cat1, cat2))

  818.             return PLUGIN_CATEGORY_DELAY;

  819.         if (LV2_IS_SIMULATOR(cat1, cat2))

  820.             return PLUGIN_CATEGORY_OTHER;

  821.         if (LV2_IS_SPATIAL(cat1, cat2))

  822.             return PLUGIN_CATEGORY_OTHER;

  823.         if (LV2_IS_SPECTRAL(cat1, cat2))

  824.             return PLUGIN_CATEGORY_UTILITY;

  825.         if (LV2_IS_UTILITY(cat1, cat2))

  826.             return PLUGIN_CATEGORY_UTILITY;

  827. 

  828.         return CarlaPlugin::getCategory();

  829.     }

  830. 

  831.     uint32_t getLatencyInFrames() const noexcept override

  832.     {

  833.         if (fLatencyIndex < 0 || fParamBuffers == nullptr)

  834.             return 0;

  835. 

  836.         const float latency(fParamBuffers[fLatencyIndex]);

  837.         CARLA_SAFE_ASSERT_RETURN(latency >= 0.0f, 0);

  838. 

  839.         return static_cast<uint32_t>(latency);

  840.     }

  841. 

  842.     // -------------------------------------------------------------------

  843.     // Information (count)

  844. 

  845.     uint32_t getMidiInCount() const noexcept override

  846.     {

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

  848. 

  849.         uint32_t count = 0;

  850. 

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

  852.         {

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

  854. 

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

  856.                 ++count;

  857.         }

  858. 

  859.         return count;

  860.     }

  861. 

  862.     uint32_t getMidiOutCount() const noexcept override

  863.     {

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

  865. 

  866.         uint32_t count = 0;

  867. 

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

  869.         {

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

  871. 

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

  873.                 ++count;

  874.         }

  875. 

  876.         return count;

  877.     }

  878. 

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

  880.     {

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

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

  883. 

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

  885. 

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

  887.         {

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

  889.             return port->ScalePointCount;

  890.         }

  891. 

  892.         return 0;

  893.     }

  894. 

  895.     // -------------------------------------------------------------------

  896.     // Information (current data)

  897. 

  898.     // nothing

  899. 

  900.     // -------------------------------------------------------------------

  901.     // Information (per-plugin data)

  902. 

  903.     uint getOptionsAvailable() const noexcept override

  904.     {

  905.         uint options = 0x0;

  906. 

  907.         // can't disable fixed buffers if using latency or MIDI output

  908.         if (fLatencyIndex == -1 && getMidiOutCount() == 0 && ! fNeedsFixedBuffers)

  909.             options |= PLUGIN_OPTION_FIXED_BUFFERS;

  910. 

  911.         // can't disable forced stereo if enabled in the engine

  912.         if (pData->engine->getOptions().forceStereo)

  913.             pass();

  914.         // if inputs or outputs are just 1, then yes we can force stereo

  915.         else if ((pData->audioIn.count == 1 || pData->audioOut.count == 1) || fHandle2 != nullptr)

  916.             options |= PLUGIN_OPTION_FORCE_STEREO;

  917. 

  918.         if (fExt.programs != nullptr)

  919.             options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  920. 

  921.         if (getMidiInCount() != 0)

  922.         {

  923.             options |= PLUGIN_OPTION_SEND_CONTROL_CHANGES;

  924.             options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  925.             options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

  926.             options |= PLUGIN_OPTION_SEND_PITCHBEND;

  927.             options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  928.             options |= PLUGIN_OPTION_SEND_PROGRAM_CHANGES;

  929.         }

  930. 

  931.         return options;

  932.     }

  933. 

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

  935.     {

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

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

  938. 

  939.         if (pData->param.data[parameterId].type == PARAMETER_INPUT)

  940.         {

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

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

  943.         }

  944.         else

  945.         {

  946.             if (fStrictBounds >= 0 && (pData->param.data[parameterId].hints & PARAMETER_IS_STRICT_BOUNDS) == 0)

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

  948.         }

  949. 

  950.         return fParamBuffers[parameterId];

  951.     }

  952. 

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

  954.     {

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

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

  957. 

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

  959. 

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

  961.         {

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

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

  964. 

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

  966.             return portScalePoint->Value;

  967.         }

  968. 

  969.         return 0.0f;

  970.     }

  971. 

  972.     bool getLabel(char* const strBuf) const noexcept override

  973.     {

  974.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr, false);

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

  976. 

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

  978.         return true;

  979.     }

  980. 

  981.     bool getMaker(char* const strBuf) const noexcept override

  982.     {

  983.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr, false);

  984. 

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

  986.         {

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

  988.             return true;

  989.         }

  990. 

  991.         return false;

  992.     }

  993. 

  994.     bool getCopyright(char* const strBuf) const noexcept override

  995.     {

  996.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr, false);

  997. 

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

  999.         {

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

  1001.             return true;

  1002.         }

  1003. 

  1004.         return false;

  1005.     }

  1006. 

  1007.     bool getRealName(char* const strBuf) const noexcept override

  1008.     {

  1009.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr, false);

  1010. 

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

  1012.         {

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

  1014.             return true;

  1015.         }

  1016. 

  1017.         return false;

  1018.     }

  1019. 

  1020.     bool getParameterName(const uint32_t parameterId, char* const strBuf) const noexcept override

  1021.     {

  1022.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr, false);

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

  1024. 

  1025.         int32_t rindex = pData->param.data[parameterId].rindex;

  1026.         CARLA_SAFE_ASSERT_RETURN(rindex >= 0, false);

  1027. 

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

  1029.         {

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

  1031.             return true;

  1032.         }

  1033. 

  1034.         rindex -= static_cast<int32_t>(fRdfDescriptor->PortCount);

  1035. 

  1036.         if (rindex < static_cast<int32_t>(fRdfDescriptor->ParameterCount))

  1037.         {

  1038.             std::strncpy(strBuf, fRdfDescriptor->Parameters[rindex].Label, STR_MAX);

  1039.             return true;

  1040.         }

  1041. 

  1042.         return CarlaPlugin::getParameterName(parameterId, strBuf);

  1043.     }

  1044. 

  1045.     bool getParameterSymbol(const uint32_t parameterId, char* const strBuf) const noexcept override

  1046.     {

  1047.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr, false);

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

  1049. 

  1050.         int32_t rindex = pData->param.data[parameterId].rindex;

  1051.         CARLA_SAFE_ASSERT_RETURN(rindex >= 0, false);

  1052. 

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

  1054.         {

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

  1056.             return true;

  1057.         }

  1058. 

  1059.         rindex -= static_cast<int32_t>(fRdfDescriptor->PortCount);

  1060. 

  1061.         if (rindex < static_cast<int32_t>(fRdfDescriptor->ParameterCount))

  1062.         {

  1063.             std::strncpy(strBuf, fRdfDescriptor->Parameters[rindex].URI, STR_MAX);

  1064.             return true;

  1065.         }

  1066. 

  1067.         return CarlaPlugin::getParameterSymbol(parameterId, strBuf);

  1068.     }

  1069. 

  1070.     bool getParameterUnit(const uint32_t parameterId, char* const strBuf) const noexcept override

  1071.     {

  1072.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr, false);

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

  1074. 

  1075.         LV2_RDF_PortUnit* portUnit = nullptr;

  1076. 

  1077.         int32_t rindex = pData->param.data[parameterId].rindex;

  1078.         CARLA_SAFE_ASSERT_RETURN(rindex >= 0, false);

  1079. 

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

  1081.         {

  1082.             portUnit = &fRdfDescriptor->Ports[rindex].Unit;

  1083.         }

  1084.         else

  1085.         {

  1086.             rindex -= static_cast<int32_t>(fRdfDescriptor->PortCount);

  1087. 

  1088.             if (rindex < static_cast<int32_t>(fRdfDescriptor->ParameterCount))

  1089.             {

  1090.                 portUnit = &fRdfDescriptor->Parameters[rindex].Unit;

  1091.             }

  1092.         }

  1093. 

  1094.         if (portUnit != nullptr)

  1095.         {

  1096.             if (LV2_HAVE_PORT_UNIT_SYMBOL(portUnit->Hints) && portUnit->Symbol != nullptr)

  1097.             {

  1098.                 std::strncpy(strBuf, portUnit->Symbol, STR_MAX);

  1099.                 return true;

  1100.             }

  1101. 

  1102.             if (LV2_HAVE_PORT_UNIT_UNIT(portUnit->Hints))

  1103.             {

  1104.                 switch (portUnit->Unit)

  1105.                 {

  1106.                 case LV2_PORT_UNIT_BAR:

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

  1108.                     return true;

  1109.                 case LV2_PORT_UNIT_BEAT:

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

  1111.                     return true;

  1112.                 case LV2_PORT_UNIT_BPM:

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

  1114.                     return true;

  1115.                 case LV2_PORT_UNIT_CENT:

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

  1117.                     return true;

  1118.                 case LV2_PORT_UNIT_CM:

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

  1120.                     return true;

  1121.                 case LV2_PORT_UNIT_COEF:

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

  1123.                     return true;

  1124.                 case LV2_PORT_UNIT_DB:

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

  1126.                     return true;

  1127.                 case LV2_PORT_UNIT_DEGREE:

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

  1129.                     return true;

  1130.                 case LV2_PORT_UNIT_FRAME:

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

  1132.                     return true;

  1133.                 case LV2_PORT_UNIT_HZ:

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

  1135.                     return true;

  1136.                 case LV2_PORT_UNIT_INCH:

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

  1138.                     return true;

  1139.                 case LV2_PORT_UNIT_KHZ:

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

  1141.                     return true;

  1142.                 case LV2_PORT_UNIT_KM:

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

  1144.                     return true;

  1145.                 case LV2_PORT_UNIT_M:

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

  1147.                     return true;

  1148.                 case LV2_PORT_UNIT_MHZ:

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

  1150.                     return true;

  1151.                 case LV2_PORT_UNIT_MIDINOTE:

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

  1153.                     return true;

  1154.                 case LV2_PORT_UNIT_MILE:

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

  1156.                     return true;

  1157.                 case LV2_PORT_UNIT_MIN:

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

  1159.                     return true;

  1160.                 case LV2_PORT_UNIT_MM:

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

  1162.                     return true;

  1163.                 case LV2_PORT_UNIT_MS:

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

  1165.                     return true;

  1166.                 case LV2_PORT_UNIT_OCT:

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

  1168.                     return true;

  1169.                 case LV2_PORT_UNIT_PC:

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

  1171.                     return true;

  1172.                 case LV2_PORT_UNIT_S:

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

  1174.                     return true;

  1175.                 case LV2_PORT_UNIT_SEMITONE:

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

  1177.                     return true;

  1178.                 }

  1179.             }

  1180.         }

  1181. 

  1182.         return CarlaPlugin::getParameterUnit(parameterId, strBuf);

  1183.     }

  1184. 

  1185.     bool getParameterComment(const uint32_t parameterId, char* const strBuf) const noexcept override

  1186.     {

  1187.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr, false);

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

  1189. 

  1190.         int32_t rindex = pData->param.data[parameterId].rindex;

  1191.         CARLA_SAFE_ASSERT_RETURN(rindex >= 0, false);

  1192. 

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

  1194.         {

  1195.             if (const char* const comment = fRdfDescriptor->Ports[rindex].Comment)

  1196.             {

  1197.                 std::strncpy(strBuf, comment, STR_MAX);

  1198.                 return true;

  1199.             }

  1200.             return false;

  1201.         }

  1202. 

  1203.         rindex -= static_cast<int32_t>(fRdfDescriptor->PortCount);

  1204. 

  1205.         if (rindex < static_cast<int32_t>(fRdfDescriptor->ParameterCount))

  1206.         {

  1207.             if (const char* const comment = fRdfDescriptor->Parameters[rindex].Comment)

  1208.             {

  1209.                 std::strncpy(strBuf, comment, STR_MAX);

  1210.                 return true;

  1211.             }

  1212.             return false;

  1213.         }

  1214. 

  1215.         return CarlaPlugin::getParameterComment(parameterId, strBuf);

  1216.     }

  1217. 

  1218.     bool getParameterGroupName(const uint32_t parameterId, char* const strBuf) const noexcept override

  1219.     {

  1220.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr, false);

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

  1222. 

  1223.         int32_t rindex = pData->param.data[parameterId].rindex;

  1224.         CARLA_SAFE_ASSERT_RETURN(rindex >= 0, false);

  1225. 

  1226.         const char* uri = nullptr;

  1227. 

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

  1229.         {

  1230.             uri = fRdfDescriptor->Ports[rindex].GroupURI;

  1231.         }

  1232.         else

  1233.         {

  1234.             rindex -= static_cast<int32_t>(fRdfDescriptor->PortCount);

  1235. 

  1236.             if (rindex < static_cast<int32_t>(fRdfDescriptor->ParameterCount))

  1237.                 uri = fRdfDescriptor->Parameters[rindex].GroupURI;

  1238.         }

  1239. 

  1240.         if (uri == nullptr)

  1241.             return false;

  1242. 

  1243.         for (uint32_t i=0; i<fRdfDescriptor->PortGroupCount; ++i)

  1244.         {

  1245.             if (std::strcmp(fRdfDescriptor->PortGroups[i].URI, uri) == 0)

  1246.             {

  1247.                 const char* const name   = fRdfDescriptor->PortGroups[i].Name;

  1248.                 const char* const symbol = fRdfDescriptor->PortGroups[i].Symbol;

  1249. 

  1250.                 if (name != nullptr && symbol != nullptr)

  1251.                 {

  1252.                     std::snprintf(strBuf, STR_MAX, "%s:%s", symbol, name);

  1253.                     return true;

  1254.                 }

  1255.                 return false;

  1256.             }

  1257.         }

  1258. 

  1259.         return false;

  1260.     }

  1261. 

  1262.     bool getParameterScalePointLabel(const uint32_t parameterId, const uint32_t scalePointId, char* const strBuf) const noexcept override

  1263.     {

  1264.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr, false);

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

  1266. 

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

  1268.         CARLA_SAFE_ASSERT_RETURN(rindex >= 0, false);

  1269. 

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

  1271.         {

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

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

  1274. 

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

  1276. 

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

  1278.             {

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

  1280.                 return true;

  1281.             }

  1282.         }

  1283. 

  1284.         return CarlaPlugin::getParameterScalePointLabel(parameterId, scalePointId, strBuf);

  1285.     }

  1286. 

  1287.     // -------------------------------------------------------------------

  1288.     // Set data (state)

  1289. 

  1290.     void prepareForSave() override

  1291.     {

  1292.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  1293. 

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

  1295.         {

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

  1297. 

  1298.             if (fHandle2 != nullptr)

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

  1300.         }

  1301.     }

  1302. 

  1303.     // -------------------------------------------------------------------

  1304.     // Set data (internal stuff)

  1305. 

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

  1307.     {

  1308.         CarlaPlugin::setName(newName);

  1309. 

  1310.         if (fLv2Options.windowTitle != nullptr && pData->uiTitle.isEmpty())

  1311.             setWindowTitle(nullptr);

  1312.     }

  1313. 

  1314.     void setWindowTitle(const char* const title) noexcept

  1315.     {

  1316.         CarlaString uiTitle;

  1317. 

  1318.         if (title != nullptr)

  1319.         {

  1320.             uiTitle = title;

  1321.         }

  1322.         else

  1323.         {

  1324.             uiTitle  = pData->name;

  1325.             uiTitle += " (GUI)";

  1326.         }

  1327. 

  1328.         std::free(const_cast<char*>(fLv2Options.windowTitle));

  1329.         fLv2Options.windowTitle = uiTitle.releaseBufferPointer();

  1330. 

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

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

  1333. 

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

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

  1336. 

  1337.         if (fPipeServer.isPipeRunning())

  1338.             fPipeServer.writeUiTitleMessage(fLv2Options.windowTitle);

  1339. 

  1340. #ifndef LV2_UIS_ONLY_BRIDGES

  1341.         if (fUI.window != nullptr)

  1342.         {

  1343.             try {

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

  1345.             } CARLA_SAFE_EXCEPTION("set custom title");

  1346.         }

  1347. #endif

  1348.     }

  1349. 

  1350.     // -------------------------------------------------------------------

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

  1352. 

  1353.     float setParamterValueCommon(const uint32_t parameterId, const float value) noexcept

  1354.     {

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

  1356.         fParamBuffers[parameterId] = fixedValue;

  1357. 

  1358.         if (pData->param.data[parameterId].rindex >= static_cast<int32_t>(fRdfDescriptor->PortCount))

  1359.         {

  1360.             const uint32_t rparamId = static_cast<uint32_t>(pData->param.data[parameterId].rindex) - fRdfDescriptor->PortCount;

  1361.             CARLA_SAFE_ASSERT_UINT2_RETURN(rparamId < fRdfDescriptor->ParameterCount,

  1362.                                            rparamId, fRdfDescriptor->PortCount, fixedValue);

  1363. 

  1364.             uint8_t atomBuf[256];

  1365.             lv2_atom_forge_set_buffer(&fAtomForge, atomBuf, sizeof(atomBuf));

  1366. 

  1367.             LV2_Atom_Forge_Frame forgeFrame;

  1368.             lv2_atom_forge_object(&fAtomForge, &forgeFrame, kUridNull, kUridPatchSet);

  1369. 

  1370.             lv2_atom_forge_key(&fAtomForge, kUridPatchPoperty);

  1371.             lv2_atom_forge_urid(&fAtomForge, getCustomURID(fRdfDescriptor->Parameters[rparamId].URI));

  1372.             lv2_atom_forge_key(&fAtomForge, kUridPatchValue);

  1373. 

  1374.             switch (fRdfDescriptor->Parameters[rparamId].Type)

  1375.             {

  1376.             case LV2_PARAMETER_BOOL:

  1377.                 lv2_atom_forge_bool(&fAtomForge, fixedValue > 0.5f);

  1378.                 break;

  1379.             case LV2_PARAMETER_INT:

  1380.                 lv2_atom_forge_int(&fAtomForge, static_cast<int32_t>(fixedValue + 0.5f));

  1381.                 break;

  1382.             case LV2_PARAMETER_LONG:

  1383.                 lv2_atom_forge_long(&fAtomForge, static_cast<int64_t>(fixedValue + 0.5f));

  1384.                 break;

  1385.             case LV2_PARAMETER_FLOAT:

  1386.                 lv2_atom_forge_float(&fAtomForge, fixedValue);

  1387.                 break;

  1388.             case LV2_PARAMETER_DOUBLE:

  1389.                 lv2_atom_forge_double(&fAtomForge, fixedValue);

  1390.                 break;

  1391.             default:

  1392.                 carla_stderr2("setParameterValue called for invalid parameter, expect issues!");

  1393.                 break;

  1394.             }

  1395. 

  1396.             lv2_atom_forge_pop(&fAtomForge, &forgeFrame);

  1397. 

  1398.             LV2_Atom* const atom((LV2_Atom*)atomBuf);

  1399.             CARLA_SAFE_ASSERT(atom->size < sizeof(atomBuf));

  1400. 

  1401.             fAtomBufferEvIn.put(atom, fEventsIn.ctrlIndex);

  1402.         }

  1403. 

  1404.         return fixedValue;

  1405.     }

  1406. 

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

  1408.     {

  1409.         CARLA_SAFE_ASSERT_RETURN(fParamBuffers != nullptr,);

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

  1411. 

  1412.         const float fixedValue = setParamterValueCommon(parameterId, value);

  1413. 

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

  1415.     }

  1416. 

  1417.     void setParameterValueRT(const uint32_t parameterId, const float value, const bool sendCallbackLater) noexcept override

  1418.     {

  1419.         CARLA_SAFE_ASSERT_RETURN(fParamBuffers != nullptr,);

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

  1421. 

  1422.         const float fixedValue = setParamterValueCommon(parameterId, value);

  1423. 

  1424.         CarlaPlugin::setParameterValueRT(parameterId, fixedValue, sendCallbackLater);

  1425.     }

  1426. 

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

  1428.     {

  1429.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  1430.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

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

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

  1433.         CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

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

  1435. 

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

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

  1438. 

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

  1440.     }

  1441. 

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

  1443.     {

  1444.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

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

  1446.         CARLA_SAFE_ASSERT_RETURN(sendGui || sendOsc || sendCallback,);

  1447. 

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

  1449.         {

  1450.             const LV2_URID_Map* const uridMap = (const LV2_URID_Map*)fFeatures[kFeatureIdUridMap]->data;

  1451. 

  1452.             LilvState* const state = Lv2WorldClass::getInstance().getStateFromURI(fRdfDescriptor->Presets[index].URI,

  1453.                                                                                   uridMap);

  1454.             CARLA_SAFE_ASSERT_RETURN(state != nullptr,);

  1455. 

  1456.             // invalidate midi-program selection

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

  1458. 

  1459.             if (fExt.state != nullptr)

  1460.             {

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

  1462. 

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

  1464. 

  1465.                 if (fHandle2 != nullptr)

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

  1467.             }

  1468.             else

  1469.             {

  1470.                 lilv_state_emit_port_values(state, carla_lilv_set_port_value, this);

  1471.             }

  1472. 

  1473.             lilv_state_free(state);

  1474.         }

  1475. 

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

  1477.     }

  1478. 

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

  1480.     {

  1481.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

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

  1483.         CARLA_SAFE_ASSERT_RETURN(sendGui || sendOsc || sendCallback || doingInit,);

  1484. 

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

  1486.         {

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

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

  1489. 

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

  1491. 

  1492.             try {

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

  1494.             } CARLA_SAFE_EXCEPTION("select program");

  1495. 

  1496.             if (fHandle2 != nullptr)

  1497.             {

  1498.                 try {

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

  1500.                 } CARLA_SAFE_EXCEPTION("select program 2");

  1501.             }

  1502.         }

  1503. 

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

  1505.     }

  1506. 

  1507.     void setMidiProgramRT(const uint32_t uindex, const bool sendCallbackLater) noexcept override

  1508.     {

  1509.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  1510.         CARLA_SAFE_ASSERT_RETURN(uindex < pData->midiprog.count,);

  1511. 

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

  1513.         {

  1514.             const uint32_t bank(pData->midiprog.data[uindex].bank);

  1515.             const uint32_t program(pData->midiprog.data[uindex].program);

  1516. 

  1517.             try {

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

  1519.             } CARLA_SAFE_EXCEPTION("select program RT");

  1520. 

  1521.             if (fHandle2 != nullptr)

  1522.             {

  1523.                 try {

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

  1525.                 } CARLA_SAFE_EXCEPTION("select program RT 2");

  1526.             }

  1527.         }

  1528. 

  1529.         CarlaPlugin::setMidiProgramRT(uindex, sendCallbackLater);

  1530.     }

  1531. 

  1532.     // -------------------------------------------------------------------

  1533.     // Set ui stuff

  1534. 

  1535.     void setCustomUITitle(const char* const title) noexcept override

  1536.     {

  1537.         setWindowTitle(title);

  1538.         CarlaPlugin::setCustomUITitle(title);

  1539.     }

  1540. 

  1541.     void showCustomUI(const bool yesNo) override

  1542.     {

  1543.         if (fUI.type == UI::TYPE_NULL)

  1544.         {

  1545.             if (fFilePathURI.isNotEmpty())

  1546.             {

  1547.                 const char* const path = pData->engine->runFileCallback(FILE_CALLBACK_OPEN, false, "Open File", "");

  1548. 

  1549.                 if (path != nullptr && path[0] != '\0')

  1550.                 {

  1551.                     carla_stdout("LV2 file path to send: '%s'", path);

  1552.                     writeAtomPath(path, getCustomURID(fFilePathURI));

  1553.                 }

  1554.             }

  1555.             else

  1556.             {

  1557.                 CARLA_SAFE_ASSERT(!yesNo);

  1558.             }

  1559.             pData->engine->callback(true, true,

  1560.                                     ENGINE_CALLBACK_UI_STATE_CHANGED, pData->id, 0, 0, 0, 0.0f, nullptr);

  1561.             return;

  1562.         }

  1563. 

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

  1565. 

  1566. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1567.         if (! yesNo)

  1568.             pData->transientTryCounter = 0;

  1569. #endif

  1570. 

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

  1572.         {

  1573.             if (yesNo)

  1574.             {

  1575.                 if (fPipeServer.isPipeRunning())

  1576.                 {

  1577.                     fPipeServer.writeFocusMessage();

  1578.                     return;

  1579.                 }

  1580. 

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

  1582.                 {

  1583.                     pData->engine->callback(true, true,

  1584.                                             ENGINE_CALLBACK_UI_STATE_CHANGED, pData->id, 0, 0, 0, 0.0f, nullptr);

  1585.                     return;

  1586.                 }

  1587. 

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

  1589.                 {

  1590.                     char tmpBuf[0xff];

  1591.                     tmpBuf[0xfe] = '\0';

  1592. 

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

  1594.                     const CarlaScopedLocale csl;

  1595. 

  1596.                     // write URI mappings

  1597.                     uint32_t u = 0;

  1598.                     for (std::vector<std::string>::iterator it=fCustomURIDs.begin(), end=fCustomURIDs.end(); it != end; ++it, ++u)

  1599.                     {

  1600.                         if (u < kUridCount)

  1601.                             continue;

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

  1603. 

  1604.                         if (! fPipeServer.writeMessage("urid\n", 5))

  1605.                             return;

  1606. 

  1607.                         std::snprintf(tmpBuf, 0xfe, "%u\n", u);

  1608.                         if (! fPipeServer.writeMessage(tmpBuf))

  1609.                             return;

  1610. 

  1611.                         std::snprintf(tmpBuf, 0xfe, "%lu\n", static_cast<long unsigned>(uri.length()));

  1612.                         if (! fPipeServer.writeMessage(tmpBuf))

  1613.                             return;

  1614. 

  1615.                         if (! fPipeServer.writeAndFixMessage(uri.c_str()))

  1616.                             return;

  1617.                     }

  1618. 

  1619.                     // write UI options

  1620.                     if (! fPipeServer.writeMessage("uiOptions\n", 10))

  1621.                         return;

  1622. 

  1623.                     const EngineOptions& opts(pData->engine->getOptions());

  1624. 

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

  1626.                     if (! fPipeServer.writeMessage(tmpBuf))

  1627.                         return;

  1628. 

  1629.                     std::snprintf(tmpBuf, 0xff, "%u\n", opts.bgColor);

  1630.                     if (! fPipeServer.writeMessage(tmpBuf))

  1631.                         return;

  1632. 

  1633.                     std::snprintf(tmpBuf, 0xff, "%u\n", opts.fgColor);

  1634.                     if (! fPipeServer.writeMessage(tmpBuf))

  1635.                         return;

  1636. 

  1637.                     std::snprintf(tmpBuf, 0xff, "%.12g\n", static_cast<double>(opts.uiScale));

  1638.                     if (! fPipeServer.writeMessage(tmpBuf))

  1639.                         return;

  1640. 

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

  1642.                     if (! fPipeServer.writeMessage(tmpBuf))

  1643.                         return;

  1644. 

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

  1646.                     if (! fPipeServer.writeMessage(tmpBuf))

  1647.                         return;

  1648. 

  1649.                     if (! fPipeServer.writeAndFixMessage(fLv2Options.windowTitle != nullptr

  1650.                                                          ? fLv2Options.windowTitle

  1651.                                                          : ""))

  1652.                         return;

  1653. 

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

  1655.                     if (! fPipeServer.writeMessage(tmpBuf))

  1656.                         return;

  1657. 

  1658.                     // write parameter values

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

  1660.                     {

  1661.                         if (! fPipeServer.writeMessage("control\n", 8))

  1662.                             return;

  1663. 

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

  1665.                         if (! fPipeServer.writeMessage(tmpBuf))

  1666.                             return;

  1667. 

  1668.                         std::snprintf(tmpBuf, 0xff, "%.12g\n", static_cast<double>(getParameterValue(i)));

  1669.                         if (! fPipeServer.writeMessage(tmpBuf))

  1670.                             return;

  1671.                     }

  1672. 

  1673.                     // ready to show

  1674.                     if (! fPipeServer.writeMessage("show\n", 5))

  1675.                         return;

  1676. 

  1677.                     fPipeServer.flushMessages();

  1678.                 }

  1679. 

  1680. #ifndef BUILD_BRIDGE

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

  1682.                     pData->tryTransient();

  1683. #endif

  1684.             }

  1685.             else

  1686.             {

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

  1688.             }

  1689.             return;

  1690.         }

  1691. 

  1692.         // take some precautions

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

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

  1695. 

  1696.         if (yesNo)

  1697.         {

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

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

  1700.         }

  1701.         else

  1702.         {

  1703.             if (fUI.handle == nullptr)

  1704.                 return;

  1705.         }

  1706. 

  1707.         if (yesNo)

  1708.         {

  1709.             if (fUI.handle == nullptr)

  1710.             {

  1711. #ifndef LV2_UIS_ONLY_BRIDGES

  1712.                 if (fUI.type == UI::TYPE_EMBED && fUI.rdfDescriptor->Type != LV2_UI_NONE && fUI.window == nullptr)

  1713.                 {

  1714.                     const char* msg = nullptr;

  1715. 

  1716.                     switch (fUI.rdfDescriptor->Type)

  1717.                     {

  1718.                     case LV2_UI_GTK2:

  1719.                     case LV2_UI_GTK3:

  1720.                     case LV2_UI_QT4:

  1721.                     case LV2_UI_QT5:

  1722.                     case LV2_UI_EXTERNAL:

  1723.                     case LV2_UI_OLD_EXTERNAL:

  1724.                         msg = "Invalid UI type";

  1725.                         break;

  1726. 

  1727.                     case LV2_UI_COCOA:

  1728. # ifdef CARLA_OS_MAC

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

  1730. # else

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

  1732. # endif

  1733.                         break;

  1734. 

  1735.                     case LV2_UI_WINDOWS:

  1736. # ifdef CARLA_OS_WIN

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

  1738. # else

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

  1740. # endif

  1741.                         break;

  1742. 

  1743.                     case LV2_UI_X11:

  1744. # ifdef HAVE_X11

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

  1746. # else

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

  1748. # endif

  1749.                         break;

  1750. 

  1751.                     default:

  1752.                         msg = "Unknown UI type";

  1753.                         break;

  1754.                     }

  1755. 

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

  1757.                         return pData->engine->callback(true, true,

  1758.                                                        ENGINE_CALLBACK_UI_STATE_CHANGED, pData->id, -1, 0, 0, 0.0f, msg);

  1759. 

  1760.                     if (fUI.window != nullptr)

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

  1762.                 }

  1763. #endif

  1764.                 fUI.widget = nullptr;

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

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

  1767. 

  1768.                 if (fUI.window != nullptr)

  1769.                 {

  1770.                     if (fUI.widget != nullptr)

  1771.                         fUI.window->setChildWindow(fUI.widget);

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

  1773.                 }

  1774.             }

  1775. 

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

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

  1778. 

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

  1780.             {

  1781.                 fUI.widget = nullptr;

  1782. 

  1783.                 if (fUI.handle != nullptr)

  1784.                 {

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

  1786.                     fUI.handle = nullptr;

  1787.                 }

  1788. 

  1789.                 return pData->engine->callback(true, true,

  1790.                                                ENGINE_CALLBACK_UI_STATE_CHANGED,

  1791.                                                pData->id,

  1792.                                                -1,

  1793.                                                0, 0, 0.0f,

  1794.                                                "Plugin refused to open its own UI");

  1795.             }

  1796. 

  1797.             updateUi();

  1798. 

  1799. #ifndef LV2_UIS_ONLY_BRIDGES

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

  1801.             {

  1802.                 if (fUI.window != nullptr)

  1803.                 {

  1804.                     fUI.window->show();

  1805.                 }

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

  1807.                 {

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

  1809. # ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1810.                     pData->tryTransient();

  1811. # endif

  1812.                 }

  1813.             }

  1814.             else

  1815. #endif

  1816.             {

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

  1818. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1819.                 pData->tryTransient();

  1820. #endif

  1821.             }

  1822.         }

  1823.         else

  1824.         {

  1825. #ifndef LV2_UIS_ONLY_BRIDGES

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

  1827.             {

  1828.                 if (fUI.window != nullptr)

  1829.                     fUI.window->hide();

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

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

  1832.             }

  1833.             else

  1834. #endif

  1835.             {

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

  1837. 

  1838.                 if (fUI.widget != nullptr)

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

  1840.             }

  1841. 

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

  1843.             fUI.handle = nullptr;

  1844.             fUI.widget = nullptr;

  1845.         }

  1846.     }

  1847. 

  1848.     void idle() override

  1849.     {

  1850.         if (fAtomBufferWorkerIn.isDataAvailableForReading())

  1851.         {

  1852.             Lv2AtomRingBuffer tmpRingBuffer(fAtomBufferWorkerIn, fAtomBufferWorkerInTmpData);

  1853.             CARLA_SAFE_ASSERT_RETURN(tmpRingBuffer.isDataAvailableForReading(),);

  1854.             CARLA_SAFE_ASSERT_RETURN(fExt.worker != nullptr && fExt.worker->work != nullptr,);

  1855. 

  1856.             uint32_t portIndex;

  1857.             const LV2_Atom* atom;

  1858. 

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

  1860.             {

  1861.                 CARLA_SAFE_ASSERT_CONTINUE(atom->type == kUridCarlaAtomWorkerIn);

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

  1863.             }

  1864.         }

  1865. 

  1866.         if (fInlineDisplayNeedsRedraw)

  1867.         {

  1868.             // TESTING

  1869.             CARLA_SAFE_ASSERT(pData->enabled)

  1870.             CARLA_SAFE_ASSERT(!pData->engine->isAboutToClose());

  1871.             CARLA_SAFE_ASSERT(pData->client->isActive());

  1872. 

  1873.             if (pData->enabled && !pData->engine->isAboutToClose() && pData->client->isActive())

  1874.             {

  1875.                 const int64_t timeNow = water::Time::currentTimeMillis();

  1876. 

  1877.                 if (timeNow - fInlineDisplayLastRedrawTime > (1000 / 30))

  1878.                 {

  1879.                     fInlineDisplayNeedsRedraw = false;

  1880.                     fInlineDisplayLastRedrawTime = timeNow;

  1881.                     pData->engine->callback(true, true,

  1882.                                             ENGINE_CALLBACK_INLINE_DISPLAY_REDRAW,

  1883.                                             pData->id,

  1884.                                             0, 0, 0, 0.0f, nullptr);

  1885.                 }

  1886.             }

  1887.             else

  1888.             {

  1889.                 fInlineDisplayNeedsRedraw = false;

  1890.             }

  1891.         }

  1892. 

  1893.         CarlaPlugin::idle();

  1894.     }

  1895. 

  1896.     void uiIdle() override

  1897.     {

  1898.         if (const char* const fileNeededForURI = fUI.fileNeededForURI)

  1899.         {

  1900.             fUI.fileBrowserOpen = true;

  1901.             fUI.fileNeededForURI = nullptr;

  1902. 

  1903.             const char* const path = pData->engine->runFileCallback(FILE_CALLBACK_OPEN,

  1904.                                                                     /* isDir   */ false,

  1905.                                                                     /* title   */ "File open",

  1906.                                                                     /* filters */ "");

  1907. 

  1908.             fUI.fileBrowserOpen = false;

  1909. 

  1910.             if (path != nullptr)

  1911.             {

  1912.                 carla_stdout("LV2 requested path to send: '%s'", path);

  1913.                 writeAtomPath(path, getCustomURID(fileNeededForURI));

  1914.             }

  1915. 

  1916.             // this function will be called recursively, stop here

  1917.             return;

  1918.         }

  1919. 

  1920.         if (fAtomBufferUiOut.isDataAvailableForReading())

  1921.         {

  1922.             Lv2AtomRingBuffer tmpRingBuffer(fAtomBufferUiOut, fAtomBufferUiOutTmpData);

  1923.             CARLA_SAFE_ASSERT(tmpRingBuffer.isDataAvailableForReading());

  1924. 

  1925.             uint32_t portIndex;

  1926.             const LV2_Atom* atom;

  1927.             const bool hasPortEvent(fUI.handle != nullptr &&

  1928.                                     fUI.descriptor != nullptr &&

  1929.                                     fUI.descriptor->port_event != nullptr);

  1930. 

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

  1932.             {

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

  1934.                 {

  1935.                     if (fPipeServer.isPipeRunning())

  1936.                         fPipeServer.writeLv2AtomMessage(portIndex, atom);

  1937.                 }

  1938.                 else

  1939.                 {

  1940.                     if (hasPortEvent && ! fNeedsUiClose)

  1941.                         fUI.descriptor->port_event(fUI.handle, portIndex, lv2_atom_total_size(atom), kUridAtomTransferEvent, atom);

  1942.                 }

  1943.             }

  1944.         }

  1945. 

  1946.         if (fPipeServer.isPipeRunning())

  1947.         {

  1948.             fPipeServer.idlePipe();

  1949. 

  1950.             switch (fPipeServer.getAndResetUiState())

  1951.             {

  1952.             case CarlaPipeServerLV2::UiNone:

  1953.             case CarlaPipeServerLV2::UiShow:

  1954.                 break;

  1955.             case CarlaPipeServerLV2::UiHide:

  1956.                 fPipeServer.stopPipeServer(2000);

  1957.                 // fall through

  1958.             case CarlaPipeServerLV2::UiCrashed:

  1959. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1960.                 pData->transientTryCounter = 0;

  1961. #endif

  1962.                 pData->engine->callback(true, true,

  1963.                                         ENGINE_CALLBACK_UI_STATE_CHANGED,

  1964.                                         pData->id,

  1965.                                         0,

  1966.                                         0, 0, 0.0f, nullptr);

  1967.                 break;

  1968.             }

  1969.         }

  1970.         else

  1971.         {

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

  1973.         }

  1974. 

  1975.         if (fNeedsUiClose)

  1976.         {

  1977.             fNeedsUiClose = false;

  1978.             showCustomUI(false);

  1979.             pData->engine->callback(true, true,

  1980.                                     ENGINE_CALLBACK_UI_STATE_CHANGED,

  1981.                                     pData->id,

  1982.                                     0,

  1983.                                     0, 0, 0.0f, nullptr);

  1984.         }

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

  1986.         {

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

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

  1989. #ifndef LV2_UIS_ONLY_BRIDGES

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

  1991.                 fUI.window->idle();

  1992. 

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

  1994.             if (fNeedsUiClose)

  1995.             {

  1996.                 pass();

  1997.             }

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

  1999.             {

  2000.                 showCustomUI(false);

  2001.                 pData->engine->callback(true, true,

  2002.                                         ENGINE_CALLBACK_UI_STATE_CHANGED,

  2003.                                         pData->id,

  2004.                                         0,

  2005.                                         0, 0, 0.0f, nullptr);

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

  2007.             }

  2008. #endif

  2009.         }

  2010. 

  2011.         CarlaPlugin::uiIdle();

  2012.     }

  2013. 

  2014.     // -------------------------------------------------------------------

  2015.     // Plugin state

  2016. 

  2017.     void reload() override

  2018.     {

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

  2020.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  2021.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  2022.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr,);

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

  2024. 

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

  2026. 

  2027.         // Safely disable plugin for reload

  2028.         const ScopedDisabler sd(this);

  2029. 

  2030.         if (pData->active)

  2031.             deactivate();

  2032. 

  2033.         clearBuffers();

  2034. 

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

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

  2037. 

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

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

  2040.         LinkedList<uint> evIns, evOuts;

  2041. 

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

  2043. 

  2044.         bool forcedStereoIn, forcedStereoOut;

  2045.         forcedStereoIn = forcedStereoOut = false;

  2046. 

  2047.         bool needsCtrlIn, needsCtrlOut;

  2048.         needsCtrlIn = needsCtrlOut = false;

  2049. 

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

  2051.         {

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

  2053. 

  2054.             if (LV2_IS_PORT_AUDIO(portTypes))

  2055.             {

  2056.                 if (LV2_IS_PORT_INPUT(portTypes))

  2057.                     aIns += 1;

  2058.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  2059.                     aOuts += 1;

  2060.             }

  2061.             else if (LV2_IS_PORT_CV(portTypes))

  2062.             {

  2063.                 if (LV2_IS_PORT_INPUT(portTypes))

  2064.                     cvIns += 1;

  2065.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  2066.                     cvOuts += 1;

  2067.             }

  2068.             else if (LV2_IS_PORT_ATOM_SEQUENCE(portTypes))

  2069.             {

  2070.                 if (LV2_IS_PORT_INPUT(portTypes))

  2071.                     evIns.append(CARLA_EVENT_DATA_ATOM);

  2072.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  2073.                     evOuts.append(CARLA_EVENT_DATA_ATOM);

  2074.             }

  2075.             else if (LV2_IS_PORT_EVENT(portTypes))

  2076.             {

  2077.                 if (LV2_IS_PORT_INPUT(portTypes))

  2078.                     evIns.append(CARLA_EVENT_DATA_EVENT);

  2079.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  2080.                     evOuts.append(CARLA_EVENT_DATA_EVENT);

  2081.             }

  2082.             else if (LV2_IS_PORT_MIDI_LL(portTypes))

  2083.             {

  2084.                 if (LV2_IS_PORT_INPUT(portTypes))

  2085.                     evIns.append(CARLA_EVENT_DATA_MIDI_LL);

  2086.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  2087.                     evOuts.append(CARLA_EVENT_DATA_MIDI_LL);

  2088.             }

  2089.             else if (LV2_IS_PORT_CONTROL(portTypes))

  2090.                 params += 1;

  2091.         }

  2092. 

  2093.         for (uint32_t i=0; i < fRdfDescriptor->ParameterCount; ++i)

  2094.         {

  2095.             switch (fRdfDescriptor->Parameters[i].Type)

  2096.             {

  2097.             case LV2_PARAMETER_BOOL:

  2098.             case LV2_PARAMETER_INT:

  2099.             // case LV2_PARAMETER_LONG:

  2100.             case LV2_PARAMETER_FLOAT:

  2101.             case LV2_PARAMETER_DOUBLE:

  2102.                 params += 1;

  2103.                 break;

  2104.             case LV2_PARAMETER_PATH:

  2105.                 if (fFilePathURI.isEmpty())

  2106.                     fFilePathURI = fRdfDescriptor->Parameters[i].URI;

  2107.                 break;

  2108.             }

  2109.         }

  2110. 

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

  2112.         {

  2113.             if (fHandle2 == nullptr)

  2114.             {

  2115.                 try {

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

  2117.                 } catch(...) {}

  2118.             }

  2119. 

  2120.             if (fHandle2 != nullptr)

  2121.             {

  2122.                 if (aIns == 1)

  2123.                 {

  2124.                     aIns = 2;

  2125.                     forcedStereoIn = true;

  2126.                 }

  2127. 

  2128.                 if (aOuts == 1)

  2129.                 {

  2130.                     aOuts = 2;

  2131.                     forcedStereoOut = true;

  2132.                 }

  2133.             }

  2134.         }

  2135. 

  2136.         if (aIns > 0)

  2137.         {

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

  2139.             fAudioInBuffers = new float*[aIns];

  2140. 

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

  2142.                 fAudioInBuffers[i] = nullptr;

  2143.         }

  2144. 

  2145.         if (aOuts > 0)

  2146.         {

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

  2148.             fAudioOutBuffers = new float*[aOuts];

  2149.             needsCtrlIn = true;

  2150. 

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

  2152.                 fAudioOutBuffers[i] = nullptr;

  2153.         }

  2154. 

  2155.         if (cvIns > 0)

  2156.         {

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

  2158.             fCvInBuffers = new float*[cvIns];

  2159. 

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

  2161.                 fCvInBuffers[i] = nullptr;

  2162.         }

  2163. 

  2164.         if (cvOuts > 0)

  2165.         {

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

  2167.             fCvOutBuffers = new float*[cvOuts];

  2168. 

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

  2170.                 fCvOutBuffers[i] = nullptr;

  2171.         }

  2172. 

  2173.         if (params > 0)

  2174.         {

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

  2176.             fParamBuffers = new float[params];

  2177.             carla_zeroFloats(fParamBuffers, params);

  2178.         }

  2179. 

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

  2181.         {

  2182.             fEventsIn.createNew(count);

  2183. 

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

  2185.             {

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

  2187. 

  2188.                 if (type == CARLA_EVENT_DATA_ATOM)

  2189.                 {

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

  2191.                     fEventsIn.data[i].atom = lv2_atom_buffer_new(eventBufferSize, kUridNull, kUridAtomSequence, true);

  2192.                 }

  2193.                 else if (type == CARLA_EVENT_DATA_EVENT)

  2194.                 {

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

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

  2197.                 }

  2198.                 else if (type == CARLA_EVENT_DATA_MIDI_LL)

  2199.                 {

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

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

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

  2203.                 }

  2204.             }

  2205.         }

  2206.         else

  2207.         {

  2208.             fEventsIn.createNew(1);

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

  2210.         }

  2211. 

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

  2213.         {

  2214.             fEventsOut.createNew(count);

  2215. 

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

  2217.             {

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

  2219. 

  2220.                 if (type == CARLA_EVENT_DATA_ATOM)

  2221.                 {

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

  2223.                     fEventsOut.data[i].atom = lv2_atom_buffer_new(eventBufferSize, kUridNull, kUridAtomSequence, false);

  2224.                 }

  2225.                 else if (type == CARLA_EVENT_DATA_EVENT)

  2226.                 {

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

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

  2229.                 }

  2230.                 else if (type == CARLA_EVENT_DATA_MIDI_LL)

  2231.                 {

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

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

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

  2235.                 }

  2236.             }

  2237.         }

  2238. 

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

  2240.         CarlaString portName;

  2241.         uint32_t iCtrl = 0;

  2242. 

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

  2244.         {

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

  2246. 

  2247.             portName.clear();

  2248. 

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

  2250.             {

  2251.                 if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  2252.                 {

  2253.                     portName  = pData->name;

  2254.                     portName += ":";

  2255.                 }

  2256. 

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

  2258.                 portName.truncate(portNameSize);

  2259.             }

  2260. 

  2261.             if (LV2_IS_PORT_AUDIO(portTypes))

  2262.             {

  2263.                 if (LV2_IS_PORT_INPUT(portTypes))

  2264.                 {

  2265.                     const uint32_t j = iAudioIn++;

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

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

  2268. 

  2269.                     if (forcedStereoIn)

  2270.                     {

  2271.                         portName += "_2";

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

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

  2274.                     }

  2275.                 }

  2276.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  2277.                 {

  2278.                     const uint32_t j = iAudioOut++;

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

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

  2281. 

  2282.                     if (forcedStereoOut)

  2283.                     {

  2284.                         portName += "_2";

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

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

  2287.                     }

  2288.                 }

  2289.                 else

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

  2291.             }

  2292.             else if (LV2_IS_PORT_CV(portTypes))

  2293.             {

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

  2295.                 float min, max;

  2296. 

  2297.                 // min value

  2298.                 if (LV2_HAVE_MINIMUM_PORT_POINT(portPoints.Hints))

  2299.                     min = portPoints.Minimum;

  2300.                 else

  2301.                     min = -1.0f;

  2302. 

  2303.                 // max value

  2304.                 if (LV2_HAVE_MAXIMUM_PORT_POINT(portPoints.Hints))

  2305.                     max = portPoints.Maximum;

  2306.                 else

  2307.                     max = 1.0f;

  2308. 

  2309.                 if (LV2_IS_PORT_INPUT(portTypes))

  2310.                 {

  2311.                     const uint32_t j = iCvIn++;

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

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

  2314.                     pData->cvIn.ports[j].port->setRange(min, max);

  2315.                 }

  2316.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  2317.                 {

  2318.                     const uint32_t j = iCvOut++;

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

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

  2321.                     pData->cvOut.ports[j].port->setRange(min, max);

  2322.                 }

  2323.                 else

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

  2325.             }

  2326.             else if (LV2_IS_PORT_ATOM_SEQUENCE(portTypes))

  2327.             {

  2328.                 if (LV2_IS_PORT_INPUT(portTypes))

  2329.                 {

  2330.                     const uint32_t j = iEvIn++;

  2331. 

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

  2333. 

  2334.                     if (fHandle2 != nullptr)

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

  2336. 

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

  2338. 

  2339.                     if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

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

  2341.                     if (portTypes & LV2_PORT_DATA_PATCH_MESSAGE)

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

  2343.                     if (portTypes & LV2_PORT_DATA_TIME_POSITION)

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

  2345. 

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

  2347.                     {

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

  2349.                         fEventsIn.ctrlIndex = j;

  2350. 

  2351.                         if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

  2352.                             needsCtrlIn = true;

  2353.                     }

  2354.                     else

  2355.                     {

  2356.                         if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

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

  2358. 

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

  2360.                         {

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

  2362.                             fEventsIn.ctrlIndex = j;

  2363.                         }

  2364.                     }

  2365.                 }

  2366.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  2367.                 {

  2368.                     const uint32_t j = iEvOut++;

  2369. 

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

  2371. 

  2372.                     if (fHandle2 != nullptr)

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

  2374. 

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

  2376. 

  2377.                     if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

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

  2379.                     if (portTypes & LV2_PORT_DATA_PATCH_MESSAGE)

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

  2381.                     if (portTypes & LV2_PORT_DATA_TIME_POSITION)

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

  2383. 

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

  2385.                     {

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

  2387.                         fEventsOut.ctrlIndex = j;

  2388. 

  2389.                         if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

  2390.                             needsCtrlOut = true;

  2391.                     }

  2392.                     else

  2393.                     {

  2394.                         if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

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

  2396. 

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

  2398.                         {

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

  2400.                             fEventsOut.ctrlIndex = j;

  2401.                         }

  2402.                     }

  2403.                 }

  2404.                 else

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

  2406.             }

  2407.             else if (LV2_IS_PORT_EVENT(portTypes))

  2408.             {

  2409.                 if (LV2_IS_PORT_INPUT(portTypes))

  2410.                 {

  2411.                     const uint32_t j = iEvIn++;

  2412. 

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

  2414. 

  2415.                     if (fHandle2 != nullptr)

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

  2417. 

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

  2419. 

  2420.                     if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

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

  2422.                     if (portTypes & LV2_PORT_DATA_PATCH_MESSAGE)

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

  2424.                     if (portTypes & LV2_PORT_DATA_TIME_POSITION)

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

  2426. 

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

  2428.                     {

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

  2430.                         fEventsIn.ctrlIndex = j;

  2431. 

  2432.                         if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

  2433.                             needsCtrlIn = true;

  2434.                     }

  2435.                     else

  2436.                     {

  2437.                         if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

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

  2439. 

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

  2441.                         {

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

  2443.                             fEventsIn.ctrlIndex = j;

  2444.                         }

  2445.                     }

  2446.                 }

  2447.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  2448.                 {

  2449.                     const uint32_t j = iEvOut++;

  2450. 

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

  2452. 

  2453.                     if (fHandle2 != nullptr)

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

  2455. 

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

  2457. 

  2458.                     if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

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

  2460.                     if (portTypes & LV2_PORT_DATA_PATCH_MESSAGE)

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

  2462.                     if (portTypes & LV2_PORT_DATA_TIME_POSITION)

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

  2464. 

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

  2466.                     {

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

  2468.                         fEventsOut.ctrlIndex = j;

  2469. 

  2470.                         if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

  2471.                             needsCtrlOut = true;

  2472.                     }

  2473.                     else

  2474.                     {

  2475.                         if (portTypes & LV2_PORT_DATA_MIDI_EVENT)

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

  2477. 

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

  2479.                         {

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

  2481.                             fEventsOut.ctrlIndex = j;

  2482.                         }

  2483.                     }

  2484.                 }

  2485.                 else

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

  2487.             }

  2488.             else if (LV2_IS_PORT_MIDI_LL(portTypes))

  2489.             {

  2490.                 if (LV2_IS_PORT_INPUT(portTypes))

  2491.                 {

  2492.                     const uint32_t j = iEvIn++;

  2493. 

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

  2495. 

  2496.                     if (fHandle2 != nullptr)

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

  2498. 

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

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

  2501. 

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

  2503.                     {

  2504.                         needsCtrlIn = true;

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

  2506.                         fEventsIn.ctrlIndex = j;

  2507.                     }

  2508.                     else

  2509.                     {

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

  2511. 

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

  2513.                         {

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

  2515.                             fEventsIn.ctrlIndex = j;

  2516.                         }

  2517.                     }

  2518.                 }

  2519.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  2520.                 {

  2521.                     const uint32_t j = iEvOut++;

  2522. 

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

  2524. 

  2525.                     if (fHandle2 != nullptr)

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

  2527. 

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

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

  2530. 

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

  2532.                     {

  2533.                         needsCtrlOut = true;

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

  2535.                         fEventsOut.ctrlIndex = j;

  2536.                     }

  2537.                     else

  2538.                     {

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

  2540. 

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

  2542.                         {

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

  2544.                             fEventsOut.ctrlIndex = j;

  2545.                         }

  2546.                     }

  2547.                 }

  2548.                 else

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

  2550.             }

  2551.             else if (LV2_IS_PORT_CONTROL(portTypes))

  2552.             {

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

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

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

  2556. 

  2557.                 const uint32_t j = iCtrl++;

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

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

  2560. 

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

  2562. 

  2563.                 // min value

  2564.                 if (LV2_HAVE_MINIMUM_PORT_POINT(portPoints.Hints))

  2565.                     min = portPoints.Minimum;

  2566.                 else

  2567.                     min = 0.0f;

  2568. 

  2569.                 // max value

  2570.                 if (LV2_HAVE_MAXIMUM_PORT_POINT(portPoints.Hints))

  2571.                     max = portPoints.Maximum;

  2572.                 else

  2573.                     max = 1.0f;

  2574. 

  2575.                 if (LV2_IS_PORT_SAMPLE_RATE(portProps))

  2576.                 {

  2577.                     min *= sampleRate;

  2578.                     max *= sampleRate;

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

  2580.                 }

  2581. 

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

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

  2584.                 {

  2585.                     min = 0.0f;

  2586.                     max = (float)0xffffff;

  2587.                 }

  2588. 

  2589.                 if (min >= max)

  2590.                 {

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

  2592.                     max = min + 0.1f;

  2593.                 }

  2594. 

  2595.                 // default value

  2596.                 if (LV2_HAVE_DEFAULT_PORT_POINT(portPoints.Hints))

  2597.                 {

  2598.                     def = portPoints.Default;

  2599.                 }

  2600.                 else

  2601.                 {

  2602.                     // no default value

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

  2604.                         def = 0.0f;

  2605.                     else

  2606.                         def = min;

  2607.                 }

  2608. 

  2609.                 if (def < min)

  2610.                     def = min;

  2611.                 else if (def > max)

  2612.                     def = max;

  2613. 

  2614.                 if (LV2_IS_PORT_TOGGLED(portProps))

  2615.                 {

  2616.                     step = max - min;

  2617.                     stepSmall = step;

  2618.                     stepLarge = step;

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

  2620.                 }

  2621.                 else if (LV2_IS_PORT_INTEGER(portProps))

  2622.                 {

  2623.                     step = 1.0f;

  2624.                     stepSmall = 1.0f;

  2625.                     stepLarge = 10.0f;

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

  2627.                 }

  2628.                 else

  2629.                 {

  2630.                     float range = max - min;

  2631.                     step = range/100.0f;

  2632.                     stepSmall = range/1000.0f;

  2633.                     stepLarge = range/10.0f;

  2634.                 }

  2635. 

  2636.                 if (LV2_IS_PORT_INPUT(portTypes))

  2637.                 {

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

  2639. 

  2640.                     if (LV2_IS_PORT_DESIGNATION_LATENCY(portDesignation))

  2641.                     {

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

  2643.                     }

  2644.                     else if (LV2_IS_PORT_DESIGNATION_SAMPLE_RATE(portDesignation))

  2645.                     {

  2646.                         def = sampleRate;

  2647.                         step = 1.0f;

  2648.                         stepSmall = 1.0f;

  2649.                         stepLarge = 1.0f;

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

  2651.                     }

  2652.                     else if (LV2_IS_PORT_DESIGNATION_FREEWHEELING(portDesignation))

  2653.                     {

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

  2655.                     }

  2656.                     else if (LV2_IS_PORT_DESIGNATION_TIME(portDesignation))

  2657.                     {

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

  2659.                     }

  2660.                     else

  2661.                     {

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

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

  2664.                         needsCtrlIn = true;

  2665. 

  2666.                         if (! LV2_IS_PORT_CAUSES_ARTIFACTS(portProps) &&

  2667.                             ! LV2_IS_PORT_ENUMERATION(portProps) &&

  2668.                             ! LV2_IS_PORT_EXPENSIVE(portProps) &&

  2669.                             ! LV2_IS_PORT_NOT_AUTOMATIC(portProps) &&

  2670.                             ! LV2_IS_PORT_NOT_ON_GUI(portProps) &&

  2671.                             ! LV2_IS_PORT_TRIGGER(portProps))

  2672.                         {

  2673.                             pData->param.data[j].hints |= PARAMETER_CAN_BE_CV_CONTROLLED;

  2674.                         }

  2675.                     }

  2676. 

  2677.                     // MIDI CC value

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

  2679. 

  2680.                     if (LV2_IS_PORT_MIDI_MAP_CC(portMidiMap.Type))

  2681.                     {

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

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

  2684.                     }

  2685.                 }

  2686.                 else if (LV2_IS_PORT_OUTPUT(portTypes))

  2687.                 {

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

  2689. 

  2690.                     if (LV2_IS_PORT_DESIGNATION_LATENCY(portDesignation))

  2691.                     {

  2692.                         min = 0.0f;

  2693.                         max = sampleRate;

  2694.                         def = 0.0f;

  2695.                         step = 1.0f;

  2696.                         stepSmall = 1.0f;

  2697.                         stepLarge = 1.0f;

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

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

  2700.                     }

  2701.                     else if (LV2_IS_PORT_DESIGNATION_SAMPLE_RATE(portDesignation))

  2702.                     {

  2703.                         def = sampleRate;

  2704.                         step = 1.0f;

  2705.                         stepSmall = 1.0f;

  2706.                         stepLarge = 1.0f;

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

  2708.                     }

  2709.                     else if (LV2_IS_PORT_DESIGNATION_FREEWHEELING(portDesignation))

  2710.                     {

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

  2712.                     }

  2713.                     else if (LV2_IS_PORT_DESIGNATION_TIME(portDesignation))

  2714.                     {

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

  2716.                     }

  2717.                     else

  2718.                     {

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

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

  2721.                         needsCtrlOut = true;

  2722.                     }

  2723.                 }

  2724.                 else

  2725.                 {

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

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

  2728.                 }

  2729. 

  2730.                 // extra parameter hints

  2731.                 if (LV2_IS_PORT_LOGARITHMIC(portProps))

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

  2733. 

  2734.                 if (LV2_IS_PORT_TRIGGER(portProps))

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

  2736. 

  2737.                 if (LV2_IS_PORT_STRICT_BOUNDS(portProps))

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

  2739. 

  2740.                 if (LV2_IS_PORT_ENUMERATION(portProps))

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

  2742. 

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

  2744.                 if (LV2_IS_PORT_NOT_ON_GUI(portProps))

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

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

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

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

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

  2750. 

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

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

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

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

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

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

  2757. 

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

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

  2760.                     fParamBuffers[j] = min;

  2761.                 else

  2762.                     fParamBuffers[j] = def;

  2763. 

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

  2765. 

  2766.                 if (fHandle2 != nullptr)

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

  2768.             }

  2769.             else

  2770.             {

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

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

  2773. 

  2774.                 if (fHandle2 != nullptr)

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

  2776.             }

  2777.         }

  2778. 

  2779.         for (uint32_t i=0; i < fRdfDescriptor->ParameterCount; ++i)

  2780.         {

  2781.             const LV2_RDF_Parameter& rdfParam(fRdfDescriptor->Parameters[i]);

  2782. 

  2783.             switch (rdfParam.Type)

  2784.             {

  2785.             case LV2_PARAMETER_BOOL:

  2786.             case LV2_PARAMETER_INT:

  2787.             // case LV2_PARAMETER_LONG:

  2788.             case LV2_PARAMETER_FLOAT:

  2789.             case LV2_PARAMETER_DOUBLE:

  2790.                 break;

  2791.             default:

  2792.                 continue;

  2793.             }

  2794. 

  2795.             const LV2_RDF_PortPoints& portPoints(rdfParam.Points);

  2796. 

  2797.             const uint32_t j = iCtrl++;

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

  2799.             pData->param.data[j].rindex = static_cast<int32_t>(fRdfDescriptor->PortCount + i);

  2800. 

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

  2802. 

  2803.             // min value

  2804.             if (LV2_HAVE_MINIMUM_PORT_POINT(portPoints.Hints))

  2805.                 min = portPoints.Minimum;

  2806.             else

  2807.                 min = 0.0f;

  2808. 

  2809.             // max value

  2810.             if (LV2_HAVE_MAXIMUM_PORT_POINT(portPoints.Hints))

  2811.                 max = portPoints.Maximum;

  2812.             else

  2813.                 max = 1.0f;

  2814. 

  2815.             if (min >= max)

  2816.             {

  2817.                 carla_stderr2("WARNING - Broken plugin parameter '%s': min >= max", rdfParam.Label);

  2818.                 max = min + 0.1f;

  2819.             }

  2820. 

  2821.             // default value

  2822.             if (LV2_HAVE_DEFAULT_PORT_POINT(portPoints.Hints))

  2823.             {

  2824.                 def = portPoints.Default;

  2825.             }

  2826.             else

  2827.             {

  2828.                 // no default value

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

  2830.                     def = 0.0f;

  2831.                 else

  2832.                     def = min;

  2833.             }

  2834. 

  2835.             if (def < min)

  2836.                 def = min;

  2837.             else if (def > max)

  2838.                 def = max;

  2839. 

  2840.             switch (rdfParam.Type)

  2841.             {

  2842.             case LV2_PARAMETER_BOOL:

  2843.                 step = max - min;

  2844.                 stepSmall = step;

  2845.                 stepLarge = step;

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

  2847.                 break;

  2848. 

  2849.             case LV2_PARAMETER_INT:

  2850.             case LV2_PARAMETER_LONG:

  2851.                 step = 1.0f;

  2852.                 stepSmall = 1.0f;

  2853.                 stepLarge = 10.0f;

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

  2855.                 break;

  2856. 

  2857.             default:

  2858.                 const float range = max - min;

  2859.                 step = range/100.0f;

  2860.                 stepSmall = range/1000.0f;

  2861.                 stepLarge = range/10.0f;

  2862.                 break;

  2863.             }

  2864. 

  2865.             if (rdfParam.Input)

  2866.             {

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

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

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

  2870.                 needsCtrlIn = true;

  2871.             }

  2872.             else

  2873.             {

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

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

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

  2877.                 needsCtrlOut = true;

  2878.             }

  2879. 

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

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

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

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

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

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

  2886. 

  2887.             fParamBuffers[j] = def;

  2888.         }

  2889. 

  2890.         if (needsCtrlIn)

  2891.         {

  2892.             portName.clear();

  2893. 

  2894.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  2895.             {

  2896.                 portName  = pData->name;

  2897.                 portName += ":";

  2898.             }

  2899. 

  2900.             portName += "events-in";

  2901.             portName.truncate(portNameSize);

  2902. 

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

  2904. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2905.             pData->event.cvSourcePorts = pData->client->createCVSourcePorts();

  2906. #endif

  2907.         }

  2908. 

  2909.         if (needsCtrlOut)

  2910.         {

  2911.             portName.clear();

  2912. 

  2913.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  2914.             {

  2915.                 portName  = pData->name;

  2916.                 portName += ":";

  2917.             }

  2918. 

  2919.             portName += "events-out";

  2920.             portName.truncate(portNameSize);

  2921. 

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

  2923.         }

  2924. 

  2925.         if (fExt.worker != nullptr && fEventsIn.ctrl != nullptr)

  2926.         {

  2927.             fAtomBufferWorkerIn.createBuffer(eventBufferSize);

  2928.             fAtomBufferWorkerResp.createBuffer(eventBufferSize);

  2929.             fAtomBufferWorkerInTmpData = new uint8_t[fAtomBufferWorkerIn.getSize()];

  2930.         }

  2931. 

  2932.         if (fRdfDescriptor->ParameterCount > 0 ||

  2933.             (fUI.type != UI::TYPE_NULL && fEventsIn.count > 0 && (fEventsIn.data[0].type & CARLA_EVENT_DATA_ATOM) != 0))

  2934.             fAtomBufferEvIn.createBuffer(eventBufferSize);

  2935. 

  2936.         if (fUI.type != UI::TYPE_NULL && fEventsOut.count > 0 && (fEventsOut.data[0].type & CARLA_EVENT_DATA_ATOM) != 0)

  2937.         {

  2938.             fAtomBufferUiOut.createBuffer(std::min(eventBufferSize*32, 1638400U));

  2939.             fAtomBufferUiOutTmpData = new uint8_t[fAtomBufferUiOut.getSize()];

  2940.         }

  2941. 

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

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

  2944. 

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

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

  2947. 

  2948.         if (fEventsIn.ctrl != nullptr && fExt.midnam != nullptr)

  2949.         {

  2950.             if (char* const midnam = fExt.midnam->midnam(fHandle))

  2951.             {

  2952.                 fEventsIn.ctrl->port->setMetaData("http://www.midi.org/dtds/MIDINameDocument10.dtd",

  2953.                                                   midnam, "text/xml");

  2954.                 if (fExt.midnam->free != nullptr)

  2955.                     fExt.midnam->free(midnam);

  2956.             }

  2957.         }

  2958. 

  2959.         if (forcedStereoIn || forcedStereoOut)

  2960.             pData->options |= PLUGIN_OPTION_FORCE_STEREO;

  2961.         else

  2962.             pData->options &= ~PLUGIN_OPTION_FORCE_STEREO;

  2963. 

  2964.         // plugin hints

  2965.         pData->hints = (pData->hints & PLUGIN_HAS_INLINE_DISPLAY) ? PLUGIN_HAS_INLINE_DISPLAY : 0

  2966.                      | (pData->hints & PLUGIN_NEEDS_UI_MAIN_THREAD) ? PLUGIN_NEEDS_UI_MAIN_THREAD : 0;

  2967. 

  2968.         if (isRealtimeSafe())

  2969.             pData->hints |= PLUGIN_IS_RTSAFE;

  2970. 

  2971.         if (fUI.type != UI::TYPE_NULL || fFilePathURI.isNotEmpty())

  2972.         {

  2973.             pData->hints |= PLUGIN_HAS_CUSTOM_UI;

  2974. 

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

  2976.                 pData->hints |= PLUGIN_NEEDS_UI_MAIN_THREAD;

  2977.         }

  2978. 

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

  2980.             pData->hints |= PLUGIN_IS_SYNTH;

  2981. 

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

  2983.             pData->hints |= PLUGIN_CAN_DRYWET;

  2984. 

  2985.         if (aOuts > 0)

  2986.             pData->hints |= PLUGIN_CAN_VOLUME;

  2987. 

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

  2989.             pData->hints |= PLUGIN_CAN_BALANCE;

  2990. 

  2991.         // extra plugin hints

  2992.         pData->extraHints = 0x0;

  2993. 

  2994.         // check initial latency

  2995.         findInitialLatencyValue(aIns, cvIns, aOuts, cvOuts);

  2996. 

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

  2998.         reloadPrograms(true);

  2999. 

  3000.         evIns.clear();

  3001.         evOuts.clear();

  3002. 

  3003.         if (pData->active)

  3004.             activate();

  3005. 

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

  3007.     }

  3008. 

  3009.     void findInitialLatencyValue(const uint32_t aIns,

  3010.                                  const uint32_t cvIns,

  3011.                                  const uint32_t aOuts,

  3012.                                  const uint32_t cvOuts) const

  3013.     {

  3014.         if (fLatencyIndex < 0)

  3015.             return;

  3016. 

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

  3018.         const uint32_t bufferSize = static_cast<uint32_t>(fLv2Options.nominalBufferSize);

  3019. 

  3020.         float tmpIn [( aIns+cvIns  > 0) ?  aIns+cvIns  : 1][bufferSize];

  3021.         float tmpOut[(aOuts+cvOuts > 0) ? aOuts+cvOuts : 1][bufferSize];

  3022. 

  3023.         {

  3024.             uint32_t i=0;

  3025.             for (; i < aIns; ++i)

  3026.             {

  3027.                 carla_zeroFloats(tmpIn[i], bufferSize);

  3028. 

  3029.                 try {

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

  3031.                 } CARLA_SAFE_EXCEPTION("LV2 connect_port latency audio input");

  3032.             }

  3033. 

  3034.             for (uint32_t j=0; j < cvIns; ++i, ++j)

  3035.             {

  3036.                 carla_zeroFloats(tmpIn[i], bufferSize);

  3037. 

  3038.                 try {

  3039.                     fDescriptor->connect_port(fHandle, pData->cvIn.ports[j].rindex, tmpIn[i]);

  3040.                 } CARLA_SAFE_EXCEPTION("LV2 connect_port latency cv input");

  3041.             }

  3042.         }

  3043. 

  3044.         {

  3045.             uint32_t i=0;

  3046.             for (; i < aOuts; ++i)

  3047.             {

  3048.                 carla_zeroFloats(tmpOut[i], bufferSize);

  3049. 

  3050.                 try {

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

  3052.                 } CARLA_SAFE_EXCEPTION("LV2 connect_port latency audio output");

  3053.             }

  3054. 

  3055.             for (uint32_t j=0; j < cvOuts; ++i, ++j)

  3056.             {

  3057.                 carla_zeroFloats(tmpOut[i], bufferSize);

  3058. 

  3059.                 try {

  3060.                     fDescriptor->connect_port(fHandle, pData->cvOut.ports[j].rindex, tmpOut[i]);

  3061.                 } CARLA_SAFE_EXCEPTION("LV2 connect_port latency cv output");

  3062.             }

  3063.         }

  3064. 

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

  3066.         {

  3067.             try {

  3068.                 fDescriptor->activate(fHandle);

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

  3070.         }

  3071. 

  3072.         try {

  3073.             fDescriptor->run(fHandle, bufferSize);

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

  3075. 

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

  3077.         {

  3078.             try {

  3079.                 fDescriptor->deactivate(fHandle);

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

  3081.         }

  3082. 

  3083.         // done, let's get the value

  3084.         if (const uint32_t latency = getLatencyInFrames())

  3085.         {

  3086.             pData->client->setLatency(latency);

  3087. #ifndef BUILD_BRIDGE

  3088.             pData->latency.recreateBuffers(std::max(aIns, aOuts), latency);

  3089. #endif

  3090.         }

  3091.     }

  3092. 

  3093.     void reloadPrograms(const bool doInit) override

  3094.     {

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

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

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

  3098. 

  3099.         // special LV2 programs handling

  3100.         if (doInit)

  3101.         {

  3102.             pData->prog.clear();

  3103. 

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

  3105. 

  3106.             if (presetCount > 0)

  3107.             {

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

  3109. 

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

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

  3112.             }

  3113.         }

  3114. 

  3115.         // Delete old programs

  3116.         pData->midiprog.clear();

  3117. 

  3118.         // Query new programs

  3119.         uint32_t newCount = 0;

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

  3121.         {

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

  3123.                 ++newCount;

  3124.         }

  3125. 

  3126.         if (newCount > 0)

  3127.         {

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

  3129. 

  3130.             // Update data

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

  3132.             {

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

  3134.                 CARLA_SAFE_ASSERT_CONTINUE(pdesc != nullptr);

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

  3136. 

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

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

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

  3140.             }

  3141.         }

  3142. 

  3143.         if (doInit)

  3144.         {

  3145.             if (newCount > 0)

  3146.             {

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

  3148.             }

  3149.             else

  3150.             {

  3151.                 // load default state

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

  3153.                 {

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

  3155. 

  3156.                     if (fHandle2 != nullptr)

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

  3158. 

  3159.                     lilv_state_free(state);

  3160.                 }

  3161.             }

  3162.         }

  3163.         else

  3164.         {

  3165.             // Check if current program is invalid

  3166.             bool programChanged = false;

  3167. 

  3168.             if (newCount == oldCount+1)

  3169.             {

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

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

  3172.                 programChanged = true;

  3173.             }

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

  3175.             {

  3176.                 // programs exist now, but not before

  3177.                 pData->midiprog.current = 0;

  3178.                 programChanged = true;

  3179.             }

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

  3181.             {

  3182.                 // programs existed before, but not anymore

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

  3184.                 programChanged = true;

  3185.             }

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

  3187.             {

  3188.                 // current midi program > count

  3189.                 pData->midiprog.current = 0;

  3190.                 programChanged = true;

  3191.             }

  3192.             else

  3193.             {

  3194.                 // no change

  3195.                 pData->midiprog.current = current;

  3196.             }

  3197. 

  3198.             if (programChanged)

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

  3200. 

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

  3202.         }

  3203.     }

  3204. 

  3205.     // -------------------------------------------------------------------

  3206.     // Plugin processing

  3207. 

  3208.     void activate() noexcept override

  3209.     {

  3210.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  3211.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  3212. 

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

  3214.         {

  3215.             try {

  3216.                 fDescriptor->activate(fHandle);

  3217.             } CARLA_SAFE_EXCEPTION("LV2 activate");

  3218. 

  3219.             if (fHandle2 != nullptr)

  3220.             {

  3221.                 try {

  3222.                     fDescriptor->activate(fHandle2);

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

  3224.             }

  3225.         }

  3226. 

  3227.         fFirstActive = true;

  3228.     }

  3229. 

  3230.     void deactivate() noexcept override

  3231.     {

  3232.         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);

  3233.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);

  3234. 

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

  3236.         {

  3237.             try {

  3238.                 fDescriptor->deactivate(fHandle);

  3239.             } CARLA_SAFE_EXCEPTION("LV2 deactivate");

  3240. 

  3241.             if (fHandle2 != nullptr)

  3242.             {

  3243.                 try {

  3244.                     fDescriptor->deactivate(fHandle2);

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

  3246.             }

  3247.         }

  3248.     }

  3249. 

  3250.     void process(const float* const* const audioIn, float** const audioOut,

  3251.                  const float* const* const cvIn, float** const cvOut, const uint32_t frames) override

  3252.     {

  3253.         // --------------------------------------------------------------------------------------------------------

  3254.         // Check if active

  3255. 

  3256.         if (! pData->active)

  3257.         {

  3258.             // disable any output sound

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

  3260.                 carla_zeroFloats(audioOut[i], frames);

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

  3262.                 carla_zeroFloats(cvOut[i], frames);

  3263.             return;

  3264.         }

  3265. 

  3266.         // --------------------------------------------------------------------------------------------------------

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

  3268. 

  3269.         LV2_Atom_Buffer_Iterator evInAtomIters[fEventsIn.count];

  3270.         LV2_Event_Iterator       evInEventIters[fEventsIn.count];

  3271.         LV2_MIDIState            evInMidiStates[fEventsIn.count];

  3272. 

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

  3274.         {

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

  3276.             {

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

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

  3279.             }

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

  3281.             {

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

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

  3284.             }

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

  3286.             {

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

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

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

  3290.                 evInMidiStates[i].frame_count = frames;

  3291.                 evInMidiStates[i].position    = 0;

  3292.             }

  3293.         }

  3294. 

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

  3296.         {

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

  3298.             {

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

  3300.             }

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

  3302.             {

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

  3304.             }

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

  3306.             {

  3307.                 // not needed

  3308.             }

  3309.         }

  3310. 

  3311.         // --------------------------------------------------------------------------------------------------------

  3312.         // Check if needs reset

  3313. 

  3314.         if (pData->needsReset)

  3315.         {

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

  3317.             {

  3318.                 const uint32_t j = fEventsIn.ctrlIndex;

  3319.                 CARLA_ASSERT(j < fEventsIn.count);

  3320. 

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

  3322. 

  3323.                 if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  3324.                 {

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

  3326.                     {

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

  3328.                         midiData[1] = MIDI_CONTROL_ALL_NOTES_OFF;

  3329. 

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

  3331.                             lv2_atom_buffer_write(&evInAtomIters[j], 0, 0, kUridMidiEvent, 3, midiData);

  3332. 

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

  3334.                             lv2_event_write(&evInEventIters[j], 0, 0, kUridMidiEvent, 3, midiData);

  3335. 

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

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

  3338. 

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

  3340.                         midiData[1] = MIDI_CONTROL_ALL_SOUND_OFF;

  3341. 

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

  3343.                             lv2_atom_buffer_write(&evInAtomIters[j], 0, 0, kUridMidiEvent, 3, midiData);

  3344. 

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

  3346.                             lv2_event_write(&evInEventIters[j], 0, 0, kUridMidiEvent, 3, midiData);

  3347. 

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

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

  3350.                     }

  3351.                 }

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

  3353.                 {

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

  3355.                     {

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

  3357.                         midiData[1] = k;

  3358. 

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

  3360.                             lv2_atom_buffer_write(&evInAtomIters[j], 0, 0, kUridMidiEvent, 3, midiData);

  3361. 

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

  3363.                             lv2_event_write(&evInEventIters[j], 0, 0, kUridMidiEvent, 3, midiData);

  3364. 

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

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

  3367.                     }

  3368.                 }

  3369.             }

  3370. 

  3371.             pData->needsReset = false;

  3372.         }

  3373. 

  3374.         // --------------------------------------------------------------------------------------------------------

  3375.         // TimeInfo

  3376. 

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

  3378. 

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

  3380.         {

  3381.             bool doPostRt;

  3382.             int32_t rindex;

  3383. 

  3384.             const double barBeat = static_cast<double>(timeInfo.bbt.beat - 1)

  3385.                                  + (timeInfo.bbt.tick / timeInfo.bbt.ticksPerBeat);

  3386. 

  3387.             // update input ports

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

  3389.             {

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

  3391.                     continue;

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

  3393.                     continue;

  3394. 

  3395.                 doPostRt = false;

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

  3397. 

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

  3399. 

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

  3401.                 {

  3402.                 // Non-BBT

  3403.                 case LV2_PORT_DESIGNATION_TIME_SPEED:

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

  3405.                     {

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

  3407.                         doPostRt = true;

  3408.                     }

  3409.                     break;

  3410. 

  3411.                 case LV2_PORT_DESIGNATION_TIME_FRAME:

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

  3413.                     {

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

  3415.                         doPostRt = true;

  3416.                     }

  3417.                     break;

  3418. 

  3419.                 case LV2_PORT_DESIGNATION_TIME_FRAMES_PER_SECOND:

  3420.                     break;

  3421. 

  3422.                 // BBT

  3423.                 case LV2_PORT_DESIGNATION_TIME_BAR:

  3424.                     if (timeInfo.bbt.valid && fLastTimeInfo.bbt.bar != timeInfo.bbt.bar)

  3425.                     {

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

  3427.                         doPostRt = true;

  3428.                     }

  3429.                     break;

  3430. 

  3431.                 case LV2_PORT_DESIGNATION_TIME_BAR_BEAT:

  3432.                     if (timeInfo.bbt.valid && (carla_isNotEqual(fLastTimeInfo.bbt.tick, timeInfo.bbt.tick) ||

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

  3434.                     {

  3435.                         fParamBuffers[k] = static_cast<float>(barBeat);

  3436.                         doPostRt = true;

  3437.                     }

  3438.                     break;

  3439. 

  3440.                 case LV2_PORT_DESIGNATION_TIME_BEAT:

  3441.                     if (timeInfo.bbt.valid && fLastTimeInfo.bbt.beat != timeInfo.bbt.beat)

  3442.                     {

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

  3444.                         doPostRt = true;

  3445.                     }

  3446.                     break;

  3447. 

  3448.                 case LV2_PORT_DESIGNATION_TIME_BEAT_UNIT:

  3449.                     if (timeInfo.bbt.valid && carla_isNotEqual(fLastTimeInfo.bbt.beatType, timeInfo.bbt.beatType))

  3450.                     {

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

  3452.                         doPostRt = true;

  3453.                     }

  3454.                     break;

  3455.                 case LV2_PORT_DESIGNATION_TIME_BEATS_PER_BAR:

  3456.                     if (timeInfo.bbt.valid && carla_isNotEqual(fLastTimeInfo.bbt.beatsPerBar, timeInfo.bbt.beatsPerBar))

  3457.                     {

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

  3459.                         doPostRt = true;

  3460.                     }

  3461.                     break;

  3462. 

  3463.                 case LV2_PORT_DESIGNATION_TIME_BEATS_PER_MINUTE:

  3464.                     if (timeInfo.bbt.valid && carla_isNotEqual(fLastTimeInfo.bbt.beatsPerMinute, timeInfo.bbt.beatsPerMinute))

  3465.                     {

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

  3467.                         doPostRt = true;

  3468.                     }

  3469.                     break;

  3470. 

  3471.                 case LV2_PORT_DESIGNATION_TIME_TICKS_PER_BEAT:

  3472.                     if (timeInfo.bbt.valid && carla_isNotEqual(fLastTimeInfo.bbt.ticksPerBeat, timeInfo.bbt.ticksPerBeat))

  3473.                     {

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

  3475.                         doPostRt = true;

  3476.                     }

  3477.                     break;

  3478.                 }

  3479. 

  3480.                 if (doPostRt)

  3481.                     pData->postponeRtEvent(kPluginPostRtEventParameterChange,

  3482.                                            true,

  3483.                                            static_cast<int32_t>(k),

  3484.                                            0,

  3485.                                            0,

  3486.                                            fParamBuffers[k]);

  3487.             }

  3488. 

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

  3490.             {

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

  3492.                     continue;

  3493. 

  3494.                 uint8_t timeInfoBuf[256];

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

  3496. 

  3497.                 LV2_Atom_Forge_Frame forgeFrame;

  3498.                 lv2_atom_forge_object(&fAtomForge, &forgeFrame, kUridNull, kUridTimePosition);

  3499. 

  3500.                 lv2_atom_forge_key(&fAtomForge, kUridTimeSpeed);

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

  3502. 

  3503.                 lv2_atom_forge_key(&fAtomForge, kUridTimeFrame);

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

  3505. 

  3506.                 if (timeInfo.bbt.valid)

  3507.                 {

  3508.                     lv2_atom_forge_key(&fAtomForge, kUridTimeBar);

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

  3510. 

  3511.                     lv2_atom_forge_key(&fAtomForge, kUridTimeBarBeat);

  3512.                     lv2_atom_forge_float(&fAtomForge, static_cast<float>(barBeat));

  3513. 

  3514.                     lv2_atom_forge_key(&fAtomForge, kUridTimeBeat);

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

  3516. 

  3517.                     lv2_atom_forge_key(&fAtomForge, kUridTimeBeatUnit);

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

  3519. 

  3520.                     lv2_atom_forge_key(&fAtomForge, kUridTimeBeatsPerBar);

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

  3522. 

  3523.                     lv2_atom_forge_key(&fAtomForge, kUridTimeBeatsPerMinute);

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

  3525. 

  3526.                     lv2_atom_forge_key(&fAtomForge, kUridTimeTicksPerBeat);

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

  3528.                 }

  3529. 

  3530.                 lv2_atom_forge_pop(&fAtomForge, &forgeFrame);

  3531. 

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

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

  3534. 

  3535.                 // send only deprecated blank object for now

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

  3537. 

  3538.                 // for atom:object

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

  3540.             }

  3541. 

  3542.             pData->postRtEvents.trySplice();

  3543. 

  3544.             fLastTimeInfo = timeInfo;

  3545.         }

  3546. 

  3547.         // --------------------------------------------------------------------------------------------------------

  3548.         // Event Input and Processing

  3549. 

  3550.         if (fEventsIn.ctrl != nullptr)

  3551.         {

  3552.             // ----------------------------------------------------------------------------------------------------

  3553.             // Message Input

  3554. 

  3555.             if (fAtomBufferEvIn.tryLock())

  3556.             {

  3557.                 if (fAtomBufferEvIn.isDataAvailableForReading())

  3558.                 {

  3559.                     const LV2_Atom* atom;

  3560.                     uint32_t j, portIndex;

  3561. 

  3562.                     for (; fAtomBufferEvIn.get(atom, portIndex);)

  3563.                     {

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

  3565. 

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

  3567.                         {

  3568.                             carla_stderr2("Event input buffer full, at least 1 message lost");

  3569.                             continue;

  3570.                         }

  3571.                     }

  3572.                 }

  3573. 

  3574.                 fAtomBufferEvIn.unlock();

  3575.             }

  3576. 

  3577.             if (fExt.worker != nullptr && fAtomBufferWorkerIn.tryLock())

  3578.             {

  3579.                 if (fAtomBufferWorkerIn.isDataAvailableForReading())

  3580.                 {

  3581.                     const LV2_Atom* atom;

  3582.                     uint32_t portIndex;

  3583. 

  3584.                     for (; fAtomBufferWorkerIn.get(atom, portIndex);)

  3585.                     {

  3586.                         CARLA_SAFE_ASSERT_CONTINUE(atom->type == kUridCarlaAtomWorkerIn);

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

  3588.                     }

  3589.                 }

  3590. 

  3591.                 fAtomBufferWorkerIn.unlock();

  3592.             }

  3593. 

  3594.             // ----------------------------------------------------------------------------------------------------

  3595.             // MIDI Input (External)

  3596. 

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

  3598.             {

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

  3600.                 {

  3601.                     // does not handle MIDI

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

  3603.                 }

  3604.                 else

  3605.                 {

  3606.                     const uint32_t j = fEventsIn.ctrlIndex;

  3607. 

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

  3609.                     {

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

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

  3612. 

  3613.                         uint8_t midiEvent[3];

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

  3615.                         midiEvent[1] = note.note;

  3616.                         midiEvent[2] = note.velo;

  3617. 

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

  3619.                             lv2_atom_buffer_write(&evInAtomIters[j], 0, 0, kUridMidiEvent, 3, midiEvent);

  3620. 

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

  3622.                             lv2_event_write(&evInEventIters[j], 0, 0, kUridMidiEvent, 3, midiEvent);

  3623. 

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

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

  3626.                     }

  3627. 

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

  3629.                 }

  3630. 

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

  3632. 

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

  3634. 

  3635.             // ----------------------------------------------------------------------------------------------------

  3636.             // Event Input (System)

  3637. 

  3638. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  3639.             bool allNotesOffSent  = false;

  3640. #endif

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

  3642. 

  3643.             uint32_t startTime  = 0;

  3644.             uint32_t timeOffset = 0;

  3645.             uint32_t nextBankId;

  3646. 

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

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

  3649.             else

  3650.                 nextBankId = 0;

  3651. 

  3652. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  3653.             if (cvIn != nullptr && pData->event.cvSourcePorts != nullptr)

  3654.                 pData->event.cvSourcePorts->initPortBuffers(cvIn + pData->cvIn.count, frames, isSampleAccurate, pData->event.portIn);

  3655. #endif

  3656. 

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

  3658. 

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

  3660.             {

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

  3662. 

  3663.                 uint32_t eventTime = event.time;

  3664.                 CARLA_SAFE_ASSERT_UINT2_CONTINUE(eventTime < frames, eventTime, frames);

  3665. 

  3666.                 if (eventTime < timeOffset)

  3667.                 {

  3668.                     carla_stderr2("Timing error, eventTime:%u < timeOffset:%u for '%s'",

  3669.                                   eventTime, timeOffset, pData->name);

  3670.                     eventTime = timeOffset;

  3671.                 }

  3672. 

  3673.                 if (isSampleAccurate && eventTime > timeOffset)

  3674.                 {

  3675.                     if (processSingle(audioIn, audioOut, cvIn, cvOut, eventTime - timeOffset, timeOffset))

  3676.                     {

  3677.                         startTime  = 0;

  3678.                         timeOffset = eventTime;

  3679. 

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

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

  3682.                         else

  3683.                             nextBankId = 0;

  3684. 

  3685.                         for (uint32_t j=0; j < fEventsIn.count; ++j)

  3686.                         {

  3687.                             if (fEventsIn.data[j].type & CARLA_EVENT_DATA_ATOM)

  3688.                             {

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

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

  3691.                             }

  3692.                             else if (fEventsIn.data[j].type & CARLA_EVENT_DATA_EVENT)

  3693.                             {

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

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

  3696.                             }

  3697.                             else if (fEventsIn.data[j].type & CARLA_EVENT_DATA_MIDI_LL)

  3698.                             {

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

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

  3701.                                 evInMidiStates[j].position         = eventTime;

  3702.                             }

  3703.                         }

  3704. 

  3705.                         for (uint32_t j=0; j < fEventsOut.count; ++j)

  3706.                         {

  3707.                             if (fEventsOut.data[j].type & CARLA_EVENT_DATA_ATOM)

  3708.                             {

  3709.                                 lv2_atom_buffer_reset(fEventsOut.data[j].atom, false);

  3710.                             }

  3711.                             else if (fEventsOut.data[j].type & CARLA_EVENT_DATA_EVENT)

  3712.                             {

  3713.                                 lv2_event_buffer_reset(fEventsOut.data[j].event, LV2_EVENT_AUDIO_STAMP, fEventsOut.data[j].event->data);

  3714.                             }

  3715.                             else if (fEventsOut.data[j].type & CARLA_EVENT_DATA_MIDI_LL)

  3716.                             {

  3717.                                 // not needed

  3718.                             }

  3719.                         }

  3720.                     }

  3721.                     else

  3722.                     {

  3723.                         startTime += timeOffset;

  3724.                     }

  3725.                 }

  3726. 

  3727.                 switch (event.type)

  3728.                 {

  3729.                 case kEngineEventTypeNull:

  3730.                     break;

  3731. 

  3732.                 case kEngineEventTypeControl: {

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

  3734. 

  3735.                     switch (ctrlEvent.type)

  3736.                     {

  3737.                     case kEngineControlEventTypeNull:

  3738.                         break;

  3739. 

  3740.                     case kEngineControlEventTypeParameter: {

  3741.                         float value;

  3742. 

  3743. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  3744.                         // non-midi

  3745.                         if (event.channel == kEngineEventNonMidiChannel)

  3746.                         {

  3747.                             const uint32_t k = ctrlEvent.param;

  3748.                             CARLA_SAFE_ASSERT_CONTINUE(k < pData->param.count);

  3749. 

  3750.                             value = pData->param.getFinalUnnormalizedValue(k, ctrlEvent.value);

  3751.                             setParameterValueRT(k, value, true);

  3752.                             continue;

  3753.                         }

  3754. 

  3755.                         // Control backend stuff

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

  3757.                         {

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

  3759.                             {

  3760.                                 value = ctrlEvent.value;

  3761.                                 setDryWetRT(value, true);

  3762.                             }

  3763. 

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

  3765.                             {

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

  3767.                                 setVolumeRT(value, true);

  3768.                             }

  3769. 

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

  3771.                             {

  3772.                                 float left, right;

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

  3774. 

  3775.                                 if (value < 0.0f)

  3776.                                 {

  3777.                                     left  = -1.0f;

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

  3779.                                 }

  3780.                                 else if (value > 0.0f)

  3781.                                 {

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

  3783.                                     right = 1.0f;

  3784.                                 }

  3785.                                 else

  3786.                                 {

  3787.                                     left  = -1.0f;

  3788.                                     right = 1.0f;

  3789.                                 }

  3790. 

  3791.                                 setBalanceLeftRT(left, true);

  3792.                                 setBalanceRightRT(right, true);

  3793.                             }

  3794.                         }

  3795. #endif

  3796.                         // Control plugin parameters

  3797.                         uint32_t k;

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

  3799.                         {

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

  3801.                                 continue;

  3802.                             if (pData->param.data[k].mappedControlIndex != ctrlEvent.param)

  3803.                                 continue;

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

  3805.                                 continue;

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

  3807.                                 continue;

  3808. 

  3809.                             value = pData->param.getFinalUnnormalizedValue(k, ctrlEvent.value);

  3810.                             setParameterValueRT(k, value, true);

  3811.                         }

  3812. 

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

  3814.                         {

  3815.                             uint8_t midiData[3];

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

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

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

  3819. 

  3820.                             const uint32_t mtime(isSampleAccurate ? startTime : eventTime);

  3821. 

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

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

  3824. 

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

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

  3827. 

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

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

  3830.                         }

  3831. 

  3832.                         break;

  3833.                     } // case kEngineControlEventTypeParameter

  3834. 

  3835.                     case kEngineControlEventTypeMidiBank:

  3836.                         if (pData->options & PLUGIN_OPTION_MAP_PROGRAM_CHANGES)

  3837.                         {

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

  3839.                                 nextBankId = ctrlEvent.param;

  3840.                         }

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

  3842.                         {

  3843.                             uint8_t midiData[3];

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

  3845.                             midiData[1] = MIDI_CONTROL_BANK_SELECT;

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

  3847. 

  3848.                             const uint32_t mtime(isSampleAccurate ? startTime : eventTime);

  3849. 

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

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

  3852. 

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

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

  3855. 

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

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

  3858.                         }

  3859.                         break;

  3860. 

  3861.                     case kEngineControlEventTypeMidiProgram:

  3862.                         if (pData->options & PLUGIN_OPTION_MAP_PROGRAM_CHANGES)

  3863.                         {

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

  3865.                             {

  3866.                                 const uint32_t nextProgramId(ctrlEvent.param);

  3867. 

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

  3869.                                 {

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

  3871.                                     {

  3872.                                         setMidiProgramRT(k, true);

  3873.                                         break;

  3874.                                     }

  3875.                                 }

  3876.                             }

  3877.                         }

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

  3879.                         {

  3880.                             uint8_t midiData[2];

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

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

  3883. 

  3884.                             const uint32_t mtime(isSampleAccurate ? startTime : eventTime);

  3885. 

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

  3887.                                 lv2_atom_buffer_write(&evInAtomIters[fEventsIn.ctrlIndex], mtime, 0, kUridMidiEvent, 2, midiData);

  3888. 

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

  3890.                                 lv2_event_write(&evInEventIters[fEventsIn.ctrlIndex], mtime, 0, kUridMidiEvent, 2, midiData);

  3891. 

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

  3893.                                 lv2midi_put_event(&evInMidiStates[fEventsIn.ctrlIndex], mtime, 2, midiData);

  3894.                         }

  3895.                         break;

  3896. 

  3897.                     case kEngineControlEventTypeAllSoundOff:

  3898.                         if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  3899.                         {

  3900.                             const uint32_t mtime(isSampleAccurate ? startTime : eventTime);

  3901. 

  3902.                             uint8_t midiData[3];

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

  3904.                             midiData[1] = MIDI_CONTROL_ALL_SOUND_OFF;

  3905.                             midiData[2] = 0;

  3906. 

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

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

  3909. 

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

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

  3912. 

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

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

  3915.                         }

  3916.                         break;

  3917. 

  3918.                     case kEngineControlEventTypeAllNotesOff:

  3919.                         if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  3920.                         {

  3921. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  3922.                             if (event.channel == pData->ctrlChannel && ! allNotesOffSent)

  3923.                             {

  3924.                                 allNotesOffSent = true;

  3925.                                 postponeRtAllNotesOff();

  3926.                             }

  3927. #endif

  3928. 

  3929.                             const uint32_t mtime(isSampleAccurate ? startTime : eventTime);

  3930. 

  3931.                             uint8_t midiData[3];

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

  3933.                             midiData[1] = MIDI_CONTROL_ALL_NOTES_OFF;

  3934.                             midiData[2] = 0;

  3935. 

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

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

  3938. 

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

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

  3941. 

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

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

  3944.                         }

  3945.                         break;

  3946.                     } // switch (ctrlEvent.type)

  3947.                     break;

  3948.                 } // case kEngineEventTypeControl

  3949. 

  3950.                 case kEngineEventTypeMidi: {

  3951.                     const EngineMidiEvent& midiEvent(event.midi);

  3952. 

  3953.                     const uint8_t* const midiData(midiEvent.size > EngineMidiEvent::kDataSize ? midiEvent.dataExt : midiEvent.data);

  3954. 

  3955.                     uint8_t status = uint8_t(MIDI_GET_STATUS_FROM_DATA(midiData));

  3956. 

  3957.                     if (status == MIDI_STATUS_CHANNEL_PRESSURE && (pData->options & PLUGIN_OPTION_SEND_CHANNEL_PRESSURE) == 0)

  3958.                         continue;

  3959.                     if (status == MIDI_STATUS_CONTROL_CHANGE && (pData->options & PLUGIN_OPTION_SEND_CONTROL_CHANGES) == 0)

  3960.                         continue;

  3961.                     if (status == MIDI_STATUS_POLYPHONIC_AFTERTOUCH && (pData->options & PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH) == 0)

  3962.                         continue;

  3963.                     if (status == MIDI_STATUS_PITCH_WHEEL_CONTROL && (pData->options & PLUGIN_OPTION_SEND_PITCHBEND) == 0)

  3964.                         continue;

  3965. 

  3966.                     // Fix bad note-off (per LV2 spec)

  3967.                     if (status == MIDI_STATUS_NOTE_ON && midiData[2] == 0)

  3968.                         status = MIDI_STATUS_NOTE_OFF;

  3969. 

  3970.                     const uint32_t j     = fEventsIn.ctrlIndex;

  3971.                     const uint32_t mtime = isSampleAccurate ? startTime : eventTime;

  3972. 

  3973.                     // put back channel in data

  3974.                     uint8_t midiData2[midiEvent.size];

  3975.                     midiData2[0] = uint8_t(status | (event.channel & MIDI_CHANNEL_BIT));

  3976.                     std::memcpy(midiData2+1, midiData+1, static_cast<std::size_t>(midiEvent.size-1));

  3977. 

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

  3979.                         lv2_atom_buffer_write(&evInAtomIters[j], mtime, 0, kUridMidiEvent, midiEvent.size, midiData2);

  3980. 

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

  3982.                         lv2_event_write(&evInEventIters[j], mtime, 0, kUridMidiEvent, midiEvent.size, midiData2);

  3983. 

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

  3985.                         lv2midi_put_event(&evInMidiStates[j], mtime, midiEvent.size, midiData2);

  3986. 

  3987.                     if (status == MIDI_STATUS_NOTE_ON)

  3988.                     {

  3989.                         pData->postponeRtEvent(kPluginPostRtEventNoteOn,

  3990.                                                true,

  3991.                                                event.channel,

  3992.                                                midiData[1],

  3993.                                                midiData[2],

  3994.                                                0.0f);

  3995.                     }

  3996.                     else if (status == MIDI_STATUS_NOTE_OFF)

  3997.                     {

  3998.                         pData->postponeRtEvent(kPluginPostRtEventNoteOff,

  3999.                                                true,

  4000.                                                event.channel,

  4001.                                                midiData[1],

  4002.                                                0, 0.0f);

  4003.                     }

  4004.                 } break;

  4005.                 } // switch (event.type)

  4006.             }

  4007. 

  4008.             pData->postRtEvents.trySplice();

  4009. 

  4010.             if (frames > timeOffset)

  4011.                 processSingle(audioIn, audioOut, cvIn, cvOut, frames - timeOffset, timeOffset);

  4012. 

  4013.         } // End of Event Input and Processing

  4014. 

  4015.         // --------------------------------------------------------------------------------------------------------

  4016.         // Plugin processing (no events)

  4017. 

  4018.         else

  4019.         {

  4020.             processSingle(audioIn, audioOut, cvIn, cvOut, frames, 0);

  4021. 

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

  4023. 

  4024.         // --------------------------------------------------------------------------------------------------------

  4025.         // Events/MIDI Output

  4026. 

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

  4028.         {

  4029.             uint32_t lastFrame = 0;

  4030.             Lv2EventData& evData(fEventsOut.data[i]);

  4031. 

  4032.             if (evData.type & CARLA_EVENT_DATA_ATOM)

  4033.             {

  4034.                 const LV2_Atom_Event* ev;

  4035.                 LV2_Atom_Buffer_Iterator iter;

  4036. 

  4037.                 uint8_t* data;

  4038.                 lv2_atom_buffer_begin(&iter, evData.atom);

  4039. 

  4040.                 for (;;)

  4041.                 {

  4042.                     data = nullptr;

  4043.                     ev = lv2_atom_buffer_get(&iter, &data);

  4044. 

  4045.                     if (ev == nullptr || ev->body.size == 0 || data == nullptr)

  4046.                         break;

  4047. 

  4048.                     if (ev->body.type == kUridMidiEvent)

  4049.                     {

  4050.                         if (evData.port != nullptr)

  4051.                         {

  4052.                             CARLA_SAFE_ASSERT_CONTINUE(ev->time.frames >= 0);

  4053.                             CARLA_SAFE_ASSERT_CONTINUE(ev->body.size < 0xFF);

  4054. 

  4055.                             uint32_t currentFrame = static_cast<uint32_t>(ev->time.frames);

  4056.                             if (currentFrame < lastFrame)

  4057.                                 currentFrame = lastFrame;

  4058.                             else if (currentFrame >= frames)

  4059.                                 currentFrame = frames - 1;

  4060. 

  4061.                             evData.port->writeMidiEvent(currentFrame, static_cast<uint8_t>(ev->body.size), data);

  4062.                         }

  4063.                     }

  4064.                     else if (fAtomBufferUiOutTmpData != nullptr)

  4065.                     {

  4066.                         fAtomBufferUiOut.put(&ev->body, evData.rindex);

  4067.                     }

  4068. 

  4069.                     lv2_atom_buffer_increment(&iter);

  4070.                 }

  4071.             }

  4072.             else if ((evData.type & CARLA_EVENT_DATA_EVENT) != 0 && evData.port != nullptr)

  4073.             {

  4074.                 const LV2_Event* ev;

  4075.                 LV2_Event_Iterator iter;

  4076. 

  4077.                 uint8_t* data;

  4078.                 lv2_event_begin(&iter, evData.event);

  4079. 

  4080.                 for (;;)

  4081.                 {

  4082.                     data = nullptr;

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

  4084. 

  4085.                     if (ev == nullptr || data == nullptr)

  4086.                         break;

  4087. 

  4088.                     uint32_t currentFrame = ev->frames;

  4089.                     if (currentFrame < lastFrame)

  4090.                         currentFrame = lastFrame;

  4091.                     else if (currentFrame >= frames)

  4092.                         currentFrame = frames - 1;

  4093. 

  4094.                     if (ev->type == kUridMidiEvent)

  4095.                     {

  4096.                         CARLA_SAFE_ASSERT_CONTINUE(ev->size < 0xFF);

  4097.                         evData.port->writeMidiEvent(currentFrame, static_cast<uint8_t>(ev->size), data);

  4098.                     }

  4099. 

  4100.                     lv2_event_increment(&iter);

  4101.                 }

  4102.             }

  4103.             else if ((evData.type & CARLA_EVENT_DATA_MIDI_LL) != 0 && evData.port != nullptr)

  4104.             {

  4105.                 LV2_MIDIState state = { &evData.midi, frames, 0 };

  4106. 

  4107.                 uint32_t eventSize;

  4108.                 double   eventTime;

  4109.                 uchar* eventData;

  4110. 

  4111.                 for (;;)

  4112.                 {

  4113.                     eventSize = 0;

  4114.                     eventTime = 0.0;

  4115.                     eventData = nullptr;

  4116.                     lv2midi_get_event(&state, &eventTime, &eventSize, &eventData);

  4117. 

  4118.                     if (eventData == nullptr || eventSize == 0)

  4119.                         break;

  4120. 

  4121.                     CARLA_SAFE_ASSERT_CONTINUE(eventSize < 0xFF);

  4122.                     CARLA_SAFE_ASSERT_CONTINUE(eventTime >= 0.0);

  4123. 

  4124.                     evData.port->writeMidiEvent(static_cast<uint32_t>(eventTime), static_cast<uint8_t>(eventSize), eventData);

  4125.                     lv2midi_step(&state);

  4126.                 }

  4127.             }

  4128.         }

  4129. 

  4130. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  4131.         // --------------------------------------------------------------------------------------------------------

  4132.         // Control Output

  4133. 

  4134.         if (pData->event.portOut != nullptr)

  4135.         {

  4136.             uint8_t  channel;

  4137.             uint16_t param;

  4138.             float    value;

  4139. 

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

  4141.             {

  4142.                 if (pData->param.data[k].type != PARAMETER_OUTPUT)

  4143.                     continue;

  4144. 

  4145.                 if (fStrictBounds >= 0 && (pData->param.data[k].hints & PARAMETER_IS_STRICT_BOUNDS) != 0)

  4146.                     // plugin is responsible to ensure correct bounds

  4147.                     pData->param.ranges[k].fixValue(fParamBuffers[k]);

  4148. 

  4149.                 if (pData->param.data[k].mappedControlIndex > 0)

  4150.                 {

  4151.                     channel = pData->param.data[k].midiChannel;

  4152.                     param   = static_cast<uint16_t>(pData->param.data[k].mappedControlIndex);

  4153.                     value   = pData->param.ranges[k].getNormalizedValue(fParamBuffers[k]);

  4154.                     pData->event.portOut->writeControlEvent(0, channel, kEngineControlEventTypeParameter, param, value);

  4155.                 }

  4156.             }

  4157.         } // End of Control Output

  4158. #endif

  4159. 

  4160.         // --------------------------------------------------------------------------------------------------------

  4161.         // Final work

  4162. 

  4163.         if (fEventsIn.ctrl != nullptr && fExt.worker != nullptr && fAtomBufferWorkerResp.tryLock())

  4164.         {

  4165.             if (fAtomBufferWorkerResp.isDataAvailableForReading())

  4166.             {

  4167.                 const LV2_Atom* atom;

  4168.                 uint32_t portIndex;

  4169. 

  4170.                 for (; fAtomBufferWorkerResp.get(atom, portIndex);)

  4171.                 {

  4172.                     CARLA_SAFE_ASSERT_CONTINUE(atom->type == kUridCarlaAtomWorkerResp);

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

  4174.                 }

  4175.             }

  4176. 

  4177.             fAtomBufferWorkerResp.unlock();

  4178.         }

  4179. 

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

  4181.         {

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

  4183. 

  4184.             if (fHandle2 != nullptr)

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

  4186.         }

  4187. 

  4188.         fFirstActive = false;

  4189. 

  4190.         // --------------------------------------------------------------------------------------------------------

  4191.     }

  4192. 

  4193.     bool processSingle(const float* const* const audioIn, float** const audioOut,

  4194.                        const float* const* const cvIn, float** const cvOut,

  4195.                        const uint32_t frames, const uint32_t timeOffset)

  4196.     {

  4197.         CARLA_SAFE_ASSERT_RETURN(frames > 0, false);

  4198. 

  4199.         if (pData->audioIn.count > 0)

  4200.         {

  4201.             CARLA_SAFE_ASSERT_RETURN(audioIn != nullptr, false);

  4202.             CARLA_SAFE_ASSERT_RETURN(fAudioInBuffers != nullptr, false);

  4203.         }

  4204.         if (pData->audioOut.count > 0)

  4205.         {

  4206.             CARLA_SAFE_ASSERT_RETURN(audioOut != nullptr, false);

  4207.             CARLA_SAFE_ASSERT_RETURN(fAudioOutBuffers != nullptr, false);

  4208.         }

  4209.         if (pData->cvIn.count > 0)

  4210.         {

  4211.             CARLA_SAFE_ASSERT_RETURN(cvIn != nullptr, false);

  4212.         }

  4213.         if (pData->cvOut.count > 0)

  4214.         {

  4215.             CARLA_SAFE_ASSERT_RETURN(cvOut != nullptr, false);

  4216.         }

  4217. 

  4218.         // --------------------------------------------------------------------------------------------------------

  4219.         // Try lock, silence otherwise

  4220. 

  4221. #ifndef STOAT_TEST_BUILD

  4222.         if (pData->engine->isOffline())

  4223.         {

  4224.             pData->singleMutex.lock();

  4225.         }

  4226.         else

  4227. #endif

  4228.         if (! pData->singleMutex.tryLock())

  4229.         {

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

  4231.             {

  4232.                 for (uint32_t k=0; k < frames; ++k)

  4233.                     audioOut[i][k+timeOffset] = 0.0f;

  4234.             }

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

  4236.             {

  4237.                 for (uint32_t k=0; k < frames; ++k)

  4238.                     cvOut[i][k+timeOffset] = 0.0f;

  4239.             }

  4240. 

  4241.             return false;

  4242.         }

  4243. 

  4244.         // --------------------------------------------------------------------------------------------------------

  4245.         // Set audio buffers

  4246. 

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

  4248.             carla_copyFloats(fAudioInBuffers[i], audioIn[i]+timeOffset, frames);

  4249. 

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

  4251.             carla_zeroFloats(fAudioOutBuffers[i], frames);

  4252. 

  4253.         // --------------------------------------------------------------------------------------------------------

  4254.         // Set CV buffers

  4255. 

  4256.         for (uint32_t i=0; i < pData->cvIn.count; ++i)

  4257.             carla_copyFloats(fCvInBuffers[i], cvIn[i]+timeOffset, frames);

  4258. 

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

  4260.             carla_zeroFloats(fCvOutBuffers[i], frames);

  4261. 

  4262.         // --------------------------------------------------------------------------------------------------------

  4263.         // Run plugin

  4264. 

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

  4266. 

  4267.         if (fHandle2 != nullptr)

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

  4269. 

  4270.         // --------------------------------------------------------------------------------------------------------

  4271.         // Handle trigger parameters

  4272. 

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

  4274.         {

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

  4276.                 continue;

  4277. 

  4278.             if (pData->param.data[k].hints & PARAMETER_IS_TRIGGER)

  4279.             {

  4280.                 if (carla_isNotEqual(fParamBuffers[k], pData->param.ranges[k].def))

  4281.                 {

  4282.                     fParamBuffers[k] = pData->param.ranges[k].def;

  4283.                     pData->postponeRtEvent(kPluginPostRtEventParameterChange,

  4284.                                            true,

  4285.                                            static_cast<int32_t>(k),

  4286.                                            1, 0,

  4287.                                            fParamBuffers[k]);

  4288.                 }

  4289.             }

  4290.         }

  4291. 

  4292.         pData->postRtEvents.trySplice();

  4293. 

  4294. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  4295.         // --------------------------------------------------------------------------------------------------------

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

  4297. 

  4298.         {

  4299.             const bool doDryWet  = (pData->hints & PLUGIN_CAN_DRYWET) != 0 && carla_isNotEqual(pData->postProc.dryWet, 1.0f);

  4300.             const bool doBalance = (pData->hints & PLUGIN_CAN_BALANCE) != 0 && ! (carla_isEqual(pData->postProc.balanceLeft, -1.0f) && carla_isEqual(pData->postProc.balanceRight, 1.0f));

  4301.             const bool isMono    = (pData->audioIn.count == 1);

  4302. 

  4303.             bool isPair;

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

  4305. 

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

  4307.             {

  4308.                 // Dry/Wet

  4309.                 if (doDryWet)

  4310.                 {

  4311.                     const uint32_t c = isMono ? 0 : i;

  4312. 

  4313.                     for (uint32_t k=0; k < frames; ++k)

  4314.                     {

  4315. # ifndef BUILD_BRIDGE

  4316.                         if (k < pData->latency.frames && pData->latency.buffers != nullptr)

  4317.                             bufValue = pData->latency.buffers[c][k];

  4318.                         else if (pData->latency.frames < frames)

  4319.                             bufValue = fAudioInBuffers[c][k-pData->latency.frames];

  4320.                         else

  4321. # endif

  4322.                             bufValue = fAudioInBuffers[c][k];

  4323. 

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

  4325.                     }

  4326.                 }

  4327. 

  4328.                 // Balance

  4329.                 if (doBalance)

  4330.                 {

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

  4332. 

  4333.                     if (isPair)

  4334.                     {

  4335.                         CARLA_ASSERT(i+1 < pData->audioOut.count);

  4336.                         carla_copyFloats(oldBufLeft, fAudioOutBuffers[i], frames);

  4337.                     }

  4338. 

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

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

  4341. 

  4342.                     for (uint32_t k=0; k < frames; ++k)

  4343.                     {

  4344.                         if (isPair)

  4345.                         {

  4346.                             // left

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

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

  4349.                         }

  4350.                         else

  4351.                         {

  4352.                             // right

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

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

  4355.                         }

  4356.                     }

  4357.                 }

  4358. 

  4359.                 // Volume (and buffer copy)

  4360.                 {

  4361.                     for (uint32_t k=0; k < frames; ++k)

  4362.                         audioOut[i][k+timeOffset] = fAudioOutBuffers[i][k] * pData->postProc.volume;

  4363.                 }

  4364.             }

  4365.         } // End of Post-processing

  4366. 

  4367. # ifndef BUILD_BRIDGE

  4368.         // --------------------------------------------------------------------------------------------------------

  4369.         // Save latency values for next callback

  4370. 

  4371.         if (pData->latency.frames != 0 && pData->latency.buffers != nullptr)

  4372.         {

  4373.             CARLA_SAFE_ASSERT(timeOffset == 0);

  4374.             const uint32_t latframes = pData->latency.frames;

  4375. 

  4376.             if (latframes <= frames)

  4377.             {

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

  4379.                     carla_copyFloats(pData->latency.buffers[i], audioIn[i]+(frames-latframes), latframes);

  4380.             }

  4381.             else

  4382.             {

  4383.                 const uint32_t diff = latframes - frames;

  4384. 

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

  4386.                 {

  4387.                     // push back buffer by 'frames'

  4388.                     for (k=0; k < diff; ++k)

  4389.                         pData->latency.buffers[i][k] = pData->latency.buffers[i][k+frames];

  4390. 

  4391.                     // put current input at the end

  4392.                     for (uint32_t j=0; k < latframes; ++j, ++k)

  4393.                         pData->latency.buffers[i][k] = audioIn[i][j];

  4394.                 }

  4395.             }

  4396.         }

  4397. # endif

  4398. #else // BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  4400.         {

  4401.             for (uint32_t k=0; k < frames; ++k)

  4402.                 audioOut[i][k+timeOffset] = fAudioOutBuffers[i][k];

  4403.         }

  4404. #endif

  4405. 

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

  4407.         {

  4408.             for (uint32_t k=0; k < frames; ++k)

  4409.                 cvOut[i][k+timeOffset] = fCvOutBuffers[i][k];

  4410.         }

  4411. 

  4412.         // --------------------------------------------------------------------------------------------------------

  4413. 

  4414.         pData->singleMutex.unlock();

  4415.         return true;

  4416.     }

  4417. 

  4418.     void bufferSizeChanged(const uint32_t newBufferSize) override

  4419.     {

  4420.         CARLA_ASSERT_INT(newBufferSize > 0, newBufferSize);

  4421.         carla_debug("CarlaPluginLV2::bufferSizeChanged(%i) - start", newBufferSize);

  4422. 

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

  4424.         {

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

  4426.                 delete[] fAudioInBuffers[i];

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

  4428.         }

  4429. 

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

  4431.         {

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

  4433.                 delete[] fAudioOutBuffers[i];

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

  4435.         }

  4436. 

  4437.         if (fHandle2 == nullptr)

  4438.         {

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

  4440.             {

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

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

  4443.             }

  4444. 

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

  4446.             {

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

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

  4449.             }

  4450.         }

  4451.         else

  4452.         {

  4453.             if (pData->audioIn.count > 0)

  4454.             {

  4455.                 CARLA_ASSERT(pData->audioIn.count == 2);

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

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

  4458. 

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

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

  4461.             }

  4462. 

  4463.             if (pData->audioOut.count > 0)

  4464.             {

  4465.                 CARLA_ASSERT(pData->audioOut.count == 2);

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

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

  4468. 

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

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

  4471.             }

  4472.         }

  4473. 

  4474.         for (uint32_t i=0; i < pData->cvIn.count; ++i)

  4475.         {

  4476.             if (fCvInBuffers[i] != nullptr)

  4477.                 delete[] fCvInBuffers[i];

  4478.             fCvInBuffers[i] = new float[newBufferSize];

  4479. 

  4480.             fDescriptor->connect_port(fHandle, pData->cvIn.ports[i].rindex, fCvInBuffers[i]);

  4481. 

  4482.             if (fHandle2 != nullptr)

  4483.                 fDescriptor->connect_port(fHandle2, pData->cvIn.ports[i].rindex, fCvInBuffers[i]);

  4484.         }

  4485. 

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

  4487.         {

  4488.             if (fCvOutBuffers[i] != nullptr)

  4489.                 delete[] fCvOutBuffers[i];

  4490.             fCvOutBuffers[i] = new float[newBufferSize];

  4491. 

  4492.             fDescriptor->connect_port(fHandle, pData->cvOut.ports[i].rindex, fCvOutBuffers[i]);

  4493. 

  4494.             if (fHandle2 != nullptr)

  4495.                 fDescriptor->connect_port(fHandle2, pData->cvOut.ports[i].rindex, fCvOutBuffers[i]);

  4496.         }

  4497. 

  4498.         const int newBufferSizeInt(static_cast<int>(newBufferSize));

  4499. 

  4500.         if (fLv2Options.maxBufferSize != newBufferSizeInt || (fLv2Options.minBufferSize != 1 && fLv2Options.minBufferSize != newBufferSizeInt))

  4501.         {

  4502.             fLv2Options.maxBufferSize = fLv2Options.nominalBufferSize = newBufferSizeInt;

  4503. 

  4504.             if (fLv2Options.minBufferSize != 1)

  4505.                 fLv2Options.minBufferSize = newBufferSizeInt;

  4506. 

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

  4508.             {

  4509.                 fExt.options->set(fHandle, &fLv2Options.opts[CarlaPluginLV2Options::MaxBlockLenth]);

  4510.                 fExt.options->set(fHandle, &fLv2Options.opts[CarlaPluginLV2Options::NominalBlockLenth]);

  4511. 

  4512.                 if (fLv2Options.minBufferSize != 1)

  4513.                     fExt.options->set(fHandle, &fLv2Options.opts[CarlaPluginLV2Options::MinBlockLenth]);

  4514.             }

  4515.         }

  4516. 

  4517.         carla_debug("CarlaPluginLV2::bufferSizeChanged(%i) - end", newBufferSize);

  4518.     }

  4519. 

  4520.     void sampleRateChanged(const double newSampleRate) override

  4521.     {

  4522.         CARLA_ASSERT_INT(newSampleRate > 0.0, newSampleRate);

  4523.         carla_debug("CarlaPluginLV2::sampleRateChanged(%g) - start", newSampleRate);

  4524. 

  4525.         const float sampleRatef = static_cast<float>(newSampleRate);

  4526. 

  4527.         if (carla_isNotEqual(fLv2Options.sampleRate, sampleRatef))

  4528.         {

  4529.             fLv2Options.sampleRate = sampleRatef;

  4530. 

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

  4532.             {

  4533.                 LV2_Options_Option options[2];

  4534.                 carla_zeroStructs(options, 2);

  4535. 

  4536.                 LV2_Options_Option& optSampleRate(options[0]);

  4537.                 optSampleRate.context = LV2_OPTIONS_INSTANCE;

  4538.                 optSampleRate.subject = 0;

  4539.                 optSampleRate.key     = kUridParamSampleRate;

  4540.                 optSampleRate.size    = sizeof(float);

  4541.                 optSampleRate.type    = kUridAtomFloat;

  4542.                 optSampleRate.value   = &fLv2Options.sampleRate;

  4543. 

  4544.                 fExt.options->set(fHandle, options);

  4545.             }

  4546.         }

  4547. 

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

  4549.         {

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

  4551.                 continue;

  4552.             if (pData->param.special[k] != PARAMETER_SPECIAL_SAMPLE_RATE)

  4553.                 continue;

  4554. 

  4555.             fParamBuffers[k] = sampleRatef;

  4556.             pData->postponeRtEvent(kPluginPostRtEventParameterChange,

  4557.                                    true,

  4558.                                    static_cast<int32_t>(k),

  4559.                                    0,

  4560.                                    0,

  4561.                                    fParamBuffers[k]);

  4562.             break;

  4563.         }

  4564. 

  4565.         carla_debug("CarlaPluginLV2::sampleRateChanged(%g) - end", newSampleRate);

  4566.     }

  4567. 

  4568.     void offlineModeChanged(const bool isOffline) override

  4569.     {

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

  4571.         {

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

  4573.             {

  4574.                 fParamBuffers[k] = isOffline ? pData->param.ranges[k].max : pData->param.ranges[k].min;

  4575.                 pData->postponeRtEvent(kPluginPostRtEventParameterChange,

  4576.                                        true,

  4577.                                        static_cast<int32_t>(k),

  4578.                                        0,

  4579.                                        0,

  4580.                                        fParamBuffers[k]);

  4581.                 break;

  4582.             }

  4583.         }

  4584.     }

  4585. 

  4586.     // -------------------------------------------------------------------

  4587.     // Plugin buffers

  4588. 

  4589.     void initBuffers() const noexcept override

  4590.     {

  4591.         fEventsIn.initBuffers();

  4592.         fEventsOut.initBuffers();

  4593. 

  4594.         CarlaPlugin::initBuffers();

  4595.     }

  4596. 

  4597.     void clearBuffers() noexcept override

  4598.     {

  4599.         carla_debug("CarlaPluginLV2::clearBuffers() - start");

  4600. 

  4601.         if (fAudioInBuffers != nullptr)

  4602.         {

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

  4604.             {

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

  4606.                 {

  4607.                     delete[] fAudioInBuffers[i];

  4608.                     fAudioInBuffers[i] = nullptr;

  4609.                 }

  4610.             }

  4611. 

  4612.             delete[] fAudioInBuffers;

  4613.             fAudioInBuffers = nullptr;

  4614.         }

  4615. 

  4616.         if (fAudioOutBuffers != nullptr)

  4617.         {

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

  4619.             {

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

  4621.                 {

  4622.                     delete[] fAudioOutBuffers[i];

  4623.                     fAudioOutBuffers[i] = nullptr;

  4624.                 }

  4625.             }

  4626. 

  4627.             delete[] fAudioOutBuffers;

  4628.             fAudioOutBuffers = nullptr;

  4629.         }

  4630. 

  4631.         if (fCvInBuffers != nullptr)

  4632.         {

  4633.             for (uint32_t i=0; i < pData->cvIn.count; ++i)

  4634.             {

  4635.                 if (fCvInBuffers[i] != nullptr)

  4636.                 {

  4637.                     delete[] fCvInBuffers[i];

  4638.                     fCvInBuffers[i] = nullptr;

  4639.                 }

  4640.             }

  4641. 

  4642.             delete[] fCvInBuffers;

  4643.             fCvInBuffers = nullptr;

  4644.         }

  4645. 

  4646.         if (fCvOutBuffers != nullptr)

  4647.         {

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

  4649.             {

  4650.                 if (fCvOutBuffers[i] != nullptr)

  4651.                 {

  4652.                     delete[] fCvOutBuffers[i];

  4653.                     fCvOutBuffers[i] = nullptr;

  4654.                 }

  4655.             }

  4656. 

  4657.             delete[] fCvOutBuffers;

  4658.             fCvOutBuffers = nullptr;

  4659.         }

  4660. 

  4661.         if (fParamBuffers != nullptr)

  4662.         {

  4663.             delete[] fParamBuffers;

  4664.             fParamBuffers = nullptr;

  4665.         }

  4666. 

  4667.         fEventsIn.clear();

  4668.         fEventsOut.clear();

  4669. 

  4670.         CarlaPlugin::clearBuffers();

  4671. 

  4672.         carla_debug("CarlaPluginLV2::clearBuffers() - end");

  4673.     }

  4674. 

  4675.     // -------------------------------------------------------------------

  4676.     // Post-poned UI Stuff

  4677. 

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

  4679.     {

  4680.         CARLA_SAFE_ASSERT_RETURN(fUI.type != UI::TYPE_NULL || fFilePathURI.isNotEmpty(),);

  4681.         CARLA_SAFE_ASSERT_RETURN(index < pData->param.count,);

  4682. 

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

  4684.         {

  4685.             if (fPipeServer.isPipeRunning())

  4686.                 fPipeServer.writeControlMessage(static_cast<uint32_t>(pData->param.data[index].rindex), value);

  4687.         }

  4688.         else

  4689.         {

  4690.             if (fUI.handle != nullptr && fUI.descriptor != nullptr && fUI.descriptor->port_event != nullptr && ! fNeedsUiClose)

  4691.             {

  4692.                 CARLA_SAFE_ASSERT_RETURN(pData->param.data[index].rindex >= 0,);

  4693.                 fUI.descriptor->port_event(fUI.handle, static_cast<uint32_t>(pData->param.data[index].rindex), sizeof(float), kUridNull, &value);

  4694.             }

  4695.         }

  4696.     }

  4697. 

  4698.     void uiMidiProgramChange(const uint32_t index) noexcept override

  4699.     {

  4700.         CARLA_SAFE_ASSERT_RETURN(fUI.type != UI::TYPE_NULL || fFilePathURI.isNotEmpty(),);

  4701.         CARLA_SAFE_ASSERT_RETURN(index < pData->midiprog.count,);

  4702. 

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

  4704.         {

  4705.             if (fPipeServer.isPipeRunning())

  4706.                 fPipeServer.writeMidiProgramMessage(pData->midiprog.data[index].bank, pData->midiprog.data[index].program);

  4707.         }

  4708.         else

  4709.         {

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

  4711.                 fExt.uiprograms->select_program(fUI.handle, pData->midiprog.data[index].bank, pData->midiprog.data[index].program);

  4712.         }

  4713.     }

  4714. 

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

  4716.     {

  4717.         CARLA_SAFE_ASSERT_RETURN(fUI.type != UI::TYPE_NULL || fFilePathURI.isNotEmpty(),);

  4718.         CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  4719.         CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

  4720.         CARLA_SAFE_ASSERT_RETURN(velo > 0 && velo < MAX_MIDI_VALUE,);

  4721. 

  4722. #if 0

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

  4724.         {

  4725.             if (fPipeServer.isPipeRunning())

  4726.                 fPipeServer.writeMidiNoteMessage(false, channel, note, velo);

  4727.         }

  4728.         else

  4729.         {

  4730.             if (fUI.handle != nullptr && fUI.descriptor != nullptr && fUI.descriptor->port_event != nullptr && fEventsIn.ctrl != nullptr && ! fNeedsUiClose)

  4731.             {

  4732.                 LV2_Atom_MidiEvent midiEv;

  4733.                 midiEv.atom.type = kUridMidiEvent;

  4734.                 midiEv.atom.size = 3;

  4735.                 midiEv.data[0] = uint8_t(MIDI_STATUS_NOTE_ON | (channel & MIDI_CHANNEL_BIT));

  4736.                 midiEv.data[1] = note;

  4737.                 midiEv.data[2] = velo;

  4738. 

  4739.                 fUI.descriptor->port_event(fUI.handle, fEventsIn.ctrl->rindex, lv2_atom_total_size(midiEv), kUridAtomTransferEvent, &midiEv);

  4740.             }

  4741.         }

  4742. #endif

  4743.     }

  4744. 

  4745.     void uiNoteOff(const uint8_t channel, const uint8_t note) noexcept override

  4746.     {

  4747.         CARLA_SAFE_ASSERT_RETURN(fUI.type != UI::TYPE_NULL || fFilePathURI.isNotEmpty(),);

  4748.         CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  4749.         CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

  4750. 

  4751. #if 0

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

  4753.         {

  4754.             if (fPipeServer.isPipeRunning())

  4755.                 fPipeServer.writeMidiNoteMessage(false, channel, note, 0);

  4756.         }

  4757.         else

  4758.         {

  4759.             if (fUI.handle != nullptr && fUI.descriptor != nullptr && fUI.descriptor->port_event != nullptr && fEventsIn.ctrl != nullptr && ! fNeedsUiClose)

  4760.             {

  4761.                 LV2_Atom_MidiEvent midiEv;

  4762.                 midiEv.atom.type = kUridMidiEvent;

  4763.                 midiEv.atom.size = 3;

  4764.                 midiEv.data[0] = uint8_t(MIDI_STATUS_NOTE_OFF | (channel & MIDI_CHANNEL_BIT));

  4765.                 midiEv.data[1] = note;

  4766.                 midiEv.data[2] = 0;

  4767. 

  4768.                 fUI.descriptor->port_event(fUI.handle, fEventsIn.ctrl->rindex, lv2_atom_total_size(midiEv), kUridAtomTransferEvent, &midiEv);

  4769.             }

  4770.         }

  4771. #endif

  4772.     }

  4773. 

  4774.     // -------------------------------------------------------------------

  4775.     // Internal helper functions

  4776. 

  4777.     void restoreLV2State() noexcept override

  4778.     {

  4779.         if (fExt.state == nullptr)

  4780.             return;

  4781. 

  4782.         LV2_State_Status status = LV2_STATE_ERR_UNKNOWN;

  4783. 

  4784.         {

  4785.             const ScopedSingleProcessLocker spl(this, true);

  4786. 

  4787.             try {

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

  4789.             } catch(...) {}

  4790. 

  4791.             if (fHandle2 != nullptr)

  4792.             {

  4793.                 try {

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

  4795.                 } catch(...) {}

  4796.             }

  4797.         }

  4798. 

  4799.         switch (status)

  4800.         {

  4801.         case LV2_STATE_SUCCESS:

  4802.             carla_debug("CarlaPluginLV2::updateLV2State() - success");

  4803.             break;

  4804.         case LV2_STATE_ERR_UNKNOWN:

  4805.             carla_stderr("CarlaPluginLV2::updateLV2State() - unknown error");

  4806.             break;

  4807.         case LV2_STATE_ERR_BAD_TYPE:

  4808.             carla_stderr("CarlaPluginLV2::updateLV2State() - error, bad type");

  4809.             break;

  4810.         case LV2_STATE_ERR_BAD_FLAGS:

  4811.             carla_stderr("CarlaPluginLV2::updateLV2State() - error, bad flags");

  4812.             break;

  4813.         case LV2_STATE_ERR_NO_FEATURE:

  4814.             carla_stderr("CarlaPluginLV2::updateLV2State() - error, missing feature");

  4815.             break;

  4816.         case LV2_STATE_ERR_NO_PROPERTY:

  4817.             carla_stderr("CarlaPluginLV2::updateLV2State() - error, missing property");

  4818.             break;

  4819.         case LV2_STATE_ERR_NO_SPACE:

  4820.             carla_stderr("CarlaPluginLV2::updateLV2State() - error, insufficient space");

  4821.             break;

  4822.         }

  4823.     }

  4824. 

  4825.     // -------------------------------------------------------------------

  4826. 

  4827.     bool isRealtimeSafe() const noexcept

  4828.     {

  4829.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr, false);

  4830. 

  4831.         for (uint32_t i=0; i < fRdfDescriptor->FeatureCount; ++i)

  4832.         {

  4833.             if (std::strcmp(fRdfDescriptor->Features[i].URI, LV2_CORE__hardRTCapable) == 0)

  4834.                 return true;

  4835.         }

  4836. 

  4837.         return false;

  4838.     }

  4839. 

  4840.     // -------------------------------------------------------------------

  4841. 

  4842.     bool isUiBridgeable(const uint32_t uiId) const noexcept

  4843.     {

  4844.         CARLA_SAFE_ASSERT_RETURN(uiId < fRdfDescriptor->UICount, false);

  4845. 

  4846. #ifndef LV2_UIS_ONLY_INPROCESS

  4847.         const LV2_RDF_UI* const rdfUI(&fRdfDescriptor->UIs[uiId]);

  4848. 

  4849.         for (uint32_t i=0; i < rdfUI->FeatureCount; ++i)

  4850.         {

  4851.             const LV2_RDF_Feature& feat(rdfUI->Features[i]);

  4852. 

  4853.             if (! feat.Required)

  4854.                 continue;

  4855.             if (std::strcmp(feat.URI, LV2_INSTANCE_ACCESS_URI) == 0)

  4856.                 return false;

  4857.             if (std::strcmp(feat.URI, LV2_DATA_ACCESS_URI) == 0)

  4858.                 return false;

  4859.         }

  4860. 

  4861.         // Calf UIs are mostly useless without their special graphs

  4862.         // but they can be crashy under certain conditions, so follow user preferences

  4863.         if (std::strstr(rdfUI->URI, "http://calf.sourceforge.net/plugins/gui/") != nullptr)

  4864.             return pData->engine->getOptions().preferUiBridges;

  4865. 

  4866.         // LSP-Plugins UIs make heavy use of URIDs, for which carla right now is very slow

  4867.         // FIXME after some optimization, remove this

  4868.         if (std::strstr(rdfUI->URI, "http://lsp-plug.in/ui/lv2/") != nullptr)

  4869.             return false;

  4870. 

  4871.         return true;

  4872. #else

  4873.         return false;

  4874. #endif

  4875.     }

  4876. 

  4877.     bool isUiResizable() const noexcept

  4878.     {

  4879.         CARLA_SAFE_ASSERT_RETURN(fUI.rdfDescriptor != nullptr, false);

  4880. 

  4881.         for (uint32_t i=0; i < fUI.rdfDescriptor->FeatureCount; ++i)

  4882.         {

  4883.             if (std::strcmp(fUI.rdfDescriptor->Features[i].URI, LV2_UI__fixedSize) == 0)

  4884.                 return false;

  4885.             if (std::strcmp(fUI.rdfDescriptor->Features[i].URI, LV2_UI__noUserResize) == 0)

  4886.                 return false;

  4887.         }

  4888. 

  4889.         return true;

  4890.     }

  4891. 

  4892.     const char* getUiBridgeBinary(const LV2_Property type) const

  4893.     {

  4894.         CarlaString bridgeBinary(pData->engine->getOptions().binaryDir);

  4895. 

  4896.         if (bridgeBinary.isEmpty())

  4897.             return nullptr;

  4898. 

  4899.         switch (type)

  4900.         {

  4901.         case LV2_UI_GTK2:

  4902.             bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-lv2-gtk2";

  4903.             break;

  4904.         case LV2_UI_GTK3:

  4905.             bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-lv2-gtk3";

  4906.             break;

  4907.         case LV2_UI_QT4:

  4908.             bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-lv2-qt4";

  4909.             break;

  4910.         case LV2_UI_QT5:

  4911.             bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-lv2-qt5";

  4912.             break;

  4913.         case LV2_UI_COCOA:

  4914.             bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-lv2-cocoa";

  4915.             break;

  4916.         case LV2_UI_WINDOWS:

  4917.             bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-lv2-windows";

  4918.             break;

  4919.         case LV2_UI_X11:

  4920.             bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-lv2-x11";

  4921.             break;

  4922.         case LV2_UI_MOD:

  4923.             bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-lv2-modgui";

  4924.             break;

  4925. #if 0

  4926.         case LV2_UI_EXTERNAL:

  4927.         case LV2_UI_OLD_EXTERNAL:

  4928.             bridgeBinary += CARLA_OS_SEP_STR "carla-bridge-lv2-external";

  4929.             break;

  4930. #endif

  4931.         default:

  4932.             return nullptr;

  4933.         }

  4934. 

  4935. #ifdef CARLA_OS_WIN

  4936.         bridgeBinary += ".exe";

  4937. #endif

  4938. 

  4939.         if (! File(bridgeBinary.buffer()).existsAsFile())

  4940.             return nullptr;

  4941. 

  4942.         return bridgeBinary.dupSafe();

  4943.     }

  4944. 

  4945.     // -------------------------------------------------------------------

  4946. 

  4947.     void recheckExtensions()

  4948.     {

  4949.         CARLA_SAFE_ASSERT_RETURN(fRdfDescriptor != nullptr,);

  4950.         carla_debug("CarlaPluginLV2::recheckExtensions()");

  4951. 

  4952.         fExt.options  = nullptr;

  4953.         fExt.programs = nullptr;

  4954.         fExt.state    = nullptr;

  4955.         fExt.worker   = nullptr;

  4956.         fExt.inlineDisplay = nullptr;

  4957. 

  4958.         for (uint32_t i=0; i < fRdfDescriptor->ExtensionCount; ++i)

  4959.         {

  4960.             const char* const extension = fRdfDescriptor->Extensions[i];

  4961.             CARLA_SAFE_ASSERT_CONTINUE(extension != nullptr);

  4962. 

  4963.             /**/ if (std::strcmp(extension, LV2_OPTIONS__interface) == 0)

  4964.                 pData->hints |= PLUGIN_HAS_EXTENSION_OPTIONS;

  4965.             else if (std::strcmp(extension, LV2_PROGRAMS__Interface) == 0)

  4966.                 pData->hints |= PLUGIN_HAS_EXTENSION_PROGRAMS;

  4967.             else if (std::strcmp(extension, LV2_STATE__interface) == 0)

  4968.                 pData->hints |= PLUGIN_HAS_EXTENSION_STATE;

  4969.             else if (std::strcmp(extension, LV2_WORKER__interface) == 0)

  4970.                 pData->hints |= PLUGIN_HAS_EXTENSION_WORKER;

  4971.             else if (std::strcmp(extension, LV2_INLINEDISPLAY__interface) == 0)

  4972.                 pData->hints |= PLUGIN_HAS_EXTENSION_INLINE_DISPLAY;

  4973.             else if (std::strcmp(extension, LV2_MIDNAM__interface) == 0)

  4974.                 pData->hints |= PLUGIN_HAS_EXTENSION_MIDNAM;

  4975.             else

  4976.                 carla_stdout("Plugin '%s' has non-supported extension: '%s'", fRdfDescriptor->URI, extension);

  4977.         }

  4978. 

  4979.         // Fix for broken plugins, nasty!

  4980.         for (uint32_t i=0; i < fRdfDescriptor->FeatureCount; ++i)

  4981.         {

  4982.             const LV2_RDF_Feature& feature(fRdfDescriptor->Features[i]);

  4983. 

  4984.             if (std::strcmp(feature.URI, LV2_INLINEDISPLAY__queue_draw) == 0)

  4985.             {

  4986.                 if (pData->hints & PLUGIN_HAS_EXTENSION_INLINE_DISPLAY)

  4987.                     break;

  4988. 

  4989.                 carla_stdout("Plugin '%s' uses inline-display but does not set extension data, nasty!", fRdfDescriptor->URI);

  4990.                 pData->hints |= PLUGIN_HAS_EXTENSION_INLINE_DISPLAY;

  4991.             }

  4992.             else if (std::strcmp(feature.URI, LV2_MIDNAM__update) == 0)

  4993.             {

  4994.                 if (pData->hints & PLUGIN_HAS_EXTENSION_MIDNAM)

  4995.                     break;

  4996. 

  4997.                 carla_stdout("Plugin '%s' uses midnam but does not set extension data, nasty!", fRdfDescriptor->URI);

  4998.                 pData->hints |= PLUGIN_HAS_EXTENSION_MIDNAM;

  4999.             }

  5000.         }

  5001. 

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

  5003.         {

  5004.             if (pData->hints & PLUGIN_HAS_EXTENSION_OPTIONS)

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

  5006. 

  5007.             if (pData->hints & PLUGIN_HAS_EXTENSION_PROGRAMS)

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

  5009. 

  5010.             if (pData->hints & PLUGIN_HAS_EXTENSION_STATE)

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

  5012. 

  5013.             if (pData->hints & PLUGIN_HAS_EXTENSION_WORKER)

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

  5015. 

  5016.             if (pData->hints & PLUGIN_HAS_EXTENSION_INLINE_DISPLAY)

  5017.                 fExt.inlineDisplay = (const LV2_Inline_Display_Interface*)fDescriptor->extension_data(LV2_INLINEDISPLAY__interface);

  5018. 

  5019.             if (pData->hints & PLUGIN_HAS_EXTENSION_MIDNAM)

  5020.                 fExt.midnam = (const LV2_Midnam_Interface*)fDescriptor->extension_data(LV2_MIDNAM__interface);

  5021. 

  5022.             // check if invalid

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

  5024.                 fExt.options = nullptr;

  5025. 

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

  5027.                 fExt.programs = nullptr;

  5028. 

  5029.             if (fExt.state != nullptr && (fExt.state->save == nullptr || fExt.state->restore == nullptr))

  5030.                 fExt.state = nullptr;

  5031. 

  5032.             if (fExt.worker != nullptr && fExt.worker->work == nullptr)

  5033.                 fExt.worker = nullptr;

  5034. 

  5035.             if (fExt.inlineDisplay != nullptr)

  5036.             {

  5037.                 if (fExt.inlineDisplay->render != nullptr)

  5038.                 {

  5039.                     pData->hints |= PLUGIN_HAS_INLINE_DISPLAY;

  5040.                     pData->setCanDeleteLib(false);

  5041.                 }

  5042.                 else

  5043.                 {

  5044.                     fExt.inlineDisplay = nullptr;

  5045.                 }

  5046.             }

  5047. 

  5048.             if (fExt.midnam != nullptr && fExt.midnam->midnam == nullptr)

  5049.                 fExt.midnam = nullptr;

  5050.         }

  5051. 

  5052.         CARLA_SAFE_ASSERT_RETURN(fLatencyIndex == -1,);

  5053. 

  5054.         int32_t iCtrl=0;

  5055.         for (uint32_t i=0, count=fRdfDescriptor->PortCount; i<count; ++i)

  5056.         {

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

  5058. 

  5059.             if (! LV2_IS_PORT_CONTROL(portTypes))

  5060.                 continue;

  5061. 

  5062.             const CarlaScopedValueSetter<int32_t> svs(iCtrl, iCtrl, iCtrl+1);

  5063. 

  5064.             if (! LV2_IS_PORT_OUTPUT(portTypes))

  5065.                 continue;

  5066. 

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

  5068. 

  5069.             if (! LV2_IS_PORT_DESIGNATION_LATENCY(portDesignation))

  5070.                 continue;

  5071. 

  5072.             fLatencyIndex = iCtrl;

  5073.             break;

  5074.         }

  5075.     }

  5076. 

  5077.     // -------------------------------------------------------------------

  5078. 

  5079.     void updateUi()

  5080.     {

  5081.         CARLA_SAFE_ASSERT_RETURN(fUI.handle != nullptr,);

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

  5083.         carla_debug("CarlaPluginLV2::updateUi()");

  5084. 

  5085.         // update midi program

  5086.         if (fExt.uiprograms != nullptr && pData->midiprog.count > 0 && pData->midiprog.current >= 0)

  5087.         {

  5088.             const MidiProgramData& curData(pData->midiprog.getCurrent());

  5089.             fExt.uiprograms->select_program(fUI.handle, curData.bank, curData.program);

  5090.         }

  5091. 

  5092.         // update control ports

  5093.         if (fUI.descriptor->port_event != nullptr)

  5094.         {

  5095.             float value;

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

  5097.             {

  5098.                 value = getParameterValue(i);

  5099.                 fUI.descriptor->port_event(fUI.handle, static_cast<uint32_t>(pData->param.data[i].rindex), sizeof(float), kUridNull, &value);

  5100.             }

  5101.         }

  5102.     }

  5103. 

  5104.     // -------------------------------------------------------------------

  5105. 

  5106.     LV2_URID getCustomURID(const char* const uri)

  5107.     {

  5108.         CARLA_SAFE_ASSERT_RETURN(uri != nullptr && uri[0] != '\0', kUridNull);

  5109.         carla_debug("CarlaPluginLV2::getCustomURID(\"%s\")", uri);

  5110. 

  5111.         const std::string    s_uri(uri);

  5112.         const std::ptrdiff_t s_pos(std::find(fCustomURIDs.begin(), fCustomURIDs.end(), s_uri) - fCustomURIDs.begin());

  5113. 

  5114.         if (s_pos <= 0 || s_pos >= INT32_MAX)

  5115.             return kUridNull;

  5116. 

  5117.         const LV2_URID urid     = static_cast<LV2_URID>(s_pos);

  5118.         const LV2_URID uriCount = static_cast<LV2_URID>(fCustomURIDs.size());

  5119. 

  5120.         if (urid < uriCount)

  5121.             return urid;

  5122. 

  5123.         CARLA_SAFE_ASSERT(urid == uriCount);

  5124. 

  5125.         fCustomURIDs.push_back(uri);

  5126. 

  5127.         if (fUI.type == UI::TYPE_BRIDGE && fPipeServer.isPipeRunning())

  5128.             fPipeServer.writeLv2UridMessage(urid, uri);

  5129. 

  5130.         return urid;

  5131.     }

  5132. 

  5133.     const char* getCustomURIDString(const LV2_URID urid) const noexcept

  5134.     {

  5135.         CARLA_SAFE_ASSERT_RETURN(urid != kUridNull, kUnmapFallback);

  5136.         CARLA_SAFE_ASSERT_RETURN(urid < fCustomURIDs.size(), kUnmapFallback);

  5137.         carla_debug("CarlaPluginLV2::getCustomURIString(%i)", urid);

  5138. 

  5139.         return fCustomURIDs[urid].c_str();

  5140.     }

  5141. 

  5142.     // -------------------------------------------------------------------

  5143. 

  5144.     void handleProgramChanged(const int32_t index)

  5145.     {

  5146.         CARLA_SAFE_ASSERT_RETURN(index >= -1,);

  5147.         carla_debug("CarlaPluginLV2::handleProgramChanged(%i)", index);

  5148. 

  5149.         if (index == -1)

  5150.         {

  5151.             const ScopedSingleProcessLocker spl(this, true);

  5152.             return reloadPrograms(false);

  5153.         }

  5154. 

  5155.         if (index < static_cast<int32_t>(pData->midiprog.count) && fExt.programs != nullptr && fExt.programs->get_program != nullptr)

  5156.         {

  5157.             if (const LV2_Program_Descriptor* const progDesc = fExt.programs->get_program(fHandle, static_cast<uint32_t>(index)))

  5158.             {

  5159.                 CARLA_SAFE_ASSERT_RETURN(progDesc->name != nullptr,);

  5160. 

  5161.                 if (pData->midiprog.data[index].name != nullptr)

  5162.                     delete[] pData->midiprog.data[index].name;

  5163. 

  5164.                 pData->midiprog.data[index].name = carla_strdup(progDesc->name);

  5165. 

  5166.                 if (index == pData->midiprog.current)

  5167.                     pData->engine->callback(true, true, ENGINE_CALLBACK_UPDATE, pData->id, 0, 0, 0, 0.0, nullptr);

  5168.                 else

  5169.                     pData->engine->callback(true, true, ENGINE_CALLBACK_RELOAD_PROGRAMS, pData->id, 0, 0, 0, 0.0, nullptr);

  5170.             }

  5171.         }

  5172.     }

  5173. 

  5174.     // -------------------------------------------------------------------

  5175. 

  5176.     LV2_Resize_Port_Status handleResizePort(const uint32_t index, const size_t size)

  5177.     {

  5178.         CARLA_SAFE_ASSERT_RETURN(size > 0, LV2_RESIZE_PORT_ERR_UNKNOWN);

  5179.         carla_debug("CarlaPluginLV2::handleResizePort(%i, " P_SIZE ")", index, size);

  5180. 

  5181.         // TODO

  5182.         return LV2_RESIZE_PORT_ERR_NO_SPACE;

  5183.         (void)index;

  5184.     }

  5185. 

  5186.     // -------------------------------------------------------------------

  5187. 

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

  5189.     {

  5190.         CARLA_SAFE_ASSERT_RETURN(key != kUridNull, LV2_STATE_ERR_NO_PROPERTY);

  5191.         CARLA_SAFE_ASSERT_RETURN(value != nullptr, LV2_STATE_ERR_NO_PROPERTY);

  5192.         CARLA_SAFE_ASSERT_RETURN(size > 0, LV2_STATE_ERR_NO_PROPERTY);

  5193.         CARLA_SAFE_ASSERT_RETURN(type != kUridNull, LV2_STATE_ERR_BAD_TYPE);

  5194. 

  5195.         // FIXME linuxsampler does not set POD flag

  5196.         // CARLA_SAFE_ASSERT_RETURN(flags & LV2_STATE_IS_POD, LV2_STATE_ERR_BAD_FLAGS);

  5197. 

  5198.         carla_debug("CarlaPluginLV2::handleStateStore(%i:\"%s\", %p, " P_SIZE ", %i:\"%s\", %i)",

  5199.                     key, carla_lv2_urid_unmap(this, key), value, size, type, carla_lv2_urid_unmap(this, type), flags);

  5200. 

  5201.         const char* const skey(carla_lv2_urid_unmap(this, key));

  5202.         const char* const stype(carla_lv2_urid_unmap(this, type));

  5203. 

  5204.         CARLA_SAFE_ASSERT_RETURN(skey != nullptr && skey != kUnmapFallback, LV2_STATE_ERR_BAD_TYPE);

  5205.         CARLA_SAFE_ASSERT_RETURN(stype != nullptr && stype != kUnmapFallback, LV2_STATE_ERR_BAD_TYPE);

  5206. 

  5207.         // Check if we already have this key

  5208.         for (LinkedList<CustomData>::Itenerator it = pData->custom.begin2(); it.valid(); it.next())

  5209.         {

  5210.             CustomData& cData(it.getValue(kCustomDataFallbackNC));

  5211.             CARLA_SAFE_ASSERT_CONTINUE(cData.isValid());

  5212. 

  5213.             if (std::strcmp(cData.key, skey) == 0)

  5214.             {

  5215.                 // found it

  5216.                 delete[] cData.value;

  5217. 

  5218.                 if (type == kUridAtomString || type == kUridAtomPath)

  5219.                     cData.value = carla_strdup((const char*)value);

  5220.                 else

  5221.                     cData.value = CarlaString::asBase64(value, size).dup();

  5222. 

  5223.                 return LV2_STATE_SUCCESS;

  5224.             }

  5225.         }

  5226. 

  5227.         // Otherwise store it

  5228.         CustomData newData;

  5229.         newData.type = carla_strdup(stype);

  5230.         newData.key  = carla_strdup(skey);

  5231. 

  5232.         if (type == kUridAtomString || type == kUridAtomPath)

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

  5234.         else

  5235.             newData.value = CarlaString::asBase64(value, size).dup();

  5236. 

  5237.         pData->custom.append(newData);

  5238. 

  5239.         return LV2_STATE_SUCCESS;

  5240. 

  5241.         // unused

  5242.         (void)flags;

  5243.     }

  5244. 

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

  5246.     {

  5247.         CARLA_SAFE_ASSERT_RETURN(key != kUridNull, nullptr);

  5248.         CARLA_SAFE_ASSERT_RETURN(size != nullptr, nullptr);

  5249.         CARLA_SAFE_ASSERT_RETURN(type != nullptr, nullptr);

  5250.         CARLA_SAFE_ASSERT_RETURN(flags != nullptr, nullptr);

  5251.         carla_debug("CarlaPluginLV2::handleStateRetrieve(%i, %p, %p, %p)", key, size, type, flags);

  5252. 

  5253.         const char* const skey(carla_lv2_urid_unmap(this, key));

  5254.         CARLA_SAFE_ASSERT_RETURN(skey != nullptr && skey != kUnmapFallback, nullptr);

  5255. 

  5256.         const char* stype = nullptr;

  5257.         const char* stringData = nullptr;

  5258. 

  5259.         for (LinkedList<CustomData>::Itenerator it = pData->custom.begin2(); it.valid(); it.next())

  5260.         {

  5261.             const CustomData& cData(it.getValue(kCustomDataFallback));

  5262.             CARLA_SAFE_ASSERT_CONTINUE(cData.isValid());

  5263. 

  5264.             if (std::strcmp(cData.key, skey) == 0)

  5265.             {

  5266.                 stype      = cData.type;

  5267.                 stringData = cData.value;

  5268.                 break;

  5269.             }

  5270.         }

  5271. 

  5272.         if (stype == nullptr || stringData == nullptr)

  5273.         {

  5274.             carla_stderr("Plugin requested value for '%s' which is not available", skey);

  5275.             *size = *type = *flags = 0;

  5276.             return nullptr;

  5277.         }

  5278. 

  5279.         *type  = carla_lv2_urid_map(this, stype);

  5280.         *flags = LV2_STATE_IS_POD;

  5281. 

  5282.         if (*type == kUridAtomString || *type == kUridAtomPath)

  5283.         {

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

  5285.             return stringData;

  5286.         }

  5287. 

  5288.         if (fLastStateChunk != nullptr)

  5289.         {

  5290.             std::free(fLastStateChunk);

  5291.             fLastStateChunk = nullptr;

  5292.         }

  5293. 

  5294.         std::vector<uint8_t> chunk(carla_getChunkFromBase64String(stringData));

  5295.         CARLA_SAFE_ASSERT_RETURN(chunk.size() > 0, nullptr);

  5296. 

  5297.         fLastStateChunk = std::malloc(chunk.size());

  5298.         CARLA_SAFE_ASSERT_RETURN(fLastStateChunk != nullptr, nullptr);

  5299. 

  5300. #ifdef CARLA_PROPER_CPP11_SUPPORT

  5301.         std::memcpy(fLastStateChunk, chunk.data(), chunk.size());

  5302. #else

  5303.         std::memcpy(fLastStateChunk, &chunk.front(), chunk.size());

  5304. #endif

  5305. 

  5306.         *size = chunk.size();

  5307.         return fLastStateChunk;

  5308.     }

  5309. 

  5310.     // -------------------------------------------------------------------

  5311. 

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

  5313.     {

  5314.         CARLA_SAFE_ASSERT_RETURN(fExt.worker != nullptr && fExt.worker->work != nullptr, LV2_WORKER_ERR_UNKNOWN);

  5315.         CARLA_SAFE_ASSERT_RETURN(fEventsIn.ctrl != nullptr, LV2_WORKER_ERR_UNKNOWN);

  5316.         carla_debug("CarlaPluginLV2::handleWorkerSchedule(%i, %p)", size, data);

  5317. 

  5318.         if (pData->engine->isOffline())

  5319.         {

  5320.             fExt.worker->work(fHandle, carla_lv2_worker_respond, this, size, data);

  5321.             return LV2_WORKER_SUCCESS;

  5322.         }

  5323. 

  5324.         LV2_Atom atom;

  5325.         atom.size = size;

  5326.         atom.type = kUridCarlaAtomWorkerIn;

  5327. 

  5328.         return fAtomBufferWorkerIn.putChunk(&atom, data, fEventsOut.ctrlIndex) ? LV2_WORKER_SUCCESS : LV2_WORKER_ERR_NO_SPACE;

  5329.     }

  5330. 

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

  5332.     {

  5333.         CARLA_SAFE_ASSERT_RETURN(fExt.worker != nullptr && fExt.worker->work_response != nullptr, LV2_WORKER_ERR_UNKNOWN);

  5334.         carla_debug("CarlaPluginLV2::handleWorkerRespond(%i, %p)", size, data);

  5335. 

  5336.         LV2_Atom atom;

  5337.         atom.size = size;

  5338.         atom.type = kUridCarlaAtomWorkerResp;

  5339. 

  5340.         return fAtomBufferWorkerResp.putChunk(&atom, data, fEventsIn.ctrlIndex) ? LV2_WORKER_SUCCESS : LV2_WORKER_ERR_NO_SPACE;

  5341.     }

  5342. 

  5343.     // -------------------------------------------------------------------

  5344. 

  5345.     void handleInlineDisplayQueueRedraw()

  5346.     {

  5347.         fInlineDisplayNeedsRedraw = true;

  5348.     }

  5349. 

  5350.     const LV2_Inline_Display_Image_Surface* renderInlineDisplay(const uint32_t width, const uint32_t height) const

  5351.     {

  5352.         CARLA_SAFE_ASSERT_RETURN(fExt.inlineDisplay != nullptr && fExt.inlineDisplay->render != nullptr, nullptr);

  5353.         CARLA_SAFE_ASSERT_RETURN(width > 0, nullptr);

  5354.         CARLA_SAFE_ASSERT_RETURN(height > 0, nullptr);

  5355. 

  5356.         return fExt.inlineDisplay->render(fHandle, width, height);

  5357.     }

  5358. 

  5359.     // -------------------------------------------------------------------

  5360. 

  5361.     void handleMidnamUpdate()

  5362.     {

  5363.         CARLA_SAFE_ASSERT_RETURN(fExt.midnam != nullptr,);

  5364. 

  5365.         if (fEventsIn.ctrl == nullptr)

  5366.             return;

  5367. 

  5368.         char* const midnam = fExt.midnam->midnam(fHandle);

  5369.         CARLA_SAFE_ASSERT_RETURN(midnam != nullptr,);

  5370. 

  5371.         fEventsIn.ctrl->port->setMetaData("http://www.midi.org/dtds/MIDINameDocument10.dtd", midnam, "text/xml");

  5372. 

  5373.         if (fExt.midnam->free != nullptr)

  5374.             fExt.midnam->free(midnam);

  5375.     }

  5376. 

  5377.     // -------------------------------------------------------------------

  5378. 

  5379.     void handleExternalUIClosed()

  5380.     {

  5381.         CARLA_SAFE_ASSERT_RETURN(fUI.type == UI::TYPE_EXTERNAL,);

  5382.         carla_debug("CarlaPluginLV2::handleExternalUIClosed()");

  5383. 

  5384.         fNeedsUiClose = true;

  5385.     }

  5386. 

  5387.     void handlePluginUIClosed() override

  5388.     {

  5389.         CARLA_SAFE_ASSERT_RETURN(fUI.type == UI::TYPE_EMBED,);

  5390.         CARLA_SAFE_ASSERT_RETURN(fUI.window != nullptr,);

  5391.         carla_debug("CarlaPluginLV2::handlePluginUIClosed()");

  5392. 

  5393.         fNeedsUiClose = true;

  5394.     }

  5395. 

  5396.     void handlePluginUIResized(const uint width, const uint height) override

  5397.     {

  5398.         CARLA_SAFE_ASSERT_RETURN(fUI.type == UI::TYPE_EMBED,);

  5399.         CARLA_SAFE_ASSERT_RETURN(fUI.window != nullptr,);

  5400.         carla_debug("CarlaPluginLV2::handlePluginUIResized(%u, %u)", width, height);

  5401. 

  5402.         if (fUI.handle != nullptr && fExt.uiresize != nullptr)

  5403.             fExt.uiresize->ui_resize(fUI.handle, static_cast<int>(width), static_cast<int>(height));

  5404.     }

  5405. 

  5406.     // -------------------------------------------------------------------

  5407. 

  5408.     uint32_t handleUIPortMap(const char* const symbol) const noexcept

  5409.     {

  5410.         CARLA_SAFE_ASSERT_RETURN(symbol != nullptr && symbol[0] != '\0', LV2UI_INVALID_PORT_INDEX);

  5411.         carla_debug("CarlaPluginLV2::handleUIPortMap(\"%s\")", symbol);

  5412. 

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

  5414.         {

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

  5416.                 return i;

  5417.         }

  5418. 

  5419.         return LV2UI_INVALID_PORT_INDEX;

  5420.     }

  5421. 

  5422.     LV2UI_Request_Value_Status handleUIRequestValue(const LV2_URID key,

  5423.                                                     const LV2_URID type,

  5424.                                                     const LV2_Feature* const* features)

  5425.     {

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

  5427.         carla_debug("CarlaPluginLV2::handleUIRequestValue(%u, %u, %p)", key, type, features);

  5428. 

  5429.         if (type != kUridAtomPath)

  5430.             return LV2UI_REQUEST_VALUE_ERR_UNSUPPORTED;

  5431. 

  5432.         const char* const uri = getCustomURIDString(key);

  5433.         CARLA_SAFE_ASSERT_RETURN(uri != nullptr && uri != kUnmapFallback, LV2UI_REQUEST_VALUE_ERR_UNKNOWN);

  5434. 

  5435.         // check if a file browser is already open

  5436.         if (fUI.fileNeededForURI != nullptr || fUI.fileBrowserOpen)

  5437.             return LV2UI_REQUEST_VALUE_BUSY;

  5438. 

  5439.         for (uint32_t i=0; i < fRdfDescriptor->ParameterCount; ++i)

  5440.         {

  5441.             if (fRdfDescriptor->Parameters[i].Type != LV2_PARAMETER_PATH)

  5442.                 continue;

  5443.             if (std::strcmp(fRdfDescriptor->Parameters[i].URI, uri) != 0)

  5444.                 continue;

  5445. 

  5446.             // TODO file browser filters, also store label to use for title

  5447.             fUI.fileNeededForURI = uri;

  5448. 

  5449.             return LV2UI_REQUEST_VALUE_SUCCESS;

  5450.         }

  5451. 

  5452.         return LV2UI_REQUEST_VALUE_ERR_UNSUPPORTED;

  5453. 

  5454.         // may be unused

  5455.         (void)features;

  5456.     }

  5457. 

  5458.     int handleUIResize(const int width, const int height)

  5459.     {

  5460.         CARLA_SAFE_ASSERT_RETURN(fUI.window != nullptr, 1);

  5461.         CARLA_SAFE_ASSERT_RETURN(width > 0, 1);

  5462.         CARLA_SAFE_ASSERT_RETURN(height > 0, 1);

  5463.         carla_debug("CarlaPluginLV2::handleUIResize(%i, %i)", width, height);

  5464. 

  5465.         fUI.window->setSize(static_cast<uint>(width), static_cast<uint>(height), true);

  5466.         return 0;

  5467.     }

  5468. 

  5469.     void handleUITouch(const uint32_t rindex, const bool touch)

  5470.     {

  5471.         carla_debug("CarlaPluginLV2::handleUITouch(%u, %s)", rindex, bool2str(touch));

  5472. 

  5473.         uint32_t index = LV2UI_INVALID_PORT_INDEX;

  5474. 

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

  5476.         {

  5477.             if (pData->param.data[i].rindex != static_cast<int32_t>(rindex))

  5478.                 continue;

  5479.             index = i;

  5480.             break;

  5481.         }

  5482. 

  5483.         CARLA_SAFE_ASSERT_RETURN(index != LV2UI_INVALID_PORT_INDEX,);

  5484. 

  5485.         pData->engine->touchPluginParameter(pData->id, index, touch);

  5486.     }

  5487. 

  5488.     void handleUIWrite(const uint32_t rindex, const uint32_t bufferSize, const uint32_t format, const void* const buffer)

  5489.     {

  5490.         CARLA_SAFE_ASSERT_RETURN(buffer != nullptr,);

  5491.         CARLA_SAFE_ASSERT_RETURN(bufferSize > 0,);

  5492.         carla_debug("CarlaPluginLV2::handleUIWrite(%i, %i, %i, %p)", rindex, bufferSize, format, buffer);

  5493. 

  5494.         uint32_t index = LV2UI_INVALID_PORT_INDEX;

  5495. 

  5496.         switch (format)

  5497.         {

  5498.         case kUridNull: {

  5499.             CARLA_SAFE_ASSERT_RETURN(rindex < fRdfDescriptor->PortCount,);

  5500.             CARLA_SAFE_ASSERT_RETURN(bufferSize == sizeof(float),);

  5501. 

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

  5503.             {

  5504.                 if (pData->param.data[i].rindex != static_cast<int32_t>(rindex))

  5505.                     continue;

  5506.                 index = i;

  5507.                 break;

  5508.             }

  5509. 

  5510.             CARLA_SAFE_ASSERT_RETURN(index != LV2UI_INVALID_PORT_INDEX,);

  5511. 

  5512.             const float value(*(const float*)buffer);

  5513. 

  5514.             // check if we should feedback message back to UI

  5515.             bool sendGui = false;

  5516. 

  5517.             if (const uint32_t notifCount = fUI.rdfDescriptor->PortNotificationCount)

  5518.             {

  5519.                 const char* const portSymbol = fRdfDescriptor->Ports[rindex].Symbol;

  5520. 

  5521.                 for (uint32_t i=0; i < notifCount; ++i)

  5522.                 {

  5523.                     const LV2_RDF_UI_PortNotification& portNotif(fUI.rdfDescriptor->PortNotifications[i]);

  5524. 

  5525.                     if (portNotif.Protocol != LV2_UI_PORT_PROTOCOL_FLOAT)

  5526.                         continue;

  5527. 

  5528.                     if (portNotif.Symbol != nullptr)

  5529.                     {

  5530.                         if (std::strcmp(portNotif.Symbol, portSymbol) != 0)

  5531.                             continue;

  5532.                     }

  5533.                     else if (portNotif.Index != rindex)

  5534.                     {

  5535.                         continue;

  5536.                     }

  5537. 

  5538.                     sendGui = true;

  5539.                     break;

  5540.                 }

  5541.             }

  5542. 

  5543.             setParameterValue(index, value, sendGui, true, true);

  5544. 

  5545.         } break;

  5546. 

  5547.         case kUridAtomTransferAtom:

  5548.         case kUridAtomTransferEvent: {

  5549.             CARLA_SAFE_ASSERT_RETURN(bufferSize >= sizeof(LV2_Atom),);

  5550. 

  5551.             const LV2_Atom* const atom((const LV2_Atom*)buffer);

  5552. 

  5553.             // plugins sometimes fail on this, not good...

  5554.             const uint32_t totalSize = lv2_atom_total_size(atom);

  5555.             const uint32_t paddedSize = lv2_atom_pad_size(totalSize);

  5556. 

  5557.             if (bufferSize != totalSize && bufferSize != paddedSize)

  5558.                 carla_stderr2("Warning: LV2 UI sending atom with invalid size %u! size: %u, padded-size: %u",

  5559.                               bufferSize, totalSize, paddedSize);

  5560. 

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

  5562.             {

  5563.                 if (fEventsIn.data[i].rindex != rindex)

  5564.                     continue;

  5565.                 index = i;

  5566.                 break;

  5567.             }

  5568. 

  5569.             // for bad plugins

  5570.             if (index == LV2UI_INVALID_PORT_INDEX)

  5571.             {

  5572.                 CARLA_SAFE_ASSERT(index != LV2UI_INVALID_PORT_INDEX); // FIXME

  5573.                 index = fEventsIn.ctrlIndex;

  5574.             }

  5575. 

  5576.             fAtomBufferEvIn.put(atom, index);

  5577.         } break;

  5578. 

  5579.         default:

  5580.             carla_stdout("CarlaPluginLV2::handleUIWrite(%i, %i, %i:\"%s\", %p) - unknown format",

  5581.                          rindex, bufferSize, format, carla_lv2_urid_unmap(this, format), buffer);

  5582.             break;

  5583.         }

  5584.     }

  5585. 

  5586.     // -------------------------------------------------------------------

  5587. 

  5588.     void handleLilvSetPortValue(const char* const portSymbol, const void* const value, const uint32_t size, const uint32_t type)

  5589.     {

  5590.         CARLA_SAFE_ASSERT_RETURN(portSymbol != nullptr && portSymbol[0] != '\0',);

  5591.         CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

  5592.         CARLA_SAFE_ASSERT_RETURN(size > 0,);

  5593.         CARLA_SAFE_ASSERT_RETURN(type != kUridNull,);

  5594.         carla_debug("CarlaPluginLV2::handleLilvSetPortValue(\"%s\", %p, %i, %i)", portSymbol, value, size, type);

  5595. 

  5596.         int32_t rindex = -1;

  5597. 

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

  5599.         {

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

  5601.             {

  5602.                 rindex = static_cast<int32_t>(i);

  5603.                 break;

  5604.             }

  5605.         }

  5606. 

  5607.         CARLA_SAFE_ASSERT_RETURN(rindex >= 0,);

  5608. 

  5609.         float paramValue;

  5610. 

  5611.         switch (type)

  5612.         {

  5613.         case kUridAtomBool:

  5614.             CARLA_SAFE_ASSERT_RETURN(size == sizeof(bool),);

  5615.             paramValue = (*(const bool*)value) ? 1.0f : 0.0f;

  5616.             break;

  5617.         case kUridAtomDouble:

  5618.             CARLA_SAFE_ASSERT_RETURN(size == sizeof(double),);

  5619.             paramValue = static_cast<float>((*(const double*)value));

  5620.             break;

  5621.         case kUridAtomFloat:

  5622.             CARLA_SAFE_ASSERT_RETURN(size == sizeof(float),);

  5623.             paramValue = (*(const float*)value);

  5624.             break;

  5625.         case kUridAtomInt:

  5626.             CARLA_SAFE_ASSERT_RETURN(size == sizeof(int32_t),);

  5627.             paramValue = static_cast<float>((*(const int32_t*)value));

  5628.             break;

  5629.         case kUridAtomLong:

  5630.             CARLA_SAFE_ASSERT_RETURN(size == sizeof(int64_t),);

  5631.             paramValue = static_cast<float>((*(const int64_t*)value));

  5632.             break;

  5633.         default:

  5634.             carla_stdout("CarlaPluginLV2::handleLilvSetPortValue(\"%s\", %p, %i, %i:\"%s\") - unknown type",

  5635.                          portSymbol, value, size, type, carla_lv2_urid_unmap(this, type));

  5636.             return;

  5637.         }

  5638. 

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

  5640.         {

  5641.             if (pData->param.data[i].rindex == rindex)

  5642.             {

  5643.                 setParameterValueRT(i, paramValue, true);

  5644.                 break;

  5645.             }

  5646.         }

  5647.     }

  5648. 

  5649.     // -------------------------------------------------------------------

  5650. 

  5651.     void* getNativeHandle() const noexcept override

  5652.     {

  5653.         return fHandle;

  5654.     }

  5655. 

  5656.     const void* getNativeDescriptor() const noexcept override

  5657.     {

  5658.         return fDescriptor;

  5659.     }

  5660. 

  5661.     uintptr_t getUiBridgeProcessId() const noexcept override

  5662.     {

  5663.         return fPipeServer.isPipeRunning() ? fPipeServer.getPID() : 0;

  5664.     }

  5665. 

  5666.     // -------------------------------------------------------------------

  5667. 

  5668. public:

  5669.     bool init(const CarlaPluginPtr plugin,

  5670.               const char* const name, const char* const uri, const uint options)

  5671.     {

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

  5673. 

  5674.         // ---------------------------------------------------------------

  5675.         // first checks

  5676. 

  5677.         if (pData->client != nullptr)

  5678.         {

  5679.             pData->engine->setLastError("Plugin client is already registered");

  5680.             return false;

  5681.         }

  5682. 

  5683.         if (uri == nullptr || uri[0] == '\0')

  5684.         {

  5685.             pData->engine->setLastError("null uri");

  5686.             return false;

  5687.         }

  5688. 

  5689.         const EngineOptions& opts(pData->engine->getOptions());

  5690. 

  5691.         // ---------------------------------------------------------------

  5692.         // Init LV2 World if needed, sets LV2_PATH for lilv

  5693. 

  5694.         Lv2WorldClass& lv2World(Lv2WorldClass::getInstance());

  5695. 

  5696.         if (opts.pathLV2 != nullptr && opts.pathLV2[0] != '\0')

  5697.             lv2World.initIfNeeded(opts.pathLV2);

  5698.         else if (const char* const LV2_PATH = std::getenv("LV2_PATH"))

  5699.             lv2World.initIfNeeded(LV2_PATH);

  5700.         else

  5701.             lv2World.initIfNeeded(LILV_DEFAULT_LV2_PATH);

  5702. 

  5703.         // ---------------------------------------------------------------

  5704.         // get plugin from lv2_rdf (lilv)

  5705. 

  5706.         fRdfDescriptor = lv2_rdf_new(uri, true);

  5707. 

  5708.         if (fRdfDescriptor == nullptr)

  5709.         {

  5710.             pData->engine->setLastError("Failed to find the requested plugin");

  5711.             return false;

  5712.         }

  5713. 

  5714.         // ---------------------------------------------------------------

  5715.         // open DLL

  5716. 

  5717.         if (! pData->libOpen(fRdfDescriptor->Binary))

  5718.         {

  5719.             pData->engine->setLastError(pData->libError(fRdfDescriptor->Binary));

  5720.             return false;

  5721.         }

  5722. 

  5723.         // ---------------------------------------------------------------

  5724.         // try to get DLL main entry via new mode

  5725. 

  5726.         if (const LV2_Lib_Descriptor_Function libDescFn = pData->libSymbol<LV2_Lib_Descriptor_Function>("lv2_lib_descriptor"))

  5727.         {

  5728.             // -----------------------------------------------------------

  5729.             // all ok, get lib descriptor

  5730. 

  5731.             const LV2_Lib_Descriptor* const libDesc = libDescFn(fRdfDescriptor->Bundle, nullptr);

  5732. 

  5733.             if (libDesc == nullptr)

  5734.             {

  5735.                 pData->engine->setLastError("Could not find the LV2 Descriptor");

  5736.                 return false;

  5737.             }

  5738. 

  5739.             // -----------------------------------------------------------

  5740.             // get descriptor that matches URI (new mode)

  5741. 

  5742.             uint32_t i = 0;

  5743.             while ((fDescriptor = libDesc->get_plugin(libDesc->handle, i++)))

  5744.             {

  5745.                 if (std::strcmp(fDescriptor->URI, uri) == 0)

  5746.                     break;

  5747.             }

  5748.         }

  5749.         else

  5750.         {

  5751.             // -----------------------------------------------------------

  5752.             // get DLL main entry (old mode)

  5753. 

  5754.             const LV2_Descriptor_Function descFn = pData->libSymbol<LV2_Descriptor_Function>("lv2_descriptor");

  5755. 

  5756.             if (descFn == nullptr)

  5757.             {

  5758.                 pData->engine->setLastError("Could not find the LV2 Descriptor in the plugin library");

  5759.                 return false;

  5760.             }

  5761. 

  5762.             // -----------------------------------------------------------

  5763.             // get descriptor that matches URI (old mode)

  5764. 

  5765.             uint32_t i = 0;

  5766.             while ((fDescriptor = descFn(i++)))

  5767.             {

  5768.                 if (std::strcmp(fDescriptor->URI, uri) == 0)

  5769.                     break;

  5770.             }

  5771.         }

  5772. 

  5773.         if (fDescriptor == nullptr)

  5774.         {

  5775.             pData->engine->setLastError("Could not find the requested plugin URI in the plugin library");

  5776.             return false;

  5777.         }

  5778. 

  5779.         // ---------------------------------------------------------------

  5780.         // check supported port-types and features

  5781. 

  5782.         bool canContinue = true;

  5783. 

  5784.         // Check supported ports

  5785.         for (uint32_t j=0; j < fRdfDescriptor->PortCount; ++j)

  5786.         {

  5787.             const LV2_Property portTypes(fRdfDescriptor->Ports[j].Types);

  5788. 

  5789.             if (! is_lv2_port_supported(portTypes))

  5790.             {

  5791.                 if (! LV2_IS_PORT_OPTIONAL(fRdfDescriptor->Ports[j].Properties))

  5792.                 {

  5793.                     pData->engine->setLastError("Plugin requires a port type that is not currently supported");

  5794.                     canContinue = false;

  5795.                     break;

  5796.                 }

  5797.             }

  5798.         }

  5799. 

  5800.         // Check supported features

  5801.         for (uint32_t j=0; j < fRdfDescriptor->FeatureCount && canContinue; ++j)

  5802.         {

  5803.             const LV2_RDF_Feature& feature(fRdfDescriptor->Features[j]);

  5804. 

  5805.             if (std::strcmp(feature.URI, LV2_DATA_ACCESS_URI) == 0 || std::strcmp(feature.URI, LV2_INSTANCE_ACCESS_URI) == 0)

  5806.             {

  5807.                 carla_stderr("Plugin DSP wants UI feature '%s', ignoring this", feature.URI);

  5808.             }

  5809.             else if (std::strcmp(feature.URI, LV2_BUF_SIZE__fixedBlockLength) == 0)

  5810.             {

  5811.                 fNeedsFixedBuffers = true;

  5812.             }

  5813.             else if (std::strcmp(feature.URI, LV2_PORT_PROPS__supportsStrictBounds) == 0)

  5814.             {

  5815.                 fStrictBounds = feature.Required ? 1 : 0;

  5816.             }

  5817.             else if (feature.Required && ! is_lv2_feature_supported(feature.URI))

  5818.             {

  5819.                 CarlaString msg("Plugin wants a feature that is not supported:\n");

  5820.                 msg += feature.URI;

  5821. 

  5822.                 canContinue = false;

  5823.                 pData->engine->setLastError(msg);

  5824.                 break;

  5825.             }

  5826.         }

  5827. 

  5828.         if (! canContinue)

  5829.         {

  5830.             // error already set

  5831.             return false;

  5832.         }

  5833. 

  5834.         if (fNeedsFixedBuffers && ! pData->engine->usesConstantBufferSize())

  5835.         {

  5836.             pData->engine->setLastError("Cannot use this plugin under the current engine.\n"

  5837.                                         "The plugin requires a fixed block size which is not possible right now.");

  5838.             return false;

  5839.         }

  5840. 

  5841.         // ---------------------------------------------------------------

  5842.         // set icon

  5843. 

  5844.         if (std::strncmp(fDescriptor->URI, "http://distrho.sf.net/", 22) == 0)

  5845.             pData->iconName = carla_strdup_safe("distrho");

  5846. 

  5847.         // ---------------------------------------------------------------

  5848.         // set info

  5849. 

  5850.         if (name != nullptr && name[0] != '\0')

  5851.             pData->name = pData->engine->getUniquePluginName(name);

  5852.         else

  5853.             pData->name = pData->engine->getUniquePluginName(fRdfDescriptor->Name);

  5854. 

  5855.         // ---------------------------------------------------------------

  5856.         // register client

  5857. 

  5858.         pData->client = pData->engine->addClient(plugin);

  5859. 

  5860.         if (pData->client == nullptr || ! pData->client->isOk())

  5861.         {

  5862.             pData->engine->setLastError("Failed to register plugin client");

  5863.             return false;

  5864.         }

  5865. 

  5866.         // ---------------------------------------------------------------

  5867.         // initialize options

  5868. 

  5869.         const int bufferSize = static_cast<int>(pData->engine->getBufferSize());

  5870. 

  5871.         fLv2Options.minBufferSize     = fNeedsFixedBuffers ? bufferSize : 1;

  5872.         fLv2Options.maxBufferSize     = bufferSize;

  5873.         fLv2Options.nominalBufferSize = bufferSize;

  5874.         fLv2Options.sampleRate        = static_cast<float>(pData->engine->getSampleRate());

  5875.         fLv2Options.transientWinId    = static_cast<int64_t>(opts.frontendWinId);

  5876. 

  5877.         uint32_t eventBufferSize = MAX_DEFAULT_BUFFER_SIZE;

  5878. 

  5879.         for (uint32_t j=0; j < fRdfDescriptor->PortCount; ++j)

  5880.         {

  5881.             const LV2_Property portTypes(fRdfDescriptor->Ports[j].Types);

  5882. 

  5883.             if (LV2_IS_PORT_ATOM_SEQUENCE(portTypes) || LV2_IS_PORT_EVENT(portTypes) || LV2_IS_PORT_MIDI_LL(portTypes))

  5884.             {

  5885.                 if (fRdfDescriptor->Ports[j].MinimumSize > eventBufferSize)

  5886.                     eventBufferSize = fRdfDescriptor->Ports[j].MinimumSize;

  5887.             }

  5888.         }

  5889. 

  5890.         fLv2Options.sequenceSize = static_cast<int>(eventBufferSize);

  5891. 

  5892.         fLv2Options.bgColor = opts.bgColor;

  5893.         fLv2Options.fgColor = opts.fgColor;

  5894.         fLv2Options.uiScale = opts.uiScale;

  5895. 

  5896.         // ---------------------------------------------------------------

  5897.         // initialize features (part 1)

  5898. 

  5899.         LV2_Event_Feature* const eventFt = new LV2_Event_Feature;

  5900.         eventFt->callback_data           = this;

  5901.         eventFt->lv2_event_ref           = carla_lv2_event_ref;

  5902.         eventFt->lv2_event_unref         = carla_lv2_event_unref;

  5903. 

  5904.         LV2_Log_Log* const logFt = new LV2_Log_Log;

  5905.         logFt->handle            = this;

  5906.         logFt->printf            = carla_lv2_log_printf;

  5907.         logFt->vprintf           = carla_lv2_log_vprintf;

  5908. 

  5909.         LV2_State_Free_Path* const stateFreePathFt = new LV2_State_Free_Path;

  5910.         stateFreePathFt->handle                    = this;

  5911.         stateFreePathFt->free_path                 = carla_lv2_state_free_path;

  5912. 

  5913.         LV2_State_Make_Path* const stateMakePathFt = new LV2_State_Make_Path;

  5914.         stateMakePathFt->handle                    = this;

  5915.         stateMakePathFt->path                      = carla_lv2_state_make_path;

  5916. 

  5917.         LV2_State_Map_Path* const stateMapPathFt = new LV2_State_Map_Path;

  5918.         stateMapPathFt->handle                   = this;

  5919.         stateMapPathFt->abstract_path            = carla_lv2_state_map_abstract_path;

  5920.         stateMapPathFt->absolute_path            = carla_lv2_state_map_absolute_path;

  5921. 

  5922.         LV2_Programs_Host* const programsFt = new LV2_Programs_Host;

  5923.         programsFt->handle                  = this;

  5924.         programsFt->program_changed         = carla_lv2_program_changed;

  5925. 

  5926.         LV2_Resize_Port_Resize* const rsPortFt = new LV2_Resize_Port_Resize;

  5927.         rsPortFt->data                         = this;

  5928.         rsPortFt->resize                       = carla_lv2_resize_port;

  5929. 

  5930.         LV2_RtMemPool_Pool* const rtMemPoolFt = new LV2_RtMemPool_Pool;

  5931.         lv2_rtmempool_init(rtMemPoolFt);

  5932. 

  5933.         LV2_RtMemPool_Pool_Deprecated* const rtMemPoolOldFt = new LV2_RtMemPool_Pool_Deprecated;

  5934.         lv2_rtmempool_init_deprecated(rtMemPoolOldFt);

  5935. 

  5936.         LV2_URI_Map_Feature* const uriMapFt = new LV2_URI_Map_Feature;

  5937.         uriMapFt->callback_data             = this;

  5938.         uriMapFt->uri_to_id                 = carla_lv2_uri_to_id;

  5939. 

  5940.         LV2_URID_Map* const uridMapFt = new LV2_URID_Map;

  5941.         uridMapFt->handle             = this;

  5942.         uridMapFt->map                = carla_lv2_urid_map;

  5943. 

  5944.         LV2_URID_Unmap* const uridUnmapFt = new LV2_URID_Unmap;

  5945.         uridUnmapFt->handle               = this;

  5946.         uridUnmapFt->unmap                = carla_lv2_urid_unmap;

  5947. 

  5948.         LV2_Worker_Schedule* const workerFt = new LV2_Worker_Schedule;

  5949.         workerFt->handle                    = this;

  5950.         workerFt->schedule_work             = carla_lv2_worker_schedule;

  5951. 

  5952.         LV2_Inline_Display* const inlineDisplay = new LV2_Inline_Display;

  5953.         inlineDisplay->handle                   = this;

  5954.         inlineDisplay->queue_draw               = carla_lv2_inline_display_queue_draw;

  5955. 

  5956.         LV2_Midnam* const midnam = new LV2_Midnam;

  5957.         midnam->handle = this;

  5958.         midnam->update = carla_lv2_midnam_update;

  5959. 

  5960.         // ---------------------------------------------------------------

  5961.         // initialize features (part 2)

  5962. 

  5963.         for (uint32_t j=0; j < kFeatureCountPlugin; ++j)

  5964.             fFeatures[j] = new LV2_Feature;

  5965. 

  5966.         fFeatures[kFeatureIdBufSizeBounded]->URI   = LV2_BUF_SIZE__boundedBlockLength;

  5967.         fFeatures[kFeatureIdBufSizeBounded]->data  = nullptr;

  5968. 

  5969.         fFeatures[kFeatureIdBufSizeFixed]->URI     = fNeedsFixedBuffers

  5970.                                                    ? LV2_BUF_SIZE__fixedBlockLength

  5971.                                                    : LV2_BUF_SIZE__boundedBlockLength;

  5972.         fFeatures[kFeatureIdBufSizeFixed]->data    = nullptr;

  5973. 

  5974.         fFeatures[kFeatureIdBufSizePowerOf2]->URI  = LV2_BUF_SIZE__powerOf2BlockLength;

  5975.         fFeatures[kFeatureIdBufSizePowerOf2]->data = nullptr;

  5976. 

  5977.         fFeatures[kFeatureIdEvent]->URI          = LV2_EVENT_URI;

  5978.         fFeatures[kFeatureIdEvent]->data         = eventFt;

  5979. 

  5980.         fFeatures[kFeatureIdHardRtCapable]->URI  = LV2_CORE__hardRTCapable;

  5981.         fFeatures[kFeatureIdHardRtCapable]->data = nullptr;

  5982. 

  5983.         fFeatures[kFeatureIdInPlaceBroken]->URI  = LV2_CORE__inPlaceBroken;

  5984.         fFeatures[kFeatureIdInPlaceBroken]->data = nullptr;

  5985. 

  5986.         fFeatures[kFeatureIdIsLive]->URI         = LV2_CORE__isLive;

  5987.         fFeatures[kFeatureIdIsLive]->data        = nullptr;

  5988. 

  5989.         fFeatures[kFeatureIdLogs]->URI       = LV2_LOG__log;

  5990.         fFeatures[kFeatureIdLogs]->data      = logFt;

  5991. 

  5992.         fFeatures[kFeatureIdOptions]->URI    = LV2_OPTIONS__options;

  5993.         fFeatures[kFeatureIdOptions]->data   = fLv2Options.opts;

  5994. 

  5995.         fFeatures[kFeatureIdPrograms]->URI   = LV2_PROGRAMS__Host;

  5996.         fFeatures[kFeatureIdPrograms]->data  = programsFt;

  5997. 

  5998.         fFeatures[kFeatureIdResizePort]->URI   = LV2_RESIZE_PORT__resize;

  5999.         fFeatures[kFeatureIdResizePort]->data  = rsPortFt;

  6000. 

  6001.         fFeatures[kFeatureIdRtMemPool]->URI  = LV2_RTSAFE_MEMORY_POOL__Pool;

  6002.         fFeatures[kFeatureIdRtMemPool]->data = rtMemPoolFt;

  6003. 

  6004.         fFeatures[kFeatureIdRtMemPoolOld]->URI  = LV2_RTSAFE_MEMORY_POOL_DEPRECATED_URI;

  6005.         fFeatures[kFeatureIdRtMemPoolOld]->data = rtMemPoolOldFt;

  6006. 

  6007.         fFeatures[kFeatureIdStateFreePath]->URI  = LV2_STATE__freePath;

  6008.         fFeatures[kFeatureIdStateFreePath]->data = stateFreePathFt;

  6009. 

  6010.         fFeatures[kFeatureIdStateMakePath]->URI  = LV2_STATE__makePath;

  6011.         fFeatures[kFeatureIdStateMakePath]->data = stateMakePathFt;

  6012. 

  6013.         fFeatures[kFeatureIdStateMapPath]->URI   = LV2_STATE__mapPath;

  6014.         fFeatures[kFeatureIdStateMapPath]->data  = stateMapPathFt;

  6015. 

  6016.         fFeatures[kFeatureIdStrictBounds]->URI   = LV2_PORT_PROPS__supportsStrictBounds;

  6017.         fFeatures[kFeatureIdStrictBounds]->data  = nullptr;

  6018. 

  6019.         fFeatures[kFeatureIdUriMap]->URI     = LV2_URI_MAP_URI;

  6020.         fFeatures[kFeatureIdUriMap]->data    = uriMapFt;

  6021. 

  6022.         fFeatures[kFeatureIdUridMap]->URI    = LV2_URID__map;

  6023.         fFeatures[kFeatureIdUridMap]->data   = uridMapFt;

  6024. 

  6025.         fFeatures[kFeatureIdUridUnmap]->URI  = LV2_URID__unmap;

  6026.         fFeatures[kFeatureIdUridUnmap]->data = uridUnmapFt;

  6027. 

  6028.         fFeatures[kFeatureIdWorker]->URI     = LV2_WORKER__schedule;

  6029.         fFeatures[kFeatureIdWorker]->data    = workerFt;

  6030. 

  6031.         fFeatures[kFeatureIdInlineDisplay]->URI  = LV2_INLINEDISPLAY__queue_draw;

  6032.         fFeatures[kFeatureIdInlineDisplay]->data = inlineDisplay;

  6033. 

  6034.         fFeatures[kFeatureIdMidnam]->URI  = LV2_MIDNAM__update;

  6035.         fFeatures[kFeatureIdMidnam]->data = midnam;

  6036. 

  6037.         // ---------------------------------------------------------------

  6038.         // initialize plugin

  6039. 

  6040.         try {

  6041.             fHandle = fDescriptor->instantiate(fDescriptor, pData->engine->getSampleRate(), fRdfDescriptor->Bundle, fFeatures);

  6042.         } catch(...) {}

  6043. 

  6044.         if (fHandle == nullptr)

  6045.         {

  6046.             pData->engine->setLastError("Plugin failed to initialize");

  6047.             return false;

  6048.         }

  6049. 

  6050.         recheckExtensions();

  6051. 

  6052.         // ---------------------------------------------------------------

  6053.         // set options

  6054. 

  6055.         pData->options = 0x0;

  6056. 

  6057.         if (fLatencyIndex >= 0 || getMidiOutCount() != 0 || fNeedsFixedBuffers)

  6058.             pData->options |= PLUGIN_OPTION_FIXED_BUFFERS;

  6059.         else if (options & PLUGIN_OPTION_FIXED_BUFFERS)

  6060.             pData->options |= PLUGIN_OPTION_FIXED_BUFFERS;

  6061. 

  6062.         if (opts.forceStereo)

  6063.             pData->options |= PLUGIN_OPTION_FORCE_STEREO;

  6064.         else if (options & PLUGIN_OPTION_FORCE_STEREO)

  6065.             pData->options |= PLUGIN_OPTION_FORCE_STEREO;

  6066. 

  6067.         if (getMidiInCount() != 0)

  6068.         {

  6069.             if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_CONTROL_CHANGES))

  6070.                 pData->options |= PLUGIN_OPTION_SEND_CONTROL_CHANGES;

  6071.             if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_CHANNEL_PRESSURE))

  6072.                 pData->options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  6073.             if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH))

  6074.                 pData->options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

  6075.             if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_PITCHBEND))

  6076.                 pData->options |= PLUGIN_OPTION_SEND_PITCHBEND;

  6077.             if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_ALL_SOUND_OFF))

  6078.                 pData->options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  6079.             if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_PROGRAM_CHANGES))

  6080.                 pData->options |= PLUGIN_OPTION_SEND_PROGRAM_CHANGES;

  6081.         }

  6082. 

  6083.         if (fExt.programs != nullptr && (pData->options & PLUGIN_OPTION_SEND_PROGRAM_CHANGES) == 0)

  6084.         {

  6085.             if (isPluginOptionEnabled(options, PLUGIN_OPTION_MAP_PROGRAM_CHANGES))

  6086.                 pData->options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  6087.         }

  6088. 

  6089.         // ---------------------------------------------------------------

  6090.         // gui stuff

  6091. 

  6092.         if (fRdfDescriptor->UICount != 0)

  6093.             initUi();

  6094. 

  6095.         return true;

  6096.     }

  6097. 

  6098.     // -------------------------------------------------------------------

  6099. 

  6100.     void initUi()

  6101.     {

  6102.         // ---------------------------------------------------------------

  6103.         // find the most appropriate ui

  6104. 

  6105.         int eQt4, eQt5, eGtk2, eGtk3, eCocoa, eWindows, eX11, eMod, iCocoa, iWindows, iX11, iExt, iFinal;

  6106.         eQt4 = eQt5 = eGtk2 = eGtk3 = eCocoa = eWindows = eX11 = eMod = iCocoa = iWindows = iX11 = iExt = iFinal = -1;

  6107. 

  6108. #if defined(LV2_UIS_ONLY_BRIDGES)

  6109.         const bool preferUiBridges = true;

  6110. #elif defined(BUILD_BRIDGE)

  6111.         const bool preferUiBridges = false;

  6112. #else

  6113.         const bool preferUiBridges = pData->engine->getOptions().preferUiBridges;

  6114. #endif

  6115.         bool hasShowInterface = false;

  6116. 

  6117.         for (uint32_t i=0; i < fRdfDescriptor->UICount; ++i)

  6118.         {

  6119.             CARLA_SAFE_ASSERT_CONTINUE(fRdfDescriptor->UIs[i].URI != nullptr);

  6120. 

  6121.             const int ii(static_cast<int>(i));

  6122. 

  6123.             switch (fRdfDescriptor->UIs[i].Type)

  6124.             {

  6125.             case LV2_UI_QT4:

  6126.                 if (isUiBridgeable(i))

  6127.                     eQt4 = ii;

  6128.                 break;

  6129.             case LV2_UI_QT5:

  6130.                 if (isUiBridgeable(i))

  6131.                     eQt5 = ii;

  6132.                 break;

  6133.             case LV2_UI_GTK2:

  6134.                 if (isUiBridgeable(i))

  6135.                     eGtk2 = ii;

  6136.                 break;

  6137.             case LV2_UI_GTK3:

  6138.                 if (isUiBridgeable(i))

  6139.                     eGtk3 = ii;

  6140.                 break;

  6141. #ifdef CARLA_OS_MAC

  6142.             case LV2_UI_COCOA:

  6143.                 if (isUiBridgeable(i) && preferUiBridges)

  6144.                     eCocoa = ii;

  6145.                 iCocoa = ii;

  6146.                 break;

  6147. #endif

  6148. #ifdef CARLA_OS_WIN

  6149.             case LV2_UI_WINDOWS:

  6150.                 if (isUiBridgeable(i) && preferUiBridges)

  6151.                     eWindows = ii;

  6152.                 iWindows = ii;

  6153.                 break;

  6154. #endif

  6155.             case LV2_UI_X11:

  6156.                 if (isUiBridgeable(i) && preferUiBridges)

  6157.                     eX11 = ii;

  6158.                 iX11 = ii;

  6159.                 break;

  6160.             case LV2_UI_EXTERNAL:

  6161.             case LV2_UI_OLD_EXTERNAL:

  6162.                 iExt = ii;

  6163.                 break;

  6164.             case LV2_UI_MOD:

  6165.                 eMod = ii;

  6166.                 break;

  6167.             default:

  6168.                 break;

  6169.             }

  6170.         }

  6171. 

  6172.         /**/ if (eQt4 >= 0)

  6173.             iFinal = eQt4;

  6174.         else if (eQt5 >= 0)

  6175.             iFinal = eQt5;

  6176.         else if (eGtk2 >= 0)

  6177.             iFinal = eGtk2;

  6178.         else if (eGtk3 >= 0)

  6179.             iFinal = eGtk3;

  6180. #ifdef CARLA_OS_MAC

  6181.         else if (eCocoa >= 0)

  6182.             iFinal = eCocoa;

  6183. #endif

  6184. #ifdef CARLA_OS_WIN

  6185.         else if (eWindows >= 0)

  6186.             iFinal = eWindows;

  6187. #endif

  6188. #ifdef HAVE_X11

  6189.         else if (eX11 >= 0)

  6190.             iFinal = eX11;

  6191. #endif

  6192. #ifndef LV2_UIS_ONLY_BRIDGES

  6193. # ifdef CARLA_OS_MAC

  6194.         else if (iCocoa >= 0)

  6195.             iFinal = iCocoa;

  6196. # endif

  6197. # ifdef CARLA_OS_WIN

  6198.         else if (iWindows >= 0)

  6199.             iFinal = iWindows;

  6200. # endif

  6201. # ifdef HAVE_X11

  6202.         else if (iX11 >= 0)

  6203.             iFinal = iX11;

  6204. # endif

  6205. #endif

  6206.         else if (iExt >= 0)

  6207.             iFinal = iExt;

  6208. 

  6209. #ifndef BUILD_BRIDGE

  6210.         if (iFinal < 0)

  6211. #endif

  6212.         {

  6213.             // no suitable UI found, see if there's one which supports ui:showInterface

  6214.             for (uint32_t i=0; i < fRdfDescriptor->UICount && ! hasShowInterface; ++i)

  6215.             {

  6216.                 LV2_RDF_UI* const ui(&fRdfDescriptor->UIs[i]);

  6217. 

  6218.                 for (uint32_t j=0; j < ui->ExtensionCount; ++j)

  6219.                 {

  6220.                     CARLA_SAFE_ASSERT_CONTINUE(ui->Extensions[j] != nullptr);

  6221. 

  6222.                     if (std::strcmp(ui->Extensions[j], LV2_UI__showInterface) != 0)

  6223.                         continue;

  6224. 

  6225.                     iFinal = static_cast<int>(i);

  6226.                     hasShowInterface = true;

  6227.                     break;

  6228.                 }

  6229.             }

  6230. 

  6231.             if (iFinal < 0)

  6232.             {

  6233.                 if (eMod < 0)

  6234.                 {

  6235.                     carla_stderr("Failed to find an appropriate LV2 UI for this plugin");

  6236.                     return;

  6237.                 }

  6238. 

  6239.                 // use MODGUI as last resort

  6240.                 iFinal = eMod;

  6241.             }

  6242.         }

  6243. 

  6244.         fUI.rdfDescriptor = &fRdfDescriptor->UIs[iFinal];

  6245. 

  6246.         // ---------------------------------------------------------------

  6247.         // check supported ui features

  6248. 

  6249.         bool canContinue = true;

  6250.         bool canDelete = true;

  6251. 

  6252.         for (uint32_t i=0; i < fUI.rdfDescriptor->FeatureCount; ++i)

  6253.         {

  6254.             const char* const uri(fUI.rdfDescriptor->Features[i].URI);

  6255.             CARLA_SAFE_ASSERT_CONTINUE(uri != nullptr && uri[0] != '\0');

  6256. 

  6257.             if (! is_lv2_ui_feature_supported(uri))

  6258.             {

  6259.                 if (fUI.rdfDescriptor->Features[i].Required)

  6260.                 {

  6261.                     carla_stderr("Plugin UI requires a feature that is not supported:\n%s", uri);

  6262.                     canContinue = false;

  6263.                     break;

  6264.                 }

  6265. 

  6266.                 carla_stderr("Plugin UI wants a feature that is not supported (ignored):\n%s", uri);

  6267.             }

  6268. 

  6269.             if (std::strcmp(uri, LV2_UI__makeResident) == 0 || std::strcmp(uri, LV2_UI__makeSONameResident) == 0)

  6270.                 canDelete = false;

  6271.             else if (std::strcmp(uri, LV2_UI__requestValue) == 0)

  6272.                 pData->hints |= PLUGIN_NEEDS_UI_MAIN_THREAD;

  6273.         }

  6274. 

  6275.         if (! canContinue)

  6276.         {

  6277.             fUI.rdfDescriptor = nullptr;

  6278.             return;

  6279.         }

  6280. 

  6281.         // ---------------------------------------------------------------

  6282.         // initialize ui according to type

  6283. 

  6284.         const LV2_Property uiType(fUI.rdfDescriptor->Type);

  6285. 

  6286.         if (

  6287.             (iFinal == eQt4     ||

  6288.              iFinal == eQt5     ||

  6289.              iFinal == eGtk2    ||

  6290.              iFinal == eGtk3    ||

  6291.              iFinal == eCocoa   ||

  6292.              iFinal == eWindows ||

  6293.              iFinal == eX11     ||

  6294.              iFinal == eMod)

  6295. #ifdef BUILD_BRIDGE

  6296.             && ! hasShowInterface

  6297. #endif

  6298.             )

  6299.         {

  6300.             // -----------------------------------------------------------

  6301.             // initialize ui-bridge

  6302. 

  6303.             if (const char* const bridgeBinary = getUiBridgeBinary(uiType))

  6304.             {

  6305.                 carla_stdout("Will use UI-Bridge for '%s', binary: \"%s\"", pData->name, bridgeBinary);

  6306. 

  6307.                 CarlaString uiTitle;

  6308. 

  6309.                 if (pData->uiTitle.isNotEmpty())

  6310.                 {

  6311.                     uiTitle = pData->uiTitle;

  6312.                 }

  6313.                 else

  6314.                 {

  6315.                     uiTitle = pData->name;

  6316.                     uiTitle += " (GUI)";

  6317.                 }

  6318. 

  6319.                 fLv2Options.windowTitle = uiTitle.releaseBufferPointer();

  6320. 

  6321.                 fUI.type = UI::TYPE_BRIDGE;

  6322.                 fPipeServer.setData(bridgeBinary, fRdfDescriptor->URI, fUI.rdfDescriptor->URI);

  6323. 

  6324.                 delete[] bridgeBinary;

  6325.                 return;

  6326.             }

  6327. 

  6328.             if (iFinal == eQt4 || iFinal == eQt5 || iFinal == eGtk2 || iFinal == eGtk3 || iFinal == eMod)

  6329.             {

  6330.                 carla_stderr2("Failed to find UI bridge binary for '%s', cannot use UI", pData->name);

  6331.                 fUI.rdfDescriptor = nullptr;

  6332.                 return;

  6333.             }

  6334.         }

  6335. 

  6336. #ifdef LV2_UIS_ONLY_BRIDGES

  6337.         carla_stderr2("Failed to get an UI working, canBridge:%s", bool2str(isUiBridgeable(static_cast<uint32_t>(iFinal))));

  6338.         fUI.rdfDescriptor = nullptr;

  6339.         return;

  6340. #endif

  6341. 

  6342.         // ---------------------------------------------------------------

  6343.         // open UI DLL

  6344. 

  6345.         if (! pData->uiLibOpen(fUI.rdfDescriptor->Binary, canDelete))

  6346.         {

  6347.             carla_stderr2("Could not load UI library, error was:\n%s", pData->libError(fUI.rdfDescriptor->Binary));

  6348.             fUI.rdfDescriptor = nullptr;

  6349.             return;

  6350.         }

  6351. 

  6352.         // ---------------------------------------------------------------

  6353.         // get UI DLL main entry

  6354. 

  6355.         LV2UI_DescriptorFunction uiDescFn = pData->uiLibSymbol<LV2UI_DescriptorFunction>("lv2ui_descriptor");

  6356. 

  6357.         if (uiDescFn == nullptr)

  6358.         {

  6359.             carla_stderr2("Could not find the LV2UI Descriptor in the UI library");

  6360.             pData->uiLibClose();

  6361.             fUI.rdfDescriptor = nullptr;

  6362.             return;

  6363.         }

  6364. 

  6365.         // ---------------------------------------------------------------

  6366.         // get UI descriptor that matches UI URI

  6367. 

  6368.         uint32_t i = 0;

  6369.         while ((fUI.descriptor = uiDescFn(i++)))

  6370.         {

  6371.             if (std::strcmp(fUI.descriptor->URI, fUI.rdfDescriptor->URI) == 0)

  6372.                 break;

  6373.         }

  6374. 

  6375.         if (fUI.descriptor == nullptr)

  6376.         {

  6377.             carla_stderr2("Could not find the requested GUI in the plugin UI library");

  6378.             pData->uiLibClose();

  6379.             fUI.rdfDescriptor = nullptr;

  6380.             return;

  6381.         }

  6382. 

  6383.         // ---------------------------------------------------------------

  6384.         // check if ui is usable

  6385. 

  6386.         switch (uiType)

  6387.         {

  6388.         case LV2_UI_NONE:

  6389.             carla_stdout("Will use LV2 Show Interface for '%s'", pData->name);

  6390.             fUI.type = UI::TYPE_EMBED;

  6391.             break;

  6392.         case LV2_UI_QT4:

  6393.             carla_stdout("Will use LV2 Qt4 UI for '%s', NOT!", pData->name);

  6394.             fUI.type = UI::TYPE_EMBED;

  6395.             break;

  6396.         case LV2_UI_QT5:

  6397.             carla_stdout("Will use LV2 Qt5 UI for '%s', NOT!", pData->name);

  6398.             fUI.type = UI::TYPE_EMBED;

  6399.             break;

  6400.         case LV2_UI_GTK2:

  6401.             carla_stdout("Will use LV2 Gtk2 UI for '%s', NOT!", pData->name);

  6402.             fUI.type = UI::TYPE_EMBED;

  6403.             break;

  6404.         case LV2_UI_GTK3:

  6405.             carla_stdout("Will use LV2 Gtk3 UI for '%s', NOT!", pData->name);

  6406.             fUI.type = UI::TYPE_EMBED;

  6407.             break;

  6408. #ifdef CARLA_OS_MAC

  6409.         case LV2_UI_COCOA:

  6410.             carla_stdout("Will use LV2 Cocoa UI for '%s'", pData->name);

  6411.             fUI.type = UI::TYPE_EMBED;

  6412.             break;

  6413. #endif

  6414. #ifdef CARLA_OS_WIN

  6415.         case LV2_UI_WINDOWS:

  6416.             carla_stdout("Will use LV2 Windows UI for '%s'", pData->name);

  6417.             fUI.type = UI::TYPE_EMBED;

  6418.             break;

  6419. #endif

  6420.         case LV2_UI_X11:

  6421. #ifdef HAVE_X11

  6422.             carla_stdout("Will use LV2 X11 UI for '%s'", pData->name);

  6423. #else

  6424.             carla_stdout("Will use LV2 X11 UI for '%s', NOT!", pData->name);

  6425. #endif

  6426.             fUI.type = UI::TYPE_EMBED;

  6427.             break;

  6428.         case LV2_UI_EXTERNAL:

  6429.         case LV2_UI_OLD_EXTERNAL:

  6430.             carla_stdout("Will use LV2 External UI for '%s'", pData->name);

  6431.             fUI.type = UI::TYPE_EXTERNAL;

  6432.             break;

  6433.         }

  6434. 

  6435.         if (fUI.type == UI::TYPE_NULL)

  6436.         {

  6437.             pData->uiLibClose();

  6438.             fUI.descriptor = nullptr;

  6439.             fUI.rdfDescriptor = nullptr;

  6440.             return;

  6441.         }

  6442. 

  6443.         // ---------------------------------------------------------------

  6444.         // initialize ui data

  6445. 

  6446.         {

  6447.             CarlaString uiTitle;

  6448. 

  6449.             if (pData->uiTitle.isNotEmpty())

  6450.             {

  6451.                 uiTitle = pData->uiTitle;

  6452.             }

  6453.             else

  6454.             {

  6455.                 uiTitle = pData->name;

  6456.                 uiTitle += " (GUI)";

  6457.             }

  6458. 

  6459.             fLv2Options.windowTitle = uiTitle.releaseBufferPointer();

  6460.         }

  6461. 

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

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

  6464. 

  6465.         // ---------------------------------------------------------------

  6466.         // initialize ui features (part 1)

  6467. 

  6468.         LV2_Extension_Data_Feature* const uiDataFt = new LV2_Extension_Data_Feature;

  6469.         uiDataFt->data_access                      = fDescriptor->extension_data;

  6470. 

  6471.         LV2UI_Port_Map* const uiPortMapFt = new LV2UI_Port_Map;

  6472.         uiPortMapFt->handle               = this;

  6473.         uiPortMapFt->port_index           = carla_lv2_ui_port_map;

  6474. 

  6475.         LV2UI_Request_Value* const uiRequestValueFt = new LV2UI_Request_Value;

  6476.         uiRequestValueFt->handle                    = this;

  6477.         uiRequestValueFt->request                   = carla_lv2_ui_request_value;

  6478. 

  6479.         LV2UI_Resize* const uiResizeFt = new LV2UI_Resize;

  6480.         uiResizeFt->handle             = this;

  6481.         uiResizeFt->ui_resize          = carla_lv2_ui_resize;

  6482. 

  6483.         LV2UI_Touch* const uiTouchFt = new LV2UI_Touch;

  6484.         uiTouchFt->handle            = this;

  6485.         uiTouchFt->touch             = carla_lv2_ui_touch;

  6486. 

  6487.         LV2_External_UI_Host* const uiExternalHostFt = new LV2_External_UI_Host;

  6488.         uiExternalHostFt->ui_closed                  = carla_lv2_external_ui_closed;

  6489.         uiExternalHostFt->plugin_human_id            = fLv2Options.windowTitle;

  6490. 

  6491.         // ---------------------------------------------------------------

  6492.         // initialize ui features (part 2)

  6493. 

  6494.         for (uint32_t j=kFeatureCountPlugin; j < kFeatureCountAll; ++j)

  6495.             fFeatures[j] = new LV2_Feature;

  6496. 

  6497.         fFeatures[kFeatureIdUiDataAccess]->URI      = LV2_DATA_ACCESS_URI;

  6498.         fFeatures[kFeatureIdUiDataAccess]->data     = uiDataFt;

  6499. 

  6500.         fFeatures[kFeatureIdUiInstanceAccess]->URI  = LV2_INSTANCE_ACCESS_URI;

  6501.         fFeatures[kFeatureIdUiInstanceAccess]->data = fHandle;

  6502. 

  6503.         fFeatures[kFeatureIdUiIdleInterface]->URI  = LV2_UI__idleInterface;

  6504.         fFeatures[kFeatureIdUiIdleInterface]->data = nullptr;

  6505. 

  6506.         fFeatures[kFeatureIdUiFixedSize]->URI      = LV2_UI__fixedSize;

  6507.         fFeatures[kFeatureIdUiFixedSize]->data     = nullptr;

  6508. 

  6509.         fFeatures[kFeatureIdUiMakeResident]->URI   = LV2_UI__makeResident;

  6510.         fFeatures[kFeatureIdUiMakeResident]->data  = nullptr;

  6511. 

  6512.         fFeatures[kFeatureIdUiMakeResident2]->URI  = LV2_UI__makeSONameResident;

  6513.         fFeatures[kFeatureIdUiMakeResident2]->data = nullptr;

  6514. 

  6515.         fFeatures[kFeatureIdUiNoUserResize]->URI   = LV2_UI__noUserResize;

  6516.         fFeatures[kFeatureIdUiNoUserResize]->data  = nullptr;

  6517. 

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

  6519.         fFeatures[kFeatureIdUiParent]->data        = nullptr;

  6520. 

  6521.         fFeatures[kFeatureIdUiPortMap]->URI        = LV2_UI__portMap;

  6522.         fFeatures[kFeatureIdUiPortMap]->data       = uiPortMapFt;

  6523. 

  6524.         fFeatures[kFeatureIdUiPortSubscribe]->URI  = LV2_UI__portSubscribe;

  6525.         fFeatures[kFeatureIdUiPortSubscribe]->data = nullptr;

  6526. 

  6527.         fFeatures[kFeatureIdUiRequestValue]->URI  = LV2_UI__requestValue;

  6528.         fFeatures[kFeatureIdUiRequestValue]->data = uiRequestValueFt;

  6529. 

  6530.         fFeatures[kFeatureIdUiResize]->URI       = LV2_UI__resize;

  6531.         fFeatures[kFeatureIdUiResize]->data      = uiResizeFt;

  6532. 

  6533.         fFeatures[kFeatureIdUiTouch]->URI        = LV2_UI__touch;

  6534.         fFeatures[kFeatureIdUiTouch]->data       = uiTouchFt;

  6535. 

  6536.         fFeatures[kFeatureIdExternalUi]->URI     = LV2_EXTERNAL_UI__Host;

  6537.         fFeatures[kFeatureIdExternalUi]->data    = uiExternalHostFt;

  6538. 

  6539.         fFeatures[kFeatureIdExternalUiOld]->URI  = LV2_EXTERNAL_UI_DEPRECATED_URI;

  6540.         fFeatures[kFeatureIdExternalUiOld]->data = uiExternalHostFt;

  6541. 

  6542.         // ---------------------------------------------------------------

  6543.         // initialize ui extensions

  6544. 

  6545.         if (fUI.descriptor->extension_data == nullptr)

  6546.             return;

  6547. 

  6548.         fExt.uiidle     = (const LV2UI_Idle_Interface*)fUI.descriptor->extension_data(LV2_UI__idleInterface);

  6549.         fExt.uishow     = (const LV2UI_Show_Interface*)fUI.descriptor->extension_data(LV2_UI__showInterface);

  6550.         fExt.uiresize   = (const LV2UI_Resize*)fUI.descriptor->extension_data(LV2_UI__resize);

  6551.         fExt.uiprograms = (const LV2_Programs_UI_Interface*)fUI.descriptor->extension_data(LV2_PROGRAMS__UIInterface);

  6552. 

  6553.         // check if invalid

  6554.         if (fExt.uiidle != nullptr && fExt.uiidle->idle == nullptr)

  6555.             fExt.uiidle = nullptr;

  6556. 

  6557.         if (fExt.uishow != nullptr && (fExt.uishow->show == nullptr || fExt.uishow->hide == nullptr))

  6558.             fExt.uishow = nullptr;

  6559. 

  6560.         if (fExt.uiresize != nullptr && fExt.uiresize->ui_resize == nullptr)

  6561.             fExt.uiresize = nullptr;

  6562. 

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

  6564.             fExt.uiprograms = nullptr;

  6565. 

  6566.         // don't use uiidle if external

  6567.         if (fUI.type == UI::TYPE_EXTERNAL)

  6568.             fExt.uiidle = nullptr;

  6569.     }

  6570. 

  6571.     // -------------------------------------------------------------------

  6572. 

  6573.     void handleTransferAtom(const uint32_t portIndex, const LV2_Atom* const atom)

  6574.     {

  6575.         CARLA_SAFE_ASSERT_RETURN(atom != nullptr,);

  6576.         carla_debug("CarlaPluginLV2::handleTransferAtom(%i, %p)", portIndex, atom);

  6577. 

  6578.         fAtomBufferEvIn.put(atom, portIndex);

  6579.     }

  6580. 

  6581.     void handleUridMap(const LV2_URID urid, const char* const uri)

  6582.     {

  6583.         CARLA_SAFE_ASSERT_RETURN(urid != kUridNull,);

  6584.         CARLA_SAFE_ASSERT_RETURN(uri != nullptr && uri[0] != '\0',);

  6585.         carla_debug("CarlaPluginLV2::handleUridMap(%i v " P_SIZE ", \"%s\")", urid, fCustomURIDs.size()-1, uri);

  6586. 

  6587.         const std::size_t uriCount(fCustomURIDs.size());

  6588. 

  6589.         if (urid < uriCount)

  6590.         {

  6591.             const char* const ourURI(carla_lv2_urid_unmap(this, urid));

  6592.             CARLA_SAFE_ASSERT_RETURN(ourURI != nullptr && ourURI != kUnmapFallback,);

  6593. 

  6594.             if (std::strcmp(ourURI, uri) != 0)

  6595.             {

  6596.                 carla_stderr2("PLUGIN :: wrong URI '%s' vs '%s'", ourURI,  uri);

  6597.             }

  6598.         }

  6599.         else

  6600.         {

  6601.             CARLA_SAFE_ASSERT_RETURN(urid == uriCount,);

  6602.             fCustomURIDs.push_back(uri);

  6603.         }

  6604.     }

  6605. 

  6606.     // -------------------------------------------------------------------

  6607. 

  6608.     void writeAtomPath(const char* const path, const LV2_URID urid)

  6609.     {

  6610.         uint8_t atomBuf[4096];

  6611.         lv2_atom_forge_set_buffer(&fAtomForge, atomBuf, sizeof(atomBuf));

  6612. 

  6613.         LV2_Atom_Forge_Frame forgeFrame;

  6614.         lv2_atom_forge_object(&fAtomForge, &forgeFrame, kUridNull, kUridPatchSet);

  6615. 

  6616.         lv2_atom_forge_key(&fAtomForge, kUridPatchPoperty);

  6617.         lv2_atom_forge_urid(&fAtomForge, urid);

  6618. 

  6619.         lv2_atom_forge_key(&fAtomForge, kUridPatchValue);

  6620.         lv2_atom_forge_path(&fAtomForge, path, static_cast<uint32_t>(std::strlen(path)));

  6621. 

  6622.         lv2_atom_forge_pop(&fAtomForge, &forgeFrame);

  6623. 

  6624.         LV2_Atom* const atom((LV2_Atom*)atomBuf);

  6625.         CARLA_SAFE_ASSERT(atom->size < sizeof(atomBuf));

  6626. 

  6627.         fAtomBufferEvIn.put(atom, fEventsIn.ctrlIndex);

  6628.     }

  6629. 

  6630.     // -------------------------------------------------------------------

  6631. 

  6632. private:

  6633.     LV2_Handle   fHandle;

  6634.     LV2_Handle   fHandle2;

  6635.     LV2_Feature* fFeatures[kFeatureCountAll+1];

  6636.     const LV2_Descriptor*     fDescriptor;

  6637.     const LV2_RDF_Descriptor* fRdfDescriptor;

  6638. 

  6639.     float** fAudioInBuffers;

  6640.     float** fAudioOutBuffers;

  6641.     float** fCvInBuffers;

  6642.     float** fCvOutBuffers;

  6643.     float*  fParamBuffers;

  6644. 

  6645.     bool    fNeedsFixedBuffers;

  6646.     bool    fNeedsUiClose;

  6647.     bool    fInlineDisplayNeedsRedraw;

  6648.     int64_t fInlineDisplayLastRedrawTime;

  6649.     int32_t fLatencyIndex; // -1 if invalid

  6650.     int     fStrictBounds; // -1 unsupported, 0 optional, 1 required

  6651. 

  6652.     Lv2AtomRingBuffer fAtomBufferEvIn;

  6653.     Lv2AtomRingBuffer fAtomBufferUiOut;

  6654.     Lv2AtomRingBuffer fAtomBufferWorkerIn;

  6655.     Lv2AtomRingBuffer fAtomBufferWorkerResp;

  6656.     LV2_Atom_Forge    fAtomForge;

  6657.     uint8_t*          fAtomBufferUiOutTmpData;

  6658.     uint8_t*          fAtomBufferWorkerInTmpData;

  6659. 

  6660.     CarlaPluginLV2EventData fEventsIn;

  6661.     CarlaPluginLV2EventData fEventsOut;

  6662.     CarlaPluginLV2Options   fLv2Options;

  6663.     CarlaPipeServerLV2      fPipeServer;

  6664. 

  6665.     std::vector<std::string> fCustomURIDs;

  6666. 

  6667.     bool fFirstActive; // first process() call after activate()

  6668.     void* fLastStateChunk;

  6669.     EngineTimeInfo fLastTimeInfo;

  6670. 

  6671.     // if plugin provides path parameter, use it as fake "gui"

  6672.     CarlaString fFilePathURI;

  6673. 

  6674.     struct Extensions {

  6675.         const LV2_Options_Interface* options;

  6676.         const LV2_State_Interface* state;

  6677.         const LV2_Worker_Interface* worker;

  6678.         const LV2_Inline_Display_Interface* inlineDisplay;

  6679.         const LV2_Midnam_Interface* midnam;

  6680.         const LV2_Programs_Interface* programs;

  6681.         const LV2UI_Idle_Interface* uiidle;

  6682.         const LV2UI_Show_Interface* uishow;

  6683.         const LV2UI_Resize* uiresize;

  6684.         const LV2_Programs_UI_Interface* uiprograms;

  6685. 

  6686.         Extensions()

  6687.             : options(nullptr),

  6688.               state(nullptr),

  6689.               worker(nullptr),

  6690.               inlineDisplay(nullptr),

  6691.               midnam(nullptr),

  6692.               programs(nullptr),

  6693.               uiidle(nullptr),

  6694.               uishow(nullptr),

  6695.               uiresize(nullptr),

  6696.               uiprograms(nullptr) {}

  6697. 

  6698.         CARLA_DECLARE_NON_COPY_STRUCT(Extensions);

  6699.     } fExt;

  6700. 

  6701.     struct UI {

  6702.         enum Type {

  6703.             TYPE_NULL = 0,

  6704.             TYPE_BRIDGE,

  6705.             TYPE_EMBED,

  6706.             TYPE_EXTERNAL

  6707.         };

  6708. 

  6709.         Type type;

  6710.         LV2UI_Handle handle;

  6711.         LV2UI_Widget widget;

  6712.         const LV2UI_Descriptor* descriptor;

  6713.         const LV2_RDF_UI*       rdfDescriptor;

  6714. 

  6715.         bool fileBrowserOpen;

  6716.         const char* fileNeededForURI;

  6717.         CarlaPluginUI* window;

  6718. 

  6719.         UI()

  6720.             : type(TYPE_NULL),

  6721.               handle(nullptr),

  6722.               widget(nullptr),

  6723.               descriptor(nullptr),

  6724.               rdfDescriptor(nullptr),

  6725.               fileBrowserOpen(false),

  6726.               fileNeededForURI(nullptr),

  6727.               window(nullptr) {}

  6728. 

  6729.         ~UI()

  6730.         {

  6731.             CARLA_SAFE_ASSERT(handle == nullptr);

  6732.             CARLA_SAFE_ASSERT(widget == nullptr);

  6733.             CARLA_SAFE_ASSERT(descriptor == nullptr);

  6734.             CARLA_SAFE_ASSERT(rdfDescriptor == nullptr);

  6735.             CARLA_SAFE_ASSERT(! fileBrowserOpen);

  6736.             CARLA_SAFE_ASSERT(fileNeededForURI == nullptr);

  6737.             CARLA_SAFE_ASSERT(window == nullptr);

  6738.         }

  6739. 

  6740.         CARLA_DECLARE_NON_COPY_STRUCT(UI);

  6741.     } fUI;

  6742. 

  6743.     // -------------------------------------------------------------------

  6744.     // Event Feature

  6745. 

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

  6747.     {

  6748.         CARLA_SAFE_ASSERT_RETURN(callback_data != nullptr, 0);

  6749.         CARLA_SAFE_ASSERT_RETURN(event != nullptr, 0);

  6750.         carla_debug("carla_lv2_event_ref(%p, %p)", callback_data, event);

  6751. 

  6752.         return 0;

  6753.     }

  6754. 

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

  6756.     {

  6757.         CARLA_SAFE_ASSERT_RETURN(callback_data != nullptr, 0);

  6758.         CARLA_SAFE_ASSERT_RETURN(event != nullptr, 0);

  6759.         carla_debug("carla_lv2_event_unref(%p, %p)", callback_data, event);

  6760. 

  6761.         return 0;

  6762.     }

  6763. 

  6764.     // -------------------------------------------------------------------

  6765.     // Logs Feature

  6766. 

  6767.     static int carla_lv2_log_printf(LV2_Log_Handle handle, LV2_URID type, const char* fmt, ...)

  6768.     {

  6769.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr, 0);

  6770.         CARLA_SAFE_ASSERT_RETURN(type != kUridNull, 0);

  6771.         CARLA_SAFE_ASSERT_RETURN(fmt != nullptr, 0);

  6772. 

  6773. #ifndef DEBUG

  6774.         if (type == kUridLogTrace)

  6775.             return 0;

  6776. #endif

  6777. 

  6778.         va_list args;

  6779.         va_start(args, fmt);

  6780.         const int ret(carla_lv2_log_vprintf(handle, type, fmt, args));

  6781.         va_end(args);

  6782. 

  6783.         return ret;

  6784.     }

  6785. 

  6786.     static int carla_lv2_log_vprintf(LV2_Log_Handle handle, LV2_URID type, const char* fmt, va_list ap)

  6787.     {

  6788.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr, 0);

  6789.         CARLA_SAFE_ASSERT_RETURN(type != kUridNull, 0);

  6790.         CARLA_SAFE_ASSERT_RETURN(fmt != nullptr, 0);

  6791. 

  6792.         int ret = 0;

  6793. 

  6794.         switch (type)

  6795.         {

  6796.         case kUridLogError:

  6797.             std::fprintf(stderr, "\x1b[31m");

  6798.             ret = std::vfprintf(stderr, fmt, ap);

  6799.             std::fprintf(stderr, "\x1b[0m");

  6800.             break;

  6801. 

  6802.         case kUridLogNote:

  6803.             ret = std::vfprintf(stdout, fmt, ap);

  6804.             break;

  6805. 

  6806.         case kUridLogTrace:

  6807. #ifdef DEBUG

  6808.             std::fprintf(stdout, "\x1b[30;1m");

  6809.             ret = std::vfprintf(stdout, fmt, ap);

  6810.             std::fprintf(stdout, "\x1b[0m");

  6811. #endif

  6812.             break;

  6813. 

  6814.         case kUridLogWarning:

  6815.             ret = std::vfprintf(stderr, fmt, ap);

  6816.             break;

  6817. 

  6818.         default:

  6819.             break;

  6820.         }

  6821. 

  6822.         return ret;

  6823.     }

  6824. 

  6825.     // -------------------------------------------------------------------

  6826.     // Programs Feature

  6827. 

  6828.     static void carla_lv2_program_changed(LV2_Programs_Handle handle, int32_t index)

  6829.     {

  6830.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

  6831.         carla_debug("carla_lv2_program_changed(%p, %i)", handle, index);

  6832. 

  6833.         ((CarlaPluginLV2*)handle)->handleProgramChanged(index);

  6834.     }

  6835. 

  6836.     // -------------------------------------------------------------------

  6837.     // Resize Port Feature

  6838. 

  6839.     static LV2_Resize_Port_Status carla_lv2_resize_port(LV2_Resize_Port_Feature_Data data, uint32_t index, size_t size)

  6840.     {

  6841.         CARLA_SAFE_ASSERT_RETURN(data != nullptr, LV2_RESIZE_PORT_ERR_UNKNOWN);

  6842.         carla_debug("carla_lv2_program_changed(%p, %i, " P_SIZE ")", data, index, size);

  6843. 

  6844.         return ((CarlaPluginLV2*)data)->handleResizePort(index, size);

  6845.     }

  6846. 

  6847.     // -------------------------------------------------------------------

  6848.     // State Feature

  6849. 

  6850.     static void carla_lv2_state_free_path(LV2_State_Free_Path_Handle handle, char* path)

  6851.     {

  6852.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

  6853.         carla_debug("carla_lv2_state_free_path(%p, \"%s\")", handle, path);

  6854. 

  6855.         std::free(path);

  6856.     }

  6857. 

  6858.     static char* carla_lv2_state_make_path(LV2_State_Make_Path_Handle handle, const char* path)

  6859.     {

  6860.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr, nullptr);

  6861.         CARLA_SAFE_ASSERT_RETURN(path != nullptr && path[0] != '\0', nullptr);

  6862.         carla_debug("carla_lv2_state_make_path(%p, \"%s\")", handle, path);

  6863. 

  6864.         File target;

  6865. 

  6866.         if (File::isAbsolutePath(path))

  6867.         {

  6868.             target = path;

  6869.         }

  6870.         else

  6871.         {

  6872. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  6873.             if (const char* const projFolder = ((CarlaPluginLV2*)handle)->pData->engine->getCurrentProjectFolder())

  6874.                 target = projFolder;

  6875.             else

  6876. #endif

  6877.                 target = File::getCurrentWorkingDirectory();

  6878. 

  6879.             target = target.getChildFile(path);

  6880.         }

  6881. 

  6882.         if (! target.exists())

  6883.             target.createDirectory();

  6884. 

  6885.         return strdup(target.getFullPathName().toRawUTF8());

  6886.     }

  6887. 

  6888.     static char* carla_lv2_state_map_abstract_path(LV2_State_Map_Path_Handle handle, const char* absolute_path)

  6889.     {

  6890.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr, nullptr);

  6891.         CARLA_SAFE_ASSERT_RETURN(absolute_path != nullptr && absolute_path[0] != '\0', nullptr);

  6892.         carla_debug("carla_lv2_state_map_abstract_path(%p, \"%s\")", handle, absolute_path);

  6893. 

  6894.         // may already be an abstract path

  6895.         if (! File::isAbsolutePath(absolute_path))

  6896.             return strdup(absolute_path);

  6897. 

  6898.         File target;

  6899. 

  6900. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  6901.         if (const char* const projFolder = ((CarlaPluginLV2*)handle)->pData->engine->getCurrentProjectFolder())

  6902.             target = projFolder;

  6903.         else

  6904. #endif

  6905.             target = File::getCurrentWorkingDirectory();

  6906. 

  6907.         return strdup(File(absolute_path).getRelativePathFrom(target).toRawUTF8());

  6908.     }

  6909. 

  6910.     static char* carla_lv2_state_map_absolute_path(LV2_State_Map_Path_Handle handle, const char* abstract_path)

  6911.     {

  6912.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr, nullptr);

  6913.         CARLA_SAFE_ASSERT_RETURN(abstract_path != nullptr && abstract_path[0] != '\0', nullptr);

  6914.         carla_debug("carla_lv2_state_map_absolute_path(%p, \"%s\")", handle, abstract_path);

  6915. 

  6916.         // may already be an absolute path

  6917.         if (File::isAbsolutePath(abstract_path))

  6918.             return strdup(abstract_path);

  6919. 

  6920.         File base;

  6921. 

  6922. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  6923.         if (const char* const projFolder = ((CarlaPluginLV2*)handle)->pData->engine->getCurrentProjectFolder())

  6924.             base = projFolder;

  6925.         else

  6926. #endif

  6927.             base = File::getCurrentWorkingDirectory();

  6928. 

  6929.         return strdup(base.getChildFile(abstract_path).getFullPathName().toRawUTF8());

  6930.     }

  6931. 

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

  6933.     {

  6934.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr, LV2_STATE_ERR_UNKNOWN);

  6935.         carla_debug("carla_lv2_state_store(%p, %i, %p, " P_SIZE ", %i, %i)", handle, key, value, size, type, flags);

  6936. 

  6937.         return ((CarlaPluginLV2*)handle)->handleStateStore(key, value, size, type, flags);

  6938.     }

  6939. 

  6940.     static const void* carla_lv2_state_retrieve(LV2_State_Handle handle, uint32_t key, size_t* size, uint32_t* type, uint32_t* flags)

  6941.     {

  6942.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr, nullptr);

  6943.         carla_debug("carla_lv2_state_retrieve(%p, %i, %p, %p, %p)", handle, key, size, type, flags);

  6944. 

  6945.         return ((CarlaPluginLV2*)handle)->handleStateRetrieve(key, size, type, flags);

  6946.     }

  6947. 

  6948.     // -------------------------------------------------------------------

  6949.     // URI-Map Feature

  6950. 

  6951.     static uint32_t carla_lv2_uri_to_id(LV2_URI_Map_Callback_Data data, const char* map, const char* uri)

  6952.     {

  6953.         carla_debug("carla_lv2_uri_to_id(%p, \"%s\", \"%s\")", data, map, uri);

  6954.         return carla_lv2_urid_map((LV2_URID_Map_Handle*)data, uri);

  6955. 

  6956.         // unused

  6957.         (void)map;

  6958.     }

  6959. 

  6960.     // -------------------------------------------------------------------

  6961.     // URID Feature

  6962. 

  6963.     static LV2_URID carla_lv2_urid_map(LV2_URID_Map_Handle handle, const char* uri)

  6964.     {

  6965.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr, kUridNull);

  6966.         CARLA_SAFE_ASSERT_RETURN(uri != nullptr && uri[0] != '\0', kUridNull);

  6967.         carla_debug("carla_lv2_urid_map(%p, \"%s\")", handle, uri);

  6968. 

  6969.         // Atom types

  6970.         if (std::strcmp(uri, LV2_ATOM__Blank) == 0)

  6971.             return kUridAtomBlank;

  6972.         if (std::strcmp(uri, LV2_ATOM__Bool) == 0)

  6973.             return kUridAtomBool;

  6974.         if (std::strcmp(uri, LV2_ATOM__Chunk) == 0)

  6975.             return kUridAtomChunk;

  6976.         if (std::strcmp(uri, LV2_ATOM__Double) == 0)

  6977.             return kUridAtomDouble;

  6978.         if (std::strcmp(uri, LV2_ATOM__Event) == 0)

  6979.             return kUridAtomEvent;

  6980.         if (std::strcmp(uri, LV2_ATOM__Float) == 0)

  6981.             return kUridAtomFloat;

  6982.         if (std::strcmp(uri, LV2_ATOM__Int) == 0)

  6983.             return kUridAtomInt;

  6984.         if (std::strcmp(uri, LV2_ATOM__Literal) == 0)

  6985.             return kUridAtomLiteral;

  6986.         if (std::strcmp(uri, LV2_ATOM__Long) == 0)

  6987.             return kUridAtomLong;

  6988.         if (std::strcmp(uri, LV2_ATOM__Number) == 0)

  6989.             return kUridAtomNumber;

  6990.         if (std::strcmp(uri, LV2_ATOM__Object) == 0)

  6991.             return kUridAtomObject;

  6992.         if (std::strcmp(uri, LV2_ATOM__Path) == 0)

  6993.             return kUridAtomPath;

  6994.         if (std::strcmp(uri, LV2_ATOM__Property) == 0)

  6995.             return kUridAtomProperty;

  6996.         if (std::strcmp(uri, LV2_ATOM__Resource) == 0)

  6997.             return kUridAtomResource;

  6998.         if (std::strcmp(uri, LV2_ATOM__Sequence) == 0)

  6999.             return kUridAtomSequence;

  7000.         if (std::strcmp(uri, LV2_ATOM__Sound) == 0)

  7001.             return kUridAtomSound;

  7002.         if (std::strcmp(uri, LV2_ATOM__String) == 0)

  7003.             return kUridAtomString;

  7004.         if (std::strcmp(uri, LV2_ATOM__Tuple) == 0)

  7005.             return kUridAtomTuple;

  7006.         if (std::strcmp(uri, LV2_ATOM__URI) == 0)

  7007.             return kUridAtomURI;

  7008.         if (std::strcmp(uri, LV2_ATOM__URID) == 0)

  7009.             return kUridAtomURID;

  7010.         if (std::strcmp(uri, LV2_ATOM__Vector) == 0)

  7011.             return kUridAtomVector;

  7012.         if (std::strcmp(uri, LV2_ATOM__atomTransfer) == 0)

  7013.             return kUridAtomTransferAtom;

  7014.         if (std::strcmp(uri, LV2_ATOM__eventTransfer) == 0)

  7015.             return kUridAtomTransferEvent;

  7016. 

  7017.         // BufSize types

  7018.         if (std::strcmp(uri, LV2_BUF_SIZE__maxBlockLength) == 0)

  7019.             return kUridBufMaxLength;

  7020.         if (std::strcmp(uri, LV2_BUF_SIZE__minBlockLength) == 0)

  7021.             return kUridBufMinLength;

  7022.         if (std::strcmp(uri, LV2_BUF_SIZE__nominalBlockLength) == 0)

  7023.             return kUridBufNominalLength;

  7024.         if (std::strcmp(uri, LV2_BUF_SIZE__sequenceSize) == 0)

  7025.             return kUridBufSequenceSize;

  7026. 

  7027.         // Log types

  7028.         if (std::strcmp(uri, LV2_LOG__Error) == 0)

  7029.             return kUridLogError;

  7030.         if (std::strcmp(uri, LV2_LOG__Note) == 0)

  7031.             return kUridLogNote;

  7032.         if (std::strcmp(uri, LV2_LOG__Trace) == 0)

  7033.             return kUridLogTrace;

  7034.         if (std::strcmp(uri, LV2_LOG__Warning) == 0)

  7035.             return kUridLogWarning;

  7036. 

  7037.         // Patch types

  7038.         if (std::strcmp(uri, LV2_PATCH__Set) == 0)

  7039.             return kUridPatchSet;

  7040.         if (std::strcmp(uri, LV2_PATCH__property) == 0)

  7041.             return kUridPatchPoperty;

  7042.         if (std::strcmp(uri, LV2_PATCH__value) == 0)

  7043.             return kUridPatchValue;

  7044. 

  7045.         // Time types

  7046.         if (std::strcmp(uri, LV2_TIME__Position) == 0)

  7047.             return kUridTimePosition;

  7048.         if (std::strcmp(uri, LV2_TIME__bar) == 0)

  7049.             return kUridTimeBar;

  7050.         if (std::strcmp(uri, LV2_TIME__barBeat) == 0)

  7051.             return kUridTimeBarBeat;

  7052.         if (std::strcmp(uri, LV2_TIME__beat) == 0)

  7053.             return kUridTimeBeat;

  7054.         if (std::strcmp(uri, LV2_TIME__beatUnit) == 0)

  7055.             return kUridTimeBeatUnit;

  7056.         if (std::strcmp(uri, LV2_TIME__beatsPerBar) == 0)

  7057.             return kUridTimeBeatsPerBar;

  7058.         if (std::strcmp(uri, LV2_TIME__beatsPerMinute) == 0)

  7059.             return kUridTimeBeatsPerMinute;

  7060.         if (std::strcmp(uri, LV2_TIME__frame) == 0)

  7061.             return kUridTimeFrame;

  7062.         if (std::strcmp(uri, LV2_TIME__framesPerSecond) == 0)

  7063.             return kUridTimeFramesPerSecond;

  7064.         if (std::strcmp(uri, LV2_TIME__speed) == 0)

  7065.             return kUridTimeSpeed;

  7066.         if (std::strcmp(uri, LV2_KXSTUDIO_PROPERTIES__TimePositionTicksPerBeat) == 0)

  7067.             return kUridTimeTicksPerBeat;

  7068. 

  7069.         // Others

  7070.         if (std::strcmp(uri, LV2_MIDI__MidiEvent) == 0)

  7071.             return kUridMidiEvent;

  7072.         if (std::strcmp(uri, LV2_PARAMETERS__sampleRate) == 0)

  7073.             return kUridParamSampleRate;

  7074.         if (std::strcmp(uri, LV2_UI__backgroundColor) == 0)

  7075.             return kUridBackgroundColor;

  7076.         if (std::strcmp(uri, LV2_UI__foregroundColor) == 0)

  7077.             return kUridForegroundColor;

  7078.         if (std::strcmp(uri, LV2_UI__scaleFactor) == 0)

  7079.             return kUridScaleFactor;

  7080.         if (std::strcmp(uri, LV2_UI__windowTitle) == 0)

  7081.             return kUridWindowTitle;

  7082. 

  7083.         // Custom Carla types

  7084.         if (std::strcmp(uri, URI_CARLA_ATOM_WORKER_IN) == 0)

  7085.             return kUridCarlaAtomWorkerIn;

  7086.         if (std::strcmp(uri, URI_CARLA_ATOM_WORKER_RESP) == 0)

  7087.             return kUridCarlaAtomWorkerResp;

  7088.         if (std::strcmp(uri, LV2_KXSTUDIO_PROPERTIES__TransientWindowId) == 0)

  7089.             return kUridCarlaTransientWindowId;

  7090. 

  7091.         // Custom plugin types

  7092.         return ((CarlaPluginLV2*)handle)->getCustomURID(uri);

  7093.     }

  7094. 

  7095.     static const char* carla_lv2_urid_unmap(LV2_URID_Map_Handle handle, LV2_URID urid)

  7096.     {

  7097.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr, nullptr);

  7098.         CARLA_SAFE_ASSERT_RETURN(urid != kUridNull, nullptr);

  7099.         carla_debug("carla_lv2_urid_unmap(%p, %i)", handle, urid);

  7100. 

  7101.         switch (urid)

  7102.         {

  7103.         // Atom types

  7104.         case kUridAtomBlank:

  7105.             return LV2_ATOM__Blank;

  7106.         case kUridAtomBool:

  7107.             return LV2_ATOM__Bool;

  7108.         case kUridAtomChunk:

  7109.             return LV2_ATOM__Chunk;

  7110.         case kUridAtomDouble:

  7111.             return LV2_ATOM__Double;

  7112.         case kUridAtomEvent:

  7113.             return LV2_ATOM__Event;

  7114.         case kUridAtomFloat:

  7115.             return LV2_ATOM__Float;

  7116.         case kUridAtomInt:

  7117.             return LV2_ATOM__Int;

  7118.         case kUridAtomLiteral:

  7119.             return LV2_ATOM__Literal;

  7120.         case kUridAtomLong:

  7121.             return LV2_ATOM__Long;

  7122.         case kUridAtomNumber:

  7123.             return LV2_ATOM__Number;

  7124.         case kUridAtomObject:

  7125.             return LV2_ATOM__Object;

  7126.         case kUridAtomPath:

  7127.             return LV2_ATOM__Path;

  7128.         case kUridAtomProperty:

  7129.             return LV2_ATOM__Property;

  7130.         case kUridAtomResource:

  7131.             return LV2_ATOM__Resource;

  7132.         case kUridAtomSequence:

  7133.             return LV2_ATOM__Sequence;

  7134.         case kUridAtomSound:

  7135.             return LV2_ATOM__Sound;

  7136.         case kUridAtomString:

  7137.             return LV2_ATOM__String;

  7138.         case kUridAtomTuple:

  7139.             return LV2_ATOM__Tuple;

  7140.         case kUridAtomURI:

  7141.             return LV2_ATOM__URI;

  7142.         case kUridAtomURID:

  7143.             return LV2_ATOM__URID;

  7144.         case kUridAtomVector:

  7145.             return LV2_ATOM__Vector;

  7146.         case kUridAtomTransferAtom:

  7147.             return LV2_ATOM__atomTransfer;

  7148.         case kUridAtomTransferEvent:

  7149.             return LV2_ATOM__eventTransfer;

  7150. 

  7151.         // BufSize types

  7152.         case kUridBufMaxLength:

  7153.             return LV2_BUF_SIZE__maxBlockLength;

  7154.         case kUridBufMinLength:

  7155.             return LV2_BUF_SIZE__minBlockLength;

  7156.         case kUridBufNominalLength:

  7157.             return LV2_BUF_SIZE__nominalBlockLength;

  7158.         case kUridBufSequenceSize:

  7159.             return LV2_BUF_SIZE__sequenceSize;

  7160. 

  7161.         // Log types

  7162.         case kUridLogError:

  7163.             return LV2_LOG__Error;

  7164.         case kUridLogNote:

  7165.             return LV2_LOG__Note;

  7166.         case kUridLogTrace:

  7167.             return LV2_LOG__Trace;

  7168.         case kUridLogWarning:

  7169.             return LV2_LOG__Warning;

  7170. 

  7171.         // Patch types

  7172.         case kUridPatchSet:

  7173.             return LV2_PATCH__Set;

  7174.         case kUridPatchPoperty:

  7175.             return LV2_PATCH__property;

  7176.         case kUridPatchValue:

  7177.             return LV2_PATCH__value;

  7178. 

  7179.         // Time types

  7180.         case kUridTimePosition:

  7181.             return LV2_TIME__Position;

  7182.         case kUridTimeBar:

  7183.             return LV2_TIME__bar;

  7184.         case kUridTimeBarBeat:

  7185.             return LV2_TIME__barBeat;

  7186.         case kUridTimeBeat:

  7187.             return LV2_TIME__beat;

  7188.         case kUridTimeBeatUnit:

  7189.             return LV2_TIME__beatUnit;

  7190.         case kUridTimeBeatsPerBar:

  7191.             return LV2_TIME__beatsPerBar;

  7192.         case kUridTimeBeatsPerMinute:

  7193.             return LV2_TIME__beatsPerMinute;

  7194.         case kUridTimeFrame:

  7195.             return LV2_TIME__frame;

  7196.         case kUridTimeFramesPerSecond:

  7197.             return LV2_TIME__framesPerSecond;

  7198.         case kUridTimeSpeed:

  7199.             return LV2_TIME__speed;

  7200.         case kUridTimeTicksPerBeat:

  7201.             return LV2_KXSTUDIO_PROPERTIES__TimePositionTicksPerBeat;

  7202. 

  7203.         // Others

  7204.         case kUridMidiEvent:

  7205.             return LV2_MIDI__MidiEvent;

  7206.         case kUridParamSampleRate:

  7207.             return LV2_PARAMETERS__sampleRate;

  7208.         case kUridBackgroundColor:

  7209.             return LV2_UI__backgroundColor;

  7210.         case kUridForegroundColor:

  7211.             return LV2_UI__foregroundColor;

  7212.         case kUridScaleFactor:

  7213.             return LV2_UI__scaleFactor;

  7214.         case kUridWindowTitle:

  7215.             return LV2_UI__windowTitle;

  7216. 

  7217.         // Custom Carla types

  7218.         case kUridCarlaAtomWorkerIn:

  7219.             return URI_CARLA_ATOM_WORKER_IN;

  7220.         case kUridCarlaAtomWorkerResp:

  7221.             return URI_CARLA_ATOM_WORKER_RESP;

  7222.         case kUridCarlaTransientWindowId:

  7223.             return LV2_KXSTUDIO_PROPERTIES__TransientWindowId;

  7224.         }

  7225. 

  7226.         // Custom plugin types

  7227.         return ((CarlaPluginLV2*)handle)->getCustomURIDString(urid);

  7228.     }

  7229. 

  7230.     // -------------------------------------------------------------------

  7231.     // Worker Feature

  7232. 

  7233.     static LV2_Worker_Status carla_lv2_worker_schedule(LV2_Worker_Schedule_Handle handle, uint32_t size, const void* data)

  7234.     {

  7235.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr, LV2_WORKER_ERR_UNKNOWN);

  7236.         carla_debug("carla_lv2_worker_schedule(%p, %i, %p)", handle, size, data);

  7237. 

  7238.         return ((CarlaPluginLV2*)handle)->handleWorkerSchedule(size, data);

  7239.     }

  7240. 

  7241.     static LV2_Worker_Status carla_lv2_worker_respond(LV2_Worker_Respond_Handle handle, uint32_t size, const void* data)

  7242.     {

  7243.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr, LV2_WORKER_ERR_UNKNOWN);

  7244.         carla_debug("carla_lv2_worker_respond(%p, %i, %p)", handle, size, data);

  7245. 

  7246.         return ((CarlaPluginLV2*)handle)->handleWorkerRespond(size, data);

  7247.     }

  7248. 

  7249.     // -------------------------------------------------------------------

  7250.     // Inline Display Feature

  7251. 

  7252.     static void carla_lv2_inline_display_queue_draw(LV2_Inline_Display_Handle handle)

  7253.     {

  7254.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

  7255.         // carla_debug("carla_lv2_inline_display_queue_draw(%p)", handle);

  7256. 

  7257.         ((CarlaPluginLV2*)handle)->handleInlineDisplayQueueRedraw();

  7258.     }

  7259. 

  7260.     // -------------------------------------------------------------------

  7261.     // Midnam Feature

  7262. 

  7263.     static void carla_lv2_midnam_update(LV2_Midnam_Handle handle)

  7264.     {

  7265.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

  7266.         carla_stdout("carla_lv2_midnam_update(%p)", handle);

  7267. 

  7268.         ((CarlaPluginLV2*)handle)->handleMidnamUpdate();

  7269.     }

  7270. 

  7271.     // -------------------------------------------------------------------

  7272.     // External UI Feature

  7273. 

  7274.     static void carla_lv2_external_ui_closed(LV2UI_Controller controller)

  7275.     {

  7276.         CARLA_SAFE_ASSERT_RETURN(controller != nullptr,);

  7277.         carla_debug("carla_lv2_external_ui_closed(%p)", controller);

  7278. 

  7279.         ((CarlaPluginLV2*)controller)->handleExternalUIClosed();

  7280.     }

  7281. 

  7282.     // -------------------------------------------------------------------

  7283.     // UI Port-Map Feature

  7284. 

  7285.     static uint32_t carla_lv2_ui_port_map(LV2UI_Feature_Handle handle, const char* symbol)

  7286.     {

  7287.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr, LV2UI_INVALID_PORT_INDEX);

  7288.         carla_debug("carla_lv2_ui_port_map(%p, \"%s\")", handle, symbol);

  7289. 

  7290.         return ((CarlaPluginLV2*)handle)->handleUIPortMap(symbol);

  7291.     }

  7292. 

  7293.     // ----------------------------------------------------------------------------------------------------------------

  7294.     // UI Request Parameter Feature

  7295. 

  7296.     static LV2UI_Request_Value_Status carla_lv2_ui_request_value(LV2UI_Feature_Handle handle,

  7297.                                                                  LV2_URID key,

  7298.                                                                  LV2_URID type,

  7299.                                                                  const LV2_Feature* const* features)

  7300.     {

  7301.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr, LV2UI_REQUEST_VALUE_ERR_UNKNOWN);

  7302.         carla_debug("carla_lv2_ui_request_value(%p, %u, %u, %p)", handle, key, type, features);

  7303. 

  7304.         return ((CarlaPluginLV2*)handle)->handleUIRequestValue(key, type, features);

  7305.     }

  7306. 

  7307.     // -------------------------------------------------------------------

  7308.     // UI Resize Feature

  7309. 

  7310.     static int carla_lv2_ui_resize(LV2UI_Feature_Handle handle, int width, int height)

  7311.     {

  7312.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr, 1);

  7313.         carla_debug("carla_lv2_ui_resize(%p, %i, %i)", handle, width, height);

  7314. 

  7315.         return ((CarlaPluginLV2*)handle)->handleUIResize(width, height);

  7316.     }

  7317. 

  7318.     // -------------------------------------------------------------------

  7319.     // UI Touch Feature

  7320. 

  7321.     static void carla_lv2_ui_touch(LV2UI_Feature_Handle handle, uint32_t port_index, bool touch)

  7322.     {

  7323.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

  7324.         carla_debug("carla_lv2_ui_touch(%p, %u, %s)", handle, port_index, bool2str(touch));

  7325. 

  7326.         ((CarlaPluginLV2*)handle)->handleUITouch(port_index, touch);

  7327.     }

  7328. 

  7329.     // -------------------------------------------------------------------

  7330.     // UI Extension

  7331. 

  7332.     static void carla_lv2_ui_write_function(LV2UI_Controller controller, uint32_t port_index, uint32_t buffer_size, uint32_t format, const void* buffer)

  7333.     {

  7334.         CARLA_SAFE_ASSERT_RETURN(controller != nullptr,);

  7335.         carla_debug("carla_lv2_ui_write_function(%p, %i, %i, %i, %p)", controller, port_index, buffer_size, format, buffer);

  7336. 

  7337.         ((CarlaPluginLV2*)controller)->handleUIWrite(port_index, buffer_size, format, buffer);

  7338.     }

  7339. 

  7340.     // -------------------------------------------------------------------

  7341.     // Lilv State

  7342. 

  7343.     static void carla_lilv_set_port_value(const char* port_symbol, void* user_data, const void* value, uint32_t size, uint32_t type)

  7344.     {

  7345.         CARLA_SAFE_ASSERT_RETURN(user_data != nullptr,);

  7346.         carla_debug("carla_lilv_set_port_value(\"%s\", %p, %p, %i, %i", port_symbol, user_data, value, size, type);

  7347. 

  7348.         ((CarlaPluginLV2*)user_data)->handleLilvSetPortValue(port_symbol, value, size, type);

  7349.     }

  7350. 

  7351.     // -------------------------------------------------------------------

  7352. 

  7353.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaPluginLV2)

  7354. };

  7355. 

  7356. // -------------------------------------------------------------------------------------------------------------------

  7357. 

  7358. bool CarlaPipeServerLV2::msgReceived(const char* const msg) noexcept

  7359. {

  7360.     if (std::strcmp(msg, "exiting") == 0)

  7361.     {

  7362.         closePipeServer();

  7363.         fUiState = UiHide;

  7364.         return true;

  7365.     }

  7366. 

  7367.     if (std::strcmp(msg, "control") == 0)

  7368.     {

  7369.         uint32_t index;

  7370.         float value;

  7371. 

  7372.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(index), true);

  7373.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsFloat(value), true);

  7374. 

  7375.         try {

  7376.             kPlugin->handleUIWrite(index, sizeof(float), kUridNull, &value);

  7377.         } CARLA_SAFE_EXCEPTION("magReceived control");

  7378. 

  7379.         return true;

  7380.     }

  7381. 

  7382.     if (std::strcmp(msg, "atom") == 0)

  7383.     {

  7384.         uint32_t index, atomTotalSize, base64Size;

  7385.         const char* base64atom;

  7386. 

  7387.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(index), true);

  7388.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(atomTotalSize), true);

  7389.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(base64Size), true);

  7390.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(base64atom, false, base64Size), true);

  7391. 

  7392.         std::vector<uint8_t> chunk(carla_getChunkFromBase64String(base64atom));

  7393.         CARLA_SAFE_ASSERT_UINT2_RETURN(chunk.size() >= sizeof(LV2_Atom), chunk.size(), sizeof(LV2_Atom), true);

  7394. 

  7395. #ifdef CARLA_PROPER_CPP11_SUPPORT

  7396.         const LV2_Atom* const atom((const LV2_Atom*)chunk.data());

  7397. #else

  7398.         const LV2_Atom* const atom((const LV2_Atom*)&chunk.front());

  7399. #endif

  7400.         CARLA_SAFE_ASSERT_RETURN(lv2_atom_total_size(atom) == chunk.size(), true);

  7401. 

  7402.         try {

  7403.             kPlugin->handleUIWrite(index, lv2_atom_total_size(atom), kUridAtomTransferEvent, atom);

  7404.         } CARLA_SAFE_EXCEPTION("magReceived atom");

  7405. 

  7406.         return true;

  7407.     }

  7408. 

  7409.     if (std::strcmp(msg, "program") == 0)

  7410.     {

  7411.         uint32_t index;

  7412. 

  7413.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(index), true);

  7414. 

  7415.         try {

  7416.             kPlugin->setMidiProgram(static_cast<int32_t>(index), false, true, true, false);

  7417.         } CARLA_SAFE_EXCEPTION("msgReceived program");

  7418. 

  7419.         return true;

  7420.     }

  7421. 

  7422.     if (std::strcmp(msg, "urid") == 0)

  7423.     {

  7424.         uint32_t urid, size;

  7425.         const char* uri;

  7426. 

  7427.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(urid), true);

  7428.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(size), true);

  7429.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(uri, false, size), true);

  7430. 

  7431.         if (urid != 0)

  7432.         {

  7433.             try {

  7434.                 kPlugin->handleUridMap(urid, uri);

  7435.             } CARLA_SAFE_EXCEPTION("msgReceived urid");

  7436.         }

  7437. 

  7438.         return true;

  7439.     }

  7440. 

  7441.     if (std::strcmp(msg, "reloadprograms") == 0)

  7442.     {

  7443.         int32_t index;

  7444. 

  7445.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsInt(index), true);

  7446. 

  7447.         try {

  7448.             kPlugin->handleProgramChanged(index);

  7449.         } CARLA_SAFE_EXCEPTION("handleProgramChanged");

  7450. 

  7451.         return true;

  7452.     }

  7453. 

  7454.     if (std::strcmp(msg, "requestvalue") == 0)

  7455.     {

  7456.         uint32_t key, type;

  7457. 

  7458.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(key), true);

  7459.         CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(type), true);

  7460. 

  7461.         if (key != 0)

  7462.         {

  7463.             try {

  7464.                 kPlugin->handleUIRequestValue(key, type, nullptr);

  7465.             } CARLA_SAFE_EXCEPTION("msgReceived requestvalue");

  7466.         }

  7467. 

  7468.         return true;

  7469.     }

  7470. 

  7471.     return false;

  7472. }

  7473. 

  7474. // -------------------------------------------------------------------------------------------------------------------

  7475. 

  7476. CarlaPluginPtr CarlaPlugin::newLV2(const Initializer& init)

  7477. {

  7478.     carla_debug("CarlaPlugin::newLV2({%p, \"%s\", \"%s\", " P_INT64 "})",

  7479.                 init.engine, init.name, init.label, init.uniqueId);

  7480. 

  7481.     std::shared_ptr<CarlaPluginLV2> plugin(new CarlaPluginLV2(init.engine, init.id));

  7482. 

  7483.     if (! plugin->init(plugin, init.name, init.label, init.options))

  7484.         return nullptr;

  7485. 

  7486.     return plugin;

  7487. }

  7488. 

  7489. // used in CarlaStandalone.cpp

  7490. const void* carla_render_inline_display_lv2(const CarlaPluginPtr& plugin, uint32_t width, uint32_t height);

  7491. 

  7492. const void* carla_render_inline_display_lv2(const CarlaPluginPtr& plugin, uint32_t width, uint32_t height)

  7493. {

  7494.     const std::shared_ptr<CarlaPluginLV2>& lv2Plugin((const std::shared_ptr<CarlaPluginLV2>&)plugin);

  7495. 

  7496.     return lv2Plugin->renderInlineDisplay(width, height);

  7497. }

  7498. 

  7499. // -------------------------------------------------------------------------------------------------------------------

  7500. 

  7501. CARLA_BACKEND_END_NAMESPACE