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.
3226 Commits
17 Branches
263MB
Tree: fdd84a4cf7
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'fdd84a4cf7'
${ noResults }
Carla/source/plugin/carla-lv2.cpp

1798 lines
61KB
Raw Blame History 

  1. /*

  2.  * Carla Native Plugins

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

  4.  *

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

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

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

  8.  * the License, or any later version.

  9.  *

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

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

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

  13.  * GNU General Public License for more details.

  14.  *

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

  16.  */

  17. 

  18. #define CARLA_NATIVE_PLUGIN_LV2

  19. #include "carla-base.cpp"

  20. 

  21. #include "CarlaLv2Utils.hpp"

  22. #include "CarlaMathUtils.hpp"

  23. #include "CarlaString.hpp"

  24. 

  25. #include "juce_audio_basics.h"

  26. 

  27. #if defined(CARLA_OS_MAC) || defined(CARLA_OS_WIN)

  28. # include "juce_gui_basics.h"

  29. #else

  30. namespace juce {

  31. # include "juce_events/messages/juce_Initialisation.h"

  32. } // namespace juce

  33. #endif

  34. 

  35. using juce::FloatVectorOperations;

  36. using juce::ScopedJuceInitialiser_GUI;

  37. using juce::SharedResourcePointer;

  38. 

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

  40. // -Weffc++ compat ext widget

  41. 

  42. extern "C" {

  43. 

  44. typedef struct _LV2_External_UI_Widget_Compat {

  45.   void (*run )(struct _LV2_External_UI_Widget_Compat*);

  46.   void (*show)(struct _LV2_External_UI_Widget_Compat*);

  47.   void (*hide)(struct _LV2_External_UI_Widget_Compat*);

  48. 

  49.   _LV2_External_UI_Widget_Compat() noexcept

  50.       : run(nullptr), show(nullptr), hide(nullptr) {}

  51. 

  52. } LV2_External_UI_Widget_Compat;

  53. 

  54. }

  55. 

  56. // -----------------------------------------------------------------------

  57. // LV2 descriptor functions

  58. 

  59. #if defined(__clang__)

  60. # pragma clang diagnostic push

  61. # pragma clang diagnostic ignored "-Weffc++"

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

  63. # pragma GCC diagnostic push

  64. # pragma GCC diagnostic ignored "-Weffc++"

  65. #endif

  66. class NativePlugin : public LV2_External_UI_Widget_Compat

  67. {

  68. #if defined(__clang__)

  69. # pragma clang diagnostic pop

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

  71. # pragma GCC diagnostic pop

  72. #endif

  73. public:

  74.     static const uint32_t kMaxMidiEvents = 512;

  75. 

  76.     NativePlugin(const NativePluginDescriptor* const desc, const double sampleRate, const char* const bundlePath, const LV2_Feature* const* features)

  77.         : fHandle(nullptr),

  78.           fHost(),

  79.           fDescriptor(desc),

  80. #ifdef CARLA_PROPER_CPP11_SUPPORT

  81.           fProgramDesc({0, 0, nullptr}),

  82. #endif

  83.           fMidiEventCount(0),

  84.           fTimeInfo(),

  85.           fIsOffline(false),

  86.           fBufferSize(0),

  87.           fSampleRate(sampleRate),

  88.           fUsingNominal(false),

  89.           fUridMap(nullptr),

  90.           fURIs(),

  91.           fUI(),

  92.           fPorts(),

  93.           sJuceInitialiser()

  94.     {

  95.         run  = extui_run;

  96.         show = extui_show;

  97.         hide = extui_hide;

  98. 

  99.         CarlaString resourceDir(bundlePath);

  100.         resourceDir += CARLA_OS_SEP_STR "resources" CARLA_OS_SEP_STR;

  101. 

  102.         fHost.handle      = this;

  103.         fHost.resourceDir = resourceDir.dup();

  104.         fHost.uiName      = nullptr;

  105.         fHost.uiParentId  = 0;

  106. 

  107.         fHost.get_buffer_size        = host_get_buffer_size;

  108.         fHost.get_sample_rate        = host_get_sample_rate;

  109.         fHost.is_offline             = host_is_offline;

  110.         fHost.get_time_info          = host_get_time_info;

  111.         fHost.write_midi_event       = host_write_midi_event;

  112.         fHost.ui_parameter_changed   = host_ui_parameter_changed;

  113.         fHost.ui_custom_data_changed = host_ui_custom_data_changed;

  114.         fHost.ui_closed              = host_ui_closed;

  115.         fHost.ui_open_file           = host_ui_open_file;

  116.         fHost.ui_save_file           = host_ui_save_file;

  117.         fHost.dispatcher             = host_dispatcher;

  118. 

  119.         const LV2_Options_Option*  options   = nullptr;

  120.         const LV2_URID_Map*        uridMap   = nullptr;

  121.         const LV2_URID_Unmap*      uridUnmap = nullptr;

  122. 

  123.         for (int i=0; features[i] != nullptr; ++i)

  124.         {

  125.             if (std::strcmp(features[i]->URI, LV2_OPTIONS__options) == 0)

  126.                 options = (const LV2_Options_Option*)features[i]->data;

  127.             else if (std::strcmp(features[i]->URI, LV2_URID__map) == 0)

  128.                 uridMap = (const LV2_URID_Map*)features[i]->data;

  129.             else if (std::strcmp(features[i]->URI, LV2_URID__unmap) == 0)

  130.                 uridUnmap = (const LV2_URID_Unmap*)features[i]->data;

  131.         }

  132. 

  133.         if (options == nullptr || uridMap == nullptr)

  134.         {

  135.             carla_stderr("Host doesn't provide option or urid-map features");

  136.             return;

  137.         }

  138. 

  139.         for (int i=0; options[i].key != 0; ++i)

  140.         {

  141.             if (uridUnmap != nullptr)

  142.             {

  143.                 carla_debug("Host option %i:\"%s\"", i, uridUnmap->unmap(uridUnmap->handle, options[i].key));

  144.             }

  145. 

  146.             if (options[i].key == uridMap->map(uridMap->handle, LV2_BUF_SIZE__nominalBlockLength))

  147.             {

  148.                 if (options[i].type == uridMap->map(uridMap->handle, LV2_ATOM__Int))

  149.                 {

  150.                     const int value(*(const int*)options[i].value);

  151.                     CARLA_SAFE_ASSERT_CONTINUE(value > 0);

  152. 

  153.                     fBufferSize = static_cast<uint32_t>(value);

  154.                     fUsingNominal = true;

  155.                 }

  156.                 else

  157.                 {

  158.                     carla_stderr("Host provides nominalBlockLength but has wrong value type");

  159.                 }

  160.                 break;

  161.             }

  162. 

  163.             if (options[i].key == uridMap->map(uridMap->handle, LV2_BUF_SIZE__maxBlockLength))

  164.             {

  165.                 if (options[i].type == uridMap->map(uridMap->handle, LV2_ATOM__Int))

  166.                 {

  167.                     const int value(*(const int*)options[i].value);

  168.                     CARLA_SAFE_ASSERT_CONTINUE(value > 0);

  169. 

  170.                     fBufferSize = static_cast<uint32_t>(value);

  171.                 }

  172.                 else

  173.                 {

  174.                     carla_stderr("Host provides maxBlockLength but has wrong value type");

  175.                 }

  176.                 // no break, continue in case host supports nominalBlockLength

  177.             }

  178.         }

  179. 

  180.         fUridMap = uridMap;

  181.     }

  182. 

  183.     ~NativePlugin()

  184.     {

  185.         CARLA_ASSERT(fHandle == nullptr);

  186. 

  187.         if (fHost.resourceDir != nullptr)

  188.         {

  189.             delete[] fHost.resourceDir;

  190.             fHost.resourceDir = nullptr;

  191.         }

  192.     }

  193. 

  194.     bool init()

  195.     {

  196.         if (fUridMap == nullptr)

  197.         {

  198.             // host is missing features

  199.             return false;

  200.         }

  201.         if (fDescriptor->instantiate == nullptr || fDescriptor->process == nullptr)

  202.         {

  203.             carla_stderr("Plugin is missing something...");

  204.             return false;

  205.         }

  206.         if (fBufferSize == 0)

  207.         {

  208.             carla_stderr("Host is missing bufferSize feature");

  209.             //return false;

  210.             // as testing, continue for now

  211.             fBufferSize = 1024;

  212.         }

  213. 

  214.         carla_zeroStructs(fMidiEvents, kMaxMidiEvents);

  215.         carla_zeroStruct(fTimeInfo);

  216. 

  217.         fHandle = fDescriptor->instantiate(&fHost);

  218.         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr, false);

  219. 

  220.         if (fDescriptor->midiIns > 0)

  221.             fUI.portOffset += fDescriptor->midiIns;

  222.         else if (fDescriptor->hints & NATIVE_PLUGIN_USES_TIME)

  223.             fUI.portOffset += 1;

  224. 

  225.         fUI.portOffset += fDescriptor->midiOuts;

  226.         fUI.portOffset += 1; // freewheel

  227.         fUI.portOffset += fDescriptor->audioIns;

  228.         fUI.portOffset += fDescriptor->audioOuts;

  229. 

  230.         fPorts.init(fDescriptor, fHandle);

  231.         fURIs.map(fUridMap);

  232. 

  233.         return true;

  234.     }

  235. 

  236.     // -------------------------------------------------------------------

  237.     // LV2 functions

  238. 

  239.     void lv2_connect_port(const uint32_t port, void* const dataLocation)

  240.     {

  241.         fPorts.connectPort(fDescriptor, port, dataLocation);

  242.     }

  243. 

  244.     void lv2_activate()

  245.     {

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

  247.             fDescriptor->activate(fHandle);

  248. 

  249.         carla_zeroStruct(fTimeInfo);

  250. 

  251.         // hosts may not send all values, resulting on some invalid data

  252.         fTimeInfo.bbt.bar   = 1;

  253.         fTimeInfo.bbt.beat  = 1;

  254.         fTimeInfo.bbt.tick  = 0;

  255.         fTimeInfo.bbt.barStartTick = 0;

  256.         fTimeInfo.bbt.beatsPerBar  = 4;

  257.         fTimeInfo.bbt.beatType     = 4;

  258.         fTimeInfo.bbt.ticksPerBeat = 960.0;

  259.         fTimeInfo.bbt.beatsPerMinute = 120.0;

  260.     }

  261. 

  262.     void lv2_deactivate()

  263.     {

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

  265.             fDescriptor->deactivate(fHandle);

  266.     }

  267. 

  268.     void lv2_cleanup()

  269.     {

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

  271.             fDescriptor->cleanup(fHandle);

  272. 

  273.         fHandle = nullptr;

  274.     }

  275. 

  276.     void lv2_run(const uint32_t frames)

  277.     {

  278.         fIsOffline = (fPorts.freewheel != nullptr && *fPorts.freewheel >= 0.5f);

  279. 

  280.         // cache midi events and time information first

  281.         if (fDescriptor->midiIns > 0 || (fDescriptor->hints & NATIVE_PLUGIN_USES_TIME) != 0)

  282.         {

  283.             fMidiEventCount = 0;

  284.             carla_zeroStructs(fMidiEvents, kMaxMidiEvents);

  285. 

  286.             if (fDescriptor->hints & NATIVE_PLUGIN_USES_TIME)

  287.             {

  288.                 LV2_ATOM_SEQUENCE_FOREACH(fPorts.eventsIn[0], event)

  289.                 {

  290.                     if (event == nullptr)

  291.                         continue;

  292.                     if (event->body.type != fURIs.atomBlank && event->body.type != fURIs.atomObject)

  293.                         continue;

  294. 

  295.                     const LV2_Atom_Object* const obj((const LV2_Atom_Object*)&event->body);

  296. 

  297.                     if (obj->body.otype != fURIs.timePos)

  298.                         continue;

  299. 

  300.                     LV2_Atom* bar     = nullptr;

  301.                     LV2_Atom* barBeat = nullptr;

  302.                     LV2_Atom* beatUnit = nullptr;

  303.                     LV2_Atom* beatsPerBar = nullptr;

  304.                     LV2_Atom* beatsPerMinute = nullptr;

  305.                     LV2_Atom* frame = nullptr;

  306.                     LV2_Atom* speed = nullptr;

  307.                     LV2_Atom* ticksPerBeat = nullptr;

  308. 

  309.                     lv2_atom_object_get(obj,

  310.                                         fURIs.timeBar, &bar,

  311.                                         fURIs.timeBarBeat, &barBeat,

  312.                                         fURIs.timeBeatUnit, &beatUnit,

  313.                                         fURIs.timeBeatsPerBar, &beatsPerBar,

  314.                                         fURIs.timeBeatsPerMinute, &beatsPerMinute,

  315.                                         fURIs.timeFrame, &frame,

  316.                                         fURIs.timeSpeed, &speed,

  317.                                         fURIs.timeTicksPerBeat, &ticksPerBeat,

  318.                                         nullptr);

  319. 

  320.                     // need to handle this first as other values depend on it

  321.                     if (ticksPerBeat != nullptr)

  322.                     {

  323.                         /**/ if (ticksPerBeat->type == fURIs.atomDouble)

  324.                             fLastPositionData.ticksPerBeat = ((LV2_Atom_Double*)ticksPerBeat)->body;

  325.                         else if (ticksPerBeat->type == fURIs.atomFloat)

  326.                             fLastPositionData.ticksPerBeat = ((LV2_Atom_Float*)ticksPerBeat)->body;

  327.                         else if (ticksPerBeat->type == fURIs.atomInt)

  328.                             fLastPositionData.ticksPerBeat = ((LV2_Atom_Int*)ticksPerBeat)->body;

  329.                         else if (ticksPerBeat->type == fURIs.atomLong)

  330.                             fLastPositionData.ticksPerBeat = ((LV2_Atom_Long*)ticksPerBeat)->body;

  331.                         else

  332.                             carla_stderr("Unknown lv2 ticksPerBeat value type");

  333. 

  334.                         if (fLastPositionData.ticksPerBeat > 0.0)

  335.                             fTimeInfo.bbt.ticksPerBeat = fLastPositionData.ticksPerBeat;

  336.                     }

  337. 

  338.                     // same

  339.                     if (speed != nullptr)

  340.                     {

  341.                         /**/ if (speed->type == fURIs.atomDouble)

  342.                             fLastPositionData.speed = ((LV2_Atom_Double*)speed)->body;

  343.                         else if (speed->type == fURIs.atomFloat)

  344.                             fLastPositionData.speed = ((LV2_Atom_Float*)speed)->body;

  345.                         else if (speed->type == fURIs.atomInt)

  346.                             fLastPositionData.speed = ((LV2_Atom_Int*)speed)->body;

  347.                         else if (speed->type == fURIs.atomLong)

  348.                             fLastPositionData.speed = ((LV2_Atom_Long*)speed)->body;

  349.                         else

  350.                             carla_stderr("Unknown lv2 speed value type");

  351. 

  352.                         fTimeInfo.playing = carla_isNotZero(fLastPositionData.speed);

  353.                     }

  354. 

  355.                     if (bar != nullptr)

  356.                     {

  357.                         /**/ if (bar->type == fURIs.atomDouble)

  358.                             fLastPositionData.bar = ((LV2_Atom_Double*)bar)->body;

  359.                         else if (bar->type == fURIs.atomFloat)

  360.                             fLastPositionData.bar = ((LV2_Atom_Float*)bar)->body;

  361.                         else if (bar->type == fURIs.atomInt)

  362.                             fLastPositionData.bar = ((LV2_Atom_Int*)bar)->body;

  363.                         else if (bar->type == fURIs.atomLong)

  364.                             fLastPositionData.bar = ((LV2_Atom_Long*)bar)->body;

  365.                         else

  366.                             carla_stderr("Unknown lv2 bar value type");

  367. 

  368.                         if (fLastPositionData.bar >= 0)

  369.                             fTimeInfo.bbt.bar = fLastPositionData.bar + 1;

  370.                     }

  371. 

  372.                     if (barBeat != nullptr)

  373.                     {

  374.                         /**/ if (barBeat->type == fURIs.atomDouble)

  375.                             fLastPositionData.barBeat = ((LV2_Atom_Double*)barBeat)->body;

  376.                         else if (barBeat->type == fURIs.atomFloat)

  377.                             fLastPositionData.barBeat = ((LV2_Atom_Float*)barBeat)->body;

  378.                         else if (barBeat->type == fURIs.atomInt)

  379.                             fLastPositionData.barBeat = ((LV2_Atom_Int*)barBeat)->body;

  380.                         else if (barBeat->type == fURIs.atomLong)

  381.                             fLastPositionData.barBeat = ((LV2_Atom_Long*)barBeat)->body;

  382.                         else

  383.                             carla_stderr("Unknown lv2 barBeat value type");

  384. 

  385.                         if (fLastPositionData.barBeat >= 0.0f)

  386.                         {

  387.                             const float rest = std::fmod(fLastPositionData.barBeat, 1.0f);

  388.                             fTimeInfo.bbt.beat = fLastPositionData.barBeat-rest+1.0f;

  389.                             fTimeInfo.bbt.tick = rest*fTimeInfo.bbt.ticksPerBeat+0.5;

  390.                         }

  391.                     }

  392. 

  393.                     if (beatUnit != nullptr)

  394.                     {

  395.                         /**/ if (beatUnit->type == fURIs.atomDouble)

  396.                             fLastPositionData.beatUnit = ((LV2_Atom_Double*)beatUnit)->body;

  397.                         else if (beatUnit->type == fURIs.atomFloat)

  398.                             fLastPositionData.beatUnit = ((LV2_Atom_Float*)beatUnit)->body;

  399.                         else if (beatUnit->type == fURIs.atomInt)

  400.                             fLastPositionData.beatUnit = ((LV2_Atom_Int*)beatUnit)->body;

  401.                         else if (beatUnit->type == fURIs.atomLong)

  402.                             fLastPositionData.beatUnit = ((LV2_Atom_Long*)beatUnit)->body;

  403.                         else

  404.                             carla_stderr("Unknown lv2 beatUnit value type");

  405. 

  406.                         if (fLastPositionData.beatUnit > 0)

  407.                             fTimeInfo.bbt.beatType = fLastPositionData.beatUnit;

  408.                     }

  409. 

  410.                     if (beatsPerBar != nullptr)

  411.                     {

  412.                         /**/ if (beatsPerBar->type == fURIs.atomDouble)

  413.                             fLastPositionData.beatsPerBar = ((LV2_Atom_Double*)beatsPerBar)->body;

  414.                         else if (beatsPerBar->type == fURIs.atomFloat)

  415.                             fLastPositionData.beatsPerBar = ((LV2_Atom_Float*)beatsPerBar)->body;

  416.                         else if (beatsPerBar->type == fURIs.atomInt)

  417.                             fLastPositionData.beatsPerBar = ((LV2_Atom_Int*)beatsPerBar)->body;

  418.                         else if (beatsPerBar->type == fURIs.atomLong)

  419.                             fLastPositionData.beatsPerBar = ((LV2_Atom_Long*)beatsPerBar)->body;

  420.                         else

  421.                             carla_stderr("Unknown lv2 beatsPerBar value type");

  422. 

  423.                         if (fLastPositionData.beatsPerBar > 0.0f)

  424.                             fTimeInfo.bbt.beatsPerBar = fLastPositionData.beatsPerBar;

  425.                     }

  426. 

  427.                     if (beatsPerMinute != nullptr)

  428.                     {

  429.                         /**/ if (beatsPerMinute->type == fURIs.atomDouble)

  430.                             fLastPositionData.beatsPerMinute = ((LV2_Atom_Double*)beatsPerMinute)->body;

  431.                         else if (beatsPerMinute->type == fURIs.atomFloat)

  432.                             fLastPositionData.beatsPerMinute = ((LV2_Atom_Float*)beatsPerMinute)->body;

  433.                         else if (beatsPerMinute->type == fURIs.atomInt)

  434.                             fLastPositionData.beatsPerMinute = ((LV2_Atom_Int*)beatsPerMinute)->body;

  435.                         else if (beatsPerMinute->type == fURIs.atomLong)

  436.                             fLastPositionData.beatsPerMinute = ((LV2_Atom_Long*)beatsPerMinute)->body;

  437.                         else

  438.                             carla_stderr("Unknown lv2 beatsPerMinute value type");

  439. 

  440.                         if (fLastPositionData.beatsPerMinute > 0.0f)

  441.                         {

  442.                             fTimeInfo.bbt.beatsPerMinute = fLastPositionData.beatsPerMinute;

  443. 

  444.                             if (carla_isNotZero(fLastPositionData.speed))

  445.                                 fTimeInfo.bbt.beatsPerMinute *= std::abs(fLastPositionData.speed);

  446.                         }

  447.                     }

  448. 

  449.                     if (frame != nullptr)

  450.                     {

  451.                         /**/ if (frame->type == fURIs.atomDouble)

  452.                             fLastPositionData.frame = ((LV2_Atom_Double*)frame)->body;

  453.                         else if (frame->type == fURIs.atomFloat)

  454.                             fLastPositionData.frame = ((LV2_Atom_Float*)frame)->body;

  455.                         else if (frame->type == fURIs.atomInt)

  456.                             fLastPositionData.frame = ((LV2_Atom_Int*)frame)->body;

  457.                         else if (frame->type == fURIs.atomLong)

  458.                             fLastPositionData.frame = ((LV2_Atom_Long*)frame)->body;

  459.                         else

  460.                             carla_stderr("Unknown lv2 frame value type");

  461. 

  462.                         if (fLastPositionData.frame >= 0)

  463.                             fTimeInfo.frame = fLastPositionData.frame;

  464.                     }

  465. 

  466.                     fTimeInfo.bbt.barStartTick = fTimeInfo.bbt.ticksPerBeat*

  467.                                                  fTimeInfo.bbt.beatsPerBar*

  468.                                                  (fTimeInfo.bbt.bar-1);

  469. 

  470.                     fTimeInfo.bbt.valid = (fLastPositionData.beatsPerMinute > 0.0 &&

  471.                                            fLastPositionData.beatUnit > 0 &&

  472.                                            fLastPositionData.beatsPerBar > 0.0f);

  473.                 }

  474.             }

  475. 

  476.             for (uint32_t i=0; i < fDescriptor->midiIns; ++i)

  477.             {

  478.                 LV2_ATOM_SEQUENCE_FOREACH(fPorts.eventsIn[i], event)

  479.                 {

  480.                     if (event == nullptr)

  481.                         continue;

  482.                     if (event->body.type != fURIs.midiEvent)

  483.                         continue;

  484.                     if (event->body.size > 4)

  485.                         continue;

  486.                     if (event->time.frames >= frames)

  487.                         break;

  488.                     if (fMidiEventCount >= kMaxMidiEvents)

  489.                         break;

  490. 

  491.                     const uint8_t* const data((const uint8_t*)(event + 1));

  492. 

  493.                     NativeMidiEvent& nativeEvent(fMidiEvents[fMidiEventCount++]);

  494. 

  495.                     nativeEvent.port = (uint8_t)i;

  496.                     nativeEvent.size = (uint8_t)event->body.size;

  497.                     nativeEvent.time = (uint32_t)event->time.frames;

  498. 

  499.                     uint32_t j=0;

  500.                     for (uint32_t size=event->body.size; j<size; ++j)

  501.                         nativeEvent.data[j] = data[j];

  502.                     for (; j<4; ++j)

  503.                         nativeEvent.data[j] = 0;

  504.                 }

  505.             }

  506.         }

  507. 

  508.         // init midi out data

  509.         if (fDescriptor->midiOuts > 0)

  510.         {

  511.             for (uint32_t i=0, size=fDescriptor->midiOuts; i<size; ++i)

  512.             {

  513.                 LV2_Atom_Sequence* const seq(fPorts.midiOuts[i]);

  514.                 CARLA_SAFE_ASSERT_CONTINUE(seq != nullptr);

  515. 

  516.                 Ports::MidiOutData& mData(fPorts.midiOutData[i]);

  517.                 mData.capacity = seq->atom.size;

  518.                 mData.offset   = 0;

  519.             }

  520.         }

  521. 

  522.         // Check for updated parameters

  523.         float curValue;

  524. 

  525.         for (uint32_t i=0; i < fPorts.paramCount; ++i)

  526.         {

  527.             if (fPorts.paramsOut[i])

  528.                 continue;

  529. 

  530.             CARLA_SAFE_ASSERT_CONTINUE(fPorts.paramsPtr[i] != nullptr)

  531. 

  532.             curValue = *fPorts.paramsPtr[i];

  533. 

  534.             if (carla_isEqual(fPorts.paramsLast[i], curValue))

  535.                 continue;

  536. 

  537.             fPorts.paramsLast[i] = curValue;

  538.             fDescriptor->set_parameter_value(fHandle, i, curValue);

  539.         }

  540. 

  541.         if (frames == 0)

  542.             return updateParameterOutputs();

  543. 

  544.         // FIXME

  545.         fDescriptor->process(fHandle, const_cast<float**>(fPorts.audioIns), fPorts.audioOuts, frames, fMidiEvents, fMidiEventCount);

  546. 

  547.         // update timePos for next callback

  548.         if (carla_isNotZero(fLastPositionData.speed))

  549.         {

  550.             if (fLastPositionData.speed > 0.0)

  551.             {

  552.                 // playing forwards

  553.                 fLastPositionData.frame += frames;

  554.             }

  555.             else

  556.             {

  557.                 // playing backwards

  558.                 fLastPositionData.frame -= frames;

  559. 

  560.                 if (fLastPositionData.frame < 0)

  561.                     fLastPositionData.frame = 0;

  562.             }

  563. 

  564.             fTimeInfo.frame = fLastPositionData.frame;

  565. 

  566.             if (fTimeInfo.bbt.valid)

  567.             {

  568.                 const double beatsPerMinute = fLastPositionData.beatsPerMinute * fLastPositionData.speed;

  569.                 const double framesPerBeat  = 60.0 * fSampleRate / beatsPerMinute;

  570.                 const double addedBarBeats  = double(frames) / framesPerBeat;

  571. 

  572.                 if (fLastPositionData.barBeat >= 0.0f)

  573.                 {

  574.                     fLastPositionData.barBeat = std::fmod(fLastPositionData.barBeat+static_cast<float>(addedBarBeats),

  575.                                                           fLastPositionData.beatsPerBar);

  576. 

  577.                     const double rest = std::fmod(fLastPositionData.barBeat, 1.0);

  578.                     fTimeInfo.bbt.beat = fLastPositionData.barBeat-rest+1.0;

  579.                     fTimeInfo.bbt.tick = rest*fTimeInfo.bbt.ticksPerBeat+0.5;

  580. 

  581.                     if (fLastPositionData.bar >= 0)

  582.                     {

  583.                         fLastPositionData.bar += std::floor((fLastPositionData.barBeat+static_cast<float>(addedBarBeats))/

  584.                                                              fLastPositionData.beatsPerBar);

  585. 

  586.                         if (fLastPositionData.bar < 0)

  587.                             fLastPositionData.bar = 0;

  588. 

  589.                         fTimeInfo.bbt.bar = fLastPositionData.bar + 1;

  590. 

  591.                         fTimeInfo.bbt.barStartTick = fTimeInfo.bbt.ticksPerBeat*

  592.                                                      fTimeInfo.bbt.beatsPerBar*

  593.                                                      (fTimeInfo.bbt.bar-1);

  594.                     }

  595.                 }

  596. 

  597.                 fTimeInfo.bbt.beatsPerMinute = std::abs(beatsPerMinute);

  598.             }

  599.         }

  600. 

  601.         updateParameterOutputs();

  602.     }

  603. 

  604.     // -------------------------------------------------------------------

  605. 

  606.     uint32_t lv2_get_options(LV2_Options_Option* const /*options*/) const

  607.     {

  608.         // currently unused

  609.         return LV2_OPTIONS_SUCCESS;

  610.     }

  611. 

  612.     uint32_t lv2_set_options(const LV2_Options_Option* const options)

  613.     {

  614.         for (int i=0; options[i].key != 0; ++i)

  615.         {

  616.             if (options[i].key == fUridMap->map(fUridMap->handle, LV2_BUF_SIZE__nominalBlockLength))

  617.             {

  618.                 if (options[i].type == fURIs.atomInt)

  619.                 {

  620.                     const int value(*(const int*)options[i].value);

  621.                     CARLA_SAFE_ASSERT_CONTINUE(value > 0);

  622. 

  623.                     fBufferSize = static_cast<uint32_t>(value);

  624. 

  625.                     if (fDescriptor->dispatcher != nullptr)

  626.                         fDescriptor->dispatcher(fHandle, NATIVE_PLUGIN_OPCODE_BUFFER_SIZE_CHANGED, 0, value, nullptr, 0.0f);

  627.                 }

  628.                 else

  629.                     carla_stderr("Host changed nominalBlockLength but with wrong value type");

  630.             }

  631.             else if (options[i].key == fUridMap->map(fUridMap->handle, LV2_BUF_SIZE__maxBlockLength) && ! fUsingNominal)

  632.             {

  633.                 if (options[i].type == fURIs.atomInt)

  634.                 {

  635.                     const int value(*(const int*)options[i].value);

  636.                     CARLA_SAFE_ASSERT_CONTINUE(value > 0);

  637. 

  638.                     fBufferSize = static_cast<uint32_t>(value);

  639. 

  640.                     if (fDescriptor->dispatcher != nullptr)

  641.                         fDescriptor->dispatcher(fHandle, NATIVE_PLUGIN_OPCODE_BUFFER_SIZE_CHANGED, 0, value, nullptr, 0.0f);

  642.                 }

  643.                 else

  644.                     carla_stderr("Host changed maxBlockLength but with wrong value type");

  645.             }

  646.             else if (options[i].key == fUridMap->map(fUridMap->handle, LV2_CORE__sampleRate))

  647.             {

  648.                 if (options[i].type == fURIs.atomDouble)

  649.                 {

  650.                     const double value(*(const double*)options[i].value);

  651.                     CARLA_SAFE_ASSERT_CONTINUE(value > 0.0);

  652. 

  653.                     fSampleRate = value;

  654. 

  655.                     if (fDescriptor->dispatcher != nullptr)

  656.                         fDescriptor->dispatcher(fHandle, NATIVE_PLUGIN_OPCODE_SAMPLE_RATE_CHANGED, 0, 0, nullptr, (float)fSampleRate);

  657.                 }

  658.                 else

  659.                     carla_stderr("Host changed sampleRate but with wrong value type");

  660.             }

  661.         }

  662. 

  663.         return LV2_OPTIONS_SUCCESS;

  664.     }

  665. 

  666.     const LV2_Program_Descriptor* lv2_get_program(const uint32_t index)

  667.     {

  668.         if (fDescriptor->category == NATIVE_PLUGIN_CATEGORY_SYNTH)

  669.             return nullptr;

  670.         if (fDescriptor->get_midi_program_count == nullptr)

  671.             return nullptr;

  672.         if (fDescriptor->get_midi_program_info == nullptr)

  673.             return nullptr;

  674.         if (index >= fDescriptor->get_midi_program_count(fHandle))

  675.             return nullptr;

  676. 

  677.         const NativeMidiProgram* const midiProg(fDescriptor->get_midi_program_info(fHandle, index));

  678. 

  679.         if (midiProg == nullptr)

  680.             return nullptr;

  681. 

  682.         fProgramDesc.bank    = midiProg->bank;

  683.         fProgramDesc.program = midiProg->program;

  684.         fProgramDesc.name    = midiProg->name;

  685. 

  686.         return &fProgramDesc;

  687.     }

  688. 

  689.     void lv2_select_program(uint32_t bank, uint32_t program)

  690.     {

  691.         if (fDescriptor->category == NATIVE_PLUGIN_CATEGORY_SYNTH)

  692.             return;

  693.         if (fDescriptor->set_midi_program == nullptr)

  694.             return;

  695. 

  696.         fDescriptor->set_midi_program(fHandle, 0, bank, program);

  697. 

  698.         for (uint32_t i=0; i < fPorts.paramCount; ++i)

  699.         {

  700.             fPorts.paramsLast[i] = fDescriptor->get_parameter_value(fHandle, i);

  701. 

  702.             if (fPorts.paramsPtr[i] != nullptr)

  703.                 *fPorts.paramsPtr[i] = fPorts.paramsLast[i];

  704.         }

  705.     }

  706. 

  707.     LV2_State_Status lv2_save(const LV2_State_Store_Function store, const LV2_State_Handle handle, const uint32_t /*flags*/, const LV2_Feature* const* const /*features*/) const

  708.     {

  709.         if ((fDescriptor->hints & NATIVE_PLUGIN_USES_STATE) == 0 || fDescriptor->get_state == nullptr)

  710.             return LV2_STATE_ERR_NO_FEATURE;

  711. 

  712.         if (char* const state = fDescriptor->get_state(fHandle))

  713.         {

  714.             store(handle, fUridMap->map(fUridMap->handle, "http://kxstudio.sf.net/ns/carla/chunk"), state, std::strlen(state)+1, fURIs.atomString, LV2_STATE_IS_POD|LV2_STATE_IS_PORTABLE);

  715.             std::free(state);

  716.             return LV2_STATE_SUCCESS;

  717.         }

  718. 

  719.         return LV2_STATE_ERR_UNKNOWN;

  720.     }

  721. 

  722.     LV2_State_Status lv2_restore(const LV2_State_Retrieve_Function retrieve, const LV2_State_Handle handle, uint32_t flags, const LV2_Feature* const* const /*features*/) const

  723.     {

  724.         if ((fDescriptor->hints & NATIVE_PLUGIN_USES_STATE) == 0 || fDescriptor->set_state == nullptr)

  725.             return LV2_STATE_ERR_NO_FEATURE;

  726. 

  727.         size_t   size = 0;

  728.         uint32_t type = 0;

  729.         const void* const data = retrieve(handle, fUridMap->map(fUridMap->handle, "http://kxstudio.sf.net/ns/carla/chunk"), &size, &type, &flags);

  730. 

  731.         if (size == 0)

  732.             return LV2_STATE_ERR_UNKNOWN;

  733.         if (type == 0)

  734.             return LV2_STATE_ERR_UNKNOWN;

  735.         if (data == nullptr)

  736.             return LV2_STATE_ERR_UNKNOWN;

  737.         if (type != fURIs.atomString)

  738.             return LV2_STATE_ERR_BAD_TYPE;

  739. 

  740.         fDescriptor->set_state(fHandle, (const char*)data);

  741. 

  742.         return LV2_STATE_SUCCESS;

  743.     }

  744. 

  745.     // -------------------------------------------------------------------

  746. 

  747.     void lv2ui_instantiate(LV2UI_Write_Function writeFunction, LV2UI_Controller controller,

  748.                            LV2UI_Widget* widget, const LV2_Feature* const* features, const bool isEmbed)

  749.     {

  750.         fUI.writeFunction = writeFunction;

  751.         fUI.controller = controller;

  752.         fUI.isEmbed = isEmbed;

  753. 

  754. #ifdef CARLA_OS_LINUX

  755.         // ---------------------------------------------------------------

  756.         // show embed UI if needed

  757. 

  758.         if (isEmbed)

  759.         {

  760.             fUI.isVisible = true;

  761. 

  762.             intptr_t parentId = 0;

  763. 

  764.             for (int i=0; features[i] != nullptr; ++i)

  765.             {

  766.                 if (std::strcmp(features[i]->URI, LV2_UI__parent) == 0)

  767.                 {

  768.                     parentId = (intptr_t)features[i]->data;

  769.                 }

  770.                 else if (std::strcmp(features[i]->URI, LV2_UI__resize) == 0)

  771.                 {

  772.                     const LV2UI_Resize* const uiResize((const LV2UI_Resize*)features[i]->data);

  773.                     uiResize->ui_resize(uiResize->handle, 740, 512);

  774.                 }

  775.             }

  776. 

  777.             char strBuf[0xff+1];

  778.             strBuf[0xff] = '\0';

  779.             std::snprintf(strBuf, 0xff, P_INTPTR, parentId);

  780. 

  781.             carla_setenv("CARLA_PLUGIN_EMBED_WINID", strBuf);

  782. 

  783.             fDescriptor->ui_show(fHandle, true);

  784. 

  785.             carla_setenv("CARLA_PLUGIN_EMBED_WINID", "0");

  786.         }

  787. #endif

  788. 

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

  790.         // see if the host supports external-ui

  791. 

  792.         for (int i=0; features[i] != nullptr; ++i)

  793.         {

  794.             if (std::strcmp(features[i]->URI, LV2_EXTERNAL_UI__Host) == 0 ||

  795.                 std::strcmp(features[i]->URI, LV2_EXTERNAL_UI_DEPRECATED_URI) == 0)

  796.             {

  797.                 fUI.host = (const LV2_External_UI_Host*)features[i]->data;

  798.                 break;

  799.             }

  800.         }

  801. 

  802.         if (fUI.host != nullptr)

  803.         {

  804.             fHost.uiName = carla_strdup(fUI.host->plugin_human_id);

  805.             *widget = this;

  806.             return;

  807.         }

  808. 

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

  810.         // no external-ui support, use showInterface

  811. 

  812.         for (int i=0; features[i] != nullptr; ++i)

  813.         {

  814.             if (std::strcmp(features[i]->URI, LV2_OPTIONS__options) == 0)

  815.             {

  816.                 const LV2_Options_Option* const options((const LV2_Options_Option*)features[i]->data);

  817. 

  818.                 for (int j=0; options[j].key != 0; ++j)

  819.                 {

  820.                     if (options[j].key == fUridMap->map(fUridMap->handle, LV2_UI__windowTitle))

  821.                     {

  822.                         fHost.uiName = carla_strdup((const char*)options[j].value);

  823.                         break;

  824.                     }

  825.                 }

  826.                 break;

  827.             }

  828.         }

  829. 

  830.         if (fHost.uiName == nullptr)

  831.             fHost.uiName = carla_strdup(fDescriptor->name);

  832. 

  833.         *widget = nullptr;

  834.     }

  835. 

  836.     void lv2ui_port_event(uint32_t portIndex, uint32_t bufferSize, uint32_t format, const void* buffer) const

  837.     {

  838.         if (format != 0 || bufferSize != sizeof(float) || buffer == nullptr)

  839.             return;

  840.         if (portIndex >= fUI.portOffset || ! fUI.isVisible)

  841.             return;

  842.         if (fDescriptor->ui_set_parameter_value == nullptr)

  843.             return;

  844. 

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

  846.         fDescriptor->ui_set_parameter_value(fHandle, portIndex-fUI.portOffset, value);

  847.     }

  848. 

  849.     void lv2ui_cleanup()

  850.     {

  851.         if (fUI.isVisible)

  852.             handleUiHide();

  853. 

  854.         fUI.host = nullptr;

  855.         fUI.writeFunction = nullptr;

  856.         fUI.controller = nullptr;

  857. 

  858.         if (fHost.uiName != nullptr)

  859.         {

  860.             delete[] fHost.uiName;

  861.             fHost.uiName = nullptr;

  862.         }

  863.     }

  864. 

  865.     // -------------------------------------------------------------------

  866. 

  867.     void lv2ui_select_program(uint32_t bank, uint32_t program) const

  868.     {

  869.         if (fDescriptor->category == NATIVE_PLUGIN_CATEGORY_SYNTH)

  870.             return;

  871.         if (fDescriptor->ui_set_midi_program == nullptr)

  872.             return;

  873. 

  874.         fDescriptor->ui_set_midi_program(fHandle, 0, bank, program);

  875.     }

  876. 

  877.     // -------------------------------------------------------------------

  878. 

  879.     int lv2ui_idle() const

  880.     {

  881.         if (! fUI.isVisible)

  882.             return 1;

  883. 

  884.         handleUiRun();

  885.         return 0;

  886.     }

  887. 

  888.     int lv2ui_show()

  889.     {

  890.         handleUiShow();

  891.         return 0;

  892.     }

  893. 

  894.     int lv2ui_hide()

  895.     {

  896.         handleUiHide();

  897.         return 0;

  898.     }

  899. 

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

  901. 

  902. protected:

  903.     void handleUiRun() const

  904.     {

  905.         if (fDescriptor->ui_idle != nullptr)

  906.             fDescriptor->ui_idle(fHandle);

  907.     }

  908. 

  909.     void handleUiShow()

  910.     {

  911.         CARLA_SAFE_ASSERT_RETURN(! fUI.isEmbed,);

  912. 

  913.         if (fDescriptor->ui_show != nullptr)

  914.             fDescriptor->ui_show(fHandle, true);

  915. 

  916.         fUI.isVisible = true;

  917.     }

  918. 

  919.     void handleUiHide()

  920.     {

  921.         if (fDescriptor->ui_show != nullptr)

  922.             fDescriptor->ui_show(fHandle, false);

  923. 

  924.         fUI.isVisible = false;

  925.     }

  926. 

  927.     // -------------------------------------------------------------------

  928. 

  929.     bool handleWriteMidiEvent(const NativeMidiEvent* const event)

  930.     {

  931.         CARLA_SAFE_ASSERT_RETURN(fDescriptor->midiOuts > 0, false);

  932.         CARLA_SAFE_ASSERT_RETURN(event != nullptr, false);

  933.         CARLA_SAFE_ASSERT_RETURN(event->size > 0, false);

  934. 

  935.         const uint8_t port(event->port);

  936.         CARLA_SAFE_ASSERT_RETURN(port < fDescriptor->midiOuts, false);

  937. 

  938.         LV2_Atom_Sequence* const seq(fPorts.midiOuts[port]);

  939.         CARLA_SAFE_ASSERT_RETURN(seq != nullptr, false);

  940. 

  941.         Ports::MidiOutData& mData(fPorts.midiOutData[port]);

  942. 

  943.         if (sizeof(LV2_Atom_Event) + event->size > mData.capacity - mData.offset)

  944.             return false;

  945. 

  946.         if (mData.offset == 0)

  947.         {

  948.             seq->atom.size = 0;

  949.             seq->atom.type = fURIs.atomSequence;

  950.             seq->body.unit = 0;

  951.             seq->body.pad  = 0;

  952.         }

  953. 

  954.         LV2_Atom_Event* const aev = (LV2_Atom_Event*)(LV2_ATOM_CONTENTS(LV2_Atom_Sequence, seq) + mData.offset);

  955. 

  956.         aev->time.frames = event->time;

  957.         aev->body.size   = event->size;

  958.         aev->body.type   = fURIs.midiEvent;

  959.         std::memcpy(LV2_ATOM_BODY(&aev->body), event->data, event->size);

  960. 

  961.         const uint32_t size = lv2_atom_pad_size(sizeof(LV2_Atom_Event) + event->size);

  962.         mData.offset       += size;

  963.         seq->atom.size     += size;

  964. 

  965.         return true;

  966.     }

  967. 

  968.     void handleUiParameterChanged(const uint32_t index, const float value) const

  969.     {

  970.         if (fUI.writeFunction != nullptr && fUI.controller != nullptr)

  971.             fUI.writeFunction(fUI.controller, index+fUI.portOffset, sizeof(float), 0, &value);

  972.     }

  973. 

  974.     void handleUiCustomDataChanged(const char* const /*key*/, const char* const /*value*/) const

  975.     {

  976.         //storeCustomData(key, value);

  977.     }

  978. 

  979.     void handleUiClosed()

  980.     {

  981.         if (fUI.host != nullptr && fUI.host->ui_closed != nullptr && fUI.controller != nullptr)

  982.             fUI.host->ui_closed(fUI.controller);

  983. 

  984.         fUI.host = nullptr;

  985.         fUI.writeFunction = nullptr;

  986.         fUI.controller = nullptr;

  987.         fUI.isVisible = false;

  988.     }

  989. 

  990.     const char* handleUiOpenFile(const bool /*isDir*/, const char* const /*title*/, const char* const /*filter*/) const

  991.     {

  992.         // TODO

  993.         return nullptr;

  994.     }

  995. 

  996.     const char* handleUiSaveFile(const bool /*isDir*/, const char* const /*title*/, const char* const /*filter*/) const

  997.     {

  998.         // TODO

  999.         return nullptr;

  1000.     }

  1001. 

  1002.     intptr_t handleDispatcher(const NativeHostDispatcherOpcode opcode, const int32_t index, const intptr_t value, void* const ptr, const float opt)

  1003.     {

  1004.         carla_debug("NativePlugin::handleDispatcher(%i, %i, " P_INTPTR ", %p, %f)", opcode, index, value, ptr, opt);

  1005. 

  1006.         intptr_t ret = 0;

  1007. 

  1008.         switch (opcode)

  1009.         {

  1010.         case NATIVE_HOST_OPCODE_NULL:

  1011.         case NATIVE_HOST_OPCODE_UPDATE_PARAMETER:

  1012.         case NATIVE_HOST_OPCODE_UPDATE_MIDI_PROGRAM:

  1013.         case NATIVE_HOST_OPCODE_RELOAD_PARAMETERS:

  1014.         case NATIVE_HOST_OPCODE_RELOAD_MIDI_PROGRAMS:

  1015.         case NATIVE_HOST_OPCODE_RELOAD_ALL:

  1016.         case NATIVE_HOST_OPCODE_HOST_IDLE:

  1017.             // nothing

  1018.             break;

  1019.         case NATIVE_HOST_OPCODE_UI_UNAVAILABLE:

  1020.             handleUiClosed();

  1021.             break;

  1022.         }

  1023. 

  1024.         return ret;

  1025. 

  1026.         // unused for now

  1027.         (void)index;

  1028.         (void)value;

  1029.         (void)ptr;

  1030.         (void)opt;

  1031.     }

  1032. 

  1033.     void updateParameterOutputs()

  1034.     {

  1035.         for (uint32_t i=0; i < fPorts.paramCount; ++i)

  1036.         {

  1037.             if (! fPorts.paramsOut[i])

  1038.                 continue;

  1039. 

  1040.             fPorts.paramsLast[i] = fDescriptor->get_parameter_value(fHandle, i);

  1041. 

  1042.             if (fPorts.paramsPtr[i] != nullptr)

  1043.                 *fPorts.paramsPtr[i] = fPorts.paramsLast[i];

  1044.         }

  1045.     }

  1046. 

  1047.     // -------------------------------------------------------------------

  1048. 

  1049. private:

  1050.     // Native data

  1051.     NativePluginHandle   fHandle;

  1052.     NativeHostDescriptor fHost;

  1053.     const NativePluginDescriptor* const fDescriptor;

  1054.     LV2_Program_Descriptor              fProgramDesc;

  1055. 

  1056.     uint32_t        fMidiEventCount;

  1057.     NativeMidiEvent fMidiEvents[kMaxMidiEvents];

  1058.     NativeTimeInfo  fTimeInfo;

  1059. 

  1060.     // Lv2 host data

  1061.     bool     fIsOffline;

  1062.     uint32_t fBufferSize;

  1063.     double   fSampleRate;

  1064.     bool     fUsingNominal;

  1065. 

  1066.     const LV2_URID_Map* fUridMap;

  1067. 

  1068.     struct Lv2PositionData {

  1069.         int64_t  bar;

  1070.         float    barBeat;

  1071.         uint32_t beatUnit;

  1072.         float    beatsPerBar;

  1073.         float    beatsPerMinute;

  1074.         int64_t  frame;

  1075.         double   speed;

  1076.         double   ticksPerBeat;

  1077. 

  1078.         Lv2PositionData()

  1079.             : bar(-1),

  1080.               barBeat(-1.0f),

  1081.               beatUnit(0),

  1082.               beatsPerBar(0.0f),

  1083.               beatsPerMinute(0.0f),

  1084.               frame(-1),

  1085.               speed(0.0),

  1086.               ticksPerBeat(-1.0) {}

  1087. 

  1088.     } fLastPositionData;

  1089. 

  1090.     struct URIDs {

  1091.         LV2_URID atomBlank;

  1092.         LV2_URID atomObject;

  1093.         LV2_URID atomDouble;

  1094.         LV2_URID atomFloat;

  1095.         LV2_URID atomInt;

  1096.         LV2_URID atomLong;

  1097.         LV2_URID atomSequence;

  1098.         LV2_URID atomString;

  1099.         LV2_URID midiEvent;

  1100.         LV2_URID timePos;

  1101.         LV2_URID timeBar;

  1102.         LV2_URID timeBarBeat;

  1103.         LV2_URID timeBeatsPerBar;

  1104.         LV2_URID timeBeatsPerMinute;

  1105.         LV2_URID timeBeatUnit;

  1106.         LV2_URID timeFrame;

  1107.         LV2_URID timeSpeed;

  1108.         LV2_URID timeTicksPerBeat;

  1109. 

  1110.         URIDs()

  1111.             : atomBlank(0),

  1112.               atomObject(0),

  1113.               atomDouble(0),

  1114.               atomFloat(0),

  1115.               atomInt(0),

  1116.               atomLong(0),

  1117.               atomSequence(0),

  1118.               atomString(0),

  1119.               midiEvent(0),

  1120.               timePos(0),

  1121.               timeBar(0),

  1122.               timeBarBeat(0),

  1123.               timeBeatsPerBar(0),

  1124.               timeBeatsPerMinute(0),

  1125.               timeBeatUnit(0),

  1126.               timeFrame(0),

  1127.               timeSpeed(0),

  1128.               timeTicksPerBeat(0) {}

  1129. 

  1130.         void map(const LV2_URID_Map* const uridMap)

  1131.         {

  1132.             atomBlank    = uridMap->map(uridMap->handle, LV2_ATOM__Blank);

  1133.             atomObject   = uridMap->map(uridMap->handle, LV2_ATOM__Object);

  1134.             atomDouble   = uridMap->map(uridMap->handle, LV2_ATOM__Double);

  1135.             atomFloat    = uridMap->map(uridMap->handle, LV2_ATOM__Float);

  1136.             atomInt      = uridMap->map(uridMap->handle, LV2_ATOM__Int);

  1137.             atomLong     = uridMap->map(uridMap->handle, LV2_ATOM__Long);

  1138.             atomSequence = uridMap->map(uridMap->handle, LV2_ATOM__Sequence);

  1139.             atomString   = uridMap->map(uridMap->handle, LV2_ATOM__String);

  1140.             midiEvent    = uridMap->map(uridMap->handle, LV2_MIDI__MidiEvent);

  1141.             timePos      = uridMap->map(uridMap->handle, LV2_TIME__Position);

  1142.             timeBar      = uridMap->map(uridMap->handle, LV2_TIME__bar);

  1143.             timeBarBeat  = uridMap->map(uridMap->handle, LV2_TIME__barBeat);

  1144.             timeBeatUnit = uridMap->map(uridMap->handle, LV2_TIME__beatUnit);

  1145.             timeFrame    = uridMap->map(uridMap->handle, LV2_TIME__frame);

  1146.             timeSpeed    = uridMap->map(uridMap->handle, LV2_TIME__speed);

  1147.             timeBeatsPerBar    = uridMap->map(uridMap->handle, LV2_TIME__beatsPerBar);

  1148.             timeBeatsPerMinute = uridMap->map(uridMap->handle, LV2_TIME__beatsPerMinute);

  1149.             timeTicksPerBeat   = uridMap->map(uridMap->handle, LV2_KXSTUDIO_PROPERTIES__TimePositionTicksPerBeat);

  1150.         }

  1151.     } fURIs;

  1152. 

  1153.     struct UI {

  1154.         const LV2_External_UI_Host* host;

  1155.         LV2UI_Write_Function writeFunction;

  1156.         LV2UI_Controller controller;

  1157.         uint32_t portOffset;

  1158.         bool isEmbed;

  1159.         bool isVisible;

  1160. 

  1161.         UI()

  1162.             : host(nullptr),

  1163.               writeFunction(nullptr),

  1164.               controller(nullptr),

  1165.               portOffset(0),

  1166.               isEmbed(false),

  1167.               isVisible(false) {}

  1168.     } fUI;

  1169. 

  1170.     struct Ports {

  1171.         // need to save current state

  1172.         struct MidiOutData {

  1173.             uint32_t capacity;

  1174.             uint32_t offset;

  1175. 

  1176.             MidiOutData()

  1177.                 : capacity(0),

  1178.                   offset(0) {}

  1179.         };

  1180. 

  1181.         const LV2_Atom_Sequence** eventsIn;

  1182.         /* */ LV2_Atom_Sequence** midiOuts;

  1183.         /* */ MidiOutData*        midiOutData;

  1184.         const float** audioIns;

  1185.         /* */ float** audioOuts;

  1186.         float*   freewheel;

  1187.         uint32_t paramCount;

  1188.         float*   paramsLast;

  1189.         float**  paramsPtr;

  1190.         bool*    paramsOut;

  1191. 

  1192.         Ports()

  1193.             : eventsIn(nullptr),

  1194.               midiOuts(nullptr),

  1195.               midiOutData(nullptr),

  1196.               audioIns(nullptr),

  1197.               audioOuts(nullptr),

  1198.               freewheel(nullptr),

  1199.               paramCount(0),

  1200.               paramsLast(nullptr),

  1201.               paramsPtr(nullptr),

  1202.               paramsOut(nullptr) {}

  1203. 

  1204.         ~Ports()

  1205.         {

  1206.             if (eventsIn != nullptr)

  1207.             {

  1208.                 delete[] eventsIn;

  1209.                 eventsIn = nullptr;

  1210.             }

  1211. 

  1212.             if (midiOuts != nullptr)

  1213.             {

  1214.                 delete[] midiOuts;

  1215.                 midiOuts = nullptr;

  1216.             }

  1217. 

  1218.             if (midiOutData != nullptr)

  1219.             {

  1220.                 delete[] midiOutData;

  1221.                 midiOutData = nullptr;

  1222.             }

  1223. 

  1224.             if (audioIns != nullptr)

  1225.             {

  1226.                 delete[] audioIns;

  1227.                 audioIns = nullptr;

  1228.             }

  1229. 

  1230.             if (audioOuts != nullptr)

  1231.             {

  1232.                 delete[] audioOuts;

  1233.                 audioOuts = nullptr;

  1234.             }

  1235. 

  1236.             if (paramsLast != nullptr)

  1237.             {

  1238.                 delete[] paramsLast;

  1239.                 paramsLast = nullptr;

  1240.             }

  1241. 

  1242.             if (paramsPtr != nullptr)

  1243.             {

  1244.                 delete[] paramsPtr;

  1245.                 paramsPtr = nullptr;

  1246.             }

  1247. 

  1248.             if (paramsOut != nullptr)

  1249.             {

  1250.                 delete[] paramsOut;

  1251.                 paramsOut = nullptr;

  1252.             }

  1253.         }

  1254. 

  1255.         void init(const NativePluginDescriptor* const desc, NativePluginHandle handle)

  1256.         {

  1257.             CARLA_SAFE_ASSERT_RETURN(desc != nullptr && handle != nullptr,)

  1258. 

  1259.             if (desc->midiIns > 0)

  1260.             {

  1261.                 eventsIn = new const LV2_Atom_Sequence*[desc->midiIns];

  1262. 

  1263.                 for (uint32_t i=0; i < desc->midiIns; ++i)

  1264.                     eventsIn[i] = nullptr;

  1265.             }

  1266.             else if (desc->hints & NATIVE_PLUGIN_USES_TIME)

  1267.             {

  1268.                 eventsIn = new const LV2_Atom_Sequence*[1];

  1269.                 eventsIn[0] = nullptr;

  1270.             }

  1271. 

  1272.             if (desc->midiOuts > 0)

  1273.             {

  1274.                 midiOuts = new LV2_Atom_Sequence*[desc->midiOuts];

  1275.                 midiOutData = new MidiOutData[desc->midiOuts];

  1276. 

  1277.                 for (uint32_t i=0; i < desc->midiOuts; ++i)

  1278.                     midiOuts[i] = nullptr;

  1279.             }

  1280. 

  1281.             if (desc->audioIns > 0)

  1282.             {

  1283.                 audioIns = new const float*[desc->audioIns];

  1284. 

  1285.                 for (uint32_t i=0; i < desc->audioIns; ++i)

  1286.                     audioIns[i] = nullptr;

  1287.             }

  1288. 

  1289.             if (desc->audioOuts > 0)

  1290.             {

  1291.                 audioOuts = new float*[desc->audioOuts];

  1292. 

  1293.                 for (uint32_t i=0; i < desc->audioOuts; ++i)

  1294.                     audioOuts[i] = nullptr;

  1295.             }

  1296. 

  1297.             if (desc->get_parameter_count != nullptr && desc->get_parameter_info != nullptr && desc->get_parameter_value != nullptr && desc->set_parameter_value != nullptr)

  1298.             {

  1299.                 paramCount = desc->get_parameter_count(handle);

  1300. 

  1301.                 if (paramCount > 0)

  1302.                 {

  1303.                     paramsLast = new float[paramCount];

  1304.                     paramsPtr  = new float*[paramCount];

  1305.                     paramsOut  = new bool[paramCount];

  1306. 

  1307.                     for (uint32_t i=0; i < paramCount; ++i)

  1308.                     {

  1309.                         paramsLast[i] = desc->get_parameter_value(handle, i);

  1310.                         paramsPtr [i] = nullptr;

  1311.                         paramsOut [i] = (desc->get_parameter_info(handle, i)->hints & NATIVE_PARAMETER_IS_OUTPUT);

  1312.                     }

  1313.                 }

  1314.             }

  1315.         }

  1316. 

  1317.         void connectPort(const NativePluginDescriptor* const desc, const uint32_t port, void* const dataLocation)

  1318.         {

  1319.             uint32_t index = 0;

  1320. 

  1321.             if (desc->midiIns > 0 || (desc->hints & NATIVE_PLUGIN_USES_TIME) != 0)

  1322.             {

  1323.                 if (port == index++)

  1324.                 {

  1325.                     eventsIn[0] = (LV2_Atom_Sequence*)dataLocation;

  1326.                     return;

  1327.                 }

  1328.             }

  1329. 

  1330.             for (uint32_t i=1; i < desc->midiIns; ++i)

  1331.             {

  1332.                 if (port == index++)

  1333.                 {

  1334.                     eventsIn[i] = (LV2_Atom_Sequence*)dataLocation;

  1335.                     return;

  1336.                 }

  1337.             }

  1338. 

  1339.             for (uint32_t i=0; i < desc->midiOuts; ++i)

  1340.             {

  1341.                 if (port == index++)

  1342.                 {

  1343.                     midiOuts[i] = (LV2_Atom_Sequence*)dataLocation;

  1344.                     return;

  1345.                 }

  1346.             }

  1347. 

  1348.             if (port == index++)

  1349.             {

  1350.                 freewheel = (float*)dataLocation;

  1351.                 return;

  1352.             }

  1353. 

  1354.             for (uint32_t i=0; i < desc->audioIns; ++i)

  1355.             {

  1356.                 if (port == index++)

  1357.                 {

  1358.                     audioIns[i] = (float*)dataLocation;

  1359.                     return;

  1360.                 }

  1361.             }

  1362. 

  1363.             for (uint32_t i=0; i < desc->audioOuts; ++i)

  1364.             {

  1365.                 if (port == index++)

  1366.                 {

  1367.                     audioOuts[i] = (float*)dataLocation;

  1368.                     return;

  1369.                 }

  1370.             }

  1371. 

  1372.             for (uint32_t i=0; i < paramCount; ++i)

  1373.             {

  1374.                 if (port == index++)

  1375.                 {

  1376.                     paramsPtr[i] = (float*)dataLocation;

  1377.                     return;

  1378.                 }

  1379.             }

  1380.         }

  1381. 

  1382.         CARLA_DECLARE_NON_COPY_STRUCT(Ports);

  1383.     } fPorts;

  1384. 

  1385.     SharedResourcePointer<ScopedJuceInitialiser_GUI> sJuceInitialiser;

  1386. 

  1387.     // -------------------------------------------------------------------

  1388. 

  1389.     #define handlePtr ((NativePlugin*)self)

  1390. 

  1391.     static void extui_run(LV2_External_UI_Widget_Compat* self)

  1392.     {

  1393.         handlePtr->handleUiRun();

  1394.     }

  1395. 

  1396.     static void extui_show(LV2_External_UI_Widget_Compat* self)

  1397.     {

  1398.         handlePtr->handleUiShow();

  1399.     }

  1400. 

  1401.     static void extui_hide(LV2_External_UI_Widget_Compat* self)

  1402.     {

  1403.         handlePtr->handleUiHide();

  1404.     }

  1405. 

  1406.     #undef handlePtr

  1407. 

  1408.     // -------------------------------------------------------------------

  1409. 

  1410.     #define handlePtr ((NativePlugin*)handle)

  1411. 

  1412.     static uint32_t host_get_buffer_size(NativeHostHandle handle)

  1413.     {

  1414.         return handlePtr->fBufferSize;

  1415.     }

  1416. 

  1417.     static double host_get_sample_rate(NativeHostHandle handle)

  1418.     {

  1419.         return handlePtr->fSampleRate;

  1420.     }

  1421. 

  1422.     static bool host_is_offline(NativeHostHandle handle)

  1423.     {

  1424.         return handlePtr->fIsOffline;

  1425.     }

  1426. 

  1427.     static const NativeTimeInfo* host_get_time_info(NativeHostHandle handle)

  1428.     {

  1429.         return &(handlePtr->fTimeInfo);

  1430.     }

  1431. 

  1432.     static bool host_write_midi_event(NativeHostHandle handle, const NativeMidiEvent* event)

  1433.     {

  1434.         return handlePtr->handleWriteMidiEvent(event);

  1435.     }

  1436. 

  1437.     static void host_ui_parameter_changed(NativeHostHandle handle, uint32_t index, float value)

  1438.     {

  1439.         handlePtr->handleUiParameterChanged(index, value);

  1440.     }

  1441. 

  1442.     static void host_ui_custom_data_changed(NativeHostHandle handle, const char* key, const char* value)

  1443.     {

  1444.         handlePtr->handleUiCustomDataChanged(key, value);

  1445.     }

  1446. 

  1447.     static void host_ui_closed(NativeHostHandle handle)

  1448.     {

  1449.         handlePtr->handleUiClosed();

  1450.     }

  1451. 

  1452.     static const char* host_ui_open_file(NativeHostHandle handle, bool isDir, const char* title, const char* filter)

  1453.     {

  1454.         return handlePtr->handleUiOpenFile(isDir, title, filter);

  1455.     }

  1456. 

  1457.     static const char* host_ui_save_file(NativeHostHandle handle, bool isDir, const char* title, const char* filter)

  1458.     {

  1459.         return handlePtr->handleUiSaveFile(isDir, title, filter);

  1460.     }

  1461. 

  1462.     static intptr_t host_dispatcher(NativeHostHandle handle, NativeHostDispatcherOpcode opcode, int32_t index, intptr_t value, void* ptr, float opt)

  1463.     {

  1464.         return handlePtr->handleDispatcher(opcode, index, value, ptr, opt);

  1465.     }

  1466. 

  1467.     #undef handlePtr

  1468. 

  1469.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(NativePlugin)

  1470. };

  1471. 

  1472. // -----------------------------------------------------------------------

  1473. // LV2 plugin descriptor functions

  1474. 

  1475. static LV2_Handle lv2_instantiate(const LV2_Descriptor* lv2Descriptor, double sampleRate, const char* bundlePath, const LV2_Feature* const* features)

  1476. {

  1477.     carla_debug("lv2_instantiate(%p, %g, %s, %p)", lv2Descriptor, sampleRate, bundlePath, features);

  1478. 

  1479.     const NativePluginDescriptor* pluginDesc  = nullptr;

  1480.     const char*                   pluginLabel = nullptr;

  1481. 

  1482.     if (std::strncmp(lv2Descriptor->URI, "http://kxstudio.sf.net/carla/plugins/", 37) == 0)

  1483.         pluginLabel = lv2Descriptor->URI+37;

  1484. 

  1485.     if (pluginLabel == nullptr)

  1486.     {

  1487.         carla_stderr("Failed to find carla native plugin with URI \"%s\"", lv2Descriptor->URI);

  1488.         return nullptr;

  1489.     }

  1490. 

  1491.     carla_debug("lv2_instantiate() - looking up label \"%s\"", pluginLabel);

  1492. 

  1493.     PluginListManager& plm(PluginListManager::getInstance());

  1494. 

  1495.     for (LinkedList<const NativePluginDescriptor*>::Itenerator it = plm.descs.begin2(); it.valid(); it.next())

  1496.     {

  1497.         const NativePluginDescriptor* const& tmpDesc(it.getValue());

  1498. 

  1499.         if (std::strcmp(tmpDesc->label, pluginLabel) == 0)

  1500.         {

  1501.             pluginDesc = tmpDesc;

  1502.             break;

  1503.         }

  1504.     }

  1505. 

  1506.     if (pluginDesc == nullptr)

  1507.     {

  1508.         carla_stderr("Failed to find carla native plugin with label \"%s\"", pluginLabel);

  1509.         return nullptr;

  1510.     }

  1511. 

  1512.     NativePlugin* const plugin(new NativePlugin(pluginDesc, sampleRate, bundlePath, features));

  1513. 

  1514.     if (! plugin->init())

  1515.     {

  1516.         carla_stderr("Failed to init plugin");

  1517.         delete plugin;

  1518.         return nullptr;

  1519.     }

  1520. 

  1521.     return (LV2_Handle)plugin;

  1522. }

  1523. 

  1524. #define instancePtr ((NativePlugin*)instance)

  1525. 

  1526. static void lv2_connect_port(LV2_Handle instance, uint32_t port, void* dataLocation)

  1527. {

  1528.     instancePtr->lv2_connect_port(port, dataLocation);

  1529. }

  1530. 

  1531. static void lv2_activate(LV2_Handle instance)

  1532. {

  1533.     carla_debug("lv2_activate(%p)", instance);

  1534.     instancePtr->lv2_activate();

  1535. }

  1536. 

  1537. static void lv2_run(LV2_Handle instance, uint32_t sampleCount)

  1538. {

  1539.     instancePtr->lv2_run(sampleCount);

  1540. }

  1541. 

  1542. static void lv2_deactivate(LV2_Handle instance)

  1543. {

  1544.     carla_debug("lv2_deactivate(%p)", instance);

  1545.     instancePtr->lv2_deactivate();

  1546. }

  1547. 

  1548. static void lv2_cleanup(LV2_Handle instance)

  1549. {

  1550.     carla_debug("lv2_cleanup(%p)", instance);

  1551.     instancePtr->lv2_cleanup();

  1552.     delete instancePtr;

  1553. }

  1554. 

  1555. static uint32_t lv2_get_options(LV2_Handle instance, LV2_Options_Option* options)

  1556. {

  1557.     carla_debug("lv2_get_options(%p, %p)", instance, options);

  1558.     return instancePtr->lv2_get_options(options);

  1559. }

  1560. 

  1561. static uint32_t lv2_set_options(LV2_Handle instance, const LV2_Options_Option* options)

  1562. {

  1563.     carla_debug("lv2_set_options(%p, %p)", instance, options);

  1564.     return instancePtr->lv2_set_options(options);

  1565. }

  1566. 

  1567. static const LV2_Program_Descriptor* lv2_get_program(LV2_Handle instance, uint32_t index)

  1568. {

  1569.     carla_debug("lv2_get_program(%p, %i)", instance, index);

  1570.     return instancePtr->lv2_get_program(index);

  1571. }

  1572. 

  1573. static void lv2_select_program(LV2_Handle instance, uint32_t bank, uint32_t program)

  1574. {

  1575.     carla_debug("lv2_select_program(%p, %i, %i)", instance, bank, program);

  1576.     return instancePtr->lv2_select_program(bank, program);

  1577. }

  1578. 

  1579. static LV2_State_Status lv2_save(LV2_Handle instance, LV2_State_Store_Function store, LV2_State_Handle handle, uint32_t flags, const LV2_Feature* const* features)

  1580. {

  1581.     carla_debug("lv2_save(%p, %p, %p, %i, %p)", instance, store, handle, flags, features);

  1582.     return instancePtr->lv2_save(store, handle, flags, features);

  1583. }

  1584. 

  1585. static LV2_State_Status lv2_restore(LV2_Handle instance, LV2_State_Retrieve_Function retrieve, LV2_State_Handle handle, uint32_t flags, const LV2_Feature* const* features)

  1586. {

  1587.     carla_debug("lv2_restore(%p, %p, %p, %i, %p)", instance, retrieve, handle, flags, features);

  1588.     return instancePtr->lv2_restore(retrieve, handle, flags, features);

  1589. }

  1590. 

  1591. static const void* lv2_extension_data(const char* uri)

  1592. {

  1593.     carla_debug("lv2_extension_data(\"%s\")", uri);

  1594. 

  1595.     static const LV2_Options_Interface  options  = { lv2_get_options, lv2_set_options };

  1596.     static const LV2_Programs_Interface programs = { lv2_get_program, lv2_select_program };

  1597.     static const LV2_State_Interface    state    = { lv2_save, lv2_restore };

  1598. 

  1599.     if (std::strcmp(uri, LV2_OPTIONS__interface) == 0)

  1600.         return &options;

  1601.     if (std::strcmp(uri, LV2_PROGRAMS__Interface) == 0)

  1602.         return &programs;

  1603.     if (std::strcmp(uri, LV2_STATE__interface) == 0)

  1604.         return &state;

  1605. 

  1606.     return nullptr;

  1607. }

  1608. 

  1609. #undef instancePtr

  1610. 

  1611. // -----------------------------------------------------------------------

  1612. // LV2 UI descriptor functions

  1613. 

  1614. static LV2UI_Handle lv2ui_instantiate(LV2UI_Write_Function writeFunction, LV2UI_Controller controller,

  1615.                                       LV2UI_Widget* widget, const LV2_Feature* const* features, const bool isEmbed)

  1616. {

  1617.     carla_debug("lv2ui_instantiate(..., %p, %p, %p)", writeFunction, controller, widget, features);

  1618. #ifndef CARLA_OS_LINUX

  1619.     CARLA_SAFE_ASSERT_RETURN(! isEmbed, nullptr);

  1620. #endif

  1621. 

  1622.     NativePlugin* plugin = nullptr;

  1623. 

  1624.     for (int i=0; features[i] != nullptr; ++i)

  1625.     {

  1626.         if (std::strcmp(features[i]->URI, LV2_INSTANCE_ACCESS_URI) == 0)

  1627.         {

  1628.             plugin = (NativePlugin*)features[i]->data;

  1629.             break;

  1630.         }

  1631.     }

  1632. 

  1633.     if (plugin == nullptr)

  1634.     {

  1635.         carla_stderr("Host doesn't support instance-access, cannot show UI");

  1636.         return nullptr;

  1637.     }

  1638. 

  1639.     plugin->lv2ui_instantiate(writeFunction, controller, widget, features, isEmbed);

  1640. 

  1641.     return (LV2UI_Handle)plugin;

  1642. }

  1643. 

  1644. #ifdef CARLA_OS_LINUX

  1645. static LV2UI_Handle lv2ui_instantiate_embed(const LV2UI_Descriptor*, const char*, const char*,

  1646.                                             LV2UI_Write_Function writeFunction, LV2UI_Controller controller,

  1647.                                             LV2UI_Widget* widget, const LV2_Feature* const* features)

  1648. {

  1649.     return lv2ui_instantiate(writeFunction, controller, widget, features, true);

  1650. }

  1651. #endif

  1652. 

  1653. static LV2UI_Handle lv2ui_instantiate_external(const LV2UI_Descriptor*, const char*, const char*,

  1654.                                                LV2UI_Write_Function writeFunction, LV2UI_Controller controller,

  1655.                                                LV2UI_Widget* widget, const LV2_Feature* const* features)

  1656. {

  1657.     return lv2ui_instantiate(writeFunction, controller, widget, features, false);

  1658. }

  1659. 

  1660. #define uiPtr ((NativePlugin*)ui)

  1661. 

  1662. static void lv2ui_port_event(LV2UI_Handle ui, uint32_t portIndex, uint32_t bufferSize, uint32_t format, const void* buffer)

  1663. {

  1664.     carla_debug("lv2ui_port_event(%p, %i, %i, %i, %p)", ui, portIndex, bufferSize, format, buffer);

  1665.     uiPtr->lv2ui_port_event(portIndex, bufferSize, format, buffer);

  1666. }

  1667. 

  1668. static void lv2ui_cleanup(LV2UI_Handle ui)

  1669. {

  1670.     carla_debug("lv2ui_cleanup(%p)", ui);

  1671.     uiPtr->lv2ui_cleanup();

  1672. }

  1673. 

  1674. static void lv2ui_select_program(LV2UI_Handle ui, uint32_t bank, uint32_t program)

  1675. {

  1676.     carla_debug("lv2ui_select_program(%p, %i, %i)", ui, bank, program);

  1677.     uiPtr->lv2ui_select_program(bank, program);

  1678. }

  1679. 

  1680. static int lv2ui_idle(LV2UI_Handle ui)

  1681. {

  1682.     return uiPtr->lv2ui_idle();

  1683. }

  1684. 

  1685. static int lv2ui_show(LV2UI_Handle ui)

  1686. {

  1687.     carla_debug("lv2ui_show(%p)", ui);

  1688.     return uiPtr->lv2ui_show();

  1689. }

  1690. 

  1691. static int lv2ui_hide(LV2UI_Handle ui)

  1692. {

  1693.     carla_debug("lv2ui_hide(%p)", ui);

  1694.     return uiPtr->lv2ui_hide();

  1695. }

  1696. 

  1697. static const void* lv2ui_extension_data(const char* uri)

  1698. {

  1699.     carla_stdout("lv2ui_extension_data(\"%s\")", uri);

  1700. 

  1701.     static const LV2UI_Idle_Interface uiidle = { lv2ui_idle };

  1702.     static const LV2UI_Show_Interface uishow = { lv2ui_show, lv2ui_hide };

  1703.     static const LV2_Programs_UI_Interface uiprograms = { lv2ui_select_program };

  1704. 

  1705.     if (std::strcmp(uri, LV2_UI__idleInterface) == 0)

  1706.         return &uiidle;

  1707.     if (std::strcmp(uri, LV2_UI__showInterface) == 0)

  1708.         return &uishow;

  1709.     if (std::strcmp(uri, LV2_PROGRAMS__UIInterface) == 0)

  1710.         return &uiprograms;

  1711. 

  1712.     return nullptr;

  1713. }

  1714. 

  1715. #undef uiPtr

  1716. 

  1717. // -----------------------------------------------------------------------

  1718. // Startup code

  1719. 

  1720. CARLA_EXPORT

  1721. const LV2_Descriptor* lv2_descriptor(uint32_t index)

  1722. {

  1723.     carla_debug("lv2_descriptor(%i)", index);

  1724. 

  1725.     PluginListManager& plm(PluginListManager::getInstance());

  1726. 

  1727.     if (index >= plm.descs.count())

  1728.     {

  1729.         carla_debug("lv2_descriptor(%i) - out of bounds", index);

  1730.         return nullptr;

  1731.     }

  1732.     if (index < plm.lv2Descs.count())

  1733.     {

  1734.         carla_debug("lv2_descriptor(%i) - found previously allocated", index);

  1735.         return plm.lv2Descs.getAt(index, nullptr);

  1736.     }

  1737. 

  1738.     const NativePluginDescriptor* const pluginDesc(plm.descs.getAt(index, nullptr));

  1739.     CARLA_SAFE_ASSERT_RETURN(pluginDesc != nullptr, nullptr);

  1740. 

  1741.     CarlaString tmpURI;

  1742.     tmpURI  = "http://kxstudio.sf.net/carla/plugins/";

  1743.     tmpURI += pluginDesc->label;

  1744. 

  1745.     carla_debug("lv2_descriptor(%i) - not found, allocating new with uri \"%s\"", index, (const char*)tmpURI);

  1746. 

  1747.     const LV2_Descriptor lv2DescTmp = {

  1748.     /* URI            */ carla_strdup(tmpURI),

  1749.     /* instantiate    */ lv2_instantiate,

  1750.     /* connect_port   */ lv2_connect_port,

  1751.     /* activate       */ lv2_activate,

  1752.     /* run            */ lv2_run,

  1753.     /* deactivate     */ lv2_deactivate,

  1754.     /* cleanup        */ lv2_cleanup,

  1755.     /* extension_data */ lv2_extension_data

  1756.     };

  1757. 

  1758.     LV2_Descriptor* const lv2Desc(new LV2_Descriptor);

  1759.     std::memcpy(lv2Desc, &lv2DescTmp, sizeof(LV2_Descriptor));

  1760. 

  1761.     plm.lv2Descs.append(lv2Desc);

  1762. 

  1763.     return lv2Desc;

  1764. }

  1765. 

  1766. CARLA_EXPORT

  1767. const LV2UI_Descriptor* lv2ui_descriptor(uint32_t index)

  1768. {

  1769.     carla_debug("lv2ui_descriptor(%i)", index);

  1770. 

  1771. #ifdef CARLA_OS_LINUX

  1772.     static const LV2UI_Descriptor lv2UiEmbedDesc = {

  1773.     /* URI            */ "http://kxstudio.sf.net/carla/ui-embed",

  1774.     /* instantiate    */ lv2ui_instantiate_embed,

  1775.     /* cleanup        */ lv2ui_cleanup,

  1776.     /* port_event     */ lv2ui_port_event,

  1777.     /* extension_data */ lv2ui_extension_data

  1778.     };

  1779. 

  1780.     if (index == 0)

  1781.         return &lv2UiEmbedDesc;

  1782.     else

  1783.         --index;

  1784. #endif

  1785. 

  1786.     static const LV2UI_Descriptor lv2UiExtDesc = {

  1787.     /* URI            */ "http://kxstudio.sf.net/carla/ui-ext",

  1788.     /* instantiate    */ lv2ui_instantiate_external,

  1789.     /* cleanup        */ lv2ui_cleanup,

  1790.     /* port_event     */ lv2ui_port_event,

  1791.     /* extension_data */ lv2ui_extension_data

  1792.     };

  1793. 

  1794.     return (index == 0) ? &lv2UiExtDesc : nullptr;

  1795. }

  1796. 

  1797. // -----------------------------------------------------------------------