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.
412 Commits
17 Branches
381MB
Tree: 46cad25ee9
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '46cad25ee9'
${ noResults }
Carla/source/bridges/CarlaBridgeUI-LV2.cpp

1120 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. #ifdef BRIDGE_LV2

  19. 

  20. #include "CarlaBridgeClient.hpp"

  21. #include "CarlaLv2Utils.hpp"

  22. #include "CarlaMIDI.h"

  23. 

  24. extern "C" {

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

  26. }

  27. 

  28. #include <vector>

  29. #include <QtCore/QDir>

  30. 

  31. Lv2WorldClass gLv2World;

  32. 

  33. CARLA_BRIDGE_START_NAMESPACE

  34. 

  35. // -------------------------------------------------------------------------

  36. 

  37. // fake values

  38. uint32_t bufferSize = 512;

  39. double   sampleRate = 44100.0;

  40. 

  41. // static max values

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

  43. 

  44. // feature ids

  45. const uint32_t lv2_feature_id_bufsize_bounded  =  0;

  46. const uint32_t lv2_feature_id_bufsize_fixed    =  1;

  47. const uint32_t lv2_feature_id_bufsize_powerof2 =  2;

  48. const uint32_t lv2_feature_id_event            =  3;

  49. const uint32_t lv2_feature_id_logs             =  4;

  50. const uint32_t lv2_feature_id_options          =  5;

  51. const uint32_t lv2_feature_id_programs         =  6;

  52. const uint32_t lv2_feature_id_rtmempool        =  7;

  53. const uint32_t lv2_feature_id_state_make_path  =  8;

  54. const uint32_t lv2_feature_id_state_map_path   =  9;

  55. const uint32_t lv2_feature_id_strict_bounds    = 10;

  56. const uint32_t lv2_feature_id_uri_map          = 11;

  57. const uint32_t lv2_feature_id_urid_map         = 12;

  58. const uint32_t lv2_feature_id_urid_unmap       = 13;

  59. const uint32_t lv2_feature_id_ui_parent        = 14;

  60. const uint32_t lv2_feature_id_ui_port_map      = 15;

  61. const uint32_t lv2_feature_id_ui_resize        = 16;

  62. const uint32_t lv2_feature_count               = 17;

  63. 

  64. // pre-set uri[d] map ids

  65. const uint32_t CARLA_URI_MAP_ID_NULL                = 0;

  66. const uint32_t CARLA_URI_MAP_ID_ATOM_CHUNK          = 1;

  67. const uint32_t CARLA_URI_MAP_ID_ATOM_DOUBLE         = 2;

  68. const uint32_t CARLA_URI_MAP_ID_ATOM_INT            = 3;

  69. const uint32_t CARLA_URI_MAP_ID_ATOM_PATH           = 4;

  70. const uint32_t CARLA_URI_MAP_ID_ATOM_SEQUENCE       = 5;

  71. const uint32_t CARLA_URI_MAP_ID_ATOM_STRING         = 6;

  72. const uint32_t CARLA_URI_MAP_ID_ATOM_WORKER         = 7;

  73. const uint32_t CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM  = 8;

  74. const uint32_t CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT = 9;

  75. const uint32_t CARLA_URI_MAP_ID_BUF_MAX_LENGTH      = 10;

  76. const uint32_t CARLA_URI_MAP_ID_BUF_MIN_LENGTH      = 11;

  77. const uint32_t CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE   = 12;

  78. const uint32_t CARLA_URI_MAP_ID_LOG_ERROR           = 13;

  79. const uint32_t CARLA_URI_MAP_ID_LOG_NOTE            = 14;

  80. const uint32_t CARLA_URI_MAP_ID_LOG_TRACE           = 15;

  81. const uint32_t CARLA_URI_MAP_ID_LOG_WARNING         = 16;

  82. const uint32_t CARLA_URI_MAP_ID_MIDI_EVENT          = 17;

  83. const uint32_t CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE   = 18;

  84. const uint32_t CARLA_URI_MAP_ID_COUNT               = 19;

  85. 

  86. // -------------------------------------------------------------------------

  87. 

  88. struct Lv2PluginOptions {

  89.     uint32_t eventSize;

  90.     uint32_t bufferSize;

  91.     double   sampleRate;

  92.     LV2_Options_Option oNull;

  93.     LV2_Options_Option oMaxBlockLenth;

  94.     LV2_Options_Option oMinBlockLenth;

  95.     LV2_Options_Option oSequenceSize;

  96.     LV2_Options_Option oSampleRate;

  97. 

  98.     Lv2PluginOptions()

  99.         : eventSize(MAX_EVENT_BUFFER),

  100.           bufferSize(0),

  101.           sampleRate(0.0) {}

  102. };

  103. 

  104. Lv2PluginOptions lv2Options;

  105. 

  106. class CarlaLv2Client : public CarlaBridgeClient

  107. {

  108. public:

  109.     CarlaLv2Client(const char* const uiTitle)

  110.         : CarlaBridgeClient(uiTitle)

  111.     {

  112.         handle = nullptr;

  113.         widget = nullptr;

  114.         descriptor = nullptr;

  115. 

  116.         rdf_descriptor = nullptr;

  117.         rdf_ui_descriptor = nullptr;

  118. 

  119.         programs = nullptr;

  120. 

  121. #ifdef BRIDGE_LV2_X11

  122.         m_resizable = false;

  123. #else

  124.         m_resizable = true;

  125. #endif

  126. 

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

  128.             customURIDs.push_back(nullptr);

  129. 

  130.         for (uint32_t i=0; i < lv2_feature_count+1; i++)

  131.             features[i] = nullptr;

  132. 

  133.         // -----------------------------------------------------------------

  134.         // initialize options

  135. 

  136.         lv2Options.bufferSize = bufferSize;

  137.         lv2Options.sampleRate = sampleRate;

  138. 

  139.         lv2Options.oNull.key   = CARLA_URI_MAP_ID_NULL;

  140.         lv2Options.oNull.size  = 0;

  141.         lv2Options.oNull.type  = CARLA_URI_MAP_ID_NULL;

  142.         lv2Options.oNull.value = nullptr;

  143. 

  144.         lv2Options.oMaxBlockLenth.key   = CARLA_URI_MAP_ID_BUF_MAX_LENGTH;

  145.         lv2Options.oMaxBlockLenth.size  = sizeof(uint32_t);

  146.         lv2Options.oMaxBlockLenth.type  = CARLA_URI_MAP_ID_ATOM_INT;

  147.         lv2Options.oMaxBlockLenth.value = &lv2Options.bufferSize;

  148. 

  149.         lv2Options.oMinBlockLenth.key   = CARLA_URI_MAP_ID_BUF_MIN_LENGTH;

  150.         lv2Options.oMinBlockLenth.size  = sizeof(uint32_t);

  151.         lv2Options.oMinBlockLenth.type  = CARLA_URI_MAP_ID_ATOM_INT;

  152.         lv2Options.oMinBlockLenth.value = &lv2Options.bufferSize;

  153. 

  154.         lv2Options.oSequenceSize.key   = CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE;

  155.         lv2Options.oSequenceSize.size  = sizeof(uint32_t);

  156.         lv2Options.oSequenceSize.type  = CARLA_URI_MAP_ID_ATOM_INT;

  157.         lv2Options.oSequenceSize.value = &lv2Options.eventSize;

  158. 

  159.         lv2Options.oSampleRate.key     = CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE;

  160.         lv2Options.oSampleRate.size    = sizeof(double);

  161.         lv2Options.oSampleRate.type    = CARLA_URI_MAP_ID_ATOM_DOUBLE;

  162.         lv2Options.oSampleRate.value   = &lv2Options.sampleRate;

  163. 

  164.         // -----------------------------------------------------------------

  165.         // initialize features

  166. 

  167.         LV2_Event_Feature* const eventFt = new LV2_Event_Feature;

  168.         eventFt->callback_data           = this;

  169.         eventFt->lv2_event_ref           = carla_lv2_event_ref;

  170.         eventFt->lv2_event_unref         = carla_lv2_event_unref;

  171. 

  172.         LV2_Log_Log* const logFt         = new LV2_Log_Log;

  173.         logFt->handle                    = this;

  174.         logFt->printf                    = carla_lv2_log_printf;

  175.         logFt->vprintf                   = carla_lv2_log_vprintf;

  176. 

  177.         LV2_Programs_Host* const programsFt        = new LV2_Programs_Host;

  178.         programsFt->handle                         = this;

  179.         programsFt->program_changed                = carla_lv2_program_changed;

  180. 

  181.         LV2_RtMemPool_Pool* const rtMemPoolFt      = new LV2_RtMemPool_Pool;

  182.         lv2_rtmempool_init(rtMemPoolFt);

  183. 

  184.         LV2_State_Make_Path* const stateMakePathFt = new LV2_State_Make_Path;

  185.         stateMakePathFt->handle                    = this;

  186.         stateMakePathFt->path                      = carla_lv2_state_make_path;

  187. 

  188.         LV2_State_Map_Path* const stateMapPathFt   = new LV2_State_Map_Path;

  189.         stateMapPathFt->handle                     = this;

  190.         stateMapPathFt->abstract_path              = carla_lv2_state_map_abstract_path;

  191.         stateMapPathFt->absolute_path              = carla_lv2_state_map_absolute_path;

  192. 

  193.         LV2_URI_Map_Feature* const uriMapFt = new LV2_URI_Map_Feature;

  194.         uriMapFt->callback_data             = this;

  195.         uriMapFt->uri_to_id                 = carla_lv2_uri_to_id;

  196. 

  197.         LV2_URID_Map* const uridMapFt       = new LV2_URID_Map;

  198.         uridMapFt->handle                   = this;

  199.         uridMapFt->map                      = carla_lv2_urid_map;

  200. 

  201.         LV2_URID_Unmap* const uridUnmapFt   = new LV2_URID_Unmap;

  202.         uridUnmapFt->handle                 = this;

  203.         uridUnmapFt->unmap                  = carla_lv2_urid_unmap;

  204. 

  205.         LV2UI_Port_Map* const uiPortMapFt   = new LV2UI_Port_Map;

  206.         uiPortMapFt->handle                 = this;

  207.         uiPortMapFt->port_index             = carla_lv2_ui_port_map;

  208. 

  209.         LV2UI_Resize* const uiResizeFt      = new LV2UI_Resize;

  210.         uiResizeFt->handle                  = this;

  211.         uiResizeFt->ui_resize               = carla_lv2_ui_resize;

  212. 

  213.         LV2_Options_Option* const optionsFt = new LV2_Options_Option [5];

  214.         optionsFt[0] = lv2Options.oMaxBlockLenth;

  215.         optionsFt[1] = lv2Options.oMinBlockLenth;

  216.         optionsFt[2] = lv2Options.oSequenceSize;

  217.         optionsFt[3] = lv2Options.oSampleRate;

  218.         optionsFt[4] = lv2Options.oNull;

  219. 

  220.         features[lv2_feature_id_bufsize_bounded]        = new LV2_Feature;

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

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

  223. 

  224.         features[lv2_feature_id_bufsize_fixed]          = new LV2_Feature;

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

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

  227. 

  228.         features[lv2_feature_id_bufsize_powerof2]       = new LV2_Feature;

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

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

  231. 

  232.         features[lv2_feature_id_event]          = new LV2_Feature;

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

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

  235. 

  236.         features[lv2_feature_id_logs]           = new LV2_Feature;

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

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

  239. 

  240.         features[lv2_feature_id_options]        = new LV2_Feature;

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

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

  243. 

  244.         features[lv2_feature_id_programs]       = new LV2_Feature;

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

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

  247. 

  248.         features[lv2_feature_id_rtmempool]       = new LV2_Feature;

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

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

  251. 

  252.         features[lv2_feature_id_state_make_path]       = new LV2_Feature;

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

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

  255. 

  256.         features[lv2_feature_id_state_map_path]        = new LV2_Feature;

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

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

  259. 

  260.         features[lv2_feature_id_strict_bounds]         = new LV2_Feature;

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

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

  263. 

  264.         features[lv2_feature_id_uri_map]          = new LV2_Feature;

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

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

  267. 

  268.         features[lv2_feature_id_urid_map]         = new LV2_Feature;

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

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

  271. 

  272.         features[lv2_feature_id_urid_unmap]       = new LV2_Feature;

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

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

  275. 

  276.         features[lv2_feature_id_ui_parent]         = new LV2_Feature;

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

  278. #ifdef BRIDGE_LV2_X11

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

  280. #else

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

  282. #endif

  283. 

  284.         features[lv2_feature_id_ui_port_map]           = new LV2_Feature;

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

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

  287. 

  288.         features[lv2_feature_id_ui_resize]             = new LV2_Feature;

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

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

  291.     }

  292. 

  293.     ~CarlaLv2Client()

  294.     {

  295.         if (rdf_descriptor)

  296.             delete rdf_descriptor;

  297. 

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

  299.         delete[] options;

  300. 

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

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

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

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

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

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

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

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

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

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

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

  312. 

  313.         for (uint32_t i=0; i < lv2_feature_count; i++)

  314.         {

  315.             if (features[i])

  316.                 delete features[i];

  317.         }

  318. 

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

  320.         {

  321.             if (customURIDs[i])

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

  323.         }

  324. 

  325.         customURIDs.clear();

  326.     }

  327. 

  328.     // ---------------------------------------------------------------------

  329.     // ui initialization

  330. 

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

  332.     {

  333.         // -----------------------------------------------------------------

  334.         // init

  335. 

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

  337. 

  338.         // -----------------------------------------------------------------

  339.         // get plugin from lv2_rdf (lilv)

  340. 

  341.         gLv2World.init();

  342.         rdf_descriptor = lv2_rdf_new(pluginURI);

  343. 

  344.         if (! rdf_descriptor)

  345.             return false;

  346. 

  347.         // -----------------------------------------------------------------

  348.         // find requested UI

  349. 

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

  351.         {

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

  353.             {

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

  355.                 break;

  356.             }

  357.         }

  358. 

  359.         if (! rdf_ui_descriptor)

  360.             return false;

  361. 

  362.         // -----------------------------------------------------------------

  363.         // open DLL

  364. 

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

  366.             return false;

  367. 

  368.         // -----------------------------------------------------------------

  369.         // get DLL main entry

  370. 

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

  372. 

  373.         if (! ui_descFn)

  374.             return false;

  375. 

  376.         // -----------------------------------------------------------

  377.         // get descriptor that matches URI

  378. 

  379.         uint32_t i = 0;

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

  381.         {

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

  383.                 break;

  384.         }

  385. 

  386.         if (! descriptor)

  387.             return false;

  388. 

  389.         // -----------------------------------------------------------

  390.         // initialize UI

  391. 

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

  393. 

  394.         if (! handle)

  395.             return false;

  396. 

  397.         // -----------------------------------------------------------

  398.         // check if not resizable

  399. 

  400. #ifndef BRIDGE_LV2_X11

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

  402.         {

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

  404.             {

  405.                 m_resizable = false;

  406.                 break;

  407.             }

  408.         }

  409. #endif

  410. 

  411.         // -----------------------------------------------------------

  412.         // check for known extensions

  413. 

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

  415.         {

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

  417.             {

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

  419. 

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

  421.                     // invalid

  422.                     programs = nullptr;

  423. 

  424.                 break;

  425.             }

  426.         }

  427. 

  428.         return true;

  429.     }

  430. 

  431.     void uiClose()

  432.     {

  433.         CarlaBridgeClient::uiClose();

  434. 

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

  436.             descriptor->cleanup(handle);

  437. 

  438.         uiLibClose();

  439.     }

  440. 

  441.     // ---------------------------------------------------------------------

  442.     // ui management

  443. 

  444.     void* getWidget() const

  445.     {

  446.         return widget;

  447.     }

  448. 

  449.     bool isResizable() const

  450.     {

  451.         return m_resizable;

  452.     }

  453. 

  454.     bool needsReparent() const

  455.     {

  456. #ifdef BRIDGE_LV2_X11

  457.         return true;

  458. #else

  459.         return false;

  460. #endif

  461.     }

  462. 

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

  464.     // processing

  465. 

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

  467.     {

  468.         CARLA_ASSERT(handle && descriptor);

  469. 

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

  471.         {

  472.             float fvalue = value;

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

  474.         }

  475.     }

  476. 

  477.     void setProgram(const uint32_t)

  478.     {

  479.     }

  480. 

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

  482.     {

  483.         CARLA_ASSERT(handle);

  484. 

  485.         if (handle && programs)

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

  487.     }

  488. 

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

  490.     {

  491.         CARLA_ASSERT(handle && descriptor);

  492. 

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

  494.         {

  495.             LV2_Atom_MidiEvent midiEv;

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

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

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

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

  500.             midiEv.data[1] = note;

  501.             midiEv.data[2] = velo;

  502. 

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

  504.         }

  505.     }

  506. 

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

  508.     {

  509.         CARLA_ASSERT(handle && descriptor);

  510. 

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

  512.         {

  513.             LV2_Atom_MidiEvent midiEv;

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

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

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

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

  518.             midiEv.data[1] = note;

  519.             midiEv.data[2] = 0;

  520. 

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

  522.         }

  523.     }

  524. 

  525.     // ---------------------------------------------------------------------

  526. 

  527.     uint32_t getCustomURID(const char* const uri)

  528.     {

  529.         qDebug("CarlaLv2Client::getCustomURID(%s)", uri);

  530.         CARLA_ASSERT(uri);

  531. 

  532.         if (! uri)

  533.             return CARLA_URI_MAP_ID_NULL;

  534. 

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

  536.         {

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

  538.                 return i;

  539.         }

  540. 

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

  542. 

  543.         return customURIDs.size()-1;

  544.     }

  545. 

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

  547.     {

  548.         qDebug("CarlaLv2Client::getCustomURIString(%i)", urid);

  549.         CARLA_ASSERT(urid > CARLA_URI_MAP_ID_NULL);

  550. 

  551.         if (urid == CARLA_URI_MAP_ID_NULL)

  552.             return nullptr;

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

  554.             return customURIDs[urid];

  555. 

  556.         return nullptr;

  557.     }

  558. 

  559.     // ---------------------------------------------------------------------

  560. 

  561.     void handleTransferAtom(const int32_t portIndex, const LV2_Atom* const atom)

  562.     {

  563.         qDebug("CarlaLv2Client::handleTransferEvent(%i, %p)", portIndex, atom);

  564.         CARLA_ASSERT(portIndex >= 0);

  565.         CARLA_ASSERT(atom);

  566. 

  567.         if (atom && handle && descriptor && descriptor->port_event)

  568.             descriptor->port_event(handle, portIndex, atom->size, CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM, atom);

  569.     }

  570. 

  571.     void handleTransferEvent(const int32_t portIndex, const LV2_Atom* const atom)

  572.     {

  573.         qDebug("CarlaLv2Client::handleTransferEvent(%i, %p)", portIndex, atom);

  574.         CARLA_ASSERT(portIndex >= 0);

  575.         CARLA_ASSERT(atom);

  576. 

  577.         if (atom && handle && descriptor && descriptor->port_event)

  578.             descriptor->port_event(handle, portIndex, atom->size, CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT, atom);

  579. #if 0

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

  581.         {

  582.             LV2_URID_Map* const URID_Map = (LV2_URID_Map*)features[lv2_feature_id_urid_map]->data;

  583.             const LV2_URID uridPatchSet  = getCustomURID(LV2_PATCH__Set);

  584.             const LV2_URID uridPatchBody = getCustomURID(LV2_PATCH__body);

  585. 

  586.             Sratom*   sratom = sratom_new(URID_Map);

  587.             SerdChunk chunk  = { nullptr, 0 };

  588. 

  589.             LV2_Atom_Forge forge;

  590.             lv2_atom_forge_init(&forge, URID_Map);

  591.             lv2_atom_forge_set_sink(&forge, sratom_forge_sink, sratom_forge_deref, &chunk);

  592. 

  593.             LV2_Atom_Forge_Frame refFrame, bodyFrame;

  594.             LV2_Atom_Forge_Ref   ref = lv2_atom_forge_blank(&forge, &refFrame, 1, uridPatchSet);

  595. 

  596.             lv2_atom_forge_property_head(&forge, uridPatchBody, CARLA_URI_MAP_ID_NULL);

  597.             lv2_atom_forge_blank(&forge, &bodyFrame, 2, CARLA_URI_MAP_ID_NULL);

  598. 

  599.             //lv2_atom_forge_property_head(&forge, getCustomURID(key), CARLA_URI_MAP_ID_NULL);

  600. 

  601.             if (std::strcmp(type, "string") == 0)

  602.                 lv2_atom_forge_string(&forge, value, std::strlen(value));

  603.             else if (std::strcmp(type, "path") == 0)

  604.                 lv2_atom_forge_path(&forge, value, std::strlen(value));

  605.             else if (std::strcmp(type, "chunk") == 0)

  606.                 lv2_atom_forge_literal(&forge, value, std::strlen(value), CARLA_URI_MAP_ID_ATOM_CHUNK, CARLA_URI_MAP_ID_NULL);

  607.             //else

  608.             //    lv2_atom_forge_literal(&forge, value, std::strlen(value), getCustomURID(key), CARLA_URI_MAP_ID_NULL);

  609. 

  610.             lv2_atom_forge_pop(&forge, &bodyFrame);

  611.             lv2_atom_forge_pop(&forge, &refFrame);

  612. 

  613.             const LV2_Atom* const atom = lv2_atom_forge_deref(&forge, ref);

  614.             descriptor->port_event(handle, 0, atom->size, CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT, atom);

  615. 

  616.             free((void*)chunk.buf);

  617.             sratom_free(sratom);

  618.         }

  619. #endif

  620.     }

  621. 

  622.     // ---------------------------------------------------------------------

  623. 

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

  625.     {

  626.         if (isOscControlRegistered())

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

  628.     }

  629. 

  630.     uint32_t handleUiPortMap(const char* const symbol)

  631.     {

  632.         CARLA_ASSERT(symbol);

  633. 

  634.         if (! symbol)

  635.             return LV2UI_INVALID_PORT_INDEX;

  636. 

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

  638.         {

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

  640.                 return i;

  641.         }

  642. 

  643.         return LV2UI_INVALID_PORT_INDEX;

  644.     }

  645. 

  646. 

  647.     int handleUiResize(int width, int height)

  648.     {

  649.         CARLA_ASSERT(width > 0);

  650.         CARLA_ASSERT(height > 0);

  651. 

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

  653.             return 1;

  654. 

  655.         toolkitResize(width, height);

  656. 

  657.         return 0;

  658.     }

  659. 

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

  661.     {

  662.         if (! (buffer && isOscControlRegistered()))

  663.             return;

  664. 

  665.         if (format == 0)

  666.         {

  667.             CARLA_ASSERT(buffer);

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

  669. 

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

  671.                 return;

  672. 

  673.             float value = *(float*)buffer;

  674.             sendOscControl(portIndex, value);

  675.         }

  676.         else if (format == CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM)

  677.         {

  678.             CARLA_ASSERT(buffer);

  679.             const LV2_Atom* const atom = (const LV2_Atom*)buffer;

  680. 

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

  682.             sendOscLv2TransferAtom(portIndex, getCustomURIString(atom->type), chunk.toBase64().constData());

  683.         }

  684.         else if (format == CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT)

  685.         {

  686.             CARLA_ASSERT(buffer);

  687.             const LV2_Atom* const atom = (const LV2_Atom*)buffer;

  688. 

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

  690.             sendOscLv2TransferEvent(portIndex, getCustomURIString(atom->type), chunk.toBase64().constData());

  691.         }

  692.     }

  693. 

  694.     // ----------------- Event Feature ---------------------------------------------------

  695. 

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

  697.     {

  698.         qDebug("CarlaLv2Client::carla_lv2_event_ref(%p, %p)", callback_data, event);

  699.         CARLA_ASSERT(callback_data);

  700.         CARLA_ASSERT(event);

  701. 

  702.         return 0;

  703.     }

  704. 

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

  706.     {

  707.         qDebug("CarlaLv2Client::carla_lv2_event_unref(%p, %p)", callback_data, event);

  708.         CARLA_ASSERT(callback_data);

  709.         CARLA_ASSERT(event);

  710. 

  711.         return 0;

  712.     }

  713. 

  714.     // ----------------- Logs Feature ----------------------------------------------------

  715. 

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

  717.     {

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

  719.         CARLA_ASSERT(handle);

  720.         CARLA_ASSERT(type > 0);

  721. 

  722. #ifndef DEBUG

  723.         if (type == CARLA_URI_MAP_ID_LOG_TRACE)

  724.             return 0;

  725. #endif

  726. 

  727.         va_list args;

  728.         va_start(args, fmt);

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

  730.         va_end(args);

  731. 

  732.         return ret;

  733.     }

  734. 

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

  736.     {

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

  738.         CARLA_ASSERT(handle);

  739.         CARLA_ASSERT(type > 0);

  740. 

  741. #ifndef DEBUG

  742.         if (type == CARLA_URI_MAP_ID_LOG_TRACE)

  743.             return 0;

  744. #endif

  745. 

  746.         char buf[8196];

  747.         vsprintf(buf, fmt, ap);

  748. 

  749.         if (*buf == 0)

  750.             return 0;

  751. 

  752.         switch (type)

  753.         {

  754.         case CARLA_URI_MAP_ID_LOG_ERROR:

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

  756.             break;

  757.         case CARLA_URI_MAP_ID_LOG_NOTE:

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

  759.             break;

  760.         case CARLA_URI_MAP_ID_LOG_TRACE:

  761.             qDebug("%s", buf);

  762.             break;

  763.         case CARLA_URI_MAP_ID_LOG_WARNING:

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

  765.             break;

  766.         default:

  767.             break;

  768.         }

  769. 

  770.         return std::strlen(buf);

  771.     }

  772. 

  773.     // ----------------- Programs Feature ------------------------------------------------

  774. 

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

  776.     {

  777.         qDebug("CarlaLv2Client::carla_lv2_program_changed(%p, %i)", handle, index);

  778.         CARLA_ASSERT(handle);

  779. 

  780.         if (! handle)

  781.             return;

  782. 

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

  784.         client->handleProgramChanged(index);

  785.     }

  786. 

  787.     // ----------------- State Feature ---------------------------------------------------

  788. 

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

  790.     {

  791.         qDebug("CarlaLv2Client::carla_lv2_state_make_path(%p, %p)", handle, path);

  792.         CARLA_ASSERT(handle);

  793.         CARLA_ASSERT(path);

  794. 

  795.         if (! path)

  796.             return nullptr;

  797. 

  798.         QDir dir;

  799.         dir.mkpath(path);

  800.         return strdup(path);

  801.     }

  802. 

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

  804.     {

  805.         qDebug("CarlaLv2Client::carla_lv2_state_map_abstract_path(%p, %p)", handle, absolute_path);

  806.         CARLA_ASSERT(handle);

  807.         CARLA_ASSERT(absolute_path);

  808. 

  809.         if (! absolute_path)

  810.             return nullptr;

  811. 

  812.         QDir dir(absolute_path);

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

  814.     }

  815. 

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

  817.     {

  818.         qDebug("CarlaLv2Client::carla_lv2_state_map_absolute_path(%p, %p)", handle, abstract_path);

  819.         CARLA_ASSERT(handle);

  820.         CARLA_ASSERT(abstract_path);

  821. 

  822.         if (! abstract_path)

  823.             return nullptr;

  824. 

  825.         QDir dir(abstract_path);

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

  827.     }

  828. 

  829.     // ----------------- URI-Map Feature ---------------------------------------

  830. 

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

  832.     {

  833.         qDebug("CarlaLv2Client::carla_lv2_uri_to_id(%p, %s, %s)", data, map, uri);

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

  835.     }

  836. 

  837.     // ----------------- URID Feature ------------------------------------------

  838. 

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

  840.     {

  841.         qDebug("CarlaLv2Client::carla_lv2_urid_map(%p, %s)", handle, uri);

  842.         CARLA_ASSERT(handle);

  843.         CARLA_ASSERT(uri);

  844. 

  845.         if (! uri)

  846.             return CARLA_URI_MAP_ID_NULL;

  847. 

  848.         // Atom types

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

  850.             return CARLA_URI_MAP_ID_ATOM_CHUNK;

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

  852.             return CARLA_URI_MAP_ID_ATOM_DOUBLE;

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

  854.             return CARLA_URI_MAP_ID_ATOM_INT;

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

  856.             return CARLA_URI_MAP_ID_ATOM_PATH;

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

  858.             return CARLA_URI_MAP_ID_ATOM_SEQUENCE;

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

  860.             return CARLA_URI_MAP_ID_ATOM_STRING;

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

  862.             return CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM;

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

  864.             return CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT;

  865. 

  866.         // BufSize types

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

  868.             return CARLA_URI_MAP_ID_BUF_MAX_LENGTH;

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

  870.             return CARLA_URI_MAP_ID_BUF_MIN_LENGTH;

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

  872.             return CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE;

  873. 

  874.         // Log types

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

  876.             return CARLA_URI_MAP_ID_LOG_ERROR;

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

  878.             return CARLA_URI_MAP_ID_LOG_NOTE;

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

  880.             return CARLA_URI_MAP_ID_LOG_TRACE;

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

  882.             return CARLA_URI_MAP_ID_LOG_WARNING;

  883. 

  884.         // Others

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

  886.             return CARLA_URI_MAP_ID_MIDI_EVENT;

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

  888.             return CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE;

  889. 

  890.         if (! handle)

  891.             return CARLA_URI_MAP_ID_NULL;

  892. 

  893.         // Custom types

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

  895.         return client->getCustomURID(uri);

  896.     }

  897. 

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

  899.     {

  900.         qDebug("CarlaLv2Client::carla_lv2_urid_unmap(%p, %i)", handle, urid);

  901.         CARLA_ASSERT(handle);

  902.         CARLA_ASSERT(urid > CARLA_URI_MAP_ID_NULL);

  903. 

  904.         if (urid == CARLA_URI_MAP_ID_NULL)

  905.             return nullptr;

  906. 

  907.         // Atom types

  908.         if (urid == CARLA_URI_MAP_ID_ATOM_CHUNK)

  909.             return LV2_ATOM__Chunk;

  910.         if (urid == CARLA_URI_MAP_ID_ATOM_DOUBLE)

  911.             return LV2_ATOM__Double;

  912.         if (urid == CARLA_URI_MAP_ID_ATOM_INT)

  913.             return LV2_ATOM__Int;

  914.         if (urid == CARLA_URI_MAP_ID_ATOM_PATH)

  915.             return LV2_ATOM__Path;

  916.         if (urid == CARLA_URI_MAP_ID_ATOM_SEQUENCE)

  917.             return LV2_ATOM__Sequence;

  918.         if (urid == CARLA_URI_MAP_ID_ATOM_STRING)

  919.             return LV2_ATOM__String;

  920.         if (urid == CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM)

  921.             return LV2_ATOM__atomTransfer;

  922.         if (urid == CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT)

  923.             return LV2_ATOM__eventTransfer;

  924. 

  925.         // BufSize types

  926.         if (urid == CARLA_URI_MAP_ID_BUF_MAX_LENGTH)

  927.             return LV2_BUF_SIZE__maxBlockLength;

  928.         if (urid == CARLA_URI_MAP_ID_BUF_MIN_LENGTH)

  929.             return LV2_BUF_SIZE__minBlockLength;

  930.         if (urid == CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE)

  931.             return LV2_BUF_SIZE__sequenceSize;

  932. 

  933.         // Log types

  934.         if (urid == CARLA_URI_MAP_ID_LOG_ERROR)

  935.             return LV2_LOG__Error;

  936.         if (urid == CARLA_URI_MAP_ID_LOG_NOTE)

  937.             return LV2_LOG__Note;

  938.         if (urid == CARLA_URI_MAP_ID_LOG_TRACE)

  939.             return LV2_LOG__Trace;

  940.         if (urid == CARLA_URI_MAP_ID_LOG_WARNING)

  941.             return LV2_LOG__Warning;

  942. 

  943.         // Others

  944.         if (urid == CARLA_URI_MAP_ID_MIDI_EVENT)

  945.             return LV2_MIDI__MidiEvent;

  946.         if (urid == CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE)

  947.             return LV2_PARAMETERS__sampleRate;

  948. 

  949.         if (! handle)

  950.             return nullptr;

  951. 

  952.         // Custom types

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

  954.         return client->getCustomURIString(urid);

  955.     }

  956. 

  957.     // ----------------- UI Port-Map Feature ---------------------------------------------

  958. 

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

  960.     {

  961.         qDebug("CarlaLv2Client::carla_lv2_ui_port_map(%p, %s)", handle, symbol);

  962.         CARLA_ASSERT(handle);

  963. 

  964.         if (! handle)

  965.             return LV2UI_INVALID_PORT_INDEX;

  966. 

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

  968.         return client->handleUiPortMap(symbol);

  969.     }

  970. 

  971. 

  972.     // ----------------- UI Resize Feature -------------------------------------

  973. 

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

  975.     {

  976.         qDebug("CarlaLv2Client::carla_lv2_ui_resize(%p, %i, %i)", handle, width, height);

  977.         CARLA_ASSERT(handle);

  978. 

  979.         if (! handle)

  980.             return 1;

  981. 

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

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

  984.     }

  985. 

  986.     // ----------------- UI Extension ------------------------------------------

  987. 

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

  989.     {

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

  991.         CARLA_ASSERT(controller);

  992. 

  993.         if (! controller)

  994.             return;

  995. 

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

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

  998.     }

  999. 

  1000. private:

  1001.     LV2UI_Handle handle;

  1002.     LV2UI_Widget widget;

  1003.     const LV2UI_Descriptor* descriptor;

  1004.     LV2_Feature* features[lv2_feature_count+1];

  1005. 

  1006.     const LV2_RDF_Descriptor* rdf_descriptor;

  1007.     const LV2_RDF_UI* rdf_ui_descriptor;

  1008. 

  1009.     const LV2_Programs_UI_Interface* programs;

  1010. 

  1011.     bool m_resizable;

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

  1013. };

  1014. 

  1015. int CarlaBridgeOsc::handleMsgLv2TransferAtom(CARLA_BRIDGE_OSC_HANDLE_ARGS)

  1016. {

  1017.     qDebug("CarlaBridgeOsc::handleMsgLv2TransferAtom()");

  1018.     CARLA_BRIDGE_OSC_CHECK_OSC_TYPES(3, "iss");

  1019. 

  1020.     if (! kClient)

  1021.         return 1;

  1022. 

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

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

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

  1026. 

  1027.     QByteArray chunk;

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

  1029. 

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

  1031.     CarlaLv2Client* const lv2Client = (CarlaLv2Client*)kClient;

  1032. 

  1033.     atom->type = lv2Client->getCustomURID(typeStr);

  1034.     lv2Client->handleTransferAtom(portIndex, atom);

  1035. 

  1036.     return 0;

  1037. }

  1038. 

  1039. int CarlaBridgeOsc::handleMsgLv2TransferEvent(CARLA_BRIDGE_OSC_HANDLE_ARGS)

  1040. {

  1041.     qDebug("CarlaBridgeOsc::handleMsgLv2TransferEvent()");

  1042.     CARLA_BRIDGE_OSC_CHECK_OSC_TYPES(3, "iss");

  1043. 

  1044.     if (! kClient)

  1045.         return 1;

  1046. 

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

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

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

  1050. 

  1051.     QByteArray chunk;

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

  1053. 

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

  1055.     CarlaLv2Client* const lv2Client = (CarlaLv2Client*)kClient;

  1056. 

  1057.     atom->type = lv2Client->getCustomURID(typeStr);

  1058.     lv2Client->handleTransferEvent(portIndex, atom);

  1059. 

  1060.     return 0;

  1061. }

  1062. 

  1063. CARLA_BRIDGE_END_NAMESPACE

  1064. 

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

  1066. {

  1067.     CARLA_BRIDGE_USE_NAMESPACE

  1068. 

  1069.     if (argc != 5)

  1070.     {

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

  1072.         return 1;

  1073.     }

  1074. 

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

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

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

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

  1079. 

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

  1081. 

  1082.     // try to get sampleRate value

  1083.     const char* const sampleRateStr = getenv("CARLA_SAMPLE_RATE");

  1084. 

  1085.     if (sampleRateStr)

  1086.         sampleRate = atof(sampleRateStr);

  1087. 

  1088.     // Init LV2 client

  1089.     CarlaLv2Client client(uiTitle);

  1090. 

  1091.     // Init OSC

  1092.     if (useOsc)

  1093.         client.oscInit(oscUrl);

  1094. 

  1095.     // Load UI

  1096.     int ret;

  1097. 

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

  1099.     {

  1100.         client.toolkitExec(!useOsc);

  1101.         ret = 0;

  1102.     }

  1103.     else

  1104.     {

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

  1106.         ret = 1;

  1107.     }

  1108. 

  1109.     // Close OSC

  1110.     if (useOsc)

  1111.         client.oscClose();

  1112. 

  1113.     // Close LV2 client

  1114.     client.uiClose();

  1115. 

  1116.     return ret;

  1117. }

  1118. 

  1119. #endif // BRIDGE_LV2