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

1765 lines
59KB
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.           fUridMap(nullptr),

  89.           fURIs(),

  90.           fUI(),

  91.           fPorts(),

  92.           sJuceInitialiser()

  93.     {

  94.         run  = extui_run;

  95.         show = extui_show;

  96.         hide = extui_hide;

  97. 

  98.         CarlaString resourceDir(bundlePath);

  99.         resourceDir += CARLA_OS_SEP_STR "resources" CARLA_OS_SEP_STR;

  100. 

  101.         fHost.handle      = this;

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

  103.         fHost.uiName      = nullptr;

  104.         fHost.uiParentId  = 0;

  105. 

  106.         fHost.get_buffer_size        = host_get_buffer_size;

  107.         fHost.get_sample_rate        = host_get_sample_rate;

  108.         fHost.is_offline             = host_is_offline;

  109.         fHost.get_time_info          = host_get_time_info;

  110.         fHost.write_midi_event       = host_write_midi_event;

  111.         fHost.ui_parameter_changed   = host_ui_parameter_changed;

  112.         fHost.ui_custom_data_changed = host_ui_custom_data_changed;

  113.         fHost.ui_closed              = host_ui_closed;

  114.         fHost.ui_open_file           = host_ui_open_file;

  115.         fHost.ui_save_file           = host_ui_save_file;

  116.         fHost.dispatcher             = host_dispatcher;

  117. 

  118.         const LV2_Options_Option*  options   = nullptr;

  119.         const LV2_URID_Map*        uridMap   = nullptr;

  120.         const LV2_URID_Unmap*      uridUnmap = nullptr;

  121. 

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

  123.         {

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

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

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

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

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

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

  130.         }

  131. 

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

  133.         {

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

  135.             return;

  136.         }

  137. 

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

  139.         {

  140.             if (uridUnmap != nullptr)

  141.             {

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

  143.             }

  144. 

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

  146.             {

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

  148.                 {

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

  150.                     CARLA_SAFE_ASSERT_CONTINUE(value > 0);

  151. 

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

  153.                 }

  154.                 else

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

  156. 

  157.                 break;

  158.             }

  159.         }

  160. 

  161.         fUridMap = uridMap;

  162.     }

  163. 

  164.     ~NativePlugin()

  165.     {

  166.         CARLA_ASSERT(fHandle == nullptr);

  167. 

  168.         if (fHost.resourceDir != nullptr)

  169.         {

  170.             delete[] fHost.resourceDir;

  171.             fHost.resourceDir = nullptr;

  172.         }

  173.     }

  174. 

  175.     bool init()

  176.     {

  177.         if (fUridMap == nullptr)

  178.         {

  179.             // host is missing features

  180.             return false;

  181.         }

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

  183.         {

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

  185.             return false;

  186.         }

  187.         if (fBufferSize == 0)

  188.         {

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

  190.             //return false;

  191.             // as testing, continue for now

  192.             fBufferSize = 1024;

  193.         }

  194. 

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

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

  197. 

  198.         carla_zeroStructs(fMidiEvents, kMaxMidiEvents);

  199.         carla_zeroStruct(fTimeInfo);

  200. 

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

  202.         fTimeInfo.bbt.bar   = 1;

  203.         fTimeInfo.bbt.beat  = 1;

  204.         fTimeInfo.bbt.tick  = 0;

  205.         fTimeInfo.bbt.barStartTick = 0;

  206.         fTimeInfo.bbt.beatsPerBar  = 4;

  207.         fTimeInfo.bbt.beatType     = 4;

  208.         fTimeInfo.bbt.ticksPerBeat = 960.0;

  209.         fTimeInfo.bbt.beatsPerMinute = 120.0;

  210. 

  211.         if (fDescriptor->midiIns > 0)

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

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

  214.             fUI.portOffset += 1;

  215. 

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

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

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

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

  220. 

  221.         fPorts.init(fDescriptor, fHandle);

  222.         fURIs.map(fUridMap);

  223. 

  224.         return true;

  225.     }

  226. 

  227.     // -------------------------------------------------------------------

  228.     // LV2 functions

  229. 

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

  231.     {

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

  233.     }

  234. 

  235.     void lv2_activate()

  236.     {

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

  238.             fDescriptor->activate(fHandle);

  239. 

  240.         carla_zeroStruct(fTimeInfo);

  241.     }

  242. 

  243.     void lv2_deactivate()

  244.     {

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

  246.             fDescriptor->deactivate(fHandle);

  247.     }

  248. 

  249.     void lv2_cleanup()

  250.     {

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

  252.             fDescriptor->cleanup(fHandle);

  253. 

  254.         fHandle = nullptr;

  255.     }

  256. 

  257.     void lv2_run(const uint32_t frames)

  258.     {

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

  260. 

  261.         if (frames == 0)

  262.             return updateParameterOutputs();

  263. 

  264.         // cache midi events and time information

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

  266.         {

  267.             fMidiEventCount = 0;

  268.             carla_zeroStructs(fMidiEvents, kMaxMidiEvents);

  269. 

  270.             if (fDescriptor->hints & NATIVE_PLUGIN_USES_TIME)

  271.             {

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

  273.                 {

  274.                     if (event == nullptr)

  275.                         continue;

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

  277.                         continue;

  278. 

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

  280. 

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

  282.                         continue;

  283. 

  284.                     LV2_Atom* bar     = nullptr;

  285.                     LV2_Atom* barBeat = nullptr;

  286.                     LV2_Atom* beatUnit = nullptr;

  287.                     LV2_Atom* beatsPerBar = nullptr;

  288.                     LV2_Atom* beatsPerMinute = nullptr;

  289.                     LV2_Atom* frame = nullptr;

  290.                     LV2_Atom* speed = nullptr;

  291.                     LV2_Atom* ticksPerBeat = nullptr;

  292. 

  293.                     lv2_atom_object_get(obj,

  294.                                         fURIs.timeBar, &bar,

  295.                                         fURIs.timeBarBeat, &barBeat,

  296.                                         fURIs.timeBeatUnit, &beatUnit,

  297.                                         fURIs.timeBeatsPerBar, &beatsPerBar,

  298.                                         fURIs.timeBeatsPerMinute, &beatsPerMinute,

  299.                                         fURIs.timeFrame, &frame,

  300.                                         fURIs.timeSpeed, &speed,

  301.                                         fURIs.timeTicksPerBeat, &ticksPerBeat,

  302.                                         nullptr);

  303. 

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

  305.                     if (ticksPerBeat != nullptr)

  306.                     {

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

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

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

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

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

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

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

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

  315.                         else

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

  317. 

  318.                         if (fLastPositionData.ticksPerBeat > 0)

  319.                             fTimeInfo.bbt.ticksPerBeat = fLastPositionData.ticksPerBeat;

  320.                     }

  321. 

  322.                     // same

  323.                     if (speed != nullptr)

  324.                     {

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

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

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

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

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

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

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

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

  333.                         else

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

  335. 

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

  337.                     }

  338. 

  339.                     if (bar != nullptr)

  340.                     {

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

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

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

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

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

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

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

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

  349.                         else

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

  351. 

  352.                         if (fLastPositionData.bar >= 0)

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

  354.                     }

  355. 

  356.                     if (barBeat != nullptr)

  357.                     {

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

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

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

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

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

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

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

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

  366.                         else

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

  368. 

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

  370.                         {

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

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

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

  374.                         }

  375.                     }

  376. 

  377.                     if (beatUnit != nullptr)

  378.                     {

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

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

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

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

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

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

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

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

  387.                         else

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

  389. 

  390.                         if (fLastPositionData.beatUnit > 0)

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

  392.                     }

  393. 

  394.                     if (beatsPerBar != nullptr)

  395.                     {

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

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

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

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

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

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

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

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

  404.                         else

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

  406. 

  407.                         if (fLastPositionData.beatsPerBar > 0.0f)

  408.                             fTimeInfo.bbt.beatsPerBar = fLastPositionData.beatsPerBar;

  409.                     }

  410. 

  411.                     if (beatsPerMinute != nullptr)

  412.                     {

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

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

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

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

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

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

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

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

  421.                         else

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

  423. 

  424.                         if (fLastPositionData.beatsPerMinute > 0.0f)

  425.                         {

  426.                             fTimeInfo.bbt.beatsPerMinute = fLastPositionData.beatsPerMinute;

  427. 

  428.                             if (carla_isNotZero(fLastPositionData.speed))

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

  430.                         }

  431.                     }

  432. 

  433.                     if (frame != nullptr)

  434.                     {

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

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

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

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

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

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

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

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

  443.                         else

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

  445. 

  446.                         if (fLastPositionData.frame >= 0)

  447.                             fTimeInfo.frame = fLastPositionData.frame;

  448.                     }

  449. 

  450.                     fTimeInfo.bbt.barStartTick = fTimeInfo.bbt.ticksPerBeat*

  451.                                                  fTimeInfo.bbt.beatsPerBar*

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

  453. 

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

  455.                                            fLastPositionData.beatUnit > 0 &&

  456.                                            fLastPositionData.beatsPerBar > 0.0f);

  457.                 }

  458.             }

  459. 

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

  461.             {

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

  463.                 {

  464.                     if (event == nullptr)

  465.                         continue;

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

  467.                         continue;

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

  469.                         continue;

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

  471.                         break;

  472.                     if (fMidiEventCount >= kMaxMidiEvents)

  473.                         break;

  474. 

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

  476. 

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

  478. 

  479.                     nativeEvent.port = (uint8_t)i;

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

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

  482. 

  483.                     uint32_t j=0;

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

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

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

  487.                         nativeEvent.data[j] = 0;

  488.                 }

  489.             }

  490.         }

  491. 

  492.         // init midi out data

  493.         if (fDescriptor->midiOuts > 0)

  494.         {

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

  496.             {

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

  498.                 CARLA_SAFE_ASSERT_CONTINUE(seq != nullptr);

  499. 

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

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

  502.                 mData.offset   = 0;

  503.             }

  504.         }

  505. 

  506.         // Check for updated parameters

  507.         float curValue;

  508. 

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

  510.         {

  511.             if (fPorts.paramsOut[i])

  512.                 continue;

  513. 

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

  515. 

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

  517. 

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

  519.                 continue;

  520. 

  521.             fPorts.paramsLast[i] = curValue;

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

  523.         }

  524. 

  525.         // FIXME

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

  527. 

  528.         // update timePos for next callback

  529.         if (carla_isNotZero(fLastPositionData.speed))

  530.         {

  531.             if (fLastPositionData.speed > 0.0)

  532.             {

  533.                 // playing forwards

  534.                 fLastPositionData.frame += frames;

  535.             }

  536.             else

  537.             {

  538.                 // playing backwards

  539.                 fLastPositionData.frame -= frames;

  540. 

  541.                 if (fLastPositionData.frame < 0)

  542.                     fLastPositionData.frame = 0;

  543.             }

  544. 

  545.             fTimeInfo.frame = fLastPositionData.frame;

  546. 

  547.             if (fTimeInfo.bbt.valid)

  548.             {

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

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

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

  552. 

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

  554.                 {

  555.                     fLastPositionData.barBeat = std::fmod(fLastPositionData.barBeat+addedBarBeats,

  556.                                                           fLastPositionData.beatsPerBar);

  557. 

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

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

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

  561. 

  562.                     if (fLastPositionData.bar >= 0)

  563.                     {

  564.                         fLastPositionData.bar += std::floor((fLastPositionData.barBeat+addedBarBeats)/

  565.                                                              fLastPositionData.beatsPerBar);

  566. 

  567.                         if (fLastPositionData.bar < 0)

  568.                             fLastPositionData.bar = 0;

  569. 

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

  571. 

  572.                         fTimeInfo.bbt.barStartTick = fTimeInfo.bbt.ticksPerBeat*

  573.                                                      fTimeInfo.bbt.beatsPerBar*

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

  575.                     }

  576.                 }

  577. 

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

  579.             }

  580.         }

  581. 

  582.         updateParameterOutputs();

  583.     }

  584. 

  585.     // -------------------------------------------------------------------

  586. 

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

  588.     {

  589.         // currently unused

  590.         return LV2_OPTIONS_SUCCESS;

  591.     }

  592. 

  593.     uint32_t lv2_set_options(const LV2_Options_Option* const options)

  594.     {

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

  596.         {

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

  598.             {

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

  600.                 {

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

  602.                     CARLA_SAFE_ASSERT_CONTINUE(value > 0);

  603. 

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

  605. 

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

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

  608.                 }

  609.                 else

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

  611.             }

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

  613.             {

  614.                 if (options[i].type == fUridMap->map(fUridMap->handle, LV2_ATOM__Double))

  615.                 {

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

  617.                     CARLA_SAFE_ASSERT_CONTINUE(value > 0.0);

  618. 

  619.                     fSampleRate = value;

  620. 

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

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

  623.                 }

  624.                 else

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

  626.             }

  627.         }

  628. 

  629.         return LV2_OPTIONS_SUCCESS;

  630.     }

  631. 

  632.     const LV2_Program_Descriptor* lv2_get_program(const uint32_t index)

  633.     {

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

  635.             return nullptr;

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

  637.             return nullptr;

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

  639.             return nullptr;

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

  641.             return nullptr;

  642. 

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

  644. 

  645.         if (midiProg == nullptr)

  646.             return nullptr;

  647. 

  648.         fProgramDesc.bank    = midiProg->bank;

  649.         fProgramDesc.program = midiProg->program;

  650.         fProgramDesc.name    = midiProg->name;

  651. 

  652.         return &fProgramDesc;

  653.     }

  654. 

  655.     void lv2_select_program(uint32_t bank, uint32_t program)

  656.     {

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

  658.             return;

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

  660.             return;

  661. 

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

  663. 

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

  665.         {

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

  667. 

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

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

  670.         }

  671.     }

  672. 

  673.     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

  674.     {

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

  676.             return LV2_STATE_ERR_NO_FEATURE;

  677. 

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

  679.         {

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

  681.             std::free(state);

  682.             return LV2_STATE_SUCCESS;

  683.         }

  684. 

  685.         return LV2_STATE_ERR_UNKNOWN;

  686.     }

  687. 

  688.     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

  689.     {

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

  691.             return LV2_STATE_ERR_NO_FEATURE;

  692. 

  693.         size_t   size = 0;

  694.         uint32_t type = 0;

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

  696. 

  697.         if (size == 0)

  698.             return LV2_STATE_ERR_UNKNOWN;

  699.         if (type == 0)

  700.             return LV2_STATE_ERR_UNKNOWN;

  701.         if (data == nullptr)

  702.             return LV2_STATE_ERR_UNKNOWN;

  703.         if (type != fURIs.atomString)

  704.             return LV2_STATE_ERR_BAD_TYPE;

  705. 

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

  707. 

  708.         return LV2_STATE_SUCCESS;

  709.     }

  710. 

  711.     // -------------------------------------------------------------------

  712. 

  713.     void lv2ui_instantiate(LV2UI_Write_Function writeFunction, LV2UI_Controller controller,

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

  715.     {

  716.         fUI.writeFunction = writeFunction;

  717.         fUI.controller = controller;

  718.         fUI.isEmbed = isEmbed;

  719. 

  720. #ifdef CARLA_OS_LINUX

  721.         // ---------------------------------------------------------------

  722.         // show embed UI if needed

  723. 

  724.         if (isEmbed)

  725.         {

  726.             fUI.isVisible = true;

  727. 

  728.             intptr_t parentId = 0;

  729. 

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

  731.             {

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

  733.                 {

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

  735.                 }

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

  737.                 {

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

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

  740.                 }

  741.             }

  742. 

  743.             char strBuf[0xff+1];

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

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

  746. 

  747.             carla_setenv("CARLA_PLUGIN_EMBED_WINID", strBuf);

  748. 

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

  750. 

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

  752.         }

  753. #endif

  754. 

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

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

  757. 

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

  759.         {

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

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

  762.             {

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

  764.                 break;

  765.             }

  766.         }

  767. 

  768.         if (fUI.host != nullptr)

  769.         {

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

  771.             *widget = this;

  772.             return;

  773.         }

  774. 

  775.         // ---------------------------------------------------------------

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

  777. 

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

  779.         {

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

  781.             {

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

  783. 

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

  785.                 {

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

  787.                     {

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

  789.                         break;

  790.                     }

  791.                 }

  792.                 break;

  793.             }

  794.         }

  795. 

  796.         if (fHost.uiName == nullptr)

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

  798. 

  799.         *widget = nullptr;

  800.     }

  801. 

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

  803.     {

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

  805.             return;

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

  807.             return;

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

  809.             return;

  810. 

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

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

  813.     }

  814. 

  815.     void lv2ui_cleanup()

  816.     {

  817.         if (fUI.isVisible)

  818.             handleUiHide();

  819. 

  820.         fUI.host = nullptr;

  821.         fUI.writeFunction = nullptr;

  822.         fUI.controller = nullptr;

  823. 

  824.         if (fHost.uiName != nullptr)

  825.         {

  826.             delete[] fHost.uiName;

  827.             fHost.uiName = nullptr;

  828.         }

  829.     }

  830. 

  831.     // -------------------------------------------------------------------

  832. 

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

  834.     {

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

  836.             return;

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

  838.             return;

  839. 

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

  841.     }

  842. 

  843.     // -------------------------------------------------------------------

  844. 

  845.     int lv2ui_idle() const

  846.     {

  847.         if (! fUI.isVisible)

  848.             return 1;

  849. 

  850.         handleUiRun();

  851.         return 0;

  852.     }

  853. 

  854.     int lv2ui_show()

  855.     {

  856.         handleUiShow();

  857.         return 0;

  858.     }

  859. 

  860.     int lv2ui_hide()

  861.     {

  862.         handleUiHide();

  863.         return 0;

  864.     }

  865. 

  866.     // -------------------------------------------------------------------

  867. 

  868. protected:

  869.     void handleUiRun() const

  870.     {

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

  872.             fDescriptor->ui_idle(fHandle);

  873.     }

  874. 

  875.     void handleUiShow()

  876.     {

  877.         CARLA_SAFE_ASSERT_RETURN(! fUI.isEmbed,);

  878. 

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

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

  881. 

  882.         fUI.isVisible = true;

  883.     }

  884. 

  885.     void handleUiHide()

  886.     {

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

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

  889. 

  890.         fUI.isVisible = false;

  891.     }

  892. 

  893.     // -------------------------------------------------------------------

  894. 

  895.     bool handleWriteMidiEvent(const NativeMidiEvent* const event)

  896.     {

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

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

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

  900. 

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

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

  903. 

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

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

  906. 

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

  908. 

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

  910.             return false;

  911. 

  912.         if (mData.offset == 0)

  913.         {

  914.             seq->atom.size = 0;

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

  916.             seq->body.unit = 0;

  917.             seq->body.pad  = 0;

  918.         }

  919. 

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

  921. 

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

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

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

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

  926. 

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

  928.         mData.offset       += size;

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

  930. 

  931.         return true;

  932.     }

  933. 

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

  935.     {

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

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

  938.     }

  939. 

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

  941.     {

  942.         //storeCustomData(key, value);

  943.     }

  944. 

  945.     void handleUiClosed()

  946.     {

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

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

  949. 

  950.         fUI.host = nullptr;

  951.         fUI.writeFunction = nullptr;

  952.         fUI.controller = nullptr;

  953.         fUI.isVisible = false;

  954.     }

  955. 

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

  957.     {

  958.         // TODO

  959.         return nullptr;

  960.     }

  961. 

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

  963.     {

  964.         // TODO

  965.         return nullptr;

  966.     }

  967. 

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

  969.     {

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

  971. 

  972.         intptr_t ret = 0;

  973. 

  974.         switch (opcode)

  975.         {

  976.         case NATIVE_HOST_OPCODE_NULL:

  977.         case NATIVE_HOST_OPCODE_UPDATE_PARAMETER:

  978.         case NATIVE_HOST_OPCODE_UPDATE_MIDI_PROGRAM:

  979.         case NATIVE_HOST_OPCODE_RELOAD_PARAMETERS:

  980.         case NATIVE_HOST_OPCODE_RELOAD_MIDI_PROGRAMS:

  981.         case NATIVE_HOST_OPCODE_RELOAD_ALL:

  982.         case NATIVE_HOST_OPCODE_HOST_IDLE:

  983.             // nothing

  984.             break;

  985.         case NATIVE_HOST_OPCODE_UI_UNAVAILABLE:

  986.             handleUiClosed();

  987.             break;

  988.         }

  989. 

  990.         return ret;

  991. 

  992.         // unused for now

  993.         (void)index;

  994.         (void)value;

  995.         (void)ptr;

  996.         (void)opt;

  997.     }

  998. 

  999.     void updateParameterOutputs()

  1000.     {

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

  1002.         {

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

  1004.                 continue;

  1005. 

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

  1007. 

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

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

  1010.         }

  1011.     }

  1012. 

  1013.     // -------------------------------------------------------------------

  1014. 

  1015. private:

  1016.     // Native data

  1017.     NativePluginHandle   fHandle;

  1018.     NativeHostDescriptor fHost;

  1019.     const NativePluginDescriptor* const fDescriptor;

  1020.     LV2_Program_Descriptor              fProgramDesc;

  1021. 

  1022.     uint32_t        fMidiEventCount;

  1023.     NativeMidiEvent fMidiEvents[kMaxMidiEvents];

  1024.     NativeTimeInfo  fTimeInfo;

  1025. 

  1026.     // Lv2 host data

  1027.     bool     fIsOffline;

  1028.     uint32_t fBufferSize;

  1029.     double   fSampleRate;

  1030. 

  1031.     const LV2_URID_Map* fUridMap;

  1032. 

  1033.     struct Lv2PositionData {

  1034.         int64_t  bar;

  1035.         float    barBeat;

  1036.         uint32_t beatUnit;

  1037.         float    beatsPerBar;

  1038.         float    beatsPerMinute;

  1039.         int64_t  frame;

  1040.         double   speed;

  1041.         int64_t  ticksPerBeat;

  1042. 

  1043.         Lv2PositionData()

  1044.             : bar(-1),

  1045.               barBeat(-1.0f),

  1046.               beatUnit(0),

  1047.               beatsPerBar(0.0f),

  1048.               beatsPerMinute(0.0f),

  1049.               frame(-1),

  1050.               speed(0.0),

  1051.               ticksPerBeat(-1) {}

  1052. 

  1053.     } fLastPositionData;

  1054. 

  1055.     struct URIDs {

  1056.         LV2_URID atomBlank;

  1057.         LV2_URID atomObject;

  1058.         LV2_URID atomDouble;

  1059.         LV2_URID atomFloat;

  1060.         LV2_URID atomInt;

  1061.         LV2_URID atomLong;

  1062.         LV2_URID atomSequence;

  1063.         LV2_URID atomString;

  1064.         LV2_URID midiEvent;

  1065.         LV2_URID timePos;

  1066.         LV2_URID timeBar;

  1067.         LV2_URID timeBeat;

  1068.         LV2_URID timeBarBeat;

  1069.         LV2_URID timeBeatsPerBar;

  1070.         LV2_URID timeBeatsPerMinute;

  1071.         LV2_URID timeBeatUnit;

  1072.         LV2_URID timeFrame;

  1073.         LV2_URID timeSpeed;

  1074.         LV2_URID timeTicksPerBeat;

  1075. 

  1076.         URIDs()

  1077.             : atomBlank(0),

  1078.               atomObject(0),

  1079.               atomDouble(0),

  1080.               atomFloat(0),

  1081.               atomInt(0),

  1082.               atomLong(0),

  1083.               atomSequence(0),

  1084.               atomString(0),

  1085.               midiEvent(0),

  1086.               timePos(0),

  1087.               timeBar(0),

  1088.               timeBeat(0),

  1089.               timeBarBeat(0),

  1090.               timeBeatsPerBar(0),

  1091.               timeBeatsPerMinute(0),

  1092.               timeBeatUnit(0),

  1093.               timeFrame(0),

  1094.               timeSpeed(0),

  1095.               timeTicksPerBeat(0) {}

  1096. 

  1097.         void map(const LV2_URID_Map* const uridMap)

  1098.         {

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

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

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

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

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

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

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

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

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

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

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

  1110.             timeBeat     = uridMap->map(uridMap->handle, LV2_TIME__beat);

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

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

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

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

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

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

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

  1118.         }

  1119.     } fURIs;

  1120. 

  1121.     struct UI {

  1122.         const LV2_External_UI_Host* host;

  1123.         LV2UI_Write_Function writeFunction;

  1124.         LV2UI_Controller controller;

  1125.         uint32_t portOffset;

  1126.         bool isEmbed;

  1127.         bool isVisible;

  1128. 

  1129.         UI()

  1130.             : host(nullptr),

  1131.               writeFunction(nullptr),

  1132.               controller(nullptr),

  1133.               portOffset(0),

  1134.               isEmbed(false),

  1135.               isVisible(false) {}

  1136.     } fUI;

  1137. 

  1138.     struct Ports {

  1139.         // need to save current state

  1140.         struct MidiOutData {

  1141.             uint32_t capacity;

  1142.             uint32_t offset;

  1143. 

  1144.             MidiOutData()

  1145.                 : capacity(0),

  1146.                   offset(0) {}

  1147.         };

  1148. 

  1149.         const LV2_Atom_Sequence** eventsIn;

  1150.         /* */ LV2_Atom_Sequence** midiOuts;

  1151.         /* */ MidiOutData*        midiOutData;

  1152.         const float** audioIns;

  1153.         /* */ float** audioOuts;

  1154.         float*   freewheel;

  1155.         uint32_t paramCount;

  1156.         float*   paramsLast;

  1157.         float**  paramsPtr;

  1158.         bool*    paramsOut;

  1159. 

  1160.         Ports()

  1161.             : eventsIn(nullptr),

  1162.               midiOuts(nullptr),

  1163.               audioIns(nullptr),

  1164.               audioOuts(nullptr),

  1165.               freewheel(nullptr),

  1166.               paramCount(0),

  1167.               paramsLast(nullptr),

  1168.               paramsPtr(nullptr),

  1169.               paramsOut(nullptr) {}

  1170. 

  1171.         ~Ports()

  1172.         {

  1173.             if (eventsIn != nullptr)

  1174.             {

  1175.                 delete[] eventsIn;

  1176.                 eventsIn = nullptr;

  1177.             }

  1178. 

  1179.             if (midiOuts != nullptr)

  1180.             {

  1181.                 delete[] midiOuts;

  1182.                 midiOuts = nullptr;

  1183.             }

  1184. 

  1185.             if (midiOutData != nullptr)

  1186.             {

  1187.                 delete[] midiOutData;

  1188.                 midiOutData = nullptr;

  1189.             }

  1190. 

  1191.             if (audioIns != nullptr)

  1192.             {

  1193.                 delete[] audioIns;

  1194.                 audioIns = nullptr;

  1195.             }

  1196. 

  1197.             if (audioOuts != nullptr)

  1198.             {

  1199.                 delete[] audioOuts;

  1200.                 audioOuts = nullptr;

  1201.             }

  1202. 

  1203.             if (paramsLast != nullptr)

  1204.             {

  1205.                 delete[] paramsLast;

  1206.                 paramsLast = nullptr;

  1207.             }

  1208. 

  1209.             if (paramsPtr != nullptr)

  1210.             {

  1211.                 delete[] paramsPtr;

  1212.                 paramsPtr = nullptr;

  1213.             }

  1214. 

  1215.             if (paramsOut != nullptr)

  1216.             {

  1217.                 delete[] paramsOut;

  1218.                 paramsOut = nullptr;

  1219.             }

  1220.         }

  1221. 

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

  1223.         {

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

  1225. 

  1226.             if (desc->midiIns > 0)

  1227.             {

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

  1229. 

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

  1231.                     eventsIn[i] = nullptr;

  1232.             }

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

  1234.             {

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

  1236.                 eventsIn[0] = nullptr;

  1237.             }

  1238. 

  1239.             if (desc->midiOuts > 0)

  1240.             {

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

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

  1243. 

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

  1245.                     midiOuts[i] = nullptr;

  1246.             }

  1247. 

  1248.             if (desc->audioIns > 0)

  1249.             {

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

  1251. 

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

  1253.                     audioIns[i] = nullptr;

  1254.             }

  1255. 

  1256.             if (desc->audioOuts > 0)

  1257.             {

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

  1259. 

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

  1261.                     audioOuts[i] = nullptr;

  1262.             }

  1263. 

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

  1265.             {

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

  1267. 

  1268.                 if (paramCount > 0)

  1269.                 {

  1270.                     paramsLast = new float[paramCount];

  1271.                     paramsPtr  = new float*[paramCount];

  1272.                     paramsOut  = new bool[paramCount];

  1273. 

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

  1275.                     {

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

  1277.                         paramsPtr [i] = nullptr;

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

  1279.                     }

  1280.                 }

  1281.             }

  1282.         }

  1283. 

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

  1285.         {

  1286.             uint32_t index = 0;

  1287. 

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

  1289.             {

  1290.                 if (port == index++)

  1291.                 {

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

  1293.                     return;

  1294.                 }

  1295.             }

  1296. 

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

  1298.             {

  1299.                 if (port == index++)

  1300.                 {

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

  1302.                     return;

  1303.                 }

  1304.             }

  1305. 

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

  1307.             {

  1308.                 if (port == index++)

  1309.                 {

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

  1311.                     return;

  1312.                 }

  1313.             }

  1314. 

  1315.             if (port == index++)

  1316.             {

  1317.                 freewheel = (float*)dataLocation;

  1318.                 return;

  1319.             }

  1320. 

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

  1322.             {

  1323.                 if (port == index++)

  1324.                 {

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

  1326.                     return;

  1327.                 }

  1328.             }

  1329. 

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

  1331.             {

  1332.                 if (port == index++)

  1333.                 {

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

  1335.                     return;

  1336.                 }

  1337.             }

  1338. 

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

  1340.             {

  1341.                 if (port == index++)

  1342.                 {

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

  1344.                     return;

  1345.                 }

  1346.             }

  1347.         }

  1348. 

  1349.         CARLA_DECLARE_NON_COPY_STRUCT(Ports);

  1350.     } fPorts;

  1351. 

  1352.     SharedResourcePointer<ScopedJuceInitialiser_GUI> sJuceInitialiser;

  1353. 

  1354.     // -------------------------------------------------------------------

  1355. 

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

  1357. 

  1358.     static void extui_run(LV2_External_UI_Widget_Compat* self)

  1359.     {

  1360.         handlePtr->handleUiRun();

  1361.     }

  1362. 

  1363.     static void extui_show(LV2_External_UI_Widget_Compat* self)

  1364.     {

  1365.         handlePtr->handleUiShow();

  1366.     }

  1367. 

  1368.     static void extui_hide(LV2_External_UI_Widget_Compat* self)

  1369.     {

  1370.         handlePtr->handleUiHide();

  1371.     }

  1372. 

  1373.     #undef handlePtr

  1374. 

  1375.     // -------------------------------------------------------------------

  1376. 

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

  1378. 

  1379.     static uint32_t host_get_buffer_size(NativeHostHandle handle)

  1380.     {

  1381.         return handlePtr->fBufferSize;

  1382.     }

  1383. 

  1384.     static double host_get_sample_rate(NativeHostHandle handle)

  1385.     {

  1386.         return handlePtr->fSampleRate;

  1387.     }

  1388. 

  1389.     static bool host_is_offline(NativeHostHandle handle)

  1390.     {

  1391.         return handlePtr->fIsOffline;

  1392.     }

  1393. 

  1394.     static const NativeTimeInfo* host_get_time_info(NativeHostHandle handle)

  1395.     {

  1396.         return &(handlePtr->fTimeInfo);

  1397.     }

  1398. 

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

  1400.     {

  1401.         return handlePtr->handleWriteMidiEvent(event);

  1402.     }

  1403. 

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

  1405.     {

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

  1407.     }

  1408. 

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

  1410.     {

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

  1412.     }

  1413. 

  1414.     static void host_ui_closed(NativeHostHandle handle)

  1415.     {

  1416.         handlePtr->handleUiClosed();

  1417.     }

  1418. 

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

  1420.     {

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

  1422.     }

  1423. 

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

  1425.     {

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

  1427.     }

  1428. 

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

  1430.     {

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

  1432.     }

  1433. 

  1434.     #undef handlePtr

  1435. 

  1436.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(NativePlugin)

  1437. };

  1438. 

  1439. // -----------------------------------------------------------------------

  1440. // LV2 plugin descriptor functions

  1441. 

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

  1443. {

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

  1445. 

  1446.     const NativePluginDescriptor* pluginDesc  = nullptr;

  1447.     const char*                   pluginLabel = nullptr;

  1448. 

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

  1450.         pluginLabel = lv2Descriptor->URI+37;

  1451. 

  1452.     if (pluginLabel == nullptr)

  1453.     {

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

  1455.         return nullptr;

  1456.     }

  1457. 

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

  1459. 

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

  1461. 

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

  1463.     {

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

  1465. 

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

  1467.         {

  1468.             pluginDesc = tmpDesc;

  1469.             break;

  1470.         }

  1471.     }

  1472. 

  1473.     if (pluginDesc == nullptr)

  1474.     {

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

  1476.         return nullptr;

  1477.     }

  1478. 

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

  1480. 

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

  1482.     {

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

  1484.         delete plugin;

  1485.         return nullptr;

  1486.     }

  1487. 

  1488.     return (LV2_Handle)plugin;

  1489. }

  1490. 

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

  1492. 

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

  1494. {

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

  1496. }

  1497. 

  1498. static void lv2_activate(LV2_Handle instance)

  1499. {

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

  1501.     instancePtr->lv2_activate();

  1502. }

  1503. 

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

  1505. {

  1506.     instancePtr->lv2_run(sampleCount);

  1507. }

  1508. 

  1509. static void lv2_deactivate(LV2_Handle instance)

  1510. {

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

  1512.     instancePtr->lv2_deactivate();

  1513. }

  1514. 

  1515. static void lv2_cleanup(LV2_Handle instance)

  1516. {

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

  1518.     instancePtr->lv2_cleanup();

  1519.     delete instancePtr;

  1520. }

  1521. 

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

  1523. {

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

  1525.     return instancePtr->lv2_get_options(options);

  1526. }

  1527. 

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

  1529. {

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

  1531.     return instancePtr->lv2_set_options(options);

  1532. }

  1533. 

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

  1535. {

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

  1537.     return instancePtr->lv2_get_program(index);

  1538. }

  1539. 

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

  1541. {

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

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

  1544. }

  1545. 

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

  1547. {

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

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

  1550. }

  1551. 

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

  1553. {

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

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

  1556. }

  1557. 

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

  1559. {

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

  1561. 

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

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

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

  1565. 

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

  1567.         return &options;

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

  1569.         return &programs;

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

  1571.         return &state;

  1572. 

  1573.     return nullptr;

  1574. }

  1575. 

  1576. #undef instancePtr

  1577. 

  1578. // -----------------------------------------------------------------------

  1579. // LV2 UI descriptor functions

  1580. 

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

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

  1583. {

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

  1585. #ifndef CARLA_OS_LINUX

  1586.     CARLA_SAFE_ASSERT_RETURN(! isEmbed, nullptr);

  1587. #endif

  1588. 

  1589.     NativePlugin* plugin = nullptr;

  1590. 

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

  1592.     {

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

  1594.         {

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

  1596.             break;

  1597.         }

  1598.     }

  1599. 

  1600.     if (plugin == nullptr)

  1601.     {

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

  1603.         return nullptr;

  1604.     }

  1605. 

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

  1607. 

  1608.     return (LV2UI_Handle)plugin;

  1609. }

  1610. 

  1611. #ifdef CARLA_OS_LINUX

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

  1613.                                             LV2UI_Write_Function writeFunction, LV2UI_Controller controller,

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

  1615. {

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

  1617. }

  1618. #endif

  1619. 

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

  1621.                                                LV2UI_Write_Function writeFunction, LV2UI_Controller controller,

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

  1623. {

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

  1625. }

  1626. 

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

  1628. 

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

  1630. {

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

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

  1633. }

  1634. 

  1635. static void lv2ui_cleanup(LV2UI_Handle ui)

  1636. {

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

  1638.     uiPtr->lv2ui_cleanup();

  1639. }

  1640. 

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

  1642. {

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

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

  1645. }

  1646. 

  1647. static int lv2ui_idle(LV2UI_Handle ui)

  1648. {

  1649.     return uiPtr->lv2ui_idle();

  1650. }

  1651. 

  1652. static int lv2ui_show(LV2UI_Handle ui)

  1653. {

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

  1655.     return uiPtr->lv2ui_show();

  1656. }

  1657. 

  1658. static int lv2ui_hide(LV2UI_Handle ui)

  1659. {

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

  1661.     return uiPtr->lv2ui_hide();

  1662. }

  1663. 

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

  1665. {

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

  1667. 

  1668.     static const LV2UI_Idle_Interface uiidle = { lv2ui_idle };

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

  1670.     static const LV2_Programs_UI_Interface uiprograms = { lv2ui_select_program };

  1671. 

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

  1673.         return &uiidle;

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

  1675.         return &uishow;

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

  1677.         return &uiprograms;

  1678. 

  1679.     return nullptr;

  1680. }

  1681. 

  1682. #undef uiPtr

  1683. 

  1684. // -----------------------------------------------------------------------

  1685. // Startup code

  1686. 

  1687. CARLA_EXPORT

  1688. const LV2_Descriptor* lv2_descriptor(uint32_t index)

  1689. {

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

  1691. 

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

  1693. 

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

  1695.     {

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

  1697.         return nullptr;

  1698.     }

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

  1700.     {

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

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

  1703.     }

  1704. 

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

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

  1707. 

  1708.     CarlaString tmpURI;

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

  1710.     tmpURI += pluginDesc->label;

  1711. 

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

  1713. 

  1714.     const LV2_Descriptor lv2DescTmp = {

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

  1716.     /* instantiate    */ lv2_instantiate,

  1717.     /* connect_port   */ lv2_connect_port,

  1718.     /* activate       */ lv2_activate,

  1719.     /* run            */ lv2_run,

  1720.     /* deactivate     */ lv2_deactivate,

  1721.     /* cleanup        */ lv2_cleanup,

  1722.     /* extension_data */ lv2_extension_data

  1723.     };

  1724. 

  1725.     LV2_Descriptor* const lv2Desc(new LV2_Descriptor);

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

  1727. 

  1728.     plm.lv2Descs.append(lv2Desc);

  1729. 

  1730.     return lv2Desc;

  1731. }

  1732. 

  1733. CARLA_EXPORT

  1734. const LV2UI_Descriptor* lv2ui_descriptor(uint32_t index)

  1735. {

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

  1737. 

  1738. #ifdef CARLA_OS_LINUX

  1739.     static const LV2UI_Descriptor lv2UiEmbedDesc = {

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

  1741.     /* instantiate    */ lv2ui_instantiate_embed,

  1742.     /* cleanup        */ lv2ui_cleanup,

  1743.     /* port_event     */ lv2ui_port_event,

  1744.     /* extension_data */ lv2ui_extension_data

  1745.     };

  1746. 

  1747.     if (index == 0)

  1748.         return &lv2UiEmbedDesc;

  1749.     else

  1750.         --index;

  1751. #endif

  1752. 

  1753.     static const LV2UI_Descriptor lv2UiExtDesc = {

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

  1755.     /* instantiate    */ lv2ui_instantiate_external,

  1756.     /* cleanup        */ lv2ui_cleanup,

  1757.     /* port_event     */ lv2ui_port_event,

  1758.     /* extension_data */ lv2ui_extension_data

  1759.     };

  1760. 

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

  1762. }

  1763. 

  1764. // -----------------------------------------------------------------------