falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 43 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
622 Commits
17 Branches
263MB
Tree: 155892e74b
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '155892e74b'
${ noResults }
Carla/source/bridges/CarlaBridgeUI-LV2.cpp

1119 lines
38KB
Raw Blame History 

  1. /*

  2.  * Carla Bridge UI, LV2 version

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

  4.  *

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

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

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

  8.  * the License, or any later version.

  9.  *

  10.  * This program is distributed in the hope that it will be useful,

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

  13.  * GNU General Public License for more details.

  14.  *

  15.  * For a full copy of the GNU General Public License see the GPL.txt file

  16.  */

  17. 

  18. #include "CarlaBridgeClient.hpp"

  19. #include "CarlaLv2Utils.hpp"

  20. #include "CarlaMIDI.h"

  21. #include "RtList.hpp"

  22. 

  23. // TODO - remove

  24. #include <vector>

  25. 

  26. #include <QtCore/QDir>

  27. 

  28. extern "C" {

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

  30. }

  31. 

  32. // -----------------------------------------------------

  33. // Our LV2 World class object

  34. 

  35. Lv2WorldClass gLv2World;

  36. 

  37. CARLA_BRIDGE_START_NAMESPACE

  38. 

  39. // -------------------------------------------------------------------------

  40. 

  41. // fake values

  42. static uint32_t gBufferSize = 1024;

  43. static double   gSampleRate = 44100.0;

  44. 

  45. // static max values

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

  47. 

  48. // LV2 URI Map Ids

  49. const uint32_t CARLA_URI_MAP_ID_NULL                   =  0;

  50. const uint32_t CARLA_URI_MAP_ID_ATOM_BLANK             =  1;

  51. const uint32_t CARLA_URI_MAP_ID_ATOM_BOOL              =  2;

  52. const uint32_t CARLA_URI_MAP_ID_ATOM_CHUNK             =  3;

  53. const uint32_t CARLA_URI_MAP_ID_ATOM_DOUBLE            =  4;

  54. const uint32_t CARLA_URI_MAP_ID_ATOM_FLOAT             =  5;

  55. const uint32_t CARLA_URI_MAP_ID_ATOM_INT               =  6;

  56. const uint32_t CARLA_URI_MAP_ID_ATOM_LITERAL           =  7;

  57. const uint32_t CARLA_URI_MAP_ID_ATOM_LONG              =  8;

  58. const uint32_t CARLA_URI_MAP_ID_ATOM_PATH              =  9;

  59. const uint32_t CARLA_URI_MAP_ID_ATOM_PROPERTY          = 10;

  60. const uint32_t CARLA_URI_MAP_ID_ATOM_RESOURCE          = 11;

  61. const uint32_t CARLA_URI_MAP_ID_ATOM_SEQUENCE          = 12;

  62. const uint32_t CARLA_URI_MAP_ID_ATOM_STRING            = 13;

  63. const uint32_t CARLA_URI_MAP_ID_ATOM_TUPLE             = 14;

  64. const uint32_t CARLA_URI_MAP_ID_ATOM_URI               = 15;

  65. const uint32_t CARLA_URI_MAP_ID_ATOM_URID              = 16;

  66. const uint32_t CARLA_URI_MAP_ID_ATOM_VECTOR            = 17;

  67. const uint32_t CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM     = 18;

  68. const uint32_t CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT    = 19;

  69. const uint32_t CARLA_URI_MAP_ID_BUF_MAX_LENGTH         = 20;

  70. const uint32_t CARLA_URI_MAP_ID_BUF_MIN_LENGTH         = 21;

  71. const uint32_t CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE      = 22;

  72. const uint32_t CARLA_URI_MAP_ID_LOG_ERROR              = 23;

  73. const uint32_t CARLA_URI_MAP_ID_LOG_NOTE               = 24;

  74. const uint32_t CARLA_URI_MAP_ID_LOG_TRACE              = 25;

  75. const uint32_t CARLA_URI_MAP_ID_LOG_WARNING            = 26;

  76. const uint32_t CARLA_URI_MAP_ID_TIME_POSITION          = 27; // base type

  77. const uint32_t CARLA_URI_MAP_ID_TIME_BAR               = 28; // values

  78. const uint32_t CARLA_URI_MAP_ID_TIME_BAR_BEAT          = 29;

  79. const uint32_t CARLA_URI_MAP_ID_TIME_BEAT              = 30;

  80. const uint32_t CARLA_URI_MAP_ID_TIME_BEAT_UNIT         = 31;

  81. const uint32_t CARLA_URI_MAP_ID_TIME_BEATS_PER_BAR     = 32;

  82. const uint32_t CARLA_URI_MAP_ID_TIME_BEATS_PER_MINUTE  = 33;

  83. const uint32_t CARLA_URI_MAP_ID_TIME_FRAME             = 34;

  84. const uint32_t CARLA_URI_MAP_ID_TIME_FRAMES_PER_SECOND = 35;

  85. const uint32_t CARLA_URI_MAP_ID_TIME_SPEED             = 36;

  86. const uint32_t CARLA_URI_MAP_ID_MIDI_EVENT             = 37;

  87. const uint32_t CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE      = 38;

  88. const uint32_t CARLA_URI_MAP_ID_COUNT                  = 39;

  89. 

  90. // LV2 Feature Ids

  91. const uint32_t kFeatureIdBufSizeBounded   =  0;

  92. const uint32_t kFeatureIdBufSizeFixed     =  1;

  93. const uint32_t kFeatureIdBufSizePowerOf2  =  2;

  94. const uint32_t kFeatureIdEvent            =  3;

  95. const uint32_t kFeatureIdHardRtCapable    =  4;

  96. const uint32_t kFeatureIdInPlaceBroken    =  5;

  97. const uint32_t kFeatureIdIsLive           =  6;

  98. const uint32_t kFeatureIdLogs             =  7;

  99. const uint32_t kFeatureIdOptions          =  8;

  100. const uint32_t kFeatureIdPrograms         =  9;

  101. const uint32_t kFeatureIdRtMemPool        = 10;

  102. const uint32_t kFeatureIdStateMakePath    = 11;

  103. const uint32_t kFeatureIdStateMapPath     = 12;

  104. const uint32_t kFeatureIdStrictBounds     = 13;

  105. const uint32_t kFeatureIdUriMap           = 14;

  106. const uint32_t kFeatureIdUridMap          = 15;

  107. const uint32_t kFeatureIdUridUnmap        = 16;

  108. const uint32_t kFeatureIdWorker           = 17;

  109. const uint32_t kFeatureIdUiDataAccess     = 18;

  110. const uint32_t kFeatureIdUiInstanceAccess = 19;

  111. const uint32_t kFeatureIdUiIdle           = 20;

  112. const uint32_t kFeatureIdUiFixedSize      = 21;

  113. const uint32_t kFeatureIdUiMakeResident   = 22;

  114. const uint32_t kFeatureIdUiNoUserResize   = 23;

  115. const uint32_t kFeatureIdUiParent         = 24;

  116. const uint32_t kFeatureIdUiPortMap        = 25;

  117. const uint32_t kFeatureIdUiPortSubscribe  = 26;

  118. const uint32_t kFeatureIdUiResize         = 27;

  119. const uint32_t kFeatureIdUiTouch          = 28;

  120. const uint32_t kFeatureIdExternalUi       = 29;

  121. const uint32_t kFeatureIdExternalUiOld    = 30;

  122. const uint32_t kFeatureCount              = 31;

  123. 

  124. // -------------------------------------------------------------------------

  125. 

  126. struct Lv2PluginOptions {

  127.     int maxBufferSize;

  128.     int minBufferSize;

  129.     int sequenceSize;

  130.     double sampleRate;

  131.     LV2_Options_Option optMaxBlockLenth;

  132.     LV2_Options_Option optMinBlockLenth;

  133.     LV2_Options_Option optSequenceSize;

  134.     LV2_Options_Option optSampleRate;

  135.     LV2_Options_Option optNull;

  136.     LV2_Options_Option* opts[5];

  137. 

  138.     Lv2PluginOptions()

  139.         : maxBufferSize(0),

  140.           minBufferSize(0),

  141.           sequenceSize(MAX_EVENT_BUFFER),

  142.           sampleRate(0.0)

  143.     {

  144.         optMaxBlockLenth.context = LV2_OPTIONS_INSTANCE;

  145.         optMaxBlockLenth.subject = 0;

  146.         optMaxBlockLenth.key     = CARLA_URI_MAP_ID_BUF_MAX_LENGTH;

  147.         optMaxBlockLenth.size    = sizeof(int);

  148.         optMaxBlockLenth.type    = CARLA_URI_MAP_ID_ATOM_INT;

  149.         optMaxBlockLenth.value   = &maxBufferSize;

  150. 

  151.         optMinBlockLenth.context = LV2_OPTIONS_INSTANCE;

  152.         optMinBlockLenth.subject = 0;

  153.         optMinBlockLenth.key     = CARLA_URI_MAP_ID_BUF_MIN_LENGTH;

  154.         optMinBlockLenth.size    = sizeof(int);

  155.         optMinBlockLenth.type    = CARLA_URI_MAP_ID_ATOM_INT;

  156.         optMinBlockLenth.value   = &minBufferSize;

  157. 

  158.         optSequenceSize.context = LV2_OPTIONS_INSTANCE;

  159.         optSequenceSize.subject = 0;

  160.         optSequenceSize.key     = CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE;

  161.         optSequenceSize.size    = sizeof(int);

  162.         optSequenceSize.type    = CARLA_URI_MAP_ID_ATOM_INT;

  163.         optSequenceSize.value   = &sequenceSize;

  164. 

  165.         optSampleRate.context = LV2_OPTIONS_INSTANCE;

  166.         optSampleRate.subject = 0;

  167.         optSampleRate.key     = CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE;

  168.         optSampleRate.size    = sizeof(double);

  169.         optSampleRate.type    = CARLA_URI_MAP_ID_ATOM_DOUBLE;

  170.         optSampleRate.value   = &sampleRate;

  171. 

  172.         optNull.context = LV2_OPTIONS_INSTANCE;

  173.         optNull.subject = 0;

  174.         optNull.key     = CARLA_URI_MAP_ID_NULL;

  175.         optNull.size    = 0;

  176.         optNull.type    = CARLA_URI_MAP_ID_NULL;

  177.         optNull.value   = nullptr;

  178. 

  179.         opts[0] = &optMinBlockLenth;

  180.         opts[1] = &optMaxBlockLenth;

  181.         opts[2] = &optSequenceSize;

  182.         opts[3] = &optSampleRate;

  183.         opts[4] = &optNull;

  184.     }

  185. 

  186.     CARLA_DECLARE_NON_COPY_STRUCT_WITH_LEAK_DETECTOR(Lv2PluginOptions)

  187. };

  188. 

  189. // -------------------------------------------------------------------------

  190. 

  191. class CarlaLv2Client : public CarlaBridgeClient

  192. {

  193. public:

  194.     CarlaLv2Client(const char* const uiTitle)

  195.         : CarlaBridgeClient(uiTitle)

  196.     {

  197.         handle = nullptr;

  198.         widget = nullptr;

  199.         descriptor = nullptr;

  200. 

  201.         rdf_descriptor = nullptr;

  202.         rdf_ui_descriptor = nullptr;

  203. 

  204.         programs = nullptr;

  205. 

  206. #ifdef BRIDGE_LV2_X11

  207.         m_resizable = false;

  208. #else

  209.         m_resizable = true;

  210. #endif

  211. 

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

  213.             customURIDs.push_back(nullptr);

  214. 

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

  216.             features[i] = nullptr;

  217. 

  218.         // -----------------------------------------------------------------

  219.         // initialize features

  220. 

  221.         LV2_Event_Feature* const eventFt = new LV2_Event_Feature;

  222.         eventFt->callback_data           = this;

  223.         eventFt->lv2_event_ref           = carla_lv2_event_ref;

  224.         eventFt->lv2_event_unref         = carla_lv2_event_unref;

  225. 

  226.         LV2_Log_Log* const logFt         = new LV2_Log_Log;

  227.         logFt->handle                    = this;

  228.         logFt->printf                    = carla_lv2_log_printf;

  229.         logFt->vprintf                   = carla_lv2_log_vprintf;

  230. 

  231.         LV2_Programs_Host* const programsFt        = new LV2_Programs_Host;

  232.         programsFt->handle                         = this;

  233.         programsFt->program_changed                = carla_lv2_program_changed;

  234. 

  235.         LV2_RtMemPool_Pool* const rtMemPoolFt      = new LV2_RtMemPool_Pool;

  236.         lv2_rtmempool_init(rtMemPoolFt);

  237. 

  238.         LV2_State_Make_Path* const stateMakePathFt = new LV2_State_Make_Path;

  239.         stateMakePathFt->handle                    = this;

  240.         stateMakePathFt->path                      = carla_lv2_state_make_path;

  241. 

  242.         LV2_State_Map_Path* const stateMapPathFt   = new LV2_State_Map_Path;

  243.         stateMapPathFt->handle                     = this;

  244.         stateMapPathFt->abstract_path              = carla_lv2_state_map_abstract_path;

  245.         stateMapPathFt->absolute_path              = carla_lv2_state_map_absolute_path;

  246. 

  247.         LV2_URI_Map_Feature* const uriMapFt = new LV2_URI_Map_Feature;

  248.         uriMapFt->callback_data             = this;

  249.         uriMapFt->uri_to_id                 = carla_lv2_uri_to_id;

  250. 

  251.         LV2_URID_Map* const uridMapFt       = new LV2_URID_Map;

  252.         uridMapFt->handle                   = this;

  253.         uridMapFt->map                      = carla_lv2_urid_map;

  254. 

  255.         LV2_URID_Unmap* const uridUnmapFt   = new LV2_URID_Unmap;

  256.         uridUnmapFt->handle                 = this;

  257.         uridUnmapFt->unmap                  = carla_lv2_urid_unmap;

  258. 

  259.         LV2UI_Port_Map* const uiPortMapFt   = new LV2UI_Port_Map;

  260.         uiPortMapFt->handle                 = this;

  261.         uiPortMapFt->port_index             = carla_lv2_ui_port_map;

  262. 

  263.         LV2UI_Resize* const uiResizeFt      = new LV2UI_Resize;

  264.         uiResizeFt->handle                  = this;

  265.         uiResizeFt->ui_resize               = carla_lv2_ui_resize;

  266. 

  267. #if 0

  268.         features[lv2_feature_id_bufsize_bounded]        = new LV2_Feature;

  269.         features[lv2_feature_id_bufsize_bounded]->URI   = LV2_BUF_SIZE__boundedBlockLength;

  270.         features[lv2_feature_id_bufsize_bounded]->data  = nullptr;

  271. 

  272.         features[lv2_feature_id_bufsize_fixed]          = new LV2_Feature;

  273.         features[lv2_feature_id_bufsize_fixed]->URI     = LV2_BUF_SIZE__fixedBlockLength;

  274.         features[lv2_feature_id_bufsize_fixed]->data    = nullptr;

  275. 

  276.         features[lv2_feature_id_bufsize_powerof2]       = new LV2_Feature;

  277.         features[lv2_feature_id_bufsize_powerof2]->URI  = LV2_BUF_SIZE__powerOf2BlockLength;

  278.         features[lv2_feature_id_bufsize_powerof2]->data = nullptr;

  279. 

  280.         features[lv2_feature_id_event]          = new LV2_Feature;

  281.         features[lv2_feature_id_event]->URI     = LV2_EVENT_URI;

  282.         features[lv2_feature_id_event]->data    = eventFt;

  283. 

  284.         features[lv2_feature_id_logs]           = new LV2_Feature;

  285.         features[lv2_feature_id_logs]->URI      = LV2_LOG__log;

  286.         features[lv2_feature_id_logs]->data     = logFt;

  287. 

  288.         features[lv2_feature_id_options]        = new LV2_Feature;

  289.         features[lv2_feature_id_options]->URI   = LV2_OPTIONS__options;

  290.         features[lv2_feature_id_options]->data  = optionsFt;

  291. 

  292.         features[lv2_feature_id_programs]       = new LV2_Feature;

  293.         features[lv2_feature_id_programs]->URI  = LV2_PROGRAMS__Host;

  294.         features[lv2_feature_id_programs]->data = programsFt;

  295. 

  296.         features[lv2_feature_id_rtmempool]       = new LV2_Feature;

  297.         features[lv2_feature_id_rtmempool]->URI  = LV2_RTSAFE_MEMORY_POOL__Pool;

  298.         features[lv2_feature_id_rtmempool]->data = rtMemPoolFt;

  299. 

  300.         features[lv2_feature_id_state_make_path]       = new LV2_Feature;

  301.         features[lv2_feature_id_state_make_path]->URI  = LV2_STATE__makePath;

  302.         features[lv2_feature_id_state_make_path]->data = stateMakePathFt;

  303. 

  304.         features[lv2_feature_id_state_map_path]        = new LV2_Feature;

  305.         features[lv2_feature_id_state_map_path]->URI   = LV2_STATE__mapPath;

  306.         features[lv2_feature_id_state_map_path]->data  = stateMapPathFt;

  307. 

  308.         features[lv2_feature_id_strict_bounds]         = new LV2_Feature;

  309.         features[lv2_feature_id_strict_bounds]->URI    = LV2_PORT_PROPS__supportsStrictBounds;

  310.         features[lv2_feature_id_strict_bounds]->data   = nullptr;

  311. 

  312.         features[lv2_feature_id_uri_map]           = new LV2_Feature;

  313.         features[lv2_feature_id_uri_map]->URI      = LV2_URI_MAP_URI;

  314.         features[lv2_feature_id_uri_map]->data     = uriMapFt;

  315. 

  316.         features[lv2_feature_id_urid_map]          = new LV2_Feature;

  317.         features[lv2_feature_id_urid_map]->URI     = LV2_URID__map;

  318.         features[lv2_feature_id_urid_map]->data    = uridMapFt;

  319. 

  320.         features[lv2_feature_id_urid_unmap]        = new LV2_Feature;

  321.         features[lv2_feature_id_urid_unmap]->URI   = LV2_URID__unmap;

  322.         features[lv2_feature_id_urid_unmap]->data  = uridUnmapFt;

  323. 

  324.         features[lv2_feature_id_ui_parent]         = new LV2_Feature;

  325.         features[lv2_feature_id_ui_parent]->URI    = LV2_UI__parent;

  326.         features[lv2_feature_id_ui_parent]->data   = nullptr;

  327. 

  328.         features[lv2_feature_id_ui_port_map]       = new LV2_Feature;

  329.         features[lv2_feature_id_ui_port_map]->URI  = LV2_UI__portMap;

  330.         features[lv2_feature_id_ui_port_map]->data = uiPortMapFt;

  331. 

  332.         features[lv2_feature_id_ui_resize]         = new LV2_Feature;

  333.         features[lv2_feature_id_ui_resize]->URI    = LV2_UI__resize;

  334.         features[lv2_feature_id_ui_resize]->data   = uiResizeFt;

  335. #endif

  336.     }

  337. 

  338.     ~CarlaLv2Client()

  339.     {

  340.         if (rdf_descriptor)

  341.             delete rdf_descriptor;

  342. 

  343. #if 0

  344.         const LV2_Options_Option* const options = (const LV2_Options_Option*)features[lv2_feature_id_options]->data;

  345.         delete[] options;

  346. 

  347.         delete (LV2_Event_Feature*)features[lv2_feature_id_event]->data;

  348.         delete (LV2_Log_Log*)features[lv2_feature_id_logs]->data;

  349.         delete (LV2_Programs_Host*)features[lv2_feature_id_programs]->data;

  350.         delete (LV2_RtMemPool_Pool*)features[lv2_feature_id_rtmempool]->data;

  351.         delete (LV2_State_Make_Path*)features[lv2_feature_id_state_make_path]->data;

  352.         delete (LV2_State_Map_Path*)features[lv2_feature_id_state_map_path]->data;

  353.         delete (LV2_URI_Map_Feature*)features[lv2_feature_id_uri_map]->data;

  354.         delete (LV2_URID_Map*)features[lv2_feature_id_urid_map]->data;

  355.         delete (LV2_URID_Unmap*)features[lv2_feature_id_urid_unmap]->data;

  356.         delete (LV2UI_Port_Map*)features[lv2_feature_id_ui_port_map]->data;

  357.         delete (LV2UI_Resize*)features[lv2_feature_id_ui_resize]->data;

  358. #endif

  359. 

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

  361.         {

  362.             if (features[i] != nullptr)

  363.                 delete features[i];

  364.         }

  365. 

  366.         for (size_t i=0; i < customURIDs.size(); ++i)

  367.         {

  368.             if (customURIDs[i])

  369.                 free((void*)customURIDs[i]);

  370.         }

  371. 

  372.         customURIDs.clear();

  373.     }

  374. 

  375.     // ---------------------------------------------------------------------

  376.     // ui initialization

  377. 

  378.     bool uiInit(const char* pluginURI, const char* uiURI)

  379.     {

  380.         // -----------------------------------------------------------------

  381.         // init

  382. 

  383.         CarlaBridgeClient::uiInit(pluginURI, uiURI);

  384. 

  385.         // -----------------------------------------------------------------

  386.         // get plugin from lv2_rdf (lilv)

  387. 

  388.         gLv2World.init();

  389.         rdf_descriptor = lv2_rdf_new(pluginURI);

  390. 

  391.         if (! rdf_descriptor)

  392.             return false;

  393. 

  394.         // -----------------------------------------------------------------

  395.         // find requested UI

  396. 

  397.         for (uint32_t i=0; i < rdf_descriptor->UICount; ++i)

  398.         {

  399.             if (std::strcmp(rdf_descriptor->UIs[i].URI, uiURI) == 0)

  400.             {

  401.                 rdf_ui_descriptor = &rdf_descriptor->UIs[i];

  402.                 break;

  403.             }

  404.         }

  405. 

  406.         if (! rdf_ui_descriptor)

  407.             return false;

  408. 

  409.         // -----------------------------------------------------------------

  410.         // open DLL

  411. 

  412.         if (! uiLibOpen(rdf_ui_descriptor->Binary))

  413.             return false;

  414. 

  415.         // -----------------------------------------------------------------

  416.         // get DLL main entry

  417. 

  418.         const LV2UI_DescriptorFunction ui_descFn = (LV2UI_DescriptorFunction)uiLibSymbol("lv2ui_descriptor");

  419. 

  420.         if (! ui_descFn)

  421.             return false;

  422. 

  423.         // -----------------------------------------------------------

  424.         // get descriptor that matches URI

  425. 

  426.         uint32_t i = 0;

  427.         while ((descriptor = ui_descFn(i++)))

  428.         {

  429.             if (std::strcmp(descriptor->URI, uiURI) == 0)

  430.                 break;

  431.         }

  432. 

  433.         if (! descriptor)

  434.             return false;

  435. 

  436.         // -----------------------------------------------------------

  437.         // initialize UI

  438. 

  439. #ifdef BRIDGE_LV2_X11

  440.         //features[lv2_feature_id_ui_parent]->data = getContainerId();

  441. #endif

  442. 

  443.         handle = descriptor->instantiate(descriptor, pluginURI, rdf_ui_descriptor->Bundle, carla_lv2_ui_write_function, this, &widget, features);

  444. 

  445.         if (! handle)

  446.             return false;

  447. 

  448.         // -----------------------------------------------------------

  449.         // check if not resizable

  450. 

  451. #ifndef BRIDGE_LV2_X11

  452.         for (uint32_t i=0; i < rdf_ui_descriptor->FeatureCount; ++i)

  453.         {

  454.             if (std::strcmp(rdf_ui_descriptor->Features[i].URI, LV2_UI__fixedSize) == 0 || std::strcmp(rdf_ui_descriptor->Features[i].URI, LV2_UI__noUserResize) == 0)

  455.             {

  456.                 m_resizable = false;

  457.                 break;

  458.             }

  459.         }

  460. #endif

  461. 

  462.         // -----------------------------------------------------------

  463.         // check for known extensions

  464. 

  465.         for (uint32_t i=0; descriptor->extension_data && i < rdf_ui_descriptor->ExtensionCount; ++i)

  466.         {

  467.             if (std::strcmp(rdf_ui_descriptor->Extensions[i], LV2_PROGRAMS__UIInterface) == 0)

  468.             {

  469.                 programs = (LV2_Programs_UI_Interface*)descriptor->extension_data(LV2_PROGRAMS__UIInterface);

  470. 

  471.                 if (programs && ! programs->select_program)

  472.                     // invalid

  473.                     programs = nullptr;

  474. 

  475.                 break;

  476.             }

  477.         }

  478. 

  479.         return true;

  480.     }

  481. 

  482.     void uiClose()

  483.     {

  484.         CarlaBridgeClient::uiClose();

  485. 

  486.         if (handle && descriptor && descriptor->cleanup)

  487.             descriptor->cleanup(handle);

  488. 

  489.         uiLibClose();

  490.     }

  491. 

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

  493.     // ui management

  494. 

  495.     void* getWidget() const

  496.     {

  497.         return widget;

  498.     }

  499. 

  500.     bool isResizable() const

  501.     {

  502.         return m_resizable;

  503.     }

  504. 

  505.     bool needsReparent() const

  506.     {

  507. #ifdef BRIDGE_LV2_X11

  508.         return true;

  509. #else

  510.         return false;

  511. #endif

  512.     }

  513. 

  514.     // ---------------------------------------------------------------------

  515.     // processing

  516. 

  517.     void setParameter(const int32_t rindex, const float value)

  518.     {

  519.         CARLA_ASSERT(handle && descriptor);

  520. 

  521.         if (handle && descriptor && descriptor->port_event)

  522.         {

  523.             float fvalue = value;

  524.             descriptor->port_event(handle, rindex, sizeof(float), 0, &fvalue);

  525.         }

  526.     }

  527. 

  528.     void setProgram(const uint32_t)

  529.     {

  530.     }

  531. 

  532.     void setMidiProgram(const uint32_t bank, const uint32_t program)

  533.     {

  534.         CARLA_ASSERT(handle);

  535. 

  536.         if (handle && programs)

  537.             programs->select_program(handle, bank, program);

  538.     }

  539. 

  540.     void noteOn(const uint8_t channel, const uint8_t note, const uint8_t velo)

  541.     {

  542.         CARLA_ASSERT(handle && descriptor);

  543. 

  544.         if (handle && descriptor && descriptor->port_event)

  545.         {

  546.             LV2_Atom_MidiEvent midiEv;

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

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

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

  550.             midiEv.data[0] = MIDI_STATUS_NOTE_ON + channel;

  551.             midiEv.data[1] = note;

  552.             midiEv.data[2] = velo;

  553. 

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

  555.         }

  556.     }

  557. 

  558.     void noteOff(const uint8_t channel, const uint8_t note)

  559.     {

  560.         CARLA_ASSERT(handle && descriptor);

  561. 

  562.         if (handle && descriptor && descriptor->port_event)

  563.         {

  564.             LV2_Atom_MidiEvent midiEv;

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

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

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

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

  569.             midiEv.data[1] = note;

  570.             midiEv.data[2] = 0;

  571. 

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

  573.         }

  574.     }

  575. 

  576.     // ---------------------------------------------------------------------

  577. 

  578.     uint32_t getCustomURID(const char* const uri)

  579.     {

  580.         carla_debug("CarlaLv2Client::getCustomURID(%s)", uri);

  581.         CARLA_ASSERT(uri);

  582. 

  583.         if (! uri)

  584.             return CARLA_URI_MAP_ID_NULL;

  585. 

  586.         for (size_t i=0; i < customURIDs.size(); ++i)

  587.         {

  588.             if (customURIDs[i] && std::strcmp(customURIDs[i], uri) == 0)

  589.                 return i;

  590.         }

  591. 

  592.         customURIDs.push_back(strdup(uri));

  593. 

  594.         return customURIDs.size()-1;

  595.     }

  596. 

  597.     const char* getCustomURIString(const LV2_URID urid) const

  598.     {

  599.         carla_debug("CarlaLv2Client::getCustomURIString(%i)", urid);

  600.         CARLA_ASSERT(urid > CARLA_URI_MAP_ID_NULL);

  601. 

  602.         if (urid == CARLA_URI_MAP_ID_NULL)

  603.             return nullptr;

  604.         if (urid < customURIDs.size())

  605.             return customURIDs[urid];

  606. 

  607.         return nullptr;

  608.     }

  609. 

  610.     // ---------------------------------------------------------------------

  611. 

  612.     void handleAtomTransfer(const uint32_t portIndex, const LV2_Atom* const atom)

  613.     {

  614.         CARLA_ASSERT(atom != nullptr);

  615.         carla_debug("CarlaLv2Client::handleTransferEvent(%i, %p)", portIndex, atom);

  616. 

  617.         if (atom != nullptr && handle != nullptr && descriptor != nullptr && descriptor->port_event != nullptr)

  618.             descriptor->port_event(handle, portIndex, lv2_atom_total_size(atom), CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM, atom);

  619.     }

  620. 

  621.     void handleUridMap(const LV2_URID urid, const char* const uri)

  622.     {

  623.         CARLA_ASSERT(urid != CARLA_URI_MAP_ID_NULL);

  624.         CARLA_ASSERT(uri != nullptr);

  625.         carla_debug("CarlaLv2Client::handleUridMap(%i, \"%s\")", urid, uri);

  626. 

  627.         // TODO

  628.     }

  629. 

  630.     // ---------------------------------------------------------------------

  631. 

  632.     void handleProgramChanged(int32_t /*index*/)

  633.     {

  634.         if (isOscControlRegistered())

  635.             sendOscConfigure("reloadprograms", "");

  636.     }

  637. 

  638.     uint32_t handleUiPortMap(const char* const symbol)

  639.     {

  640.         CARLA_ASSERT(symbol);

  641. 

  642.         if (! symbol)

  643.             return LV2UI_INVALID_PORT_INDEX;

  644. 

  645.         for (uint32_t i=0; i < rdf_descriptor->PortCount; ++i)

  646.         {

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

  648.                 return i;

  649.         }

  650. 

  651.         return LV2UI_INVALID_PORT_INDEX;

  652.     }

  653. 

  654. 

  655.     int handleUiResize(int width, int height)

  656.     {

  657.         CARLA_ASSERT(width > 0);

  658.         CARLA_ASSERT(height > 0);

  659. 

  660.         if (width <= 0 || height <= 0)

  661.             return 1;

  662. 

  663.         toolkitResize(width, height);

  664. 

  665.         return 0;

  666.     }

  667. 

  668.     void handleUiWrite(uint32_t portIndex, uint32_t bufferSize, uint32_t format, const void* buffer)

  669.     {

  670.         if (buffer == nullptr || ! isOscControlRegistered())

  671.             return;

  672. 

  673.         if (format == 0)

  674.         {

  675.             CARLA_ASSERT(bufferSize == sizeof(float));

  676. 

  677.             if (bufferSize != sizeof(float))

  678.                 return;

  679. 

  680.             const float value(*(const float*)buffer);

  681. 

  682.             sendOscControl(portIndex, value);

  683.         }

  684.         else if (format == CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM || CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT)

  685.         {

  686.             CARLA_ASSERT(bufferSize != 0);

  687. 

  688.             if (bufferSize == 0)

  689.                 return;

  690. 

  691.             QByteArray chunk((const char*)buffer, bufferSize);

  692.             sendOscLv2AtomTransfer(portIndex, chunk.toBase64().constData());

  693.         }

  694.     }

  695. 

  696.     // ----------------- Event Feature ---------------------------------------------------

  697. 

  698.     static uint32_t carla_lv2_event_ref(const LV2_Event_Callback_Data callback_data, LV2_Event* const event)

  699.     {

  700.         carla_debug("CarlaLv2Client::carla_lv2_event_ref(%p, %p)", callback_data, event);

  701.         CARLA_ASSERT(callback_data);

  702.         CARLA_ASSERT(event);

  703. 

  704.         return 0;

  705.     }

  706. 

  707.     static uint32_t carla_lv2_event_unref(const LV2_Event_Callback_Data callback_data, LV2_Event* const event)

  708.     {

  709.         carla_debug("CarlaLv2Client::carla_lv2_event_unref(%p, %p)", callback_data, event);

  710.         CARLA_ASSERT(callback_data);

  711.         CARLA_ASSERT(event);

  712. 

  713.         return 0;

  714.     }

  715. 

  716.     // ----------------- Logs Feature ----------------------------------------------------

  717. 

  718.     static int carla_lv2_log_printf(const LV2_Log_Handle handle, const LV2_URID type, const char* const fmt, ...)

  719.     {

  720.         carla_debug("CarlaLv2Client::carla_lv2_log_printf(%p, %i, %s, ...)", handle, type, fmt);

  721.         CARLA_ASSERT(handle);

  722.         CARLA_ASSERT(type > 0);

  723. 

  724. #ifndef DEBUG

  725.         if (type == CARLA_URI_MAP_ID_LOG_TRACE)

  726.             return 0;

  727. #endif

  728. 

  729.         va_list args;

  730.         va_start(args, fmt);

  731.         const int ret = carla_lv2_log_vprintf(handle, type, fmt, args);

  732.         va_end(args);

  733. 

  734.         return ret;

  735.     }

  736. 

  737.     static int carla_lv2_log_vprintf(const LV2_Log_Handle handle, const LV2_URID type, const char* const fmt, va_list ap)

  738.     {

  739.         carla_debug("CarlaLv2Client::carla_lv2_log_vprintf(%p, %i, %s, ...)", handle, type, fmt);

  740.         CARLA_ASSERT(handle);

  741.         CARLA_ASSERT(type > 0);

  742. 

  743. #ifndef DEBUG

  744.         if (type == CARLA_URI_MAP_ID_LOG_TRACE)

  745.             return 0;

  746. #endif

  747. 

  748.         char buf[8196];

  749.         vsprintf(buf, fmt, ap);

  750. 

  751.         if (*buf == 0)

  752.             return 0;

  753. 

  754.         switch (type)

  755.         {

  756.         case CARLA_URI_MAP_ID_LOG_ERROR:

  757.             qCritical("%s", buf);

  758.             break;

  759.         case CARLA_URI_MAP_ID_LOG_NOTE:

  760.             printf("%s\n", buf);

  761.             break;

  762.         case CARLA_URI_MAP_ID_LOG_TRACE:

  763.             carla_debug("%s", buf);

  764.             break;

  765.         case CARLA_URI_MAP_ID_LOG_WARNING:

  766.             carla_stderr("%s", buf);

  767.             break;

  768.         default:

  769.             break;

  770.         }

  771. 

  772.         return std::strlen(buf);

  773.     }

  774. 

  775.     // ----------------- Programs Feature ------------------------------------------------

  776. 

  777.     static void carla_lv2_program_changed(const LV2_Programs_Handle handle, const int32_t index)

  778.     {

  779.         carla_debug("CarlaLv2Client::carla_lv2_program_changed(%p, %i)", handle, index);

  780.         CARLA_ASSERT(handle);

  781. 

  782.         if (! handle)

  783.             return;

  784. 

  785.         CarlaLv2Client* const client = (CarlaLv2Client*)handle;

  786.         client->handleProgramChanged(index);

  787.     }

  788. 

  789.     // ----------------- State Feature ---------------------------------------------------

  790. 

  791.     static char* carla_lv2_state_make_path(const LV2_State_Make_Path_Handle handle, const char* const path)

  792.     {

  793.         carla_debug("CarlaLv2Client::carla_lv2_state_make_path(%p, %p)", handle, path);

  794.         CARLA_ASSERT(handle);

  795.         CARLA_ASSERT(path);

  796. 

  797.         if (! path)

  798.             return nullptr;

  799. 

  800.         QDir dir;

  801.         dir.mkpath(path);

  802.         return strdup(path);

  803.     }

  804. 

  805.     static char* carla_lv2_state_map_abstract_path(const LV2_State_Map_Path_Handle handle, const char* const absolute_path)

  806.     {

  807.         carla_debug("CarlaLv2Client::carla_lv2_state_map_abstract_path(%p, %p)", handle, absolute_path);

  808.         CARLA_ASSERT(handle);

  809.         CARLA_ASSERT(absolute_path);

  810. 

  811.         if (! absolute_path)

  812.             return nullptr;

  813. 

  814.         QDir dir(absolute_path);

  815.         return strdup(dir.canonicalPath().toUtf8().constData());

  816.     }

  817. 

  818.     static char* carla_lv2_state_map_absolute_path(const LV2_State_Map_Path_Handle handle, const char* const abstract_path)

  819.     {

  820.         carla_debug("CarlaLv2Client::carla_lv2_state_map_absolute_path(%p, %p)", handle, abstract_path);

  821.         CARLA_ASSERT(handle);

  822.         CARLA_ASSERT(abstract_path);

  823. 

  824.         if (! abstract_path)

  825.             return nullptr;

  826. 

  827.         QDir dir(abstract_path);

  828.         return strdup(dir.absolutePath().toUtf8().constData());

  829.     }

  830. 

  831.     // ----------------- URI-Map Feature ---------------------------------------

  832. 

  833.     static uint32_t carla_lv2_uri_to_id(const LV2_URI_Map_Callback_Data data, const char* const map, const char* const uri)

  834.     {

  835.         carla_debug("CarlaLv2Client::carla_lv2_uri_to_id(%p, %s, %s)", data, map, uri);

  836.         return carla_lv2_urid_map((LV2_URID_Map_Handle*)data, uri);

  837.     }

  838. 

  839.     // ----------------- URID Feature ------------------------------------------

  840. 

  841.     static LV2_URID carla_lv2_urid_map(const LV2_URID_Map_Handle handle, const char* const uri)

  842.     {

  843.         carla_debug("CarlaLv2Client::carla_lv2_urid_map(%p, %s)", handle, uri);

  844.         CARLA_ASSERT(handle);

  845.         CARLA_ASSERT(uri);

  846. 

  847.         if (! uri)

  848.             return CARLA_URI_MAP_ID_NULL;

  849. 

  850.         // Atom types

  851.         if (std::strcmp(uri, LV2_ATOM__Blank) == 0)

  852.             return CARLA_URI_MAP_ID_ATOM_BLANK;

  853.         if (std::strcmp(uri, LV2_ATOM__Chunk) == 0)

  854.             return CARLA_URI_MAP_ID_ATOM_CHUNK;

  855.         if (std::strcmp(uri, LV2_ATOM__Double) == 0)

  856.             return CARLA_URI_MAP_ID_ATOM_DOUBLE;

  857.         if (std::strcmp(uri, LV2_ATOM__Int) == 0)

  858.             return CARLA_URI_MAP_ID_ATOM_INT;

  859.         if (std::strcmp(uri, LV2_ATOM__Path) == 0)

  860.             return CARLA_URI_MAP_ID_ATOM_PATH;

  861.         if (std::strcmp(uri, LV2_ATOM__Sequence) == 0)

  862.             return CARLA_URI_MAP_ID_ATOM_SEQUENCE;

  863.         if (std::strcmp(uri, LV2_ATOM__String) == 0)

  864.             return CARLA_URI_MAP_ID_ATOM_STRING;

  865.         if (std::strcmp(uri, LV2_ATOM__atomTransfer) == 0)

  866.             return CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM;

  867.         if (std::strcmp(uri, LV2_ATOM__eventTransfer) == 0)

  868.             return CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT;

  869. 

  870.         // BufSize types

  871.         if (std::strcmp(uri, LV2_BUF_SIZE__maxBlockLength) == 0)

  872.             return CARLA_URI_MAP_ID_BUF_MAX_LENGTH;

  873.         if (std::strcmp(uri, LV2_BUF_SIZE__minBlockLength) == 0)

  874.             return CARLA_URI_MAP_ID_BUF_MIN_LENGTH;

  875.         if (std::strcmp(uri, LV2_BUF_SIZE__sequenceSize) == 0)

  876.             return CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE;

  877. 

  878.         // Log types

  879.         if (std::strcmp(uri, LV2_LOG__Error) == 0)

  880.             return CARLA_URI_MAP_ID_LOG_ERROR;

  881.         if (std::strcmp(uri, LV2_LOG__Note) == 0)

  882.             return CARLA_URI_MAP_ID_LOG_NOTE;

  883.         if (std::strcmp(uri, LV2_LOG__Trace) == 0)

  884.             return CARLA_URI_MAP_ID_LOG_TRACE;

  885.         if (std::strcmp(uri, LV2_LOG__Warning) == 0)

  886.             return CARLA_URI_MAP_ID_LOG_WARNING;

  887. 

  888.         // Others

  889.         if (std::strcmp(uri, LV2_MIDI__MidiEvent) == 0)

  890.             return CARLA_URI_MAP_ID_MIDI_EVENT;

  891.         if (std::strcmp(uri, LV2_PARAMETERS__sampleRate) == 0)

  892.             return CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE;

  893. 

  894.         if (! handle)

  895.             return CARLA_URI_MAP_ID_NULL;

  896. 

  897.         // Custom types

  898.         CarlaLv2Client* const client = (CarlaLv2Client*)handle;

  899.         return client->getCustomURID(uri);

  900.     }

  901. 

  902.     static const char* carla_lv2_urid_unmap(const LV2_URID_Map_Handle handle, const LV2_URID urid)

  903.     {

  904.         carla_debug("CarlaLv2Client::carla_lv2_urid_unmap(%p, %i)", handle, urid);

  905.         CARLA_ASSERT(handle);

  906.         CARLA_ASSERT(urid > CARLA_URI_MAP_ID_NULL);

  907. 

  908.         if (urid == CARLA_URI_MAP_ID_NULL)

  909.             return nullptr;

  910. 

  911.         // Atom types

  912.         if (urid == CARLA_URI_MAP_ID_ATOM_BLANK)

  913.             return LV2_ATOM__Blank;

  914.         if (urid == CARLA_URI_MAP_ID_ATOM_CHUNK)

  915.             return LV2_ATOM__Chunk;

  916.         if (urid == CARLA_URI_MAP_ID_ATOM_DOUBLE)

  917.             return LV2_ATOM__Double;

  918.         if (urid == CARLA_URI_MAP_ID_ATOM_INT)

  919.             return LV2_ATOM__Int;

  920.         if (urid == CARLA_URI_MAP_ID_ATOM_PATH)

  921.             return LV2_ATOM__Path;

  922.         if (urid == CARLA_URI_MAP_ID_ATOM_SEQUENCE)

  923.             return LV2_ATOM__Sequence;

  924.         if (urid == CARLA_URI_MAP_ID_ATOM_STRING)

  925.             return LV2_ATOM__String;

  926.         if (urid == CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM)

  927.             return LV2_ATOM__atomTransfer;

  928.         if (urid == CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT)

  929.             return LV2_ATOM__eventTransfer;

  930. 

  931.         // BufSize types

  932.         if (urid == CARLA_URI_MAP_ID_BUF_MAX_LENGTH)

  933.             return LV2_BUF_SIZE__maxBlockLength;

  934.         if (urid == CARLA_URI_MAP_ID_BUF_MIN_LENGTH)

  935.             return LV2_BUF_SIZE__minBlockLength;

  936.         if (urid == CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE)

  937.             return LV2_BUF_SIZE__sequenceSize;

  938. 

  939.         // Log types

  940.         if (urid == CARLA_URI_MAP_ID_LOG_ERROR)

  941.             return LV2_LOG__Error;

  942.         if (urid == CARLA_URI_MAP_ID_LOG_NOTE)

  943.             return LV2_LOG__Note;

  944.         if (urid == CARLA_URI_MAP_ID_LOG_TRACE)

  945.             return LV2_LOG__Trace;

  946.         if (urid == CARLA_URI_MAP_ID_LOG_WARNING)

  947.             return LV2_LOG__Warning;

  948. 

  949.         // Others

  950.         if (urid == CARLA_URI_MAP_ID_MIDI_EVENT)

  951.             return LV2_MIDI__MidiEvent;

  952.         if (urid == CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE)

  953.             return LV2_PARAMETERS__sampleRate;

  954. 

  955.         if (! handle)

  956.             return nullptr;

  957. 

  958.         // Custom types

  959.         CarlaLv2Client* const client = (CarlaLv2Client*)handle;

  960.         return client->getCustomURIString(urid);

  961.     }

  962. 

  963.     // ----------------- UI Port-Map Feature ---------------------------------------------

  964. 

  965.     static uint32_t carla_lv2_ui_port_map(const LV2UI_Feature_Handle handle, const char* const symbol)

  966.     {

  967.         carla_debug("CarlaLv2Client::carla_lv2_ui_port_map(%p, %s)", handle, symbol);

  968.         CARLA_ASSERT(handle);

  969. 

  970.         if (! handle)

  971.             return LV2UI_INVALID_PORT_INDEX;

  972. 

  973.         CarlaLv2Client* const client = (CarlaLv2Client*)handle;

  974.         return client->handleUiPortMap(symbol);

  975.     }

  976. 

  977. 

  978.     // ----------------- UI Resize Feature -------------------------------------

  979. 

  980.     static int carla_lv2_ui_resize(const LV2UI_Feature_Handle handle, const int width, const int height)

  981.     {

  982.         carla_debug("CarlaLv2Client::carla_lv2_ui_resize(%p, %i, %i)", handle, width, height);

  983.         CARLA_ASSERT(handle);

  984. 

  985.         if (! handle)

  986.             return 1;

  987. 

  988.         CarlaLv2Client* const client = (CarlaLv2Client*)handle;

  989.         return client->handleUiResize(width, height);

  990.     }

  991. 

  992.     // ----------------- UI Extension ------------------------------------------

  993. 

  994.     static void carla_lv2_ui_write_function(const LV2UI_Controller controller, const uint32_t port_index, const uint32_t buffer_size, const uint32_t format, const void* const buffer)

  995.     {

  996.         carla_debug("CarlaLv2Client::carla_lv2_ui_write_function(%p, %i, %i, %i, %p)", controller, port_index, buffer_size, format, buffer);

  997.         CARLA_ASSERT(controller);

  998. 

  999.         if (! controller)

  1000.             return;

  1001. 

  1002.         CarlaLv2Client* const client = (CarlaLv2Client*)controller;

  1003.         client->handleUiWrite(port_index, buffer_size, format, buffer);

  1004.     }

  1005. 

  1006. private:

  1007.     LV2UI_Handle handle;

  1008.     LV2UI_Widget widget;

  1009.     const LV2UI_Descriptor* descriptor;

  1010.     LV2_Feature* features[kFeatureCount+1];

  1011. 

  1012.     const LV2_RDF_Descriptor* rdf_descriptor;

  1013.     const LV2_RDF_UI* rdf_ui_descriptor;

  1014. 

  1015.     const LV2_Programs_UI_Interface* programs;

  1016. 

  1017.     bool m_resizable;

  1018.     std::vector<const char*> customURIDs;

  1019. };

  1020. 

  1021. #define lv2ClientPtr ((CarlaLv2Client*)kClient)

  1022. 

  1023. int CarlaBridgeOsc::handleMsgLv2AtomTransfer(CARLA_BRIDGE_OSC_HANDLE_ARGS)

  1024. {

  1025.     CARLA_BRIDGE_OSC_CHECK_OSC_TYPES(2, "is");

  1026.     carla_debug("CarlaBridgeOsc::handleMsgLv2AtomTransfer()");

  1027. 

  1028.     if (kClient == nullptr)

  1029.         return 1;

  1030. 

  1031.     const int32_t   portIndex = argv[0]->i;

  1032.     const char* const atomBuf = (const char*)&argv[1]->s;

  1033. 

  1034.     if (portIndex < 0)

  1035.         return 0;

  1036. 

  1037.     QByteArray chunk;

  1038.     chunk = QByteArray::fromBase64(atomBuf);

  1039. 

  1040.     LV2_Atom* const atom = (LV2_Atom*)chunk.constData();

  1041. 

  1042.     lv2ClientPtr->handleAtomTransfer(portIndex, atom);

  1043.     return 0;

  1044. }

  1045. 

  1046. int CarlaBridgeOsc::handleMsgLv2UridMap(CARLA_BRIDGE_OSC_HANDLE_ARGS)

  1047. {

  1048.     CARLA_BRIDGE_OSC_CHECK_OSC_TYPES(2, "is");

  1049.     carla_debug("CarlaBridgeOsc::handleMsgLv2UridMap()");

  1050. 

  1051.     if (kClient == nullptr)

  1052.         return 1;

  1053. 

  1054.     const int32_t    urid = argv[0]->i;

  1055.     const char* const uri = (const char*)&argv[1]->s;

  1056. 

  1057.     if (urid <= 0)

  1058.         return 0;

  1059. 

  1060.     lv2ClientPtr->handleUridMap(urid, uri);

  1061.     return 0;

  1062. }

  1063. 

  1064. #undef lv2ClientPtr

  1065. 

  1066. CARLA_BRIDGE_END_NAMESPACE

  1067. 

  1068. int main(int argc, char* argv[])

  1069. {

  1070.     CARLA_BRIDGE_USE_NAMESPACE

  1071. 

  1072.     if (argc != 5)

  1073.     {

  1074.         carla_stderr("usage: %s <osc-url|\"null\"> <plugin-uri> <ui-uri> <ui-title>", argv[0]);

  1075.         return 1;

  1076.     }

  1077. 

  1078.     const char* oscUrl    = argv[1];

  1079.     const char* pluginURI = argv[2];

  1080.     const char* uiURI     = argv[3];

  1081.     const char* uiTitle   = argv[4];

  1082. 

  1083.     const bool useOsc = std::strcmp(oscUrl, "null");

  1084. 

  1085.     // try to get sampleRate value

  1086.     if (const char* const sampleRateStr = getenv("CARLA_SAMPLE_RATE"))

  1087.         gSampleRate = atof(sampleRateStr);

  1088. 

  1089.     // Init LV2 client

  1090.     CarlaLv2Client client(uiTitle);

  1091. 

  1092.     // Init OSC

  1093.     if (useOsc)

  1094.         client.oscInit(oscUrl);

  1095. 

  1096.     // Load UI

  1097.     int ret;

  1098. 

  1099.     if (client.uiInit(pluginURI, uiURI))

  1100.     {

  1101.         client.toolkitExec(!useOsc);

  1102.         ret = 0;

  1103.     }

  1104.     else

  1105.     {

  1106.         qCritical("Failed to load LV2 UI");

  1107.         ret = 1;

  1108.     }

  1109. 

  1110.     // Close OSC

  1111.     if (useOsc)

  1112.         client.oscClose();

  1113. 

  1114.     // Close LV2 client

  1115.     client.uiClose();

  1116. 

  1117.     return ret;

  1118. }