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

1768 lines
60KB
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*2);

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

  263.             updateParameterOutputs();

  264.             return;

  265.         }

  266. 

  267.         // Check for updated parameters

  268.         float curValue;

  269. 

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

  271.         {

  272.             if (fPorts.paramsOut[i])

  273.                 continue;

  274. 

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

  276. 

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

  278. 

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

  280.                 continue;

  281. 

  282.             fPorts.paramsLast[i] = curValue;

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

  284.         }

  285. 

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

  287.         {

  288.             fMidiEventCount = 0;

  289.             carla_zeroStructs(fMidiEvents, kMaxMidiEvents*2);

  290. 

  291.             if (fDescriptor->hints & NATIVE_PLUGIN_USES_TIME)

  292.             {

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

  294.                 {

  295.                     if (event == nullptr)

  296.                         continue;

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

  298.                         continue;

  299. 

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

  301. 

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

  303.                         continue;

  304. 

  305.                     LV2_Atom* bar     = nullptr;

  306.                     LV2_Atom* barBeat = nullptr;

  307.                     LV2_Atom* beatUnit = nullptr;

  308.                     LV2_Atom* beatsPerBar = nullptr;

  309.                     LV2_Atom* beatsPerMinute = nullptr;

  310.                     LV2_Atom* frame = nullptr;

  311.                     LV2_Atom* speed = nullptr;

  312.                     LV2_Atom* ticksPerBeat = nullptr;

  313. 

  314.                     lv2_atom_object_get(obj,

  315.                                         fURIs.timeBar, &bar,

  316.                                         fURIs.timeBarBeat, &barBeat,

  317.                                         fURIs.timeBeatUnit, &beatUnit,

  318.                                         fURIs.timeBeatsPerBar, &beatsPerBar,

  319.                                         fURIs.timeBeatsPerMinute, &beatsPerMinute,

  320.                                         fURIs.timeFrame, &frame,

  321.                                         fURIs.timeSpeed, &speed,

  322.                                         fURIs.timeTicksPerBeat, &ticksPerBeat,

  323.                                         nullptr);

  324. 

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

  326.                     if (ticksPerBeat != nullptr)

  327.                     {

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

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

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

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

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

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

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

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

  336.                         else

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

  338. 

  339.                         if (fLastPositionData.ticksPerBeat > 0)

  340.                             fTimeInfo.bbt.ticksPerBeat = fLastPositionData.ticksPerBeat;

  341.                     }

  342. 

  343.                     // same

  344.                     if (speed != nullptr)

  345.                     {

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

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

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

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

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

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

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

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

  354.                         else

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

  356. 

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

  358.                     }

  359. 

  360.                     if (bar != nullptr)

  361.                     {

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

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

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

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

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

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

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

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

  370.                         else

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

  372. 

  373.                         if (fLastPositionData.bar >= 0)

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

  375.                     }

  376. 

  377.                     if (barBeat != nullptr)

  378.                     {

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

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

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

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

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

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

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

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

  387.                         else

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

  389. 

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

  391.                         {

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

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

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

  395.                         }

  396.                     }

  397. 

  398.                     if (beatUnit != nullptr)

  399.                     {

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

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

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

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

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

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

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

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

  408.                         else

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

  410. 

  411.                         if (fLastPositionData.beatUnit > 0)

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

  413.                     }

  414. 

  415.                     if (beatsPerBar != nullptr)

  416.                     {

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

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

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

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

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

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

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

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

  425.                         else

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

  427. 

  428.                         if (fLastPositionData.beatsPerBar > 0.0f)

  429.                             fTimeInfo.bbt.beatsPerBar = fLastPositionData.beatsPerBar;

  430.                     }

  431. 

  432.                     if (beatsPerMinute != nullptr)

  433.                     {

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

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

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

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

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

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

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

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

  442.                         else

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

  444. 

  445.                         if (fLastPositionData.beatsPerMinute > 0.0f)

  446.                         {

  447.                             fTimeInfo.bbt.beatsPerMinute = fLastPositionData.beatsPerMinute;

  448. 

  449.                             if (carla_isNotZero(fLastPositionData.speed))

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

  451.                         }

  452.                     }

  453. 

  454.                     if (frame != nullptr)

  455.                     {

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

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

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

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

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

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

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

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

  464.                         else

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

  466. 

  467.                         if (fLastPositionData.frame >= 0)

  468.                             fTimeInfo.frame = fLastPositionData.frame;

  469.                     }

  470. 

  471.                     fTimeInfo.bbt.barStartTick = fTimeInfo.bbt.ticksPerBeat*

  472.                                                  fTimeInfo.bbt.beatsPerBar*

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

  474. 

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

  476.                                            fLastPositionData.beatUnit > 0 &&

  477.                                            fLastPositionData.beatsPerBar > 0.0f);

  478.                 }

  479.             }

  480. 

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

  482.             {

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

  484.                 {

  485.                     if (event == nullptr)

  486.                         continue;

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

  488.                         continue;

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

  490.                         continue;

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

  492.                         break;

  493.                     if (fMidiEventCount >= kMaxMidiEvents*2)

  494.                         break;

  495. 

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

  497. 

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

  499.                     carla_zeroStruct(nativeEvent);

  500. 

  501.                     nativeEvent.port = (uint8_t)i;

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

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

  504. 

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

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

  507.                 }

  508.             }

  509.         }

  510. 

  511.         // FIXME

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

  513. 

  514.         // update timePos for next callback

  515.         if (carla_isNotZero(fLastPositionData.speed))

  516.         {

  517.             if (fLastPositionData.speed > 0.0)

  518.             {

  519.                 // playing forwards

  520.                 fLastPositionData.frame += frames;

  521.             }

  522.             else

  523.             {

  524.                 // playing backwards

  525.                 fLastPositionData.frame -= frames;

  526. 

  527.                 if (fLastPositionData.frame < 0)

  528.                     fLastPositionData.frame = 0;

  529.             }

  530. 

  531.             fTimeInfo.frame = fLastPositionData.frame;

  532. 

  533.             if (fTimeInfo.bbt.valid)

  534.             {

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

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

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

  538. 

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

  540.                 {

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

  542.                                                           fLastPositionData.beatsPerBar);

  543. 

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

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

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

  547. 

  548.                     if (fLastPositionData.bar >= 0)

  549.                     {

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

  551.                                                              fLastPositionData.beatsPerBar);

  552. 

  553.                         if (fLastPositionData.bar < 0)

  554.                             fLastPositionData.bar = 0;

  555. 

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

  557. 

  558.                         fTimeInfo.bbt.barStartTick = fTimeInfo.bbt.ticksPerBeat*

  559.                                                      fTimeInfo.bbt.beatsPerBar*

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

  561.                     }

  562.                 }

  563. 

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

  565.             }

  566.         }

  567. 

  568.         updateParameterOutputs();

  569. 

  570.         if (fDescriptor->midiOuts > 0)

  571.         {

  572.             uint32_t capacities[fDescriptor->midiOuts];

  573.             uint32_t offsets   [fDescriptor->midiOuts];

  574. 

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

  576.             {

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

  578.                 CARLA_SAFE_ASSERT_CONTINUE(seq != nullptr);

  579. 

  580.                 capacities[i] = seq->atom.size;

  581.                 offsets   [i] = 0;

  582.             }

  583. 

  584.             LV2_Atom_Event* aev;

  585.             uint32_t size;

  586. 

  587.             // reverse lookup MIDI events

  588.             for (uint32_t i = (kMaxMidiEvents*2)-1; i >= fMidiEventCount; --i)

  589.             {

  590.                 if (fMidiEvents[i].data[0] == 0)

  591.                     break;

  592. 

  593.                 NativeMidiEvent& nativeEvent(fMidiEvents[i]);

  594. 

  595.                 const uint8_t port(nativeEvent.port);

  596.                 CARLA_SAFE_ASSERT_CONTINUE(nativeEvent.port < fDescriptor->midiOuts);

  597. 

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

  599.                 CARLA_SAFE_ASSERT_CONTINUE(seq != nullptr);

  600. 

  601.                 if (sizeof(LV2_Atom_Event) + nativeEvent.size > capacities[port] - offsets[port])

  602.                     continue;

  603. 

  604.                 if (offsets[port] == 0)

  605.                 {

  606.                     seq->atom.size = 0;

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

  608.                     seq->body.unit = 0;

  609.                     seq->body.pad  = 0;

  610.                 }

  611. 

  612.                 aev = (LV2_Atom_Event*)(LV2_ATOM_CONTENTS(LV2_Atom_Sequence, seq) + offsets[port]);

  613.                 aev->time.frames = nativeEvent.time;

  614.                 aev->body.size   = nativeEvent.size;

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

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

  617. 

  618.                 size            = lv2_atom_pad_size(sizeof(LV2_Atom_Event) + nativeEvent.size);

  619.                 offsets[port]  += size;

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

  621.             }

  622.         }

  623.     }

  624. 

  625.     // -------------------------------------------------------------------

  626. 

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

  628.     {

  629.         // currently unused

  630.         return LV2_OPTIONS_SUCCESS;

  631.     }

  632. 

  633.     uint32_t lv2_set_options(const LV2_Options_Option* const options)

  634.     {

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

  636.         {

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

  638.             {

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

  640.                 {

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

  642.                     CARLA_SAFE_ASSERT_CONTINUE(value > 0);

  643. 

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

  645. 

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

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

  648.                 }

  649.                 else

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

  651.             }

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

  653.             {

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

  655.                 {

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

  657.                     CARLA_SAFE_ASSERT_CONTINUE(value > 0.0);

  658. 

  659.                     fSampleRate = value;

  660. 

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

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

  663.                 }

  664.                 else

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

  666.             }

  667.         }

  668. 

  669.         return LV2_OPTIONS_SUCCESS;

  670.     }

  671. 

  672.     const LV2_Program_Descriptor* lv2_get_program(const uint32_t index)

  673.     {

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

  675.             return nullptr;

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

  677.             return nullptr;

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

  679.             return nullptr;

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

  681.             return nullptr;

  682. 

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

  684. 

  685.         if (midiProg == nullptr)

  686.             return nullptr;

  687. 

  688.         fProgramDesc.bank    = midiProg->bank;

  689.         fProgramDesc.program = midiProg->program;

  690.         fProgramDesc.name    = midiProg->name;

  691. 

  692.         return &fProgramDesc;

  693.     }

  694. 

  695.     void lv2_select_program(uint32_t bank, uint32_t program)

  696.     {

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

  698.             return;

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

  700.             return;

  701. 

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

  703. 

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

  705.         {

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

  707. 

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

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

  710.         }

  711.     }

  712. 

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

  714.     {

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

  716.             return LV2_STATE_ERR_NO_FEATURE;

  717. 

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

  719.         {

  720.             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);

  721.             std::free(state);

  722.             return LV2_STATE_SUCCESS;

  723.         }

  724. 

  725.         return LV2_STATE_ERR_UNKNOWN;

  726.     }

  727. 

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

  729.     {

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

  731.             return LV2_STATE_ERR_NO_FEATURE;

  732. 

  733.         size_t   size = 0;

  734.         uint32_t type = 0;

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

  736. 

  737.         if (size == 0)

  738.             return LV2_STATE_ERR_UNKNOWN;

  739.         if (type == 0)

  740.             return LV2_STATE_ERR_UNKNOWN;

  741.         if (data == nullptr)

  742.             return LV2_STATE_ERR_UNKNOWN;

  743.         if (type != fURIs.atomString)

  744.             return LV2_STATE_ERR_BAD_TYPE;

  745. 

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

  747. 

  748.         return LV2_STATE_SUCCESS;

  749.     }

  750. 

  751.     // -------------------------------------------------------------------

  752. 

  753.     void lv2ui_instantiate(LV2UI_Write_Function writeFunction, LV2UI_Controller controller,

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

  755.     {

  756.         fUI.writeFunction = writeFunction;

  757.         fUI.controller = controller;

  758.         fUI.isEmbed = isEmbed;

  759. 

  760. #ifdef CARLA_OS_LINUX

  761.         // ---------------------------------------------------------------

  762.         // show embed UI if needed

  763. 

  764.         if (isEmbed)

  765.         {

  766.             fUI.isVisible = true;

  767. 

  768.             intptr_t parentId = 0;

  769. 

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

  771.             {

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

  773.                 {

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

  775.                 }

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

  777.                 {

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

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

  780.                 }

  781.             }

  782. 

  783.             char strBuf[0xff+1];

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

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

  786. 

  787.             carla_setenv("CARLA_PLUGIN_EMBED_WINID", strBuf);

  788. 

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

  790. 

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

  792.         }

  793. #endif

  794. 

  795.         // ---------------------------------------------------------------

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

  797. 

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

  799.         {

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

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

  802.             {

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

  804.                 break;

  805.             }

  806.         }

  807. 

  808.         if (fUI.host != nullptr)

  809.         {

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

  811.             *widget = this;

  812.             return;

  813.         }

  814. 

  815.         // ---------------------------------------------------------------

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

  817. 

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

  819.         {

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

  821.             {

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

  823. 

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

  825.                 {

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

  827.                     {

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

  829.                         break;

  830.                     }

  831.                 }

  832.                 break;

  833.             }

  834.         }

  835. 

  836.         if (fHost.uiName == nullptr)

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

  838. 

  839.         *widget = nullptr;

  840.     }

  841. 

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

  843.     {

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

  845.             return;

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

  847.             return;

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

  849.             return;

  850. 

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

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

  853.     }

  854. 

  855.     void lv2ui_cleanup()

  856.     {

  857.         if (fUI.isVisible)

  858.             handleUiHide();

  859. 

  860.         fUI.host = nullptr;

  861.         fUI.writeFunction = nullptr;

  862.         fUI.controller = nullptr;

  863. 

  864.         if (fHost.uiName != nullptr)

  865.         {

  866.             delete[] fHost.uiName;

  867.             fHost.uiName = nullptr;

  868.         }

  869.     }

  870. 

  871.     // -------------------------------------------------------------------

  872. 

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

  874.     {

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

  876.             return;

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

  878.             return;

  879. 

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

  881.     }

  882. 

  883.     // -------------------------------------------------------------------

  884. 

  885.     int lv2ui_idle() const

  886.     {

  887.         if (! fUI.isVisible)

  888.             return 1;

  889. 

  890.         handleUiRun();

  891.         return 0;

  892.     }

  893. 

  894.     int lv2ui_show()

  895.     {

  896.         handleUiShow();

  897.         return 0;

  898.     }

  899. 

  900.     int lv2ui_hide()

  901.     {

  902.         handleUiHide();

  903.         return 0;

  904.     }

  905. 

  906.     // -------------------------------------------------------------------

  907. 

  908. protected:

  909.     void handleUiRun() const

  910.     {

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

  912.             fDescriptor->ui_idle(fHandle);

  913.     }

  914. 

  915.     void handleUiShow()

  916.     {

  917.         CARLA_SAFE_ASSERT_RETURN(! fUI.isEmbed,);

  918. 

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

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

  921. 

  922.         fUI.isVisible = true;

  923.     }

  924. 

  925.     void handleUiHide()

  926.     {

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

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

  929. 

  930.         fUI.isVisible = false;

  931.     }

  932. 

  933.     // -------------------------------------------------------------------

  934. 

  935.     bool handleWriteMidiEvent(const NativeMidiEvent* const event)

  936.     {

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

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

  939.         CARLA_SAFE_ASSERT_RETURN(event->data[0] != 0, false);

  940. 

  941.         // reverse-find first free event, and put it there

  942.         for (uint32_t i=(kMaxMidiEvents*2)-1; i > fMidiEventCount; --i)

  943.         {

  944.             if (fMidiEvents[i].data[0] != 0)

  945.                 continue;

  946. 

  947.             std::memcpy(&fMidiEvents[i], event, sizeof(NativeMidiEvent));

  948.             return true;

  949.         }

  950. 

  951.         carla_stdout("NativePlugin::handleWriteMidiEvent(%p) - buffer full", event);

  952.         return false;

  953.     }

  954. 

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

  956.     {

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

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

  959.     }

  960. 

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

  962.     {

  963.         //storeCustomData(key, value);

  964.     }

  965. 

  966.     void handleUiClosed()

  967.     {

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

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

  970. 

  971.         fUI.host = nullptr;

  972.         fUI.writeFunction = nullptr;

  973.         fUI.controller = nullptr;

  974.         fUI.isVisible = false;

  975.     }

  976. 

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

  978.     {

  979.         // TODO

  980.         return nullptr;

  981.     }

  982. 

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

  984.     {

  985.         // TODO

  986.         return nullptr;

  987.     }

  988. 

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

  990.     {

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

  992. 

  993.         intptr_t ret = 0;

  994. 

  995.         switch (opcode)

  996.         {

  997.         case NATIVE_HOST_OPCODE_NULL:

  998.         case NATIVE_HOST_OPCODE_UPDATE_PARAMETER:

  999.         case NATIVE_HOST_OPCODE_UPDATE_MIDI_PROGRAM:

  1000.         case NATIVE_HOST_OPCODE_RELOAD_PARAMETERS:

  1001.         case NATIVE_HOST_OPCODE_RELOAD_MIDI_PROGRAMS:

  1002.         case NATIVE_HOST_OPCODE_RELOAD_ALL:

  1003.         case NATIVE_HOST_OPCODE_HOST_IDLE:

  1004.             // nothing

  1005.             break;

  1006.         case NATIVE_HOST_OPCODE_UI_UNAVAILABLE:

  1007.             handleUiClosed();

  1008.             break;

  1009.         }

  1010. 

  1011.         return ret;

  1012. 

  1013.         // unused for now

  1014.         (void)index;

  1015.         (void)value;

  1016.         (void)ptr;

  1017.         (void)opt;

  1018.     }

  1019. 

  1020.     void updateParameterOutputs()

  1021.     {

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

  1023.         {

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

  1025.                 continue;

  1026. 

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

  1028. 

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

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

  1031.         }

  1032.     }

  1033. 

  1034.     // -------------------------------------------------------------------

  1035. 

  1036. private:

  1037.     // Native data

  1038.     NativePluginHandle   fHandle;

  1039.     NativeHostDescriptor fHost;

  1040.     const NativePluginDescriptor* const fDescriptor;

  1041.     LV2_Program_Descriptor              fProgramDesc;

  1042. 

  1043.     uint32_t        fMidiEventCount;

  1044.     NativeMidiEvent fMidiEvents[kMaxMidiEvents*2];

  1045.     NativeTimeInfo  fTimeInfo;

  1046. 

  1047.     // Lv2 host data

  1048.     bool     fIsOffline;

  1049.     uint32_t fBufferSize;

  1050.     double   fSampleRate;

  1051. 

  1052.     const LV2_URID_Map* fUridMap;

  1053. 

  1054.     struct Lv2PositionData {

  1055.         int64_t  bar;

  1056.         float    barBeat;

  1057.         uint32_t beatUnit;

  1058.         float    beatsPerBar;

  1059.         float    beatsPerMinute;

  1060.         int64_t  frame;

  1061.         double   speed;

  1062.         int64_t  ticksPerBeat;

  1063. 

  1064.         Lv2PositionData()

  1065.             : bar(-1),

  1066.               barBeat(-1.0f),

  1067.               beatUnit(0),

  1068.               beatsPerBar(0.0f),

  1069.               beatsPerMinute(0.0f),

  1070.               frame(-1),

  1071.               speed(0.0),

  1072.               ticksPerBeat(-1) {}

  1073. 

  1074.     } fLastPositionData;

  1075. 

  1076.     struct URIDs {

  1077.         LV2_URID atomBlank;

  1078.         LV2_URID atomObject;

  1079.         LV2_URID atomDouble;

  1080.         LV2_URID atomFloat;

  1081.         LV2_URID atomInt;

  1082.         LV2_URID atomLong;

  1083.         LV2_URID atomSequence;

  1084.         LV2_URID atomString;

  1085.         LV2_URID midiEvent;

  1086.         LV2_URID timePos;

  1087.         LV2_URID timeBar;

  1088.         LV2_URID timeBeat;

  1089.         LV2_URID timeBarBeat;

  1090.         LV2_URID timeBeatsPerBar;

  1091.         LV2_URID timeBeatsPerMinute;

  1092.         LV2_URID timeBeatUnit;

  1093.         LV2_URID timeFrame;

  1094.         LV2_URID timeSpeed;

  1095.         LV2_URID timeTicksPerBeat;

  1096. 

  1097.         URIDs()

  1098.             : atomBlank(0),

  1099.               atomObject(0),

  1100.               atomDouble(0),

  1101.               atomFloat(0),

  1102.               atomInt(0),

  1103.               atomLong(0),

  1104.               atomSequence(0),

  1105.               atomString(0),

  1106.               midiEvent(0),

  1107.               timePos(0),

  1108.               timeBar(0),

  1109.               timeBeat(0),

  1110.               timeBarBeat(0),

  1111.               timeBeatsPerBar(0),

  1112.               timeBeatsPerMinute(0),

  1113.               timeBeatUnit(0),

  1114.               timeFrame(0),

  1115.               timeSpeed(0),

  1116.               timeTicksPerBeat(0) {}

  1117. 

  1118.         void map(const LV2_URID_Map* const uridMap)

  1119.         {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1139.         }

  1140.     } fURIs;

  1141. 

  1142.     struct UI {

  1143.         const LV2_External_UI_Host* host;

  1144.         LV2UI_Write_Function writeFunction;

  1145.         LV2UI_Controller controller;

  1146.         uint32_t portOffset;

  1147.         bool isEmbed;

  1148.         bool isVisible;

  1149. 

  1150.         UI()

  1151.             : host(nullptr),

  1152.               writeFunction(nullptr),

  1153.               controller(nullptr),

  1154.               portOffset(0),

  1155.               isEmbed(false),

  1156.               isVisible(false) {}

  1157.     } fUI;

  1158. 

  1159.     struct Ports {

  1160.         const LV2_Atom_Sequence** eventsIn;

  1161.         /* */ LV2_Atom_Sequence** midiOuts;

  1162.         const float** audioIns;

  1163.         /* */ float** audioOuts;

  1164.         float*   freewheel;

  1165.         uint32_t paramCount;

  1166.         float*   paramsLast;

  1167.         float**  paramsPtr;

  1168.         bool*    paramsOut;

  1169. 

  1170.         Ports()

  1171.             : eventsIn(nullptr),

  1172.               midiOuts(nullptr),

  1173.               audioIns(nullptr),

  1174.               audioOuts(nullptr),

  1175.               freewheel(nullptr),

  1176.               paramCount(0),

  1177.               paramsLast(nullptr),

  1178.               paramsPtr(nullptr),

  1179.               paramsOut(nullptr) {}

  1180. 

  1181.         ~Ports()

  1182.         {

  1183.             if (eventsIn != nullptr)

  1184.             {

  1185.                 delete[] eventsIn;

  1186.                 eventsIn = nullptr;

  1187.             }

  1188. 

  1189.             if (midiOuts != nullptr)

  1190.             {

  1191.                 delete[] midiOuts;

  1192.                 midiOuts = nullptr;

  1193.             }

  1194. 

  1195.             if (audioIns != nullptr)

  1196.             {

  1197.                 delete[] audioIns;

  1198.                 audioIns = nullptr;

  1199.             }

  1200. 

  1201.             if (audioOuts != nullptr)

  1202.             {

  1203.                 delete[] audioOuts;

  1204.                 audioOuts = nullptr;

  1205.             }

  1206. 

  1207.             if (paramsLast != nullptr)

  1208.             {

  1209.                 delete[] paramsLast;

  1210.                 paramsLast = nullptr;

  1211.             }

  1212. 

  1213.             if (paramsPtr != nullptr)

  1214.             {

  1215.                 delete[] paramsPtr;

  1216.                 paramsPtr = nullptr;

  1217.             }

  1218. 

  1219.             if (paramsOut != nullptr)

  1220.             {

  1221.                 delete[] paramsOut;

  1222.                 paramsOut = nullptr;

  1223.             }

  1224.         }

  1225. 

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

  1227.         {

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

  1229. 

  1230.             if (desc->midiIns > 0)

  1231.             {

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

  1233. 

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

  1235.                     eventsIn[i] = nullptr;

  1236.             }

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

  1238.             {

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

  1240.                 eventsIn[0] = nullptr;

  1241.             }

  1242. 

  1243.             if (desc->midiOuts > 0)

  1244.             {

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

  1246. 

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

  1248.                     midiOuts[i] = nullptr;

  1249.             }

  1250. 

  1251.             if (desc->audioIns > 0)

  1252.             {

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

  1254. 

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

  1256.                     audioIns[i] = nullptr;

  1257.             }

  1258. 

  1259.             if (desc->audioOuts > 0)

  1260.             {

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

  1262. 

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

  1264.                     audioOuts[i] = nullptr;

  1265.             }

  1266. 

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

  1268.             {

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

  1270. 

  1271.                 if (paramCount > 0)

  1272.                 {

  1273.                     paramsLast = new float[paramCount];

  1274.                     paramsPtr  = new float*[paramCount];

  1275.                     paramsOut  = new bool[paramCount];

  1276. 

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

  1278.                     {

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

  1280.                         paramsPtr [i] = nullptr;

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

  1282.                     }

  1283.                 }

  1284.             }

  1285.         }

  1286. 

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

  1288.         {

  1289.             uint32_t index = 0;

  1290. 

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

  1292.             {

  1293.                 if (port == index++)

  1294.                 {

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

  1296.                     return;

  1297.                 }

  1298.             }

  1299. 

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

  1301.             {

  1302.                 if (port == index++)

  1303.                 {

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

  1305.                     return;

  1306.                 }

  1307.             }

  1308. 

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

  1310.             {

  1311.                 if (port == index++)

  1312.                 {

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

  1314.                     return;

  1315.                 }

  1316.             }

  1317. 

  1318.             if (port == index++)

  1319.             {

  1320.                 freewheel = (float*)dataLocation;

  1321.                 return;

  1322.             }

  1323. 

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

  1325.             {

  1326.                 if (port == index++)

  1327.                 {

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

  1329.                     return;

  1330.                 }

  1331.             }

  1332. 

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

  1334.             {

  1335.                 if (port == index++)

  1336.                 {

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

  1338.                     return;

  1339.                 }

  1340.             }

  1341. 

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

  1343.             {

  1344.                 if (port == index++)

  1345.                 {

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

  1347.                     return;

  1348.                 }

  1349.             }

  1350.         }

  1351. 

  1352.         CARLA_DECLARE_NON_COPY_STRUCT(Ports);

  1353.     } fPorts;

  1354. 

  1355.     SharedResourcePointer<ScopedJuceInitialiser_GUI> sJuceInitialiser;

  1356. 

  1357.     // -------------------------------------------------------------------

  1358. 

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

  1360. 

  1361.     static void extui_run(LV2_External_UI_Widget_Compat* self)

  1362.     {

  1363.         handlePtr->handleUiRun();

  1364.     }

  1365. 

  1366.     static void extui_show(LV2_External_UI_Widget_Compat* self)

  1367.     {

  1368.         handlePtr->handleUiShow();

  1369.     }

  1370. 

  1371.     static void extui_hide(LV2_External_UI_Widget_Compat* self)

  1372.     {

  1373.         handlePtr->handleUiHide();

  1374.     }

  1375. 

  1376.     #undef handlePtr

  1377. 

  1378.     // -------------------------------------------------------------------

  1379. 

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

  1381. 

  1382.     static uint32_t host_get_buffer_size(NativeHostHandle handle)

  1383.     {

  1384.         return handlePtr->fBufferSize;

  1385.     }

  1386. 

  1387.     static double host_get_sample_rate(NativeHostHandle handle)

  1388.     {

  1389.         return handlePtr->fSampleRate;

  1390.     }

  1391. 

  1392.     static bool host_is_offline(NativeHostHandle handle)

  1393.     {

  1394.         return handlePtr->fIsOffline;

  1395.     }

  1396. 

  1397.     static const NativeTimeInfo* host_get_time_info(NativeHostHandle handle)

  1398.     {

  1399.         return &(handlePtr->fTimeInfo);

  1400.     }

  1401. 

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

  1403.     {

  1404.         return handlePtr->handleWriteMidiEvent(event);

  1405.     }

  1406. 

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

  1408.     {

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

  1410.     }

  1411. 

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

  1413.     {

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

  1415.     }

  1416. 

  1417.     static void host_ui_closed(NativeHostHandle handle)

  1418.     {

  1419.         handlePtr->handleUiClosed();

  1420.     }

  1421. 

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

  1423.     {

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

  1425.     }

  1426. 

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

  1428.     {

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

  1430.     }

  1431. 

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

  1433.     {

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

  1435.     }

  1436. 

  1437.     #undef handlePtr

  1438. 

  1439.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(NativePlugin)

  1440. };

  1441. 

  1442. // -----------------------------------------------------------------------

  1443. // LV2 plugin descriptor functions

  1444. 

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

  1446. {

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

  1448. 

  1449.     const NativePluginDescriptor* pluginDesc  = nullptr;

  1450.     const char*                   pluginLabel = nullptr;

  1451. 

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

  1453.         pluginLabel = lv2Descriptor->URI+37;

  1454. 

  1455.     if (pluginLabel == nullptr)

  1456.     {

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

  1458.         return nullptr;

  1459.     }

  1460. 

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

  1462. 

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

  1464. 

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

  1466.     {

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

  1468. 

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

  1470.         {

  1471.             pluginDesc = tmpDesc;

  1472.             break;

  1473.         }

  1474.     }

  1475. 

  1476.     if (pluginDesc == nullptr)

  1477.     {

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

  1479.         return nullptr;

  1480.     }

  1481. 

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

  1483. 

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

  1485.     {

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

  1487.         delete plugin;

  1488.         return nullptr;

  1489.     }

  1490. 

  1491.     return (LV2_Handle)plugin;

  1492. }

  1493. 

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

  1495. 

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

  1497. {

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

  1499. }

  1500. 

  1501. static void lv2_activate(LV2_Handle instance)

  1502. {

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

  1504.     instancePtr->lv2_activate();

  1505. }

  1506. 

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

  1508. {

  1509.     instancePtr->lv2_run(sampleCount);

  1510. }

  1511. 

  1512. static void lv2_deactivate(LV2_Handle instance)

  1513. {

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

  1515.     instancePtr->lv2_deactivate();

  1516. }

  1517. 

  1518. static void lv2_cleanup(LV2_Handle instance)

  1519. {

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

  1521.     instancePtr->lv2_cleanup();

  1522.     delete instancePtr;

  1523. }

  1524. 

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

  1526. {

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

  1528.     return instancePtr->lv2_get_options(options);

  1529. }

  1530. 

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

  1532. {

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

  1534.     return instancePtr->lv2_set_options(options);

  1535. }

  1536. 

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

  1538. {

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

  1540.     return instancePtr->lv2_get_program(index);

  1541. }

  1542. 

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

  1544. {

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

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

  1547. }

  1548. 

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

  1550. {

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

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

  1553. }

  1554. 

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

  1556. {

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

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

  1559. }

  1560. 

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

  1562. {

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

  1564. 

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

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

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

  1568. 

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

  1570.         return &options;

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

  1572.         return &programs;

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

  1574.         return &state;

  1575. 

  1576.     return nullptr;

  1577. }

  1578. 

  1579. #undef instancePtr

  1580. 

  1581. // -----------------------------------------------------------------------

  1582. // LV2 UI descriptor functions

  1583. 

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

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

  1586. {

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

  1588. #ifndef CARLA_OS_LINUX

  1589.     CARLA_SAFE_ASSERT_RETURN(! isEmbed, nullptr);

  1590. #endif

  1591. 

  1592.     NativePlugin* plugin = nullptr;

  1593. 

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

  1595.     {

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

  1597.         {

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

  1599.             break;

  1600.         }

  1601.     }

  1602. 

  1603.     if (plugin == nullptr)

  1604.     {

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

  1606.         return nullptr;

  1607.     }

  1608. 

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

  1610. 

  1611.     return (LV2UI_Handle)plugin;

  1612. }

  1613. 

  1614. #ifdef CARLA_OS_LINUX

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

  1616.                                             LV2UI_Write_Function writeFunction, LV2UI_Controller controller,

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

  1618. {

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

  1620. }

  1621. #endif

  1622. 

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

  1624.                                                LV2UI_Write_Function writeFunction, LV2UI_Controller controller,

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

  1626. {

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

  1628. }

  1629. 

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

  1631. 

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

  1633. {

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

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

  1636. }

  1637. 

  1638. static void lv2ui_cleanup(LV2UI_Handle ui)

  1639. {

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

  1641.     uiPtr->lv2ui_cleanup();

  1642. }

  1643. 

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

  1645. {

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

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

  1648. }

  1649. 

  1650. static int lv2ui_idle(LV2UI_Handle ui)

  1651. {

  1652.     return uiPtr->lv2ui_idle();

  1653. }

  1654. 

  1655. static int lv2ui_show(LV2UI_Handle ui)

  1656. {

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

  1658.     return uiPtr->lv2ui_show();

  1659. }

  1660. 

  1661. static int lv2ui_hide(LV2UI_Handle ui)

  1662. {

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

  1664.     return uiPtr->lv2ui_hide();

  1665. }

  1666. 

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

  1668. {

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

  1670. 

  1671.     static const LV2UI_Idle_Interface uiidle = { lv2ui_idle };

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

  1673.     static const LV2_Programs_UI_Interface uiprograms = { lv2ui_select_program };

  1674. 

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

  1676.         return &uiidle;

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

  1678.         return &uishow;

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

  1680.         return &uiprograms;

  1681. 

  1682.     return nullptr;

  1683. }

  1684. 

  1685. #undef uiPtr

  1686. 

  1687. // -----------------------------------------------------------------------

  1688. // Startup code

  1689. 

  1690. CARLA_EXPORT

  1691. const LV2_Descriptor* lv2_descriptor(uint32_t index)

  1692. {

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

  1694. 

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

  1696. 

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

  1698.     {

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

  1700.         return nullptr;

  1701.     }

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

  1703.     {

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

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

  1706.     }

  1707. 

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

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

  1710. 

  1711.     CarlaString tmpURI;

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

  1713.     tmpURI += pluginDesc->label;

  1714. 

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

  1716. 

  1717.     const LV2_Descriptor lv2DescTmp = {

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

  1719.     /* instantiate    */ lv2_instantiate,

  1720.     /* connect_port   */ lv2_connect_port,

  1721.     /* activate       */ lv2_activate,

  1722.     /* run            */ lv2_run,

  1723.     /* deactivate     */ lv2_deactivate,

  1724.     /* cleanup        */ lv2_cleanup,

  1725.     /* extension_data */ lv2_extension_data

  1726.     };

  1727. 

  1728.     LV2_Descriptor* const lv2Desc(new LV2_Descriptor);

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

  1730. 

  1731.     plm.lv2Descs.append(lv2Desc);

  1732. 

  1733.     return lv2Desc;

  1734. }

  1735. 

  1736. CARLA_EXPORT

  1737. const LV2UI_Descriptor* lv2ui_descriptor(uint32_t index)

  1738. {

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

  1740. 

  1741. #ifdef CARLA_OS_LINUX

  1742.     static const LV2UI_Descriptor lv2UiEmbedDesc = {

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

  1744.     /* instantiate    */ lv2ui_instantiate_embed,

  1745.     /* cleanup        */ lv2ui_cleanup,

  1746.     /* port_event     */ lv2ui_port_event,

  1747.     /* extension_data */ lv2ui_extension_data

  1748.     };

  1749. 

  1750.     if (index == 0)

  1751.         return &lv2UiEmbedDesc;

  1752.     else

  1753.         --index;

  1754. #endif

  1755. 

  1756.     static const LV2UI_Descriptor lv2UiExtDesc = {

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

  1758.     /* instantiate    */ lv2ui_instantiate_external,

  1759.     /* cleanup        */ lv2ui_cleanup,

  1760.     /* port_event     */ lv2ui_port_event,

  1761.     /* extension_data */ lv2ui_extension_data

  1762.     };

  1763. 

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

  1765. }

  1766. 

  1767. // -----------------------------------------------------------------------