DISTRHO
/
DPF
mirror of https://github.com/DISTRHO/DPF
1
0
Fork 0
Code Releases 0 Activity
DISTRHO Plugin Framework
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.
1589 Commits
7 Branches
71MB
Tree: d5267f11d9
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'd5267f11d9'
${ noResults }
DPF/distrho/src/DistrhoPluginLV2.cpp

1538 lines
51KB
Raw Blame History 

  1. /*

  2.  * DISTRHO Plugin Framework (DPF)

  3.  * Copyright (C) 2012-2021 Filipe Coelho <falktx@falktx.com>

  4.  *

  5.  * Permission to use, copy, modify, and/or distribute this software for any purpose with

  6.  * or without fee is hereby granted, provided that the above copyright notice and this

  7.  * permission notice appear in all copies.

  8.  *

  9.  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD

  10.  * TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN

  11.  * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL

  12.  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER

  13.  * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN

  14.  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

  15.  */

  16. 

  17. #include "DistrhoPluginInternal.hpp"

  18. 

  19. #include "lv2/atom.h"

  20. #include "lv2/atom-util.h"

  21. #include "lv2/buf-size.h"

  22. #include "lv2/data-access.h"

  23. #include "lv2/instance-access.h"

  24. #include "lv2/midi.h"

  25. #include "lv2/options.h"

  26. #include "lv2/parameters.h"

  27. #include "lv2/patch.h"

  28. #include "lv2/state.h"

  29. #include "lv2/time.h"

  30. #include "lv2/urid.h"

  31. #include "lv2/worker.h"

  32. #include "lv2/lv2_kxstudio_properties.h"

  33. #include "lv2/lv2_programs.h"

  34. #include "lv2/control-input-port-change-request.h"

  35. 

  36. #ifdef DISTRHO_PLUGIN_LICENSED_FOR_MOD

  37. # include "libmodla.h"

  38. #endif

  39. 

  40. #include <map>

  41. 

  42. #ifndef DISTRHO_PLUGIN_URI

  43. # error DISTRHO_PLUGIN_URI undefined!

  44. #endif

  45. 

  46. #ifndef DISTRHO_PLUGIN_LV2_STATE_PREFIX

  47. # define DISTRHO_PLUGIN_LV2_STATE_PREFIX "urn:distrho:"

  48. #endif

  49. 

  50. #define DISTRHO_LV2_USE_EVENTS_IN  (DISTRHO_PLUGIN_WANT_MIDI_INPUT || DISTRHO_PLUGIN_WANT_TIMEPOS || (DISTRHO_PLUGIN_WANT_STATE && DISTRHO_PLUGIN_HAS_UI) || DISTRHO_PLUGIN_WANT_STATEFILES)

  51. #define DISTRHO_LV2_USE_EVENTS_OUT (DISTRHO_PLUGIN_WANT_MIDI_OUTPUT || (DISTRHO_PLUGIN_WANT_STATE && DISTRHO_PLUGIN_HAS_UI))

  52. 

  53. START_NAMESPACE_DISTRHO

  54. 

  55. typedef std::map<const String, String> StringToStringMap;

  56. typedef std::map<const LV2_URID, String> UridToStringMap;

  57. 

  58. #if ! DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  59. static const writeMidiFunc writeMidiCallback = nullptr;

  60. #endif

  61. #if ! DISTRHO_PLUGIN_WANT_PARAMETER_VALUE_CHANGE_REQUEST

  62. static const requestParameterValueChangeFunc requestParameterValueChangeCallback = nullptr;

  63. #endif

  64. 

  65. // -----------------------------------------------------------------------

  66. 

  67. class PluginLv2

  68. {

  69. public:

  70.     PluginLv2(const double sampleRate,

  71.               const LV2_URID_Map* const uridMap,

  72.               const LV2_Worker_Schedule* const worker,

  73.               const LV2_ControlInputPort_Change_Request* const ctrlInPortChangeReq,

  74.               const bool usingNominal)

  75.         : fPlugin(this, writeMidiCallback, requestParameterValueChangeCallback),

  76.           fUsingNominal(usingNominal),

  77. #ifdef DISTRHO_PLUGIN_LICENSED_FOR_MOD

  78.           fRunCount(0),

  79. #endif

  80.           fPortControls(nullptr),

  81.           fLastControlValues(nullptr),

  82.           fSampleRate(sampleRate),

  83.           fURIDs(uridMap),

  84. #if DISTRHO_PLUGIN_WANT_PARAMETER_VALUE_CHANGE_REQUEST

  85.           fCtrlInPortChangeReq(ctrlInPortChangeReq),

  86. #endif

  87.           fUridMap(uridMap),

  88.           fWorker(worker)

  89.     {

  90. #if DISTRHO_PLUGIN_NUM_INPUTS > 0

  91.         for (uint32_t i=0; i < DISTRHO_PLUGIN_NUM_INPUTS; ++i)

  92.             fPortAudioIns[i] = nullptr;

  93. #else

  94.         fPortAudioIns = nullptr;

  95. #endif

  96. 

  97. #if DISTRHO_PLUGIN_NUM_OUTPUTS > 0

  98.         for (uint32_t i=0; i < DISTRHO_PLUGIN_NUM_OUTPUTS; ++i)

  99.             fPortAudioOuts[i] = nullptr;

  100. #else

  101.         fPortAudioOuts = nullptr;

  102. #endif

  103. 

  104.         if (const uint32_t count = fPlugin.getParameterCount())

  105.         {

  106.             fPortControls      = new float*[count];

  107.             fLastControlValues = new float[count];

  108. 

  109.             for (uint32_t i=0; i < count; ++i)

  110.             {

  111.                 fPortControls[i] = nullptr;

  112.                 fLastControlValues[i] = fPlugin.getParameterValue(i);

  113.             }

  114.         }

  115.         else

  116.         {

  117.             fPortControls      = nullptr;

  118.             fLastControlValues = nullptr;

  119.         }

  120. 

  121. #if DISTRHO_LV2_USE_EVENTS_IN

  122.         fPortEventsIn = nullptr;

  123. #endif

  124. #if DISTRHO_PLUGIN_WANT_LATENCY

  125.         fPortLatency = nullptr;

  126. #endif

  127. 

  128. #if DISTRHO_PLUGIN_WANT_STATE

  129.         if (const uint32_t count = fPlugin.getStateCount())

  130.         {

  131.             fNeededUiSends = new bool[count];

  132. 

  133.             for (uint32_t i=0; i < count; ++i)

  134.             {

  135.                 fNeededUiSends[i] = false;

  136. 

  137.                 const String& dkey(fPlugin.getStateKey(i));

  138.                 fStateMap[dkey] = fPlugin.getStateDefaultValue(i);

  139. 

  140. # if DISTRHO_PLUGIN_WANT_STATEFILES

  141.                 if (fPlugin.isStateFile(i))

  142.                 {

  143.                     const String dpf_lv2_key(DISTRHO_PLUGIN_URI "#" + dkey);

  144.                     const LV2_URID urid = uridMap->map(uridMap->handle, dpf_lv2_key.buffer());

  145.                     fUridStateFileMap[urid] = dkey;

  146.                 }

  147. # endif

  148.             }

  149.         }

  150.         else

  151.         {

  152.             fNeededUiSends = nullptr;

  153.         }

  154. #else

  155.         // unused

  156.         (void)fWorker;

  157. #endif

  158. 

  159. #if ! DISTRHO_PLUGIN_WANT_PARAMETER_VALUE_CHANGE_REQUEST

  160.         // unused

  161.         (void)ctrlInPortChangeReq;

  162. #endif

  163.     }

  164. 

  165.     ~PluginLv2()

  166.     {

  167.         if (fPortControls != nullptr)

  168.         {

  169.             delete[] fPortControls;

  170.             fPortControls = nullptr;

  171.         }

  172. 

  173.         if (fLastControlValues)

  174.         {

  175.             delete[] fLastControlValues;

  176.             fLastControlValues = nullptr;

  177.         }

  178. 

  179. #if DISTRHO_PLUGIN_WANT_STATE

  180.         if (fNeededUiSends != nullptr)

  181.         {

  182.             delete[] fNeededUiSends;

  183.             fNeededUiSends = nullptr;

  184.         }

  185. 

  186.         fStateMap.clear();

  187. #endif

  188.     }

  189. 

  190.     // -------------------------------------------------------------------

  191. 

  192.     bool getPortControlValue(uint32_t index, float& value) const

  193.     {

  194.         if (const float* control = fPortControls[index])

  195.         {

  196.             switch (fPlugin.getParameterDesignation(index))

  197.             {

  198.             default:

  199.                 value = *control;

  200.                 break;

  201.             case kParameterDesignationBypass:

  202.                 value = 1.0f - *control;

  203.                 break;

  204.             }

  205. 

  206.             return true;

  207.         }

  208. 

  209.         return false;

  210.     }

  211. 

  212.     void setPortControlValue(uint32_t index, float value)

  213.     {

  214.         if (float* control = fPortControls[index])

  215.         {

  216.             switch (fPlugin.getParameterDesignation(index))

  217.             {

  218.             default:

  219.                 *control = value;

  220.                 break;

  221.             case kParameterDesignationBypass:

  222.                 *control = 1.0f - value;

  223.                 break;

  224.             }

  225.         }

  226.     }

  227. 

  228.     // -------------------------------------------------------------------

  229. 

  230.     void lv2_activate()

  231.     {

  232. #if DISTRHO_PLUGIN_WANT_TIMEPOS

  233.         fTimePosition.clear();

  234. 

  235.         // hosts may not send all values, resulting on some invalid data, let's reset everything

  236.         fTimePosition.bbt.bar   = 1;

  237.         fTimePosition.bbt.beat  = 1;

  238.         fTimePosition.bbt.tick  = 0.0;

  239.         fTimePosition.bbt.barStartTick = 0;

  240.         fTimePosition.bbt.beatsPerBar  = 4;

  241.         fTimePosition.bbt.beatType     = 4;

  242.         fTimePosition.bbt.ticksPerBeat = 1920.0;

  243.         fTimePosition.bbt.beatsPerMinute = 120.0;

  244. #endif

  245.         fPlugin.activate();

  246.     }

  247. 

  248.     void lv2_deactivate()

  249.     {

  250.         fPlugin.deactivate();

  251.     }

  252. 

  253.     // -------------------------------------------------------------------

  254. 

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

  256.     {

  257.         uint32_t index = 0;

  258. 

  259. #if DISTRHO_PLUGIN_NUM_INPUTS > 0

  260.         for (uint32_t i=0; i < DISTRHO_PLUGIN_NUM_INPUTS; ++i)

  261.         {

  262.             if (port == index++)

  263.             {

  264.                 fPortAudioIns[i] = (const float*)dataLocation;

  265.                 return;

  266.             }

  267.         }

  268. #endif

  269. 

  270. #if DISTRHO_PLUGIN_NUM_OUTPUTS > 0

  271.         for (uint32_t i=0; i < DISTRHO_PLUGIN_NUM_OUTPUTS; ++i)

  272.         {

  273.             if (port == index++)

  274.             {

  275.                 fPortAudioOuts[i] = (float*)dataLocation;

  276.                 return;

  277.             }

  278.         }

  279. #endif

  280. 

  281. #if DISTRHO_LV2_USE_EVENTS_IN

  282.         if (port == index++)

  283.         {

  284.             fPortEventsIn = (LV2_Atom_Sequence*)dataLocation;

  285.             return;

  286.         }

  287. #endif

  288. 

  289. #if DISTRHO_LV2_USE_EVENTS_OUT

  290.         if (port == index++)

  291.         {

  292.             fEventsOutData.port = (LV2_Atom_Sequence*)dataLocation;

  293.             return;

  294.         }

  295. #endif

  296. 

  297. #if DISTRHO_PLUGIN_WANT_LATENCY

  298.         if (port == index++)

  299.         {

  300.             fPortLatency = (float*)dataLocation;

  301.             return;

  302.         }

  303. #endif

  304. 

  305.         for (uint32_t i=0, count=fPlugin.getParameterCount(); i < count; ++i)

  306.         {

  307.             if (port == index++)

  308.             {

  309.                 fPortControls[i] = (float*)dataLocation;

  310.                 return;

  311.             }

  312.         }

  313.     }

  314. 

  315.     // -------------------------------------------------------------------

  316. 

  317.     void lv2_run(const uint32_t sampleCount)

  318.     {

  319.         // cache midi input and time position first

  320. #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  321.         uint32_t midiEventCount = 0;

  322. #endif

  323. 

  324. #if DISTRHO_PLUGIN_WANT_MIDI_INPUT || DISTRHO_PLUGIN_WANT_TIMEPOS

  325.         LV2_ATOM_SEQUENCE_FOREACH(fPortEventsIn, event)

  326.         {

  327.             if (event == nullptr)

  328.                 break;

  329. 

  330. # if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  331.             if (event->body.type == fURIDs.midiEvent)

  332.             {

  333.                 if (midiEventCount >= kMaxMidiEvents)

  334.                     continue;

  335. 

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

  337. 

  338.                 MidiEvent& midiEvent(fMidiEvents[midiEventCount++]);

  339. 

  340.                 midiEvent.frame = event->time.frames;

  341.                 midiEvent.size  = event->body.size;

  342. 

  343.                 if (midiEvent.size > MidiEvent::kDataSize)

  344.                 {

  345.                     midiEvent.dataExt = data;

  346.                     std::memset(midiEvent.data, 0, MidiEvent::kDataSize);

  347.                 }

  348.                 else

  349.                 {

  350.                     midiEvent.dataExt = nullptr;

  351.                     std::memcpy(midiEvent.data, data, midiEvent.size);

  352.                 }

  353. 

  354.                 continue;

  355.             }

  356. # endif

  357. # if DISTRHO_PLUGIN_WANT_TIMEPOS

  358.             if (event->body.type == fURIDs.atomBlank || event->body.type == fURIDs.atomObject)

  359.             {

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

  361. 

  362.                 if (obj->body.otype != fURIDs.timePosition)

  363.                     continue;

  364. 

  365.                 LV2_Atom* bar = nullptr;

  366.                 LV2_Atom* barBeat = nullptr;

  367.                 LV2_Atom* beatUnit = nullptr;

  368.                 LV2_Atom* beatsPerBar = nullptr;

  369.                 LV2_Atom* beatsPerMinute = nullptr;

  370.                 LV2_Atom* frame = nullptr;

  371.                 LV2_Atom* speed = nullptr;

  372.                 LV2_Atom* ticksPerBeat = nullptr;

  373. 

  374.                 lv2_atom_object_get(obj,

  375.                                     fURIDs.timeBar, &bar,

  376.                                     fURIDs.timeBarBeat, &barBeat,

  377.                                     fURIDs.timeBeatUnit, &beatUnit,

  378.                                     fURIDs.timeBeatsPerBar, &beatsPerBar,

  379.                                     fURIDs.timeBeatsPerMinute, &beatsPerMinute,

  380.                                     fURIDs.timeFrame, &frame,

  381.                                     fURIDs.timeSpeed, &speed,

  382.                                     fURIDs.timeTicksPerBeat, &ticksPerBeat,

  383.                                     0);

  384. 

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

  386.                 if (ticksPerBeat != nullptr)

  387.                 {

  388.                     /**/ if (ticksPerBeat->type == fURIDs.atomDouble)

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

  390.                     else if (ticksPerBeat->type == fURIDs.atomFloat)

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

  392.                     else if (ticksPerBeat->type == fURIDs.atomInt)

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

  394.                     else if (ticksPerBeat->type == fURIDs.atomLong)

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

  396.                     else

  397.                         d_stderr("Unknown lv2 ticksPerBeat value type");

  398. 

  399.                     if (fLastPositionData.ticksPerBeat > 0.0)

  400.                         fTimePosition.bbt.ticksPerBeat = fLastPositionData.ticksPerBeat;

  401.                 }

  402. 

  403.                 // same

  404.                 if (speed != nullptr)

  405.                 {

  406.                     /**/ if (speed->type == fURIDs.atomDouble)

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

  408.                     else if (speed->type == fURIDs.atomFloat)

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

  410.                     else if (speed->type == fURIDs.atomInt)

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

  412.                     else if (speed->type == fURIDs.atomLong)

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

  414.                     else

  415.                         d_stderr("Unknown lv2 speed value type");

  416. 

  417.                     fTimePosition.playing = d_isNotZero(fLastPositionData.speed);

  418.                 }

  419. 

  420.                 if (bar != nullptr)

  421.                 {

  422.                     /**/ if (bar->type == fURIDs.atomDouble)

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

  424.                     else if (bar->type == fURIDs.atomFloat)

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

  426.                     else if (bar->type == fURIDs.atomInt)

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

  428.                     else if (bar->type == fURIDs.atomLong)

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

  430.                     else

  431.                         d_stderr("Unknown lv2 bar value type");

  432. 

  433.                     if (fLastPositionData.bar >= 0)

  434.                         fTimePosition.bbt.bar = fLastPositionData.bar + 1;

  435.                 }

  436. 

  437.                 if (barBeat != nullptr)

  438.                 {

  439.                     /**/ if (barBeat->type == fURIDs.atomDouble)

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

  441.                     else if (barBeat->type == fURIDs.atomFloat)

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

  443.                     else if (barBeat->type == fURIDs.atomInt)

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

  445.                     else if (barBeat->type == fURIDs.atomLong)

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

  447.                     else

  448.                         d_stderr("Unknown lv2 barBeat value type");

  449. 

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

  451.                     {

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

  453.                         fTimePosition.bbt.beat = std::round(fLastPositionData.barBeat - rest + 1.0);

  454.                         fTimePosition.bbt.tick = rest * fTimePosition.bbt.ticksPerBeat;

  455.                     }

  456.                 }

  457. 

  458.                 if (beatUnit != nullptr)

  459.                 {

  460.                     /**/ if (beatUnit->type == fURIDs.atomDouble)

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

  462.                     else if (beatUnit->type == fURIDs.atomFloat)

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

  464.                     else if (beatUnit->type == fURIDs.atomInt)

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

  466.                     else if (beatUnit->type == fURIDs.atomLong)

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

  468.                     else

  469.                         d_stderr("Unknown lv2 beatUnit value type");

  470. 

  471.                     if (fLastPositionData.beatUnit > 0)

  472.                         fTimePosition.bbt.beatType = fLastPositionData.beatUnit;

  473.                 }

  474. 

  475.                 if (beatsPerBar != nullptr)

  476.                 {

  477.                     /**/ if (beatsPerBar->type == fURIDs.atomDouble)

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

  479.                     else if (beatsPerBar->type == fURIDs.atomFloat)

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

  481.                     else if (beatsPerBar->type == fURIDs.atomInt)

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

  483.                     else if (beatsPerBar->type == fURIDs.atomLong)

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

  485.                     else

  486.                         d_stderr("Unknown lv2 beatsPerBar value type");

  487. 

  488.                     if (fLastPositionData.beatsPerBar > 0.0f)

  489.                         fTimePosition.bbt.beatsPerBar = fLastPositionData.beatsPerBar;

  490.                 }

  491. 

  492.                 if (beatsPerMinute != nullptr)

  493.                 {

  494.                     /**/ if (beatsPerMinute->type == fURIDs.atomDouble)

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

  496.                     else if (beatsPerMinute->type == fURIDs.atomFloat)

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

  498.                     else if (beatsPerMinute->type == fURIDs.atomInt)

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

  500.                     else if (beatsPerMinute->type == fURIDs.atomLong)

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

  502.                     else

  503.                         d_stderr("Unknown lv2 beatsPerMinute value type");

  504. 

  505.                     if (fLastPositionData.beatsPerMinute > 0.0f)

  506.                     {

  507.                         fTimePosition.bbt.beatsPerMinute = fLastPositionData.beatsPerMinute;

  508. 

  509.                         if (d_isNotZero(fLastPositionData.speed))

  510.                             fTimePosition.bbt.beatsPerMinute *= std::abs(fLastPositionData.speed);

  511.                     }

  512.                 }

  513. 

  514.                 if (frame != nullptr)

  515.                 {

  516.                     /**/ if (frame->type == fURIDs.atomDouble)

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

  518.                     else if (frame->type == fURIDs.atomFloat)

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

  520.                     else if (frame->type == fURIDs.atomInt)

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

  522.                     else if (frame->type == fURIDs.atomLong)

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

  524.                     else

  525.                         d_stderr("Unknown lv2 frame value type");

  526. 

  527.                     if (fLastPositionData.frame >= 0)

  528.                         fTimePosition.frame = fLastPositionData.frame;

  529.                 }

  530. 

  531.                 fTimePosition.bbt.barStartTick = fTimePosition.bbt.ticksPerBeat*

  532.                                                  fTimePosition.bbt.beatsPerBar*

  533.                                                  (fTimePosition.bbt.bar-1);

  534. 

  535.                 fTimePosition.bbt.valid = (fLastPositionData.beatsPerMinute > 0.0 &&

  536.                                            fLastPositionData.beatUnit > 0 &&

  537.                                            fLastPositionData.beatsPerBar > 0.0f);

  538. 

  539.                 fPlugin.setTimePosition(fTimePosition);

  540. 

  541.                 continue;

  542.             }

  543. # endif

  544.         }

  545. #endif

  546. 

  547.         // check for messages from UI or files

  548. #if DISTRHO_PLUGIN_WANT_STATE && (DISTRHO_PLUGIN_HAS_UI || DISTRHO_PLUGIN_WANT_STATEFILES)

  549.         LV2_ATOM_SEQUENCE_FOREACH(fPortEventsIn, event)

  550.         {

  551.             if (event == nullptr)

  552.                 break;

  553. 

  554.             if (event->body.type == fURIDs.dpfKeyValue)

  555.             {

  556.                 const void* const data = (const void*)(event + 1);

  557. 

  558.                 // check if this is our special message

  559.                 if (std::strcmp((const char*)data, "__dpf_ui_data__") == 0)

  560.                 {

  561.                     for (uint32_t i=0, count=fPlugin.getStateCount(); i < count; ++i)

  562.                         fNeededUiSends[i] = true;

  563.                 }

  564.                 // no, send to DSP as usual

  565.                 else if (fWorker != nullptr)

  566.                 {

  567.                     fWorker->schedule_work(fWorker->handle, sizeof(LV2_Atom)+event->body.size, &event->body);

  568.                 }

  569.             }

  570. # if DISTRHO_PLUGIN_WANT_STATEFILES

  571.             else if (event->body.type == fURIDs.atomObject && fWorker != nullptr)

  572.             {

  573.                 const LV2_Atom_Object* const object = (const LV2_Atom_Object*)&event->body;

  574. 

  575.                 const LV2_Atom* property = nullptr;

  576.                 const LV2_Atom* value    = nullptr;

  577.                 lv2_atom_object_get(object, fURIDs.patchProperty, &property, fURIDs.patchValue, &value, nullptr);

  578. 

  579.                 if (property != nullptr && property->type == fURIDs.atomURID &&

  580.                     value != nullptr && value->type == fURIDs.atomPath)

  581.                 {

  582.                     fWorker->schedule_work(fWorker->handle, sizeof(LV2_Atom)+event->body.size, &event->body);

  583.                 }

  584.             }

  585. # endif

  586.         }

  587. #endif

  588. 

  589.         // Check for updated parameters

  590.         float curValue;

  591. 

  592.         for (uint32_t i=0, count=fPlugin.getParameterCount(); i < count; ++i)

  593.         {

  594.             if (!getPortControlValue(i, curValue))

  595.                 continue;

  596. 

  597.             if (fPlugin.isParameterInput(i) && d_isNotEqual(fLastControlValues[i], curValue))

  598.             {

  599.                 fLastControlValues[i] = curValue;

  600. 

  601.                 fPlugin.setParameterValue(i, curValue);

  602.             }

  603.         }

  604. 

  605.         // Run plugin

  606.         if (sampleCount != 0)

  607.         {

  608. #ifdef DISTRHO_PLUGIN_LICENSED_FOR_MOD

  609.             fRunCount = mod_license_run_begin(fRunCount, sampleCount);

  610. #endif

  611. 

  612. #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  613.             fPlugin.run(fPortAudioIns, fPortAudioOuts, sampleCount, fMidiEvents, midiEventCount);

  614. #else

  615.             fPlugin.run(fPortAudioIns, fPortAudioOuts, sampleCount);

  616. #endif

  617. 

  618. #ifdef DISTRHO_PLUGIN_LICENSED_FOR_MOD

  619.             for (uint32_t i=0; i<DISTRHO_PLUGIN_NUM_OUTPUTS; ++i)

  620.                 mod_license_run_silence(fRunCount, fPortAudioOuts[i], sampleCount, i);

  621. #endif

  622. 

  623. #if DISTRHO_PLUGIN_WANT_TIMEPOS

  624.             // update timePos for next callback

  625.             if (d_isNotZero(fLastPositionData.speed))

  626.             {

  627.                 if (fLastPositionData.speed > 0.0)

  628.                 {

  629.                     // playing forwards

  630.                     fLastPositionData.frame += sampleCount;

  631.                 }

  632.                 else

  633.                 {

  634.                     // playing backwards

  635.                     fLastPositionData.frame -= sampleCount;

  636. 

  637.                     if (fLastPositionData.frame < 0)

  638.                         fLastPositionData.frame = 0;

  639.                 }

  640. 

  641.                 fTimePosition.frame = fLastPositionData.frame;

  642. 

  643.                 if (fTimePosition.bbt.valid)

  644.                 {

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

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

  647.                     const double addedBarBeats  = double(sampleCount) / framesPerBeat;

  648. 

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

  650.                     {

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

  652.                                                               (double)fLastPositionData.beatsPerBar);

  653. 

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

  655.                         fTimePosition.bbt.beat = std::round(fLastPositionData.barBeat - rest + 1.0);

  656.                         fTimePosition.bbt.tick = rest * fTimePosition.bbt.ticksPerBeat;

  657. 

  658.                         if (fLastPositionData.bar >= 0)

  659.                         {

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

  661.                                                              fLastPositionData.beatsPerBar);

  662. 

  663.                             if (fLastPositionData.bar < 0)

  664.                                 fLastPositionData.bar = 0;

  665. 

  666.                             fTimePosition.bbt.bar = fLastPositionData.bar + 1;

  667. 

  668.                             fTimePosition.bbt.barStartTick = fTimePosition.bbt.ticksPerBeat*

  669.                                                              fTimePosition.bbt.beatsPerBar*

  670.                                                             (fTimePosition.bbt.bar-1);

  671.                         }

  672.                     }

  673. 

  674.                     fTimePosition.bbt.beatsPerMinute = std::abs(beatsPerMinute);

  675.                 }

  676. 

  677.                 fPlugin.setTimePosition(fTimePosition);

  678.             }

  679. #endif

  680.         }

  681. 

  682.         updateParameterOutputsAndTriggers();

  683. 

  684. #if DISTRHO_PLUGIN_WANT_STATE && DISTRHO_PLUGIN_HAS_UI

  685.         fEventsOutData.initIfNeeded(fURIDs.atomSequence);

  686. 

  687.         LV2_Atom_Event* aev;

  688.         const uint32_t capacity = fEventsOutData.capacity;

  689. 

  690.         for (uint32_t i=0, count=fPlugin.getStateCount(); i < count; ++i)

  691.         {

  692.             if (! fNeededUiSends[i])

  693.                 continue;

  694. 

  695.             const String& curKey(fPlugin.getStateKey(i));

  696. 

  697.             for (StringToStringMap::const_iterator cit=fStateMap.begin(), cite=fStateMap.end(); cit != cite; ++cit)

  698.             {

  699.                 const String& key(cit->first);

  700. 

  701.                 if (curKey != key)

  702.                     continue;

  703. 

  704.                 const String& value(cit->second);

  705. 

  706.                 // set msg size (key + value + separator + 2x null terminator)

  707.                 const uint32_t msgSize = static_cast<uint32_t>(key.length()+value.length())+3U;

  708. 

  709.                 if (sizeof(LV2_Atom_Event) + msgSize > capacity - fEventsOutData.offset)

  710.                 {

  711.                     d_stdout("Sending key '%s' to UI failed, out of space", key.buffer());

  712.                     break;

  713.                 }

  714. 

  715.                 // put data

  716.                 aev = (LV2_Atom_Event*)(LV2_ATOM_CONTENTS(LV2_Atom_Sequence, fEventsOutData.port) + fEventsOutData.offset);

  717.                 aev->time.frames = 0;

  718.                 aev->body.type   = fURIDs.dpfKeyValue;

  719.                 aev->body.size   = msgSize;

  720. 

  721.                 uint8_t* const msgBuf = LV2_ATOM_BODY(&aev->body);

  722.                 std::memset(msgBuf, 0, msgSize);

  723. 

  724.                 // write key and value in atom buffer

  725.                 std::memcpy(msgBuf, key.buffer(), key.length()+1);

  726.                 std::memcpy(msgBuf+(key.length()+1), value.buffer(), value.length()+1);

  727. 

  728.                 fEventsOutData.growBy(lv2_atom_pad_size(sizeof(LV2_Atom_Event) + msgSize));

  729. 

  730.                 fNeededUiSends[i] = false;

  731.                 break;

  732.             }

  733.         }

  734. #endif

  735. 

  736. #if DISTRHO_LV2_USE_EVENTS_OUT

  737.         fEventsOutData.endRun();

  738. #endif

  739.     }

  740. 

  741.     // -------------------------------------------------------------------

  742. 

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

  744.     {

  745.         // currently unused

  746.         return LV2_OPTIONS_ERR_UNKNOWN;

  747.     }

  748. 

  749.     uint32_t lv2_set_options(const LV2_Options_Option* const options)

  750.     {

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

  752.         {

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

  754.             {

  755.                 if (options[i].type == fURIDs.atomInt)

  756.                 {

  757.                     const int32_t bufferSize(*(const int32_t*)options[i].value);

  758.                     fPlugin.setBufferSize(bufferSize);

  759.                 }

  760.                 else

  761.                 {

  762.                     d_stderr("Host changed nominalBlockLength but with wrong value type");

  763.                 }

  764.             }

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

  766.             {

  767.                 if (options[i].type == fURIDs.atomInt)

  768.                 {

  769.                     const int32_t bufferSize(*(const int32_t*)options[i].value);

  770.                     fPlugin.setBufferSize(bufferSize);

  771.                 }

  772.                 else

  773.                 {

  774.                     d_stderr("Host changed maxBlockLength but with wrong value type");

  775.                 }

  776.             }

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

  778.             {

  779.                 if (options[i].type == fURIDs.atomFloat)

  780.                 {

  781.                     const float sampleRate(*(const float*)options[i].value);

  782.                     fSampleRate = sampleRate;

  783.                     fPlugin.setSampleRate(sampleRate);

  784.                 }

  785.                 else

  786.                 {

  787.                     d_stderr("Host changed sampleRate but with wrong value type");

  788.                 }

  789.             }

  790.         }

  791. 

  792.         return LV2_OPTIONS_SUCCESS;

  793.     }

  794. 

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

  796. 

  797. #if DISTRHO_PLUGIN_WANT_PROGRAMS

  798.     const LV2_Program_Descriptor* lv2_get_program(const uint32_t index)

  799.     {

  800.         if (index >= fPlugin.getProgramCount())

  801.             return nullptr;

  802. 

  803.         static LV2_Program_Descriptor desc;

  804. 

  805.         desc.bank    = index / 128;

  806.         desc.program = index % 128;

  807.         desc.name    = fPlugin.getProgramName(index);

  808. 

  809.         return &desc;

  810.     }

  811. 

  812.     void lv2_select_program(const uint32_t bank, const uint32_t program)

  813.     {

  814.         const uint32_t realProgram(bank * 128 + program);

  815. 

  816.         if (realProgram >= fPlugin.getProgramCount())

  817.             return;

  818. 

  819.         fPlugin.loadProgram(realProgram);

  820. 

  821.         // Update control inputs

  822.         for (uint32_t i=0, count=fPlugin.getParameterCount(); i < count; ++i)

  823.         {

  824.             if (fPlugin.isParameterOutput(i))

  825.                 continue;

  826. 

  827.             fLastControlValues[i] = fPlugin.getParameterValue(i);

  828. 

  829.             setPortControlValue(i, fLastControlValues[i]);

  830.         }

  831. 

  832. # if DISTRHO_PLUGIN_WANT_FULL_STATE

  833.         // Update state

  834.         for (StringToStringMap::const_iterator cit=fStateMap.begin(), cite=fStateMap.end(); cit != cite; ++cit)

  835.         {

  836.             const String& key = cit->first;

  837.             fStateMap[key] = fPlugin.getState(key);

  838.         }

  839. # endif

  840.     }

  841. #endif

  842. 

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

  844. 

  845. #if DISTRHO_PLUGIN_WANT_STATE

  846.     LV2_State_Status lv2_save(const LV2_State_Store_Function store, const LV2_State_Handle handle)

  847.     {

  848. # if DISTRHO_PLUGIN_WANT_FULL_STATE

  849.         // Update current state

  850.         for (StringToStringMap::const_iterator cit=fStateMap.begin(), cite=fStateMap.end(); cit != cite; ++cit)

  851.         {

  852.             const String& key = cit->first;

  853.             fStateMap[key] = fPlugin.getState(key);

  854.         }

  855. # endif

  856. 

  857.         String dpf_lv2_key;

  858.         LV2_URID urid;

  859. 

  860.         for (uint32_t i=0, count=fPlugin.getStateCount(); i < count; ++i)

  861.         {

  862.             const String& curKey(fPlugin.getStateKey(i));

  863. 

  864.             for (StringToStringMap::const_iterator cit=fStateMap.begin(), cite=fStateMap.end(); cit != cite; ++cit)

  865.             {

  866.                 const String& key(cit->first);

  867. 

  868.                 if (curKey != key)

  869.                     continue;

  870. 

  871.                 const String& value(cit->second);

  872. 

  873. # if DISTRHO_PLUGIN_WANT_STATEFILES

  874.                 if (fPlugin.isStateFile(i))

  875.                 {

  876.                     dpf_lv2_key = DISTRHO_PLUGIN_URI "#";

  877.                     urid = fURIDs.atomPath;

  878.                 }

  879.                 else

  880. # endif

  881.                 {

  882.                     dpf_lv2_key = DISTRHO_PLUGIN_LV2_STATE_PREFIX;

  883.                     urid = fURIDs.atomString;

  884.                 }

  885. 

  886.                 dpf_lv2_key += key;

  887. 

  888.                 // some hosts need +1 for the null terminator, even though the type is string

  889.                 store(handle,

  890.                       fUridMap->map(fUridMap->handle, dpf_lv2_key.buffer()),

  891.                       value.buffer(),

  892.                       value.length()+1,

  893.                       urid,

  894.                       LV2_STATE_IS_POD|LV2_STATE_IS_PORTABLE);

  895.             }

  896.         }

  897. 

  898.         return LV2_STATE_SUCCESS;

  899.     }

  900. 

  901.     LV2_State_Status lv2_restore(const LV2_State_Retrieve_Function retrieve, const LV2_State_Handle handle)

  902.     {

  903.         size_t   size;

  904.         uint32_t type, flags;

  905. 

  906.         String dpf_lv2_key;

  907.         LV2_URID urid;

  908. 

  909.         for (uint32_t i=0, count=fPlugin.getStateCount(); i < count; ++i)

  910.         {

  911.             const String& key(fPlugin.getStateKey(i));

  912. 

  913. # if DISTRHO_PLUGIN_WANT_STATEFILES

  914.             if (fPlugin.isStateFile(i))

  915.             {

  916.                 dpf_lv2_key = DISTRHO_PLUGIN_URI "#";

  917.                 urid = fURIDs.atomPath;

  918.             }

  919.             else

  920. # endif

  921.             {

  922.                 dpf_lv2_key = DISTRHO_PLUGIN_LV2_STATE_PREFIX;

  923.                 urid = fURIDs.atomString;

  924.             }

  925. 

  926.             dpf_lv2_key += key;

  927. 

  928.             size  = 0;

  929.             type  = 0;

  930.             flags = LV2_STATE_IS_POD|LV2_STATE_IS_PORTABLE;

  931.             const void* data = retrieve(handle,

  932.                                         fUridMap->map(fUridMap->handle, dpf_lv2_key.buffer()),

  933.                                         &size, &type, &flags);

  934. 

  935.             if (data == nullptr || size == 0)

  936.                 continue;

  937. 

  938.             DISTRHO_SAFE_ASSERT_CONTINUE(type == urid);

  939. 

  940.             const char* const value  = (const char*)data;

  941.             const std::size_t length = std::strlen(value);

  942.             DISTRHO_SAFE_ASSERT_CONTINUE(length == size || length+1 == size);

  943. 

  944.             setState(key, value);

  945. 

  946. #if DISTRHO_LV2_USE_EVENTS_OUT

  947.             // signal msg needed for UI

  948.             fNeededUiSends[i] = true;

  949. #endif

  950.         }

  951. 

  952.         return LV2_STATE_SUCCESS;

  953.     }

  954. 

  955.     // -------------------------------------------------------------------

  956. 

  957.     LV2_Worker_Status lv2_work(const void* const data)

  958.     {

  959.         const LV2_Atom* const eventBody = (const LV2_Atom*)data;

  960. 

  961.         if (eventBody->type == fURIDs.dpfKeyValue)

  962.         {

  963.             const char* const key   = (const char*)(eventBody + 1);

  964.             const char* const value = key + (std::strlen(key) + 1U);

  965. 

  966.             setState(key, value);

  967.             return LV2_WORKER_SUCCESS;

  968.         }

  969. 

  970. # if DISTRHO_PLUGIN_WANT_STATEFILES

  971.         if (eventBody->type == fURIDs.atomObject)

  972.         {

  973.             const LV2_Atom_Object* const object = (const LV2_Atom_Object*)eventBody;

  974. 

  975.             const LV2_Atom* property = nullptr;

  976.             const LV2_Atom* value    = nullptr;

  977.             lv2_atom_object_get(object, fURIDs.patchProperty, &property, fURIDs.patchValue, &value, nullptr);

  978.             DISTRHO_SAFE_ASSERT_RETURN(property != nullptr, LV2_WORKER_ERR_UNKNOWN);

  979.             DISTRHO_SAFE_ASSERT_RETURN(property->type == fURIDs.atomURID, LV2_WORKER_ERR_UNKNOWN);

  980.             DISTRHO_SAFE_ASSERT_RETURN(value != nullptr, LV2_WORKER_ERR_UNKNOWN);

  981.             DISTRHO_SAFE_ASSERT_RETURN(value->type == fURIDs.atomPath, LV2_WORKER_ERR_UNKNOWN);

  982. 

  983.             const LV2_URID urid        = ((const LV2_Atom_URID*)property)->body;

  984.             const char* const filename = (const char*)(value + 1);

  985. 

  986.             String key;

  987. 

  988.             try {

  989.                 key = fUridStateFileMap[urid];

  990.             } DISTRHO_SAFE_EXCEPTION_RETURN("lv2_work fUridStateFileMap[urid]", LV2_WORKER_ERR_UNKNOWN);

  991. 

  992.             setState(key, filename);

  993. 

  994.             for (uint32_t i=0, count=fPlugin.getStateCount(); i < count; ++i)

  995.             {

  996.                 if (fPlugin.getStateKey(i) == key)

  997.                 {

  998.                     fNeededUiSends[i] = true;

  999.                     break;

  1000.                 }

  1001.             }

  1002. 

  1003.             return LV2_WORKER_SUCCESS;

  1004.         }

  1005. # endif

  1006. 

  1007.         return LV2_WORKER_ERR_UNKNOWN;

  1008.     }

  1009. 

  1010.     LV2_Worker_Status lv2_work_response(uint32_t, const void*)

  1011.     {

  1012.         return LV2_WORKER_SUCCESS;

  1013.     }

  1014. #endif

  1015. 

  1016.     // -------------------------------------------------------------------

  1017. 

  1018. #if DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  1019.     void* lv2_get_instance_pointer()

  1020.     {

  1021.         return fPlugin.getInstancePointer();

  1022.     }

  1023. #endif

  1024. 

  1025.     // -------------------------------------------------------------------

  1026. 

  1027. private:

  1028.     PluginExporter fPlugin;

  1029.     const bool fUsingNominal; // if false use maxBlockLength

  1030. 

  1031. #ifdef DISTRHO_PLUGIN_LICENSED_FOR_MOD

  1032.     uint32_t fRunCount;

  1033. #endif

  1034. 

  1035.     // LV2 ports

  1036. #if DISTRHO_PLUGIN_NUM_INPUTS > 0

  1037.     const float*  fPortAudioIns[DISTRHO_PLUGIN_NUM_INPUTS];

  1038. #else

  1039.     const float** fPortAudioIns;

  1040. #endif

  1041. #if DISTRHO_PLUGIN_NUM_OUTPUTS > 0

  1042.     float*  fPortAudioOuts[DISTRHO_PLUGIN_NUM_OUTPUTS];

  1043. #else

  1044.     float** fPortAudioOuts;

  1045. #endif

  1046.     float** fPortControls;

  1047. #if DISTRHO_LV2_USE_EVENTS_IN

  1048.     LV2_Atom_Sequence* fPortEventsIn;

  1049. #endif

  1050. #if DISTRHO_PLUGIN_WANT_LATENCY

  1051.     float* fPortLatency;

  1052. #endif

  1053. 

  1054.     // Temporary data

  1055.     float* fLastControlValues;

  1056.     double fSampleRate;

  1057. #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1058.     MidiEvent fMidiEvents[kMaxMidiEvents];

  1059. #endif

  1060. #if DISTRHO_PLUGIN_WANT_TIMEPOS

  1061.     TimePosition fTimePosition;

  1062. 

  1063.     struct Lv2PositionData {

  1064.         int64_t  bar;

  1065.         float    barBeat;

  1066.         uint32_t beatUnit;

  1067.         float    beatsPerBar;

  1068.         float    beatsPerMinute;

  1069.         int64_t  frame;

  1070.         double   speed;

  1071.         double   ticksPerBeat;

  1072. 

  1073.         Lv2PositionData()

  1074.             : bar(-1),

  1075.               barBeat(-1.0f),

  1076.               beatUnit(0),

  1077.               beatsPerBar(0.0f),

  1078.               beatsPerMinute(0.0f),

  1079.               frame(-1),

  1080.               speed(0.0),

  1081.               ticksPerBeat(-1.0) {}

  1082. 

  1083.     } fLastPositionData;

  1084. #endif

  1085. 

  1086. #if DISTRHO_LV2_USE_EVENTS_OUT

  1087.     struct Lv2EventsOutData {

  1088.         uint32_t capacity, offset;

  1089.         LV2_Atom_Sequence* port;

  1090. 

  1091.         Lv2EventsOutData()

  1092.             : capacity(0),

  1093.               offset(0),

  1094.               port(nullptr) {}

  1095. 

  1096.         void initIfNeeded(const LV2_URID uridAtomSequence)

  1097.         {

  1098.             if (capacity != 0)

  1099.                 return;

  1100. 

  1101.             capacity = port->atom.size;

  1102. 

  1103.             port->atom.size = sizeof(LV2_Atom_Sequence_Body);

  1104.             port->atom.type = uridAtomSequence;

  1105.             port->body.unit = 0;

  1106.             port->body.pad  = 0;

  1107.         }

  1108. 

  1109.         void growBy(const uint32_t size)

  1110.         {

  1111.             offset += size;

  1112.             port->atom.size += size;

  1113.         }

  1114. 

  1115.         void endRun()

  1116.         {

  1117.             capacity = 0;

  1118.             offset = 0;

  1119.         }

  1120. 

  1121.     } fEventsOutData;

  1122. #endif

  1123. 

  1124.     // LV2 URIDs

  1125.     struct URIDs {

  1126.         const LV2_URID_Map* _uridMap;

  1127.         LV2_URID atomBlank;

  1128.         LV2_URID atomObject;

  1129.         LV2_URID atomDouble;

  1130.         LV2_URID atomFloat;

  1131.         LV2_URID atomInt;

  1132.         LV2_URID atomLong;

  1133.         LV2_URID atomPath;

  1134.         LV2_URID atomSequence;

  1135.         LV2_URID atomString;

  1136.         LV2_URID atomURID;

  1137.         LV2_URID dpfKeyValue;

  1138.         LV2_URID midiEvent;

  1139.         LV2_URID patchProperty;

  1140.         LV2_URID patchValue;

  1141.         LV2_URID timePosition;

  1142.         LV2_URID timeBar;

  1143.         LV2_URID timeBarBeat;

  1144.         LV2_URID timeBeatUnit;

  1145.         LV2_URID timeBeatsPerBar;

  1146.         LV2_URID timeBeatsPerMinute;

  1147.         LV2_URID timeTicksPerBeat;

  1148.         LV2_URID timeFrame;

  1149.         LV2_URID timeSpeed;

  1150. 

  1151.         URIDs(const LV2_URID_Map* const uridMap)

  1152.             : _uridMap(uridMap),

  1153.               atomBlank(map(LV2_ATOM__Blank)),

  1154.               atomObject(map(LV2_ATOM__Object)),

  1155.               atomDouble(map(LV2_ATOM__Double)),

  1156.               atomFloat(map(LV2_ATOM__Float)),

  1157.               atomInt(map(LV2_ATOM__Int)),

  1158.               atomLong(map(LV2_ATOM__Long)),

  1159.               atomPath(map(LV2_ATOM__Path)),

  1160.               atomSequence(map(LV2_ATOM__Sequence)),

  1161.               atomString(map(LV2_ATOM__String)),

  1162.               atomURID(map(LV2_ATOM__URID)),

  1163.               dpfKeyValue(map(DISTRHO_PLUGIN_LV2_STATE_PREFIX "KeyValueState")),

  1164.               midiEvent(map(LV2_MIDI__MidiEvent)),

  1165.               patchProperty(map(LV2_PATCH__property)),

  1166.               patchValue(map(LV2_PATCH__value)),

  1167.               timePosition(map(LV2_TIME__Position)),

  1168.               timeBar(map(LV2_TIME__bar)),

  1169.               timeBarBeat(map(LV2_TIME__barBeat)),

  1170.               timeBeatUnit(map(LV2_TIME__beatUnit)),

  1171.               timeBeatsPerBar(map(LV2_TIME__beatsPerBar)),

  1172.               timeBeatsPerMinute(map(LV2_TIME__beatsPerMinute)),

  1173.               timeTicksPerBeat(map(LV2_KXSTUDIO_PROPERTIES__TimePositionTicksPerBeat)),

  1174.               timeFrame(map(LV2_TIME__frame)),

  1175.               timeSpeed(map(LV2_TIME__speed)) {}

  1176. 

  1177.         inline LV2_URID map(const char* const uri) const

  1178.         {

  1179.             return _uridMap->map(_uridMap->handle, uri);

  1180.         }

  1181.     } fURIDs;

  1182. 

  1183.     // LV2 features

  1184. #if DISTRHO_PLUGIN_WANT_PARAMETER_VALUE_CHANGE_REQUEST

  1185.     const LV2_ControlInputPort_Change_Request* const fCtrlInPortChangeReq;

  1186. #endif

  1187.     const LV2_URID_Map* const fUridMap;

  1188.     const LV2_Worker_Schedule* const fWorker;

  1189. 

  1190. #if DISTRHO_PLUGIN_WANT_STATE

  1191.     StringToStringMap fStateMap;

  1192.     bool* fNeededUiSends;

  1193. 

  1194.     void setState(const char* const key, const char* const newValue)

  1195.     {

  1196.         fPlugin.setState(key, newValue);

  1197. 

  1198.         // check if we want to save this key

  1199.         if (! fPlugin.wantStateKey(key))

  1200.             return;

  1201. 

  1202.         // check if key already exists

  1203.         for (StringToStringMap::iterator it=fStateMap.begin(), ite=fStateMap.end(); it != ite; ++it)

  1204.         {

  1205.             const String& dkey(it->first);

  1206. 

  1207.             if (dkey == key)

  1208.             {

  1209.                 it->second = newValue;

  1210.                 return;

  1211.             }

  1212.         }

  1213. 

  1214.         d_stderr("Failed to find plugin state with key \"%s\"", key);

  1215.     }

  1216. 

  1217. # if DISTRHO_PLUGIN_WANT_STATEFILES

  1218.     UridToStringMap fUridStateFileMap;

  1219. # endif

  1220. #endif

  1221. 

  1222.     void updateParameterOutputsAndTriggers()

  1223.     {

  1224.         float curValue;

  1225. 

  1226.         for (uint32_t i=0, count=fPlugin.getParameterCount(); i < count; ++i)

  1227.         {

  1228.             if (fPlugin.isParameterOutput(i))

  1229.             {

  1230.                 curValue = fLastControlValues[i] = fPlugin.getParameterValue(i);

  1231. 

  1232.                 setPortControlValue(i, curValue);

  1233.             }

  1234.             else if ((fPlugin.getParameterHints(i) & kParameterIsTrigger) == kParameterIsTrigger)

  1235.             {

  1236.                 // NOTE: host is responsible for auto-updating control port buffers

  1237.             }

  1238.         }

  1239. 

  1240. #if DISTRHO_PLUGIN_WANT_LATENCY

  1241.         if (fPortLatency != nullptr)

  1242.             *fPortLatency = fPlugin.getLatency();

  1243. #endif

  1244.     }

  1245. 

  1246. #if DISTRHO_PLUGIN_WANT_PARAMETER_VALUE_CHANGE_REQUEST

  1247.     bool requestParameterValueChange(const uint32_t index, const float value)

  1248.     {

  1249.         if (fCtrlInPortChangeReq == nullptr)

  1250.             return false;

  1251.         return fCtrlInPortChangeReq->request_change(fCtrlInPortChangeReq->handle, index, value);

  1252.     }

  1253. 

  1254.     static bool requestParameterValueChangeCallback(void* const ptr, const uint32_t index, const float value)

  1255.     {

  1256.         return (((PluginLv2*)ptr)->requestParameterValueChange(index, value) == 0);

  1257.     }

  1258. #endif

  1259. 

  1260. #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  1261.     bool writeMidi(const MidiEvent& midiEvent)

  1262.     {

  1263.         DISTRHO_SAFE_ASSERT_RETURN(fEventsOutData.port != nullptr, false);

  1264. 

  1265.         fEventsOutData.initIfNeeded(fURIDs.atomSequence);

  1266. 

  1267.         const uint32_t capacity = fEventsOutData.capacity;

  1268.         const uint32_t offset = fEventsOutData.offset;

  1269. 

  1270.         if (sizeof(LV2_Atom_Event) + midiEvent.size > capacity - offset)

  1271.             return false;

  1272. 

  1273.         LV2_Atom_Event* const aev = (LV2_Atom_Event*)(LV2_ATOM_CONTENTS(LV2_Atom_Sequence, fEventsOutData.port) + offset);

  1274.         aev->time.frames = midiEvent.frame;

  1275.         aev->body.type   = fURIDs.midiEvent;

  1276.         aev->body.size   = midiEvent.size;

  1277.         std::memcpy(LV2_ATOM_BODY(&aev->body),

  1278.                     midiEvent.size > MidiEvent::kDataSize ? midiEvent.dataExt : midiEvent.data,

  1279.                     midiEvent.size);

  1280. 

  1281.         fEventsOutData.growBy(lv2_atom_pad_size(sizeof(LV2_Atom_Event) + midiEvent.size));

  1282. 

  1283.         return true;

  1284.     }

  1285. 

  1286.     static bool writeMidiCallback(void* ptr, const MidiEvent& midiEvent)

  1287.     {

  1288.         return ((PluginLv2*)ptr)->writeMidi(midiEvent);

  1289.     }

  1290. #endif

  1291. };

  1292. 

  1293. // -----------------------------------------------------------------------

  1294. 

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

  1296. {

  1297.     const LV2_Options_Option* options = nullptr;

  1298.     const LV2_URID_Map*       uridMap = nullptr;

  1299.     const LV2_Worker_Schedule* worker = nullptr;

  1300.     const LV2_ControlInputPort_Change_Request* ctrlInPortChangeReq = nullptr;

  1301. 

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

  1303.     {

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

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

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

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

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

  1309.             worker = (const LV2_Worker_Schedule*)features[i]->data;

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

  1311.             ctrlInPortChangeReq = (const LV2_ControlInputPort_Change_Request*)features[i]->data;

  1312.     }

  1313. 

  1314.     if (options == nullptr)

  1315.     {

  1316.         d_stderr("Options feature missing, cannot continue!");

  1317.         return nullptr;

  1318.     }

  1319. 

  1320.     if (uridMap == nullptr)

  1321.     {

  1322.         d_stderr("URID Map feature missing, cannot continue!");

  1323.         return nullptr;

  1324.     }

  1325. 

  1326. #if DISTRHO_PLUGIN_WANT_STATE

  1327.     if (worker == nullptr)

  1328.     {

  1329.         d_stderr("Worker feature missing, cannot continue!");

  1330.         return nullptr;

  1331.     }

  1332. #endif

  1333. 

  1334. #ifdef DISTRHO_PLUGIN_LICENSED_FOR_MOD

  1335.     mod_license_check(features, DISTRHO_PLUGIN_URI);

  1336. #endif

  1337. 

  1338.     d_nextBufferSize = 0;

  1339.     bool usingNominal = false;

  1340. 

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

  1342.     {

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

  1344.         {

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

  1346.             {

  1347.                 d_nextBufferSize = *(const int*)options[i].value;

  1348.                 usingNominal = true;

  1349.             }

  1350.             else

  1351.             {

  1352.                 d_stderr("Host provides nominalBlockLength but has wrong value type");

  1353.             }

  1354.             break;

  1355.         }

  1356. 

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

  1358.         {

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

  1360.                 d_nextBufferSize = *(const int*)options[i].value;

  1361.             else

  1362.                 d_stderr("Host provides maxBlockLength but has wrong value type");

  1363. 

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

  1365.         }

  1366.     }

  1367. 

  1368.     if (d_nextBufferSize == 0)

  1369.     {

  1370.         d_stderr("Host does not provide nominalBlockLength or maxBlockLength options");

  1371.         d_nextBufferSize = 2048;

  1372.     }

  1373. 

  1374.     d_nextSampleRate = sampleRate;

  1375.     d_nextBundlePath = bundlePath;

  1376.     d_nextCanRequestParameterValueChanges = ctrlInPortChangeReq != nullptr;

  1377. 

  1378.     return new PluginLv2(sampleRate, uridMap, worker, ctrlInPortChangeReq, usingNominal);

  1379. }

  1380. 

  1381. #define instancePtr ((PluginLv2*)instance)

  1382. 

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

  1384. {

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

  1386. }

  1387. 

  1388. static void lv2_activate(LV2_Handle instance)

  1389. {

  1390.     instancePtr->lv2_activate();

  1391. }

  1392. 

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

  1394. {

  1395.     instancePtr->lv2_run(sampleCount);

  1396. }

  1397. 

  1398. static void lv2_deactivate(LV2_Handle instance)

  1399. {

  1400.     instancePtr->lv2_deactivate();

  1401. }

  1402. 

  1403. static void lv2_cleanup(LV2_Handle instance)

  1404. {

  1405.     delete instancePtr;

  1406. }

  1407. 

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

  1409. 

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

  1411. {

  1412.     return instancePtr->lv2_get_options(options);

  1413. }

  1414. 

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

  1416. {

  1417.     return instancePtr->lv2_set_options(options);

  1418. }

  1419. 

  1420. // -----------------------------------------------------------------------

  1421. 

  1422. #if DISTRHO_PLUGIN_WANT_PROGRAMS

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

  1424. {

  1425.     return instancePtr->lv2_get_program(index);

  1426. }

  1427. 

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

  1429. {

  1430.     instancePtr->lv2_select_program(bank, program);

  1431. }

  1432. #endif

  1433. 

  1434. // -----------------------------------------------------------------------

  1435. 

  1436. #if DISTRHO_PLUGIN_WANT_STATE

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

  1438. {

  1439.     return instancePtr->lv2_save(store, handle);

  1440. }

  1441. 

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

  1443. {

  1444.     return instancePtr->lv2_restore(retrieve, handle);

  1445. }

  1446. 

  1447. LV2_Worker_Status lv2_work(LV2_Handle instance, LV2_Worker_Respond_Function, LV2_Worker_Respond_Handle, uint32_t, const void* data)

  1448. {

  1449.     return instancePtr->lv2_work(data);

  1450. }

  1451. 

  1452. LV2_Worker_Status lv2_work_response(LV2_Handle instance, uint32_t size, const void* body)

  1453. {

  1454.     return instancePtr->lv2_work_response(size, body);

  1455. }

  1456. #endif

  1457. 

  1458. // -----------------------------------------------------------------------

  1459. 

  1460. #if DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  1461. static void* lv2_get_instance_pointer(LV2_Handle instance)

  1462. {

  1463.     return instancePtr->lv2_get_instance_pointer();

  1464. }

  1465. #endif

  1466. 

  1467. // -----------------------------------------------------------------------

  1468. 

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

  1470. {

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

  1472. 

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

  1474.         return &options;

  1475. 

  1476. #if DISTRHO_PLUGIN_WANT_PROGRAMS

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

  1478. 

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

  1480.         return &programs;

  1481. #endif

  1482. 

  1483. #if DISTRHO_PLUGIN_WANT_STATE

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

  1485.     static const LV2_Worker_Interface worker = { lv2_work, lv2_work_response, nullptr };

  1486. 

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

  1488.         return &state;

  1489.     if (std::strcmp(uri, LV2_WORKER__interface) == 0)

  1490.         return &worker;

  1491. #endif

  1492. 

  1493. #if DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  1494.     struct LV2_DirectAccess_Interface {

  1495.         void* (*get_instance_pointer)(LV2_Handle handle);

  1496.     };

  1497. 

  1498.     static const LV2_DirectAccess_Interface directaccess = { lv2_get_instance_pointer };

  1499. 

  1500.     if (std::strcmp(uri, DISTRHO_PLUGIN_LV2_STATE_PREFIX "direct-access") == 0)

  1501.         return &directaccess;

  1502. #endif

  1503. 

  1504. #ifdef DISTRHO_PLUGIN_LICENSED_FOR_MOD

  1505.     return mod_license_interface(uri);

  1506. #else

  1507.     return nullptr;

  1508. #endif

  1509. }

  1510. 

  1511. #undef instancePtr

  1512. 

  1513. // -----------------------------------------------------------------------

  1514. 

  1515. static const LV2_Descriptor sLv2Descriptor = {

  1516.     DISTRHO_PLUGIN_URI,

  1517.     lv2_instantiate,

  1518.     lv2_connect_port,

  1519.     lv2_activate,

  1520.     lv2_run,

  1521.     lv2_deactivate,

  1522.     lv2_cleanup,

  1523.     lv2_extension_data

  1524. };

  1525. 

  1526. // -----------------------------------------------------------------------

  1527. 

  1528. END_NAMESPACE_DISTRHO

  1529. 

  1530. DISTRHO_PLUGIN_EXPORT

  1531. const LV2_Descriptor* lv2_descriptor(uint32_t index)

  1532. {

  1533.     USE_NAMESPACE_DISTRHO

  1534.     return (index == 0) ? &sLv2Descriptor : nullptr;

  1535. }

  1536. 

  1537. // -----------------------------------------------------------------------