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.
1455 Commits
7 Branches
53MB
Tree: ba550f42fd
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'ba550f42fd'
${ noResults }
DPF/distrho/src/DistrhoPluginVST3.cpp

2337 lines
87KB
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. #include "../extra/ScopedPointer.hpp"

  19. 

  20. #include "travesty/audio_processor.h"

  21. #include "travesty/component.h"

  22. #include "travesty/edit_controller.h"

  23. #include "travesty/factory.h"

  24. 

  25. #include <atomic>

  26. 

  27. // TESTING awful idea dont reuse

  28. #include "../extra/Thread.hpp"

  29. 

  30. START_NAMESPACE_DISTRHO

  31. 

  32. // --------------------------------------------------------------------------------------------------------------------

  33. 

  34. #if ! DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  35. static const writeMidiFunc writeMidiCallback = nullptr;

  36. #endif

  37. #if ! DISTRHO_PLUGIN_WANT_PARAMETER_VALUE_CHANGE_REQUEST

  38. static const requestParameterValueChangeFunc requestParameterValueChangeCallback = nullptr;

  39. #endif

  40. 

  41. // --------------------------------------------------------------------------------------------------------------------

  42. // custom v3_tuid compatible type

  43. 

  44. typedef uint32_t dpf_tuid[4];

  45. static_assert(sizeof(v3_tuid) == sizeof(dpf_tuid), "uid size mismatch");

  46. 

  47. // --------------------------------------------------------------------------------------------------------------------

  48. // custom, constant uids related to DPF

  49. 

  50. static constexpr const uint32_t dpf_id_entry = d_cconst('D', 'P', 'F', ' ');

  51. static constexpr const uint32_t dpf_id_clas  = d_cconst('c', 'l', 'a', 's');

  52. static constexpr const uint32_t dpf_id_comp  = d_cconst('c', 'o', 'm', 'p');

  53. static constexpr const uint32_t dpf_id_ctrl  = d_cconst('c', 't', 'r', 'l');

  54. static constexpr const uint32_t dpf_id_proc  = d_cconst('p', 'r', 'o', 'c');

  55. static constexpr const uint32_t dpf_id_view  = d_cconst('v', 'i', 'e', 'w');

  56. 

  57. // --------------------------------------------------------------------------------------------------------------------

  58. // plugin specific uids (values are filled in during plugin init)

  59. 

  60. static dpf_tuid dpf_tuid_class = { dpf_id_entry, dpf_id_clas, 0, 0 };

  61. static dpf_tuid dpf_tuid_component = { dpf_id_entry, dpf_id_comp, 0, 0 };

  62. static dpf_tuid dpf_tuid_controller = { dpf_id_entry, dpf_id_ctrl, 0, 0 };

  63. static dpf_tuid dpf_tuid_processor = { dpf_id_entry, dpf_id_proc, 0, 0 };

  64. static dpf_tuid dpf_tuid_view = { dpf_id_entry, dpf_id_view, 0, 0 };

  65. 

  66. // --------------------------------------------------------------------------------------------------------------------

  67. // Utility functions

  68. 

  69. static const char* tuid2str(const v3_tuid iid)

  70. {

  71.     if (v3_tuid_match(iid, v3_funknown_iid))

  72.         return "{v3_funknown}";

  73.     if (v3_tuid_match(iid, v3_plugin_base_iid))

  74.         return "{v3_plugin_base}";

  75.     if (v3_tuid_match(iid, v3_plugin_factory_iid))

  76.         return "{v3_plugin_factory}";

  77.     if (v3_tuid_match(iid, v3_plugin_factory_2_iid))

  78.         return "{v3_plugin_factory_2}";

  79.     if (v3_tuid_match(iid, v3_plugin_factory_3_iid))

  80.         return "{v3_plugin_factory_3}";

  81.     if (v3_tuid_match(iid, v3_component_iid))

  82.         return "{v3_component}";

  83.     if (v3_tuid_match(iid, v3_bstream_iid))

  84.         return "{v3_bstream}";

  85.     if (v3_tuid_match(iid, v3_event_list_iid))

  86.         return "{v3_event_list}";

  87.     if (v3_tuid_match(iid, v3_param_value_queue_iid))

  88.         return "{v3_param_value_queue}";

  89.     if (v3_tuid_match(iid, v3_param_changes_iid))

  90.         return "{v3_param_changes}";

  91.     if (v3_tuid_match(iid, v3_process_context_requirements_iid))

  92.         return "{v3_process_context_requirements}";

  93.     if (v3_tuid_match(iid, v3_audio_processor_iid))

  94.         return "{v3_audio_processor}";

  95.     if (v3_tuid_match(iid, v3_component_handler_iid))

  96.         return "{v3_component_handler}";

  97.     if (v3_tuid_match(iid, v3_edit_controller_iid))

  98.         return "{v3_edit_controller}";

  99.     if (v3_tuid_match(iid, v3_plugin_view_iid))

  100.         return "{v3_plugin_view}";

  101.     if (v3_tuid_match(iid, v3_plugin_frame_iid))

  102.         return "{v3_plugin_frame}";

  103.     if (v3_tuid_match(iid, v3_plugin_view_content_scale_steinberg_iid))

  104.         return "{v3_plugin_view_content_scale_steinberg}";

  105.     if (v3_tuid_match(iid, v3_plugin_view_parameter_finder_iid))

  106.         return "{v3_plugin_view_parameter_finder}";

  107.     if (std::memcmp(iid, dpf_tuid_class, sizeof(dpf_tuid)) == 0)

  108.         return "{dpf_tuid_class}";

  109.     if (std::memcmp(iid, dpf_tuid_component, sizeof(dpf_tuid)) == 0)

  110.         return "{dpf_tuid_component}";

  111.     if (std::memcmp(iid, dpf_tuid_controller, sizeof(dpf_tuid)) == 0)

  112.         return "{dpf_tuid_controller}";

  113.     if (std::memcmp(iid, dpf_tuid_processor, sizeof(dpf_tuid)) == 0)

  114.         return "{dpf_tuid_processor}";

  115.     if (std::memcmp(iid, dpf_tuid_view, sizeof(dpf_tuid)) == 0)

  116.         return "{dpf_tuid_view}";

  117. 

  118.     static char buf[46];

  119.     std::snprintf(buf, sizeof(buf), "{0x%08X,0x%08X,0x%08X,0x%08X}",

  120.                   (uint32_t)d_cconst(iid[ 0], iid[ 1], iid[ 2], iid[ 3]),

  121.                   (uint32_t)d_cconst(iid[ 4], iid[ 5], iid[ 6], iid[ 7]),

  122.                   (uint32_t)d_cconst(iid[ 8], iid[ 9], iid[10], iid[11]),

  123.                   (uint32_t)d_cconst(iid[12], iid[13], iid[14], iid[15]));

  124.     return buf;

  125. }

  126. 

  127. // --------------------------------------------------------------------------------------------------------------------

  128. 

  129. static void strncpy(char* const dst, const char* const src, const size_t size)

  130. {

  131.     DISTRHO_SAFE_ASSERT_RETURN(size > 0,);

  132. 

  133.     if (const size_t len = std::min(std::strlen(src), size-1U))

  134.     {

  135.         std::memcpy(dst, src, len);

  136.         dst[len] = '\0';

  137.     }

  138.     else

  139.     {

  140.         dst[0] = '\0';

  141.     }

  142. }

  143. 

  144. static void strncpy_utf16(int16_t* const dst, const char* const src, const size_t size)

  145. {

  146.     DISTRHO_SAFE_ASSERT_RETURN(size > 0,);

  147. 

  148.     if (const size_t len = std::min(std::strlen(src), size-1U))

  149.     {

  150.         for (size_t i=0; i<len; ++i)

  151.         {

  152.             // skip non-ascii chars

  153.             if ((uint8_t)src[i] >= 0x80)

  154.                 continue;

  155. 

  156.             dst[i] = src[i];

  157.         }

  158.         dst[len] = 0;

  159.     }

  160.     else

  161.     {

  162.         dst[0] = 0;

  163.     }

  164. }

  165. 

  166. // --------------------------------------------------------------------------------------------------------------------

  167. 

  168. template<typename T, const char* const format>

  169. static void snprintf_t(char* const dst, const T value, const size_t size)

  170. {

  171.     DISTRHO_SAFE_ASSERT_RETURN(size > 0,);

  172.     std::snprintf(dst, size-1, format, value);

  173.     dst[size-1] = '\0';

  174. }

  175. 

  176. template<typename T, const char* const format>

  177. static void snprintf_utf16_t(int16_t* const dst, const T value, const size_t size)

  178. {

  179.     DISTRHO_SAFE_ASSERT_RETURN(size > 0,);

  180. 

  181.     char* const tmpbuf = (char*)std::malloc(size);

  182.     DISTRHO_SAFE_ASSERT_RETURN(tmpbuf != nullptr,);

  183. 

  184.     std::snprintf(tmpbuf, size-1, format, value);

  185.     tmpbuf[size-1] = '\0';

  186. 

  187.     strncpy_utf16(dst, tmpbuf, size);

  188.     std::free(tmpbuf);

  189. }

  190. 

  191. static constexpr const char format_i32[] = "%d";

  192. static constexpr const char format_f32[] = "%f";

  193. static constexpr const char format_u32[] = "%u";

  194. 

  195. static constexpr void (*const snprintf_u32)(char*, uint32_t, size_t) = snprintf_t<uint32_t, format_u32>;

  196. static constexpr void (*const snprintf_f32_utf16)(int16_t*, float, size_t) = snprintf_utf16_t<float, format_f32>;

  197. static constexpr void (*const snprintf_u32_utf16)(int16_t*, uint32_t, size_t) = snprintf_utf16_t<uint32_t, format_u32>;

  198. 

  199. // --------------------------------------------------------------------------------------------------------------------

  200. 

  201. class PluginVst3

  202. {

  203.     /* buses: we provide 1 for the main audio (if there is any) plus 1 for each sidechain or cv port.

  204.      * Main audio comes first, if available.

  205.      * Then sidechain, also if available.

  206.      * And finally each CV port individually.

  207.      *

  208.      * MIDI will have a single bus, nothing special there.

  209.      */

  210.     struct BusInfo {

  211.         uint8_t audio = 0;     // either 0 or 1

  212.         uint8_t sidechain = 0; // either 0 or 1

  213.         uint32_t numMainAudio = 0;

  214.         uint32_t numSidechain = 0;

  215.         uint32_t numCV = 0;

  216.     } inputBuses, outputBuses;

  217. 

  218. public:

  219.     PluginVst3()

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

  221.           fComponentHandler(nullptr),

  222.           fComponentHandlerArg(nullptr)

  223. #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  224.         , fHostEventOutputHandle(nullptr)

  225. #endif

  226.     {

  227. #if DISTRHO_PLUGIN_NUM_INPUTS > 0

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

  229.         {

  230.             const uint32_t hints = fPlugin.getAudioPortHints(true, i);

  231. 

  232.             if (hints & kAudioPortIsCV)

  233.                 ++inputBuses.numCV;

  234.             else

  235.                 ++inputBuses.numMainAudio;

  236. 

  237.             if (hints & kAudioPortIsSidechain)

  238.                 ++inputBuses.numSidechain;

  239.         }

  240. 

  241.         if (inputBuses.numMainAudio != 0)

  242.             inputBuses.audio = 1;

  243.         if (inputBuses.numSidechain != 0)

  244.             inputBuses.sidechain = 1;

  245. 

  246.         uint32_t cvInputBusId = 0;

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

  248.         {

  249.             AudioPortWithBusId& port(fPlugin.getAudioPort(true, i));

  250. 

  251.             if (port.hints & kAudioPortIsCV)

  252.                 port.busId = inputBuses.audio + inputBuses.sidechain + cvInputBusId++;

  253.             else if (port.hints & kAudioPortIsSidechain)

  254.                 port.busId = 1;

  255.             else

  256.                 port.busId = 0;

  257.         }

  258. #endif

  259. #if DISTRHO_PLUGIN_NUM_OUTPUTS > 0

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

  261.         {

  262.             const uint32_t hints = fPlugin.getAudioPortHints(false, i);

  263. 

  264.             if (hints & kAudioPortIsCV)

  265.                 ++outputBuses.numCV;

  266.             else

  267.                 ++outputBuses.numMainAudio;

  268. 

  269.             if (hints & kAudioPortIsSidechain)

  270.                 ++outputBuses.numSidechain;

  271.         }

  272. 

  273.         if (outputBuses.numMainAudio != 0)

  274.             outputBuses.audio = 1;

  275.         if (outputBuses.numSidechain != 0)

  276.             outputBuses.sidechain = 1;

  277. 

  278.         uint32_t cvOutputBusId = 0;

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

  280.         {

  281.             AudioPortWithBusId& port(fPlugin.getAudioPort(false, i));

  282. 

  283.             if (port.hints & kAudioPortIsCV)

  284.                 port.busId = outputBuses.audio + outputBuses.sidechain + cvOutputBusId++;

  285.             else if (port.hints & kAudioPortIsSidechain)

  286.                 port.busId = 1;

  287.             else

  288.                 port.busId = 0;

  289.         }

  290. #endif

  291.     }

  292. 

  293.     // ----------------------------------------------------------------------------------------------------------------

  294.     // stuff called for UI creation

  295. 

  296.     void* getInstancePointer() const noexcept

  297.     {

  298.         return fPlugin.getInstancePointer();

  299.     }

  300. 

  301.     double getSampleRate() const noexcept

  302.     {

  303.         return fPlugin.getSampleRate();

  304.     }

  305. 

  306.     // ----------------------------------------------------------------------------------------------------------------

  307.     // v3_component interface calls

  308. 

  309.     int32_t getBusCount(const int32_t mediaType, const int32_t busDirection) const noexcept

  310.     {

  311.         switch (mediaType)

  312.         {

  313.         case V3_AUDIO:

  314.             if (busDirection == V3_INPUT)

  315.                 return inputBuses.audio + inputBuses.sidechain + inputBuses.numCV;

  316.             if (busDirection == V3_OUTPUT)

  317.                 return outputBuses.audio + outputBuses.sidechain + outputBuses.numCV;

  318.             break;

  319.         case V3_EVENT:

  320. #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  321.             if (busDirection == V3_INPUT)

  322.                 return 1;

  323. #endif

  324. #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  325.             if (busDirection == V3_OUTPUT)

  326.                 return 1;

  327. #endif

  328.             break;

  329.         }

  330. 

  331.         return 0;

  332.     }

  333. 

  334.     v3_result getBusInfo(const int32_t mediaType,

  335.                          const int32_t busDirection,

  336.                          const int32_t busIndex,

  337.                          v3_bus_info* const info) const

  338.     {

  339.         DISTRHO_SAFE_ASSERT_INT_RETURN(mediaType == V3_AUDIO || mediaType == V3_EVENT, mediaType, V3_INVALID_ARG);

  340.         DISTRHO_SAFE_ASSERT_INT_RETURN(busDirection == V3_INPUT || busDirection == V3_OUTPUT, busDirection, V3_INVALID_ARG);

  341.         DISTRHO_SAFE_ASSERT_INT_RETURN(busIndex >= 0, busIndex, V3_INVALID_ARG);

  342. 

  343. #if DISTRHO_PLUGIN_NUM_INPUTS+DISTRHO_PLUGIN_NUM_OUTPUTS > 0 || DISTRHO_PLUGIN_WANT_MIDI_INPUT || DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  344.         const uint32_t busId = static_cast<uint32_t>(busIndex);

  345. #endif

  346. 

  347.         if (mediaType == V3_AUDIO)

  348.         {

  349.            #if DISTRHO_PLUGIN_NUM_INPUTS+DISTRHO_PLUGIN_NUM_OUTPUTS > 0

  350.             int32_t numChannels;

  351.             v3_bus_flags flags;

  352.             v3_bus_types busType;

  353.             v3_str_128 busName = {};

  354. 

  355.             if (busDirection == V3_INPUT)

  356.             {

  357.                #if DISTRHO_PLUGIN_NUM_INPUTS > 0

  358.                 switch (busId)

  359.                 {

  360.                 case 0:

  361.                     if (inputBuses.audio)

  362.                     {

  363.                         numChannels = inputBuses.numMainAudio;

  364.                         busType = V3_MAIN;

  365.                         flags = V3_DEFAULT_ACTIVE;

  366.                         break;

  367.                     }

  368.                 // fall-through

  369.                 case 1:

  370.                     if (inputBuses.sidechain)

  371.                     {

  372.                         numChannels = inputBuses.numSidechain;

  373.                         busType = V3_AUX;

  374.                         flags = v3_bus_flags(0);

  375.                         break;

  376.                     }

  377.                 // fall-through

  378.                 default:

  379.                     numChannels = 1;

  380.                     busType = V3_AUX;

  381.                     flags = V3_IS_CONTROL_VOLTAGE;

  382.                     break;

  383.                 }

  384. 

  385.                 if (busType == V3_MAIN)

  386.                 {

  387.                     strncpy_utf16(busName, "Audio Input", 128);

  388.                 }

  389.                 else

  390.                 {

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

  392.                     {

  393.                         const AudioPortWithBusId& port(fPlugin.getAudioPort(true, i));

  394. 

  395.                         // TODO find port group name

  396.                         if (port.busId == busId)

  397.                         {

  398.                             strncpy_utf16(busName, port.name, 128);

  399.                             break;

  400.                         }

  401.                     }

  402.                 }

  403.                #else

  404.                 return V3_INVALID_ARG;

  405.                #endif // DISTRHO_PLUGIN_NUM_INPUTS

  406.             }

  407.             else

  408.             {

  409.                #if DISTRHO_PLUGIN_NUM_OUTPUTS > 0

  410.                 switch (busId)

  411.                 {

  412.                 case 0:

  413.                     if (outputBuses.audio)

  414.                     {

  415.                         numChannels = outputBuses.numMainAudio;

  416.                         busType = V3_MAIN;

  417.                         flags = V3_DEFAULT_ACTIVE;

  418.                         break;

  419.                     }

  420.                 // fall-through

  421.                 case 1:

  422.                     if (outputBuses.sidechain)

  423.                     {

  424.                         numChannels = outputBuses.numSidechain;

  425.                         busType = V3_AUX;

  426.                         flags = v3_bus_flags(0);

  427.                         break;

  428.                     }

  429.                 // fall-through

  430.                 default:

  431.                     numChannels = 1;

  432.                     busType = V3_AUX;

  433.                     flags = V3_IS_CONTROL_VOLTAGE;

  434.                     break;

  435.                 }

  436. 

  437.                 if (busType == V3_MAIN)

  438.                 {

  439.                     strncpy_utf16(busName, "Audio Output", 128);

  440.                 }

  441.                 else

  442.                 {

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

  444.                     {

  445.                         const AudioPortWithBusId& port(fPlugin.getAudioPort(false, i));

  446. 

  447.                         // TODO find port group name

  448.                         if (port.busId == busId)

  449.                         {

  450.                             strncpy_utf16(busName, port.name, 128);

  451.                             break;

  452.                         }

  453.                     }

  454.                 }

  455.                #else

  456.                 return V3_INVALID_ARG;

  457.                #endif // DISTRHO_PLUGIN_NUM_OUTPUTS

  458.             }

  459. 

  460.             std::memset(info, 0, sizeof(v3_bus_info));

  461.             info->media_type = V3_AUDIO;

  462.             info->direction = busDirection;

  463.             info->channel_count = numChannels;

  464.             std::memcpy(info->bus_name, busName, sizeof(busName));

  465.             info->bus_type = busType;

  466.             info->flags = flags;

  467.             return V3_OK;

  468.            #else

  469.             return V3_INVALID_ARG;

  470.            #endif // DISTRHO_PLUGIN_NUM_INPUTS+DISTRHO_PLUGIN_NUM_OUTPUTS

  471.         }

  472.         else

  473.         {

  474.             if (busDirection == V3_INPUT)

  475.             {

  476.                #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  477.                 DISTRHO_SAFE_ASSERT_RETURN(busId == 0, V3_INVALID_ARG);

  478.                #else

  479.                 return V3_INVALID_ARG;

  480.                #endif

  481.             }

  482.             else

  483.             {

  484.                #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  485.                 DISTRHO_SAFE_ASSERT_RETURN(busId == 0, V3_INVALID_ARG);

  486.                #else

  487.                 return V3_INVALID_ARG;

  488.                #endif

  489.             }

  490.             info->media_type = V3_EVENT;

  491.             info->direction = busDirection;

  492.             info->channel_count = 1;

  493.             strncpy_utf16(info->bus_name, busDirection == V3_INPUT ? "Event/MIDI Input"

  494.                                                                    : "Event/MIDI Output", 128);

  495.             info->bus_type = V3_MAIN;

  496.             info->flags = V3_DEFAULT_ACTIVE;

  497.             return V3_OK;

  498.         }

  499.     }

  500. 

  501.     v3_result getRoutingInfo(v3_routing_info*, v3_routing_info*)

  502.     {

  503.         // TODO

  504.         return V3_NOT_IMPLEMENTED;

  505.     }

  506. 

  507.     v3_result activateBus(const int32_t /* mediaType */,

  508.                           const int32_t /* busDirection */,

  509.                           const int32_t /* busIndex */,

  510.                           const bool /* state */)

  511.     {

  512.         // TODO, returning ok to make bitwig happy

  513.         return V3_OK;

  514.     }

  515. 

  516.     v3_result setActive(const bool active)

  517.     {

  518.         if (active)

  519.             fPlugin.activate();

  520.         else

  521.             fPlugin.deactivateIfNeeded();

  522. 

  523.         return V3_OK;

  524.     }

  525. 

  526.     /* state: we pack pairs of key-value strings each separated by a null/zero byte.

  527.      * states come first, and then parameters. parameters are simply converted to/from strings and floats.

  528.      * the parameter symbol is used as the "key", so it is possible to reorder them or even remove and add safely.

  529.      * the number of states must remain constant though.

  530.      */

  531.     v3_result setState(v3_bstream* const stream, void* arg)

  532.     {

  533. #if DISTRHO_PLUGIN_WANT_STATE

  534.         // TODO

  535. #endif

  536. 

  537.         if (const uint32_t paramCount = fPlugin.getParameterCount())

  538.         {

  539.             char buffer[32], orig;

  540.             String key, value;

  541.             v3_result res;

  542.             bool fillingKey = true;

  543. 

  544.             // temporarily set locale to "C" while converting floats

  545.             const ScopedSafeLocale ssl;

  546. 

  547.             for (int32_t pos = 0, read;; pos += read)

  548.             {

  549.                 std::memset(buffer, '\xff', sizeof(buffer));

  550.                 res = stream->read(arg, buffer, sizeof(buffer)-1, &read);

  551.                 DISTRHO_SAFE_ASSERT_INT_RETURN(res == V3_OK, res, res);

  552.                 DISTRHO_SAFE_ASSERT_INT_RETURN(read > 0, read, V3_INTERNAL_ERR);

  553. 

  554.                 for (int32_t i = 0; i < read; ++i)

  555.                 {

  556.                     if (buffer[i] == '\0' && pos == 0 && i == 0)

  557.                         continue;

  558. 

  559.                     orig = buffer[read];

  560.                     buffer[read] = '\0';

  561. 

  562.                     if (fillingKey)

  563.                         key += buffer + i;

  564.                     else

  565.                         value += buffer + i;

  566. 

  567.                     i += std::strlen(buffer + i);

  568.                     buffer[read] = orig;

  569. 

  570.                     if (buffer[i] == '\0')

  571.                     {

  572.                         fillingKey = !fillingKey;

  573. 

  574.                         if (value.isNotEmpty())

  575.                         {

  576.                             // find parameter with this symbol, and set its value

  577.                             for (uint32_t j=0; j<paramCount; ++j)

  578.                             {

  579.                                 if (fPlugin.isParameterOutputOrTrigger(j))

  580.                                     continue;

  581.                                 if (fPlugin.getParameterSymbol(j) != key)

  582.                                     continue;

  583. 

  584.                                 fPlugin.setParameterValue(j, std::atof(value.buffer()));

  585.                                 break;

  586.                             }

  587. 

  588.                             key.clear();

  589.                             value.clear();

  590.                         }

  591. 

  592.                         if (buffer[i+1] == '\0')

  593.                             return V3_OK;

  594.                     }

  595.                 }

  596. 

  597.                 if (buffer[read] == '\0')

  598.                     return V3_OK;

  599.             }

  600.         }

  601. 

  602.         return V3_OK;

  603.     }

  604. 

  605.     v3_result getState(v3_bstream* const stream, void* arg)

  606.     {

  607.         const uint32_t paramCount = fPlugin.getParameterCount();

  608. #if DISTRHO_PLUGIN_WANT_STATE

  609.         const uint32_t stateCount = fPlugin.getStateCount();

  610. #else

  611.         const uint32_t stateCount = 0;

  612. #endif

  613. 

  614.         if (stateCount == 0 && paramCount == 0)

  615.         {

  616.             char buffer = '\0';

  617.             int32_t ignored;

  618.             return stream->write(arg, &buffer, 1, &ignored);

  619.         }

  620. 

  621.         String state;

  622. 

  623. #if DISTRHO_PLUGIN_WANT_FULL_STATE

  624.         /*

  625.         // Update current state

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

  627.         {

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

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

  630.         }

  631.         */

  632. #endif

  633. 

  634. #if DISTRHO_PLUGIN_WANT_STATE

  635.         /*

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

  637.         {

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

  639.             const String& value = cit->second;

  640. 

  641.             // join key and value

  642.             String tmpStr;

  643.             tmpStr  = key;

  644.             tmpStr += "\xff";

  645.             tmpStr += value;

  646.             tmpStr += "\xff";

  647. 

  648.             state += tmpStr;

  649.         }

  650.         */

  651. #endif

  652. 

  653.         if (paramCount != 0)

  654.         {

  655.             // add another separator

  656.             state += "\xff";

  657. 

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

  659.             {

  660.                 if (fPlugin.isParameterOutputOrTrigger(i))

  661.                     continue;

  662. 

  663.                 // join key and value

  664.                 String tmpStr;

  665.                 tmpStr  = fPlugin.getParameterSymbol(i);

  666.                 tmpStr += "\xff";

  667.                 tmpStr += String(fPlugin.getParameterValue(i));

  668.                 tmpStr += "\xff";

  669. 

  670.                 state += tmpStr;

  671.             }

  672.         }

  673. 

  674.         state.replace('\xff', '\0');

  675. 

  676.         // now saving state, carefully until host written bytes matches full state size

  677.         const char* buffer = state.buffer();

  678.         const int32_t size = static_cast<int32_t>(state.length())+1;

  679.         v3_result res;

  680. 

  681.         for (int32_t wrtntotal = 0, wrtn; wrtntotal < size; wrtntotal += wrtn)

  682.         {

  683.             wrtn = 0;

  684.             res = stream->write(arg, const_cast<char*>(buffer), size - wrtntotal, &wrtn);

  685. 

  686.             DISTRHO_SAFE_ASSERT_INT_RETURN(res == V3_OK, res, res);

  687.             DISTRHO_SAFE_ASSERT_INT_RETURN(wrtn > 0, wrtn, V3_INTERNAL_ERR);

  688.         }

  689. 

  690.         return V3_OK;

  691.     }

  692. 

  693.     // ----------------------------------------------------------------------------------------------------------------

  694.     // v3_bstream interface calls (for state support)

  695. 

  696.     v3_result read(void* /*buffer*/, int32_t /*num_bytes*/, int32_t* /*bytes_read*/)

  697.     {

  698.         // TODO

  699.         return V3_NOT_IMPLEMENTED;

  700.     }

  701. 

  702.     v3_result write(void* /*buffer*/, int32_t /*num_bytes*/, int32_t* /*bytes_written*/)

  703.     {

  704.         // TODO

  705.         return V3_NOT_IMPLEMENTED;

  706.     }

  707. 

  708.     v3_result seek(int64_t /*pos*/, int32_t /*seek_mode*/, int64_t* /*result*/)

  709.     {

  710.         // TODO

  711.         return V3_NOT_IMPLEMENTED;

  712.     }

  713. 

  714.     v3_result tell(int64_t* /*pos*/)

  715.     {

  716.         // TODO

  717.         return V3_NOT_IMPLEMENTED;

  718.     }

  719. 

  720.     // ----------------------------------------------------------------------------------------------------------------

  721.     // v3_audio_processor interface calls

  722. 

  723.     v3_result setBusArrangements(v3_speaker_arrangement*, int32_t, v3_speaker_arrangement*, int32_t)

  724.     {

  725.         // TODO

  726.         return V3_NOT_IMPLEMENTED;

  727.     }

  728. 

  729.     v3_result getBusArrangement(int32_t, int32_t, v3_speaker_arrangement*)

  730.     {

  731.         // TODO

  732.         return V3_NOT_IMPLEMENTED;

  733.     };

  734. 

  735.     uint32_t getLatencySamples() const noexcept

  736.     {

  737. #if DISTRHO_PLUGIN_WANT_LATENCY

  738.         return fPlugin.getLatency();

  739. #else

  740.         return 0;

  741. #endif

  742.     }

  743. 

  744.     v3_result setupProcessing(v3_process_setup* const setup)

  745.     {

  746.         DISTRHO_SAFE_ASSERT_RETURN(setup->symbolic_sample_size == V3_SAMPLE_32, V3_INVALID_ARG);

  747. 

  748.         const bool active = fPlugin.isActive();

  749.         fPlugin.deactivateIfNeeded();

  750. 

  751.         // TODO process_mode can be V3_REALTIME, V3_PREFETCH, V3_OFFLINE

  752. 

  753.         fPlugin.setSampleRate(setup->sample_rate, true);

  754.         fPlugin.setBufferSize(setup->max_block_size, true);

  755. 

  756.         if (active)

  757.             fPlugin.activate();

  758. 

  759.         // TODO create dummy buffer of max_block_size length, to use for disabled buses

  760. 

  761.         return V3_OK;

  762.     }

  763. 

  764.     v3_result setProcessing(const bool processing)

  765.     {

  766.         if (processing)

  767.         {

  768.             if (! fPlugin.isActive())

  769.                 fPlugin.activate();

  770.         }

  771.         else

  772.         {

  773.             fPlugin.deactivate();

  774.         }

  775. 

  776.         return V3_OK;

  777.     }

  778. 

  779.     v3_result process(v3_process_data* const data)

  780.     {

  781.         DISTRHO_SAFE_ASSERT_RETURN(data->symbolic_sample_size == V3_SAMPLE_32, V3_INVALID_ARG);

  782. 

  783.         if (! fPlugin.isActive())

  784.         {

  785.             // host has not activated the plugin yet, nasty!

  786.             fPlugin.activate();

  787.         }

  788. 

  789. #if DISTRHO_PLUGIN_WANT_TIMEPOS

  790.         if (v3_process_context* const ctx = data->ctx)

  791.         {

  792.             fTimePosition.playing   = ctx->state & V3_PROCESS_CTX_PLAYING;

  793.             fTimePosition.bbt.valid = ctx->state & (V3_PROCESS_CTX_TEMPO_VALID|V3_PROCESS_CTX_TIME_SIG_VALID);

  794. 

  795.             // ticksPerBeat is not possible with VST2

  796.             fTimePosition.bbt.ticksPerBeat = 1920.0;

  797. 

  798.             if (ctx->state & V3_PROCESS_CTX_CONT_TIME_VALID)

  799.                 fTimePosition.frame = ctx->continuous_time_in_samples;

  800.             else

  801.                 fTimePosition.frame = ctx->project_time_in_samples;

  802. 

  803.             if (ctx->state & V3_PROCESS_CTX_TEMPO_VALID)

  804.                 fTimePosition.bbt.beatsPerMinute = ctx->bpm;

  805.             else

  806.                 fTimePosition.bbt.beatsPerMinute = 120.0;

  807. 

  808.             if (ctx->state & (V3_PROCESS_CTX_PROJECT_TIME_VALID|V3_PROCESS_CTX_TIME_SIG_VALID))

  809.             {

  810.                 const double ppqPos    = std::abs(ctx->project_time_quarters);

  811.                 const int    ppqPerBar = ctx->time_sig_numerator * 4 / ctx->time_sig_denom;

  812.                 const double barBeats  = (std::fmod(ppqPos, ppqPerBar) / ppqPerBar) * ctx->time_sig_numerator;

  813.                 const double rest      =  std::fmod(barBeats, 1.0);

  814. 

  815.                 fTimePosition.bbt.bar         = static_cast<int32_t>(ppqPos) / ppqPerBar + 1;

  816.                 fTimePosition.bbt.beat        = static_cast<int32_t>(barBeats - rest + 0.5) + 1;

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

  818.                 fTimePosition.bbt.beatsPerBar = ctx->time_sig_numerator;

  819.                 fTimePosition.bbt.beatType    = ctx->time_sig_denom;

  820. 

  821.                 if (ctx->project_time_quarters < 0.0)

  822.                 {

  823.                     --fTimePosition.bbt.bar;

  824.                     fTimePosition.bbt.beat = ctx->time_sig_numerator - fTimePosition.bbt.beat + 1;

  825.                     fTimePosition.bbt.tick = fTimePosition.bbt.ticksPerBeat - fTimePosition.bbt.tick - 1;

  826.                 }

  827.             }

  828.             else

  829.             {

  830.                 fTimePosition.bbt.bar         = 1;

  831.                 fTimePosition.bbt.beat        = 1;

  832.                 fTimePosition.bbt.tick        = 0.0;

  833.                 fTimePosition.bbt.beatsPerBar = 4.0f;

  834.                 fTimePosition.bbt.beatType    = 4.0f;

  835.             }

  836. 

  837.             fTimePosition.bbt.barStartTick = fTimePosition.bbt.ticksPerBeat*

  838.                                              fTimePosition.bbt.beatsPerBar*

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

  840. 

  841.             fPlugin.setTimePosition(fTimePosition);

  842.         }

  843. #endif

  844. 

  845.         const float* inputs[DISTRHO_PLUGIN_NUM_INPUTS != 0 ? DISTRHO_PLUGIN_NUM_INPUTS : 1];

  846.         /* */ float* outputs[DISTRHO_PLUGIN_NUM_OUTPUTS != 0 ? DISTRHO_PLUGIN_NUM_OUTPUTS : 1];

  847. 

  848.         {

  849.             int32_t i = 0;

  850.             if (data->inputs != nullptr)

  851.             {

  852.                 for (; i < data->inputs->num_channels; ++i)

  853.                 {

  854.                     DISTRHO_SAFE_ASSERT_INT_BREAK(i < DISTRHO_PLUGIN_NUM_INPUTS, i);

  855.                     inputs[i] = data->inputs->channel_buffers_32[i];

  856.                 }

  857.             }

  858.             for (; i < std::max(1, DISTRHO_PLUGIN_NUM_INPUTS); ++i)

  859.                 inputs[i] = nullptr; // TODO use dummy buffer

  860.         }

  861. 

  862.         {

  863.             int32_t i = 0;

  864.             if (data->outputs != nullptr)

  865.             {

  866.                 for (; i < data->outputs->num_channels; ++i)

  867.                 {

  868.                     DISTRHO_SAFE_ASSERT_INT_BREAK(i < DISTRHO_PLUGIN_NUM_OUTPUTS, i);

  869.                     outputs[i] = data->outputs->channel_buffers_32[i];

  870.                 }

  871.             }

  872.             for (; i < std::max(1, DISTRHO_PLUGIN_NUM_OUTPUTS); ++i)

  873.                 outputs[i] = nullptr; // TODO use dummy buffer

  874.         }

  875. 

  876. #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  877.         fHostEventOutputHandle = data->output_events;

  878. #endif

  879. 

  880. #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  881.         uint32_t midiEventCount = 0;

  882. 

  883.         if (v3_event_list** const eventarg = data->input_events)

  884.         {

  885.             // offset struct by sizeof(v3_funknown), because of differences between C and C++

  886.             v3_event_list* const eventptr = (v3_event_list*)((uint8_t*)(*eventarg)+sizeof(v3_funknown));

  887. 

  888.             v3_event event;

  889.             for (uint32_t i = 0, count = eventptr->get_event_count(eventarg); i < count; ++i)

  890.             {

  891.                 if (eventptr->get_event(eventarg, i, &event) != V3_OK)

  892.                     break;

  893. 

  894.                 // check if event can be encoded as MIDI

  895.                 switch (event.type)

  896.                 {

  897.                 case V3_EVENT_NOTE_ON:

  898.                 case V3_EVENT_NOTE_OFF:

  899.                 // case V3_EVENT_DATA:

  900.                 case V3_EVENT_POLY_PRESSURE:

  901.                 // case V3_EVENT_NOTE_EXP_VALUE:

  902.                 // case V3_EVENT_NOTE_EXP_TEXT:

  903.                 // case V3_EVENT_CHORD:

  904.                 // case V3_EVENT_SCALE:

  905.                 case V3_EVENT_LEGACY_MIDI_CC_OUT:

  906.                     break;

  907.                 default:

  908.                     continue;

  909.                 }

  910. 

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

  912.                 midiEvent.frame = event.sample_offset;

  913. 

  914.                 // encode event as MIDI

  915.                 switch (event.type)

  916.                 {

  917.                 case V3_EVENT_NOTE_ON:

  918.                     midiEvent.size = 3;

  919.                     midiEvent.data[0] = 0x90 | (event.note_on.channel & 0xf);

  920.                     midiEvent.data[1] = event.note_on.pitch;

  921.                     midiEvent.data[2] = std::max(0, std::min(127, (int)(event.note_on.velocity * 127)));

  922.                     midiEvent.data[3] = 0;

  923.                     break;

  924.                 case V3_EVENT_NOTE_OFF:

  925.                     midiEvent.size = 3;

  926.                     midiEvent.data[0] = 0x80 | (event.note_off.channel & 0xf);

  927.                     midiEvent.data[1] = event.note_off.pitch;

  928.                     midiEvent.data[2] = std::max(0, std::min(127, (int)(event.note_off.velocity * 127)));

  929.                     midiEvent.data[3] = 0;

  930.                     break;

  931.                 case V3_EVENT_POLY_PRESSURE:

  932.                     midiEvent.size = 3;

  933.                     midiEvent.data[0] = 0xA0 | (event.poly_pressure.channel & 0xf);

  934.                     midiEvent.data[1] = event.poly_pressure.pitch;

  935.                     midiEvent.data[2] = std::max(0, std::min(127, (int)(event.poly_pressure.pressure * 127)));

  936.                     midiEvent.data[3] = 0;

  937.                     break;

  938.                 case V3_EVENT_LEGACY_MIDI_CC_OUT:

  939.                     midiEvent.size = 3;

  940.                     midiEvent.data[0] = 0xB0 | (event.midi_cc_out.channel & 0xf);

  941.                     midiEvent.data[1] = event.midi_cc_out.cc_number;

  942.                     midiEvent.data[2] = event.midi_cc_out.value;

  943.                     midiEvent.data[3] = 0;

  944.                     // midiEvent.data[3] = event.midi_cc_out.value2; // TODO check when size should be 4

  945.                     break;

  946.                 default:

  947.                     midiEvent.size = 0;

  948.                     break;

  949.                 }

  950. 

  951.                 if (midiEventCount == kMaxMidiEvents)

  952.                     break;

  953.             }

  954.         }

  955. 

  956.         fPlugin.run(inputs, outputs, data->nframes, fMidiEvents, midiEventCount);

  957. #else

  958.         fPlugin.run(inputs, outputs, data->nframes);

  959. #endif

  960. 

  961. #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  962.         fHostEventOutputHandle = nullptr;

  963. #endif

  964. 

  965.         // TODO updateParameterOutputsAndTriggers()

  966. 

  967.         return V3_OK;

  968.     }

  969. 

  970.     uint32_t getTailSamples() const noexcept

  971.     {

  972.         return 0;

  973.     }

  974. 

  975.     // ----------------------------------------------------------------------------------------------------------------

  976.     // v3_edit_controller interface calls

  977. 

  978. #if 0

  979.     v3_result setComponentState(v3_bstream*, void*)

  980.     {

  981.         // TODO

  982.         return V3_NOT_IMPLEMENTED;

  983.     }

  984. 

  985.     v3_result setState(v3_bstream*, void*)

  986.     {

  987.         // TODO

  988.         return V3_NOT_IMPLEMENTED;

  989.     }

  990. 

  991.     v3_result getState(v3_bstream*, void*)

  992.     {

  993.         // TODO

  994.         return V3_NOT_IMPLEMENTED;

  995.     }

  996. #endif

  997. 

  998.     int32_t getParameterCount() const noexcept

  999.     {

  1000.         return fPlugin.getParameterCount();

  1001.     }

  1002. 

  1003.     v3_result getParameterInfo(const int32_t index, v3_param_info* const info) const noexcept

  1004.     {

  1005.         DISTRHO_SAFE_ASSERT_RETURN(index >= 0, V3_INVALID_ARG);

  1006. 

  1007.         const uint32_t uindex = static_cast<uint32_t>(index);

  1008.         DISTRHO_SAFE_ASSERT_RETURN(uindex < fPlugin.getParameterCount(), V3_INVALID_ARG);

  1009. 

  1010.         // set up flags

  1011.         int32_t flags = 0;

  1012. 

  1013.         const auto desig = fPlugin.getParameterDesignation(index);

  1014.         const auto hints = fPlugin.getParameterHints(index);

  1015. 

  1016.         const ParameterRanges& ranges(fPlugin.getParameterRanges(index));

  1017. 

  1018.         switch (desig)

  1019.         {

  1020.         case kParameterDesignationNull:

  1021.             break;

  1022.         case kParameterDesignationBypass:

  1023.             flags |= V3_PARAM_IS_BYPASS;

  1024.             break;

  1025.         }

  1026. 

  1027.         if (hints & kParameterIsAutomable)

  1028.             flags |= V3_PARAM_CAN_AUTOMATE;

  1029.         if (hints & kParameterIsOutput)

  1030.             flags |= V3_PARAM_READ_ONLY;

  1031.         // TODO V3_PARAM_IS_LIST

  1032. 

  1033.         // set up step_count

  1034.         int32_t step_count = 0;

  1035. 

  1036.         if (hints & kParameterIsBoolean)

  1037.             step_count = 1;

  1038.         if ((hints & kParameterIsInteger) && ranges.max - ranges.min > 1)

  1039.             step_count = ranges.max - ranges.min - 1;

  1040. 

  1041.         std::memset(info, 0, sizeof(v3_param_info));

  1042.         info->param_id = index;

  1043.         info->flags = flags;

  1044.         info->step_count = step_count;

  1045.         info->default_normalised_value = ranges.getNormalizedValue(ranges.def);

  1046.         // int32_t unit_id;

  1047.         strncpy_utf16(info->title,       fPlugin.getParameterName(index), 128);

  1048.         strncpy_utf16(info->short_title, fPlugin.getParameterShortName(index), 128);

  1049.         strncpy_utf16(info->units,       fPlugin.getParameterUnit(index), 128);

  1050.         return V3_OK;

  1051.     }

  1052. 

  1053.     v3_result getParameterStringForValue(const v3_param_id index, const double normalised, v3_str_128 output)

  1054.     {

  1055.         DISTRHO_SAFE_ASSERT_RETURN(index < fPlugin.getParameterCount(), V3_INVALID_ARG);

  1056. 

  1057.         snprintf_f32_utf16(output, fPlugin.getParameterRanges(index).getUnnormalizedValue(normalised), 128);

  1058.         return V3_OK;

  1059.     }

  1060. 

  1061.     v3_result getParameterValueForString(const v3_param_id index, int16_t*, double*)

  1062.     {

  1063.         DISTRHO_SAFE_ASSERT_RETURN(index < fPlugin.getParameterCount(), V3_INVALID_ARG);

  1064. 

  1065.         // TODO

  1066.         return V3_NOT_IMPLEMENTED;

  1067.     };

  1068. 

  1069.     double normalisedParameterToPlain(const v3_param_id index, const double normalised)

  1070.     {

  1071.         DISTRHO_SAFE_ASSERT_RETURN(index < fPlugin.getParameterCount(), V3_INVALID_ARG);

  1072. 

  1073.         return fPlugin.getParameterRanges(index).getUnnormalizedValue(normalised);

  1074.     };

  1075. 

  1076.     double plainParameterToNormalised(const v3_param_id index, const double plain)

  1077.     {

  1078.         DISTRHO_SAFE_ASSERT_RETURN(index < fPlugin.getParameterCount(), V3_INVALID_ARG);

  1079. 

  1080.         return fPlugin.getParameterRanges(index).getNormalizedValue(plain);

  1081.     };

  1082. 

  1083.     double getParameterNormalized(const v3_param_id index)

  1084.     {

  1085.         DISTRHO_SAFE_ASSERT_RETURN(index < fPlugin.getParameterCount(), 0.0);

  1086. 

  1087.         const float value = fPlugin.getParameterValue(index);

  1088.         return fPlugin.getParameterRanges(index).getNormalizedValue(value);

  1089.     }

  1090. 

  1091.     v3_result setParameterNormalized(const v3_param_id index, const double value)

  1092.     {

  1093.         DISTRHO_SAFE_ASSERT_RETURN(index < fPlugin.getParameterCount(), V3_INVALID_ARG);

  1094. 

  1095.         const uint32_t hints = fPlugin.getParameterHints(index);

  1096.         const ParameterRanges& ranges(fPlugin.getParameterRanges(index));

  1097. 

  1098.         float realValue = ranges.getUnnormalizedValue(value);

  1099. 

  1100.         if (hints & kParameterIsBoolean)

  1101.         {

  1102.             const float midRange = ranges.min + (ranges.max - ranges.min) / 2.0f;

  1103.             realValue = realValue > midRange ? ranges.max : ranges.min;

  1104.         }

  1105. 

  1106.         if (hints & kParameterIsInteger)

  1107.         {

  1108.             realValue = std::round(realValue);

  1109.         }

  1110. 

  1111.         fPlugin.setParameterValue(index, realValue);

  1112.         return V3_OK;

  1113.     }

  1114. 

  1115.     v3_result setComponentHandler(v3_component_handler* const handler, void* const arg) noexcept

  1116.     {

  1117.         fComponentHandler = handler;

  1118.         fComponentHandlerArg = arg;

  1119.         return V3_OK;

  1120.     }

  1121. 

  1122.     // ----------------------------------------------------------------------------------------------------------------

  1123. 

  1124. private:

  1125.     // Plugin

  1126.     PluginExporter fPlugin;

  1127. 

  1128.     // VST3 stuff

  1129.     v3_component_handler* fComponentHandler;

  1130.     void*                 fComponentHandlerArg;

  1131. 

  1132.     // Temporary data

  1133. #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1134.     MidiEvent fMidiEvents[kMaxMidiEvents];

  1135. #endif

  1136. #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  1137.     v3_event_list** fHostEventOutputHandle;

  1138. #endif

  1139. #if DISTRHO_PLUGIN_WANT_TIMEPOS

  1140.     TimePosition fTimePosition;

  1141. #endif

  1142. 

  1143. #if DISTRHO_PLUGIN_WANT_PARAMETER_VALUE_CHANGE_REQUEST

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

  1145.     {

  1146.         DISTRHO_SAFE_ASSERT_RETURN(fComponentHandler != nullptr, false);

  1147.         DISTRHO_SAFE_ASSERT_RETURN(fComponentHandlerArg != nullptr, false);

  1148. 

  1149.         if (fComponentHandler->begin_edit(fComponentHandlerArg, index) != V3_OK)

  1150.             return false;

  1151. 

  1152.         const double normalized = fPlugin.getParameterRanges(index).getNormalizedValue(value);

  1153.         const bool ret = fComponentHandler->perform_edit(fComponentHandlerArg, index, normalized) == V3_OK;

  1154. 

  1155.         fComponentHandler->end_edit(fComponentHandlerArg, index);

  1156.         return ret;

  1157.     }

  1158. 

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

  1160.     {

  1161.         return ((PluginVst3*)ptr)->requestParameterValueChange(index, value);

  1162.     }

  1163. #endif

  1164. 

  1165. #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  1166.     bool writeMidi(const MidiEvent& midiEvent)

  1167.     {

  1168.         DISTRHO_CUSTOM_SAFE_ASSERT_ONCE_RETURN("MIDI output unsupported", fHostEventOutputHandle != nullptr, false);

  1169. 

  1170.         v3_event event;

  1171.         std::memset(&event, 0, sizeof(event));

  1172.         event.sample_offset = midiEvent.frame;

  1173. 

  1174.         const uint8_t* const data = midiEvent.size > MidiEvent::kDataSize ? midiEvent.dataExt : midiEvent.data;

  1175. 

  1176.         switch (data[0] & 0xf0)

  1177.         {

  1178.         case 0x80:

  1179.             event.type = V3_EVENT_NOTE_OFF;

  1180.             event.note_off.channel = data[0] & 0xf;

  1181.             event.note_off.pitch = data[1];

  1182.             event.note_off.velocity = (float)data[2] / 127.0f;

  1183.             // int32_t note_id;

  1184.             // float tuning;

  1185.             break;

  1186.         case 0x90:

  1187.             event.type = V3_EVENT_NOTE_ON;

  1188.             event.note_on.channel = data[0] & 0xf;

  1189.             event.note_on.pitch = data[1];

  1190.             // float tuning;

  1191.             event.note_on.velocity = (float)data[2] / 127.0f;

  1192.             // int32_t length;

  1193.             // int32_t note_id;

  1194.             break;

  1195.         case 0xA0:

  1196.             event.type = V3_EVENT_POLY_PRESSURE;

  1197.             event.poly_pressure.channel = data[0] & 0xf;

  1198.             event.poly_pressure.pitch = data[1];

  1199.             event.poly_pressure.pressure = (float)data[2] / 127.0f;

  1200.             // int32_t note_id;

  1201.             break;

  1202.         case 0xB0:

  1203.             event.type = V3_EVENT_LEGACY_MIDI_CC_OUT;

  1204.             event.midi_cc_out.channel = data[0] & 0xf;

  1205.             event.midi_cc_out.cc_number = data[1];

  1206.             event.midi_cc_out.value = data[2];

  1207.             event.midi_cc_out.value2 = midiEvent.size == 4 ? data[3] : 0;

  1208.             break;

  1209.         default:

  1210.             return true;

  1211.         }

  1212. 

  1213.         // offset struct by sizeof(v3_funknown), because of differences between C and C++

  1214.         v3_event_list* const hostptr = (v3_event_list*)((uint8_t*)(*fHostEventOutputHandle)+sizeof(v3_funknown));

  1215. 

  1216.         return hostptr->add_event(fHostEventOutputHandle, &event) == V3_OK;

  1217.     }

  1218. 

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

  1220.     {

  1221.         return ((PluginVst3*)ptr)->writeMidi(midiEvent);

  1222.     }

  1223. #endif

  1224. 

  1225. };

  1226. 

  1227. #if DISTRHO_PLUGIN_HAS_UI

  1228. // --------------------------------------------------------------------------------------------------------------------

  1229. // dpf_plugin_view_create (called from DSP side)

  1230. 

  1231. v3_funknown** dpf_plugin_view_create(void* instancePointer, double sampleRate);

  1232. #endif

  1233. 

  1234. // --------------------------------------------------------------------------------------------------------------------

  1235. // dpf_edit_controller

  1236. 

  1237. struct v3_edit_controller_cpp : v3_funknown {

  1238.     v3_plugin_base base;

  1239.     v3_edit_controller controller;

  1240. };

  1241. 

  1242. struct dpf_edit_controller : v3_edit_controller_cpp {

  1243.     std::atomic<int> refcounter;

  1244.     ScopedPointer<dpf_edit_controller>* self;

  1245.     ScopedPointer<PluginVst3>& vst3;

  1246.     bool initialized;

  1247. 

  1248.     dpf_edit_controller(ScopedPointer<dpf_edit_controller>* const s, ScopedPointer<PluginVst3>& v)

  1249.         : refcounter(1),

  1250.           self(s),

  1251.           vst3(v),

  1252.           initialized(false)

  1253.     {

  1254.         static const uint8_t* kSupportedInterfaces[] = {

  1255.             v3_funknown_iid,

  1256.             v3_edit_controller_iid

  1257.         };

  1258. 

  1259.         // ------------------------------------------------------------------------------------------------------------

  1260.         // v3_funknown

  1261. 

  1262.         query_interface = []V3_API(void* self, const v3_tuid iid, void** iface) -> v3_result

  1263.         {

  1264.             d_stdout("dpf_edit_controller::query_interface            => %p %s %p", self, tuid2str(iid), iface);

  1265.             *iface = NULL;

  1266.             DISTRHO_SAFE_ASSERT_RETURN(self != nullptr, V3_NO_INTERFACE);

  1267. 

  1268.             for (const uint8_t* interface_iid : kSupportedInterfaces)

  1269.             {

  1270.                 if (v3_tuid_match(interface_iid, iid))

  1271.                 {

  1272.                     *iface = self;

  1273.                     return V3_OK;

  1274.                 }

  1275.             }

  1276. 

  1277.             return V3_NO_INTERFACE;

  1278.         };

  1279. 

  1280.         ref = []V3_API(void* self) -> uint32_t

  1281.         {

  1282.             d_stdout("dpf_edit_controller::ref                        => %p", self);

  1283.             dpf_edit_controller* const controller = *(dpf_edit_controller**)self;

  1284.             DISTRHO_SAFE_ASSERT_RETURN(controller != nullptr, 0);

  1285. 

  1286.             return ++controller->refcounter;

  1287.         };

  1288. 

  1289.         unref = []V3_API(void* self) -> uint32_t

  1290.         {

  1291.             d_stdout("dpf_edit_controller::unref                      => %p", self);

  1292.             dpf_edit_controller* const controller = *(dpf_edit_controller**)self;

  1293.             DISTRHO_SAFE_ASSERT_RETURN(controller != nullptr, 0);

  1294. 

  1295.             if (const int refcounter = --controller->refcounter)

  1296.                 return refcounter;

  1297. 

  1298.             *(dpf_edit_controller**)self = nullptr;

  1299.             *controller->self = nullptr;

  1300.             return 0;

  1301.         };

  1302. 

  1303.         // ------------------------------------------------------------------------------------------------------------

  1304.         // v3_plugin_base

  1305. 

  1306.         base.initialise = []V3_API(void* self, struct v3_plugin_base::v3_funknown *context) -> v3_result

  1307.         {

  1308.             d_stdout("dpf_edit_controller::initialise                 => %p %p", self, context);

  1309.             dpf_edit_controller* const controller = *(dpf_edit_controller**)self;

  1310.             DISTRHO_SAFE_ASSERT_RETURN(controller != nullptr, V3_NOT_INITIALISED);

  1311. 

  1312.             const bool initialized = controller->initialized;

  1313.             DISTRHO_SAFE_ASSERT_RETURN(! initialized, V3_INVALID_ARG);

  1314. 

  1315.             controller->initialized = true;

  1316.             return V3_OK;

  1317.         };

  1318. 

  1319.         base.terminate = []V3_API(void* self) -> v3_result

  1320.         {

  1321.             d_stdout("dpf_edit_controller::terminate                  => %p", self);

  1322.             dpf_edit_controller* const controller = *(dpf_edit_controller**)self;

  1323.             DISTRHO_SAFE_ASSERT_RETURN(controller != nullptr, V3_NOT_INITIALISED);

  1324. 

  1325.             const bool initialized = controller->initialized;

  1326.             DISTRHO_SAFE_ASSERT_RETURN(initialized, V3_INVALID_ARG);

  1327. 

  1328.             controller->initialized = false;

  1329.             return V3_OK;

  1330.         };

  1331. 

  1332.         // ------------------------------------------------------------------------------------------------------------

  1333.         // v3_edit_controller

  1334. 

  1335.         controller.set_component_state = []V3_API(void* self, v3_bstream* stream) -> v3_result

  1336.         {

  1337.             d_stdout("dpf_edit_controller::set_component_state        => %p %p", self, stream);

  1338.             dpf_edit_controller* const controller = *(dpf_edit_controller**)self;

  1339.             DISTRHO_SAFE_ASSERT_RETURN(controller != nullptr, V3_NOT_INITIALISED);

  1340. 

  1341.             PluginVst3* const vst3 = controller->vst3;

  1342.             DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALISED);

  1343. 

  1344. #if 0

  1345.             // offset struct by sizeof(v3_funknown), because of differences between C and C++

  1346.             v3_bstream* const streamptr

  1347.                 = stream != nullptr ? (v3_bstream*)((uint8_t*)stream+sizeof(v3_funknown))

  1348.                                     : nullptr;

  1349. 

  1350.             return vst3->setComponentState(streamptr, stream);

  1351. #endif

  1352.             return V3_NOT_IMPLEMENTED;

  1353.         };

  1354. 

  1355.         controller.set_state = []V3_API(void* self, v3_bstream* stream) -> v3_result

  1356.         {

  1357.             d_stdout("dpf_edit_controller::set_state                  => %p %p", self, stream);

  1358.             dpf_edit_controller* const controller = *(dpf_edit_controller**)self;

  1359.             DISTRHO_SAFE_ASSERT_RETURN(controller != nullptr, V3_NOT_INITIALISED);

  1360. 

  1361.             PluginVst3* const vst3 = controller->vst3;

  1362.             DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALISED);

  1363. 

  1364. #if 0

  1365.             // offset struct by sizeof(v3_funknown), because of differences between C and C++

  1366.             v3_bstream* const streamptr

  1367.                 = stream != nullptr ? (v3_bstream*)((uint8_t*)stream+sizeof(v3_funknown))

  1368.                                     : nullptr;

  1369. 

  1370.             return vst3->setState(stream);

  1371. #endif

  1372.             return V3_NOT_IMPLEMENTED;

  1373.         };

  1374. 

  1375.         controller.get_state = []V3_API(void* self, v3_bstream* stream) -> v3_result

  1376.         {

  1377.             d_stdout("dpf_edit_controller::get_state                  => %p %p", self, stream);

  1378.             dpf_edit_controller* const controller = *(dpf_edit_controller**)self;

  1379.             DISTRHO_SAFE_ASSERT_RETURN(controller != nullptr, V3_NOT_INITIALISED);

  1380. 

  1381.             PluginVst3* const vst3 = controller->vst3;

  1382.             DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALISED);

  1383. 

  1384. #if 0

  1385.             // offset struct by sizeof(v3_funknown), because of differences between C and C++

  1386.             v3_bstream* const streamptr

  1387.                 = stream != nullptr ? (v3_bstream*)((uint8_t*)stream+sizeof(v3_funknown))

  1388.                                     : nullptr;

  1389. 

  1390.             return vst3->getState(stream);

  1391. #endif

  1392.             return V3_NOT_IMPLEMENTED;

  1393.         };

  1394. 

  1395.         controller.get_parameter_count = []V3_API(void* self) -> int32_t

  1396.         {

  1397.             d_stdout("dpf_edit_controller::get_parameter_count        => %p", self);

  1398.             dpf_edit_controller* const controller = *(dpf_edit_controller**)self;

  1399.             DISTRHO_SAFE_ASSERT_RETURN(controller != nullptr, V3_NOT_INITIALISED);

  1400. 

  1401.             PluginVst3* const vst3 = controller->vst3;

  1402.             DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALISED);

  1403. 

  1404.             return vst3->getParameterCount();

  1405.         };

  1406. 

  1407.         controller.get_parameter_info = []V3_API(void* self, int32_t param_idx, v3_param_info* param_info) -> v3_result

  1408.         {

  1409.             d_stdout("dpf_edit_controller::get_parameter_info         => %p %i", self, param_idx);

  1410.             dpf_edit_controller* const controller = *(dpf_edit_controller**)self;

  1411.             DISTRHO_SAFE_ASSERT_RETURN(controller != nullptr, V3_NOT_INITIALISED);

  1412. 

  1413.             PluginVst3* const vst3 = controller->vst3;

  1414.             DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALISED);

  1415. 

  1416.             return vst3->getParameterInfo(param_idx, param_info);

  1417.         };

  1418. 

  1419.         controller.get_parameter_string_for_value = []V3_API(void* self, v3_param_id index, double normalised, v3_str_128 output) -> v3_result

  1420.         {

  1421.             d_stdout("dpf_edit_controller::get_parameter_string_for_value => %p %u %f %p", self, index, normalised, output);

  1422.             dpf_edit_controller* const controller = *(dpf_edit_controller**)self;

  1423.             DISTRHO_SAFE_ASSERT_RETURN(controller != nullptr, V3_NOT_INITIALISED);

  1424. 

  1425.             PluginVst3* const vst3 = controller->vst3;

  1426.             DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALISED);

  1427. 

  1428.             return vst3->getParameterStringForValue(index, normalised, output);

  1429.         };

  1430. 

  1431.         controller.get_parameter_value_for_string = []V3_API(void* self, v3_param_id index, int16_t* input, double* output) -> v3_result

  1432.         {

  1433.             d_stdout("dpf_edit_controller::get_parameter_value_for_string => %p %u %p %p", self, index, input, output);

  1434.             dpf_edit_controller* const controller = *(dpf_edit_controller**)self;

  1435.             DISTRHO_SAFE_ASSERT_RETURN(controller != nullptr, V3_NOT_INITIALISED);

  1436. 

  1437.             PluginVst3* const vst3 = controller->vst3;

  1438.             DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALISED);

  1439. 

  1440.             return vst3->getParameterValueForString(index, input, output);

  1441.         };

  1442. 

  1443.         controller.normalised_parameter_to_plain = []V3_API(void* self, v3_param_id index, double normalised) -> double

  1444.         {

  1445.             d_stdout("dpf_edit_controller::normalised_parameter_to_plain  => %p %u %f", self, index, normalised);

  1446.             dpf_edit_controller* const controller = *(dpf_edit_controller**)self;

  1447.             DISTRHO_SAFE_ASSERT_RETURN(controller != nullptr, V3_NOT_INITIALISED);

  1448. 

  1449.             PluginVst3* const vst3 = controller->vst3;

  1450.             DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALISED);

  1451. 

  1452.             return vst3->normalisedParameterToPlain(index, normalised);

  1453.         };

  1454. 

  1455.         controller.plain_parameter_to_normalised = []V3_API(void* self, v3_param_id index, double plain) -> double

  1456.         {

  1457.             d_stdout("dpf_edit_controller::plain_parameter_to_normalised  => %p %f", self, plain);

  1458.             dpf_edit_controller* const controller = *(dpf_edit_controller**)self;

  1459.             DISTRHO_SAFE_ASSERT_RETURN(controller != nullptr, V3_NOT_INITIALISED);

  1460. 

  1461.             PluginVst3* const vst3 = controller->vst3;

  1462.             DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALISED);

  1463. 

  1464.             return vst3->plainParameterToNormalised(index, plain);

  1465.         };

  1466. 

  1467.         controller.get_parameter_normalised = []V3_API(void* self, v3_param_id index) -> double

  1468.         {

  1469.             d_stdout("dpf_edit_controller::get_parameter_normalised       => %p", self);

  1470.             dpf_edit_controller* const controller = *(dpf_edit_controller**)self;

  1471.             DISTRHO_SAFE_ASSERT_RETURN(controller != nullptr, 0.0);

  1472. 

  1473.             PluginVst3* const vst3 = controller->vst3;

  1474.             DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, 0.0);

  1475. 

  1476.             return vst3->getParameterNormalized(index);

  1477.         };

  1478. 

  1479.         controller.set_parameter_normalised = []V3_API(void* self, v3_param_id index, double normalised) -> v3_result

  1480.         {

  1481.             d_stdout("dpf_edit_controller::set_parameter_normalised       => %p %f", self, normalised);

  1482.             dpf_edit_controller* const controller = *(dpf_edit_controller**)self;

  1483.             DISTRHO_SAFE_ASSERT_RETURN(controller != nullptr, V3_NOT_INITIALISED);

  1484. 

  1485.             PluginVst3* const vst3 = controller->vst3;

  1486.             DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALISED);

  1487. 

  1488. //             if (dpf_plugin_view* const view = controller->view)

  1489. //             {

  1490. //                 if (UIVst3* const uivst3 = view->uivst3)

  1491. //                 {

  1492. //                     uivst3->setParameterValueFromDSP(index, vst3->normalisedParameterToPlain(index, normalised));

  1493. //                 }

  1494. //             }

  1495. 

  1496.             return vst3->setParameterNormalized(index, normalised);

  1497.         };

  1498. 

  1499.         controller.set_component_handler = []V3_API(void* self, v3_component_handler** handler) -> v3_result

  1500.         {

  1501.             d_stdout("dpf_edit_controller::set_component_handler      => %p %p", self, handler);

  1502.             dpf_edit_controller* const controller = *(dpf_edit_controller**)self;

  1503.             DISTRHO_SAFE_ASSERT_RETURN(controller != nullptr, V3_NOT_INITIALISED);

  1504. 

  1505.             PluginVst3* const vst3 = controller->vst3;

  1506.             DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALISED);

  1507. 

  1508. //             v3_component_handler_cpp** const cpphandler = (v3_component_handler_cpp**)handler;

  1509. //

  1510. //             controller->handler = cpphandler;

  1511. //

  1512. //             if (controller->view != nullptr)

  1513. //             {

  1514. //                 controller->view->handler = cpphandler;

  1515. //

  1516. //                 if (UIVst3* const uivst3 = controller->view->uivst3)

  1517. //                     uivst3->setHandler(cpphandler);

  1518. //             }

  1519. 

  1520.             // offset struct by sizeof(v3_funknown), because of differences between C and C++

  1521.             v3_component_handler* const handlerptr

  1522.                 = handler != nullptr ? (v3_component_handler*)((uint8_t*)*(handler)+sizeof(v3_funknown))

  1523.                                      : nullptr;

  1524. 

  1525.             return vst3->setComponentHandler(handlerptr, handler);

  1526.         };

  1527. 

  1528.         controller.create_view = []V3_API(void* self, const char* name) -> v3_plugin_view**

  1529.         {

  1530.             d_stdout("dpf_edit_controller::create_view                => %p %s", self, name);

  1531.             dpf_edit_controller* const controller = *(dpf_edit_controller**)self;

  1532.             DISTRHO_SAFE_ASSERT_RETURN(controller != nullptr, nullptr);

  1533. 

  1534.             PluginVst3* const vst3 = controller->vst3;

  1535.             DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, nullptr);

  1536. 

  1537. #if DISTRHO_PLUGIN_HAS_UI

  1538.             return (v3_plugin_view**)dpf_plugin_view_create(vst3->getInstancePointer(), vst3->getSampleRate());

  1539. #else

  1540.             return nullptr;

  1541. #endif

  1542.         };

  1543.     }

  1544. };

  1545. 

  1546. // --------------------------------------------------------------------------------------------------------------------

  1547. // dpf_process_context_requirements

  1548. 

  1549. struct v3_process_context_requirements_cpp : v3_funknown {

  1550.     v3_process_context_requirements req;

  1551. };

  1552. 

  1553. struct dpf_process_context_requirements : v3_process_context_requirements_cpp {

  1554.     dpf_process_context_requirements()

  1555.     {

  1556.         static const uint8_t* kSupportedInterfaces[] = {

  1557.             v3_funknown_iid,

  1558.             v3_process_context_requirements_iid

  1559.         };

  1560. 

  1561.         // ------------------------------------------------------------------------------------------------------------

  1562.         // v3_funknown

  1563. 

  1564.         query_interface = []V3_API(void* self, const v3_tuid iid, void** iface) -> v3_result

  1565.         {

  1566.             d_stdout("dpf_process_context_requirements::query_interface => %p %s %p", self, tuid2str(iid), iface);

  1567.             *iface = NULL;

  1568.             DISTRHO_SAFE_ASSERT_RETURN(self != nullptr, V3_NO_INTERFACE);

  1569. 

  1570.             for (const uint8_t* interface_iid : kSupportedInterfaces)

  1571.             {

  1572.                 if (v3_tuid_match(interface_iid, iid))

  1573.                 {

  1574.                     *iface = self;

  1575.                     return V3_OK;

  1576.                 }

  1577.             }

  1578. 

  1579.             return V3_NO_INTERFACE;

  1580.         };

  1581. 

  1582.         // this is used statically, so we don't have to care here

  1583.         ref = []V3_API(void*) -> uint32_t { return 1; };

  1584.         unref = []V3_API(void*) -> uint32_t { return 0; };

  1585. 

  1586.         // ------------------------------------------------------------------------------------------------------------

  1587.         // v3_process_context_requirements

  1588. 

  1589.         req.get_process_context_requirements = []V3_API(void*) -> uint32_t

  1590.         {

  1591. #if DISTRHO_PLUGIN_WANT_TIMEPOS

  1592.             return 0x0

  1593.                 |V3_PROCESS_CTX_NEED_CONTINUOUS_TIME  // V3_PROCESS_CTX_CONT_TIME_VALID

  1594.                 |V3_PROCESS_CTX_NEED_PROJECT_TIME     // V3_PROCESS_CTX_PROJECT_TIME_VALID

  1595.                 |V3_PROCESS_CTX_NEED_TEMPO            // V3_PROCESS_CTX_TEMPO_VALID

  1596.                 |V3_PROCESS_CTX_NEED_TIME_SIG         // V3_PROCESS_CTX_TIME_SIG_VALID

  1597.                 |V3_PROCESS_CTX_NEED_TRANSPORT_STATE; // V3_PROCESS_CTX_PLAYING

  1598. #else

  1599.             return 0x0;

  1600. #endif

  1601.         };

  1602.     }

  1603. 

  1604.     DISTRHO_PREVENT_HEAP_ALLOCATION

  1605. };

  1606. 

  1607. // --------------------------------------------------------------------------------------------------------------------

  1608. // dpf_audio_processor

  1609. 

  1610. struct v3_audio_processor_cpp : v3_funknown {

  1611.     v3_audio_processor processor;

  1612. };

  1613. 

  1614. struct dpf_audio_processor : v3_audio_processor_cpp {

  1615.     std::atomic<int> refcounter;

  1616.     ScopedPointer<dpf_audio_processor>* self;

  1617.     ScopedPointer<PluginVst3>& vst3;

  1618. 

  1619.     dpf_audio_processor(ScopedPointer<dpf_audio_processor>* const s, ScopedPointer<PluginVst3>& v)

  1620.         : refcounter(1),

  1621.           self(s),

  1622.           vst3(v)

  1623.     {

  1624.         static const uint8_t* kSupportedInterfacesBase[] = {

  1625.             v3_funknown_iid,

  1626.             v3_audio_processor_iid

  1627.         };

  1628. 

  1629.         // ------------------------------------------------------------------------------------------------------------

  1630.         // v3_funknown

  1631. 

  1632.         query_interface = []V3_API(void* self, const v3_tuid iid, void** iface) -> v3_result

  1633.         {

  1634.             d_stdout("dpf_audio_processor::query_interface         => %p %s %p", self, tuid2str(iid), iface);

  1635.             *iface = NULL;

  1636.             DISTRHO_SAFE_ASSERT_RETURN(self != nullptr, V3_NO_INTERFACE);

  1637. 

  1638.             for (const uint8_t* interface_iid : kSupportedInterfacesBase)

  1639.             {

  1640.                 if (v3_tuid_match(interface_iid, iid))

  1641.                 {

  1642.                     *iface = self;

  1643.                     return V3_OK;

  1644.                 }

  1645.             }

  1646. 

  1647.             if (v3_tuid_match(v3_process_context_requirements_iid, iid))

  1648.             {

  1649.                 static dpf_process_context_requirements context_req;

  1650.                 static dpf_process_context_requirements* context_req_ptr = &context_req;;

  1651.                 *iface = &context_req_ptr;

  1652.                 return V3_OK;

  1653.             }

  1654. 

  1655.             return V3_NO_INTERFACE;

  1656.         };

  1657. 

  1658.         ref = []V3_API(void* self) -> uint32_t

  1659.         {

  1660.             d_stdout("dpf_audio_processor::ref                     => %p", self);

  1661.             dpf_audio_processor* const processor = *(dpf_audio_processor**)self;

  1662.             DISTRHO_SAFE_ASSERT_RETURN(processor != nullptr, 0);

  1663. 

  1664.             return ++processor->refcounter;

  1665.         };

  1666. 

  1667.         unref = []V3_API(void* self) -> uint32_t

  1668.         {

  1669.             d_stdout("dpf_audio_processor::unref                   => %p", self);

  1670.             dpf_audio_processor* const processor = *(dpf_audio_processor**)self;

  1671.             DISTRHO_SAFE_ASSERT_RETURN(processor != nullptr, 0);

  1672. 

  1673.             if (const int refcounter = --processor->refcounter)

  1674.                 return refcounter;

  1675. 

  1676.             *(dpf_audio_processor**)self = nullptr;

  1677.             *processor->self = nullptr;

  1678.             return 0;

  1679.         };

  1680. 

  1681.         // ------------------------------------------------------------------------------------------------------------

  1682.         // v3_audio_processor

  1683. 

  1684.         processor.set_bus_arrangements = []V3_API(void* self,

  1685.                                                   v3_speaker_arrangement* inputs, int32_t num_inputs,

  1686.                                                   v3_speaker_arrangement* outputs, int32_t num_outputs) -> v3_result

  1687.         {

  1688.             // NOTE this is called a bunch of times

  1689.             // d_stdout("dpf_audio_processor::set_bus_arrangements    => %p %p %i %p %i", self, inputs, num_inputs, outputs, num_outputs);

  1690.             dpf_audio_processor* const processor = *(dpf_audio_processor**)self;

  1691.             DISTRHO_SAFE_ASSERT_RETURN(processor != nullptr, V3_NOT_INITIALISED);

  1692. 

  1693.             PluginVst3* const vst3 = processor->vst3;

  1694.             DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALISED);

  1695. 

  1696.             return processor->vst3->setBusArrangements(inputs, num_inputs, outputs, num_outputs);

  1697.         };

  1698. 

  1699.         processor.get_bus_arrangement = []V3_API(void* self, int32_t bus_direction,

  1700.                                                  int32_t idx, v3_speaker_arrangement* arr) -> v3_result

  1701.         {

  1702.             d_stdout("dpf_audio_processor::get_bus_arrangement     => %p %i %i %p", self, bus_direction, idx, arr);

  1703.             dpf_audio_processor* const processor = *(dpf_audio_processor**)self;

  1704.             DISTRHO_SAFE_ASSERT_RETURN(processor != nullptr, V3_NOT_INITIALISED);

  1705. 

  1706.             PluginVst3* const vst3 = processor->vst3;

  1707.             DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALISED);

  1708. 

  1709.             return processor->vst3->getBusArrangement(bus_direction, idx, arr);

  1710.         };

  1711. 

  1712.         processor.can_process_sample_size = []V3_API(void* self, int32_t symbolic_sample_size) -> v3_result

  1713.         {

  1714.             d_stdout("dpf_audio_processor::can_process_sample_size => %p %i", self, symbolic_sample_size);

  1715.             return symbolic_sample_size == V3_SAMPLE_32 ? V3_OK : V3_NOT_IMPLEMENTED;

  1716.         };

  1717. 

  1718.         processor.get_latency_samples = []V3_API(void* self) -> uint32_t

  1719.         {

  1720.             d_stdout("dpf_audio_processor::get_latency_samples     => %p", self);

  1721.             dpf_audio_processor* const processor = *(dpf_audio_processor**)self;

  1722.             DISTRHO_SAFE_ASSERT_RETURN(processor != nullptr, 0);

  1723. 

  1724.             PluginVst3* const vst3 = processor->vst3;

  1725.             DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, 0);

  1726. 

  1727.             return processor->vst3->getLatencySamples();

  1728.         };

  1729. 

  1730.         processor.setup_processing = []V3_API(void* self, v3_process_setup* setup) -> v3_result

  1731.         {

  1732.             d_stdout("dpf_audio_processor::setup_processing        => %p", self);

  1733.             dpf_audio_processor* const processor = *(dpf_audio_processor**)self;

  1734.             DISTRHO_SAFE_ASSERT_RETURN(processor != nullptr, V3_NOT_INITIALISED);

  1735. 

  1736.             PluginVst3* const vst3 = processor->vst3;

  1737.             DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALISED);

  1738. 

  1739.             d_lastBufferSize = setup->max_block_size;

  1740.             d_lastSampleRate = setup->sample_rate;

  1741.             return processor->vst3->setupProcessing(setup);

  1742.         };

  1743. 

  1744.         processor.set_processing = []V3_API(void* self, v3_bool state) -> v3_result

  1745.         {

  1746.             d_stdout("dpf_audio_processor::set_processing          => %p %u", self, state);

  1747.             dpf_audio_processor* const processor = *(dpf_audio_processor**)self;

  1748.             DISTRHO_SAFE_ASSERT_RETURN(processor != nullptr, V3_NOT_INITIALISED);

  1749. 

  1750.             PluginVst3* const vst3 = processor->vst3;

  1751.             DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALISED);

  1752. 

  1753.             return processor->vst3->setProcessing(state);

  1754.         };

  1755. 

  1756.         processor.process = []V3_API(void* self, v3_process_data* data) -> v3_result

  1757.         {

  1758.             // NOTE runs during RT

  1759.             // d_stdout("dpf_audio_processor::process                 => %p", self);

  1760.             dpf_audio_processor* const processor = *(dpf_audio_processor**)self;

  1761.             DISTRHO_SAFE_ASSERT_RETURN(processor != nullptr, V3_NOT_INITIALISED);

  1762. 

  1763.             PluginVst3* const vst3 = processor->vst3;

  1764.             DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALISED);

  1765. 

  1766.             return processor->vst3->process(data);

  1767.         };

  1768. 

  1769.         processor.get_tail_samples = []V3_API(void* self) -> uint32_t

  1770.         {

  1771.             d_stdout("dpf_audio_processor::get_tail_samples        => %p", self);

  1772.             dpf_audio_processor* const processor = *(dpf_audio_processor**)self;

  1773.             DISTRHO_SAFE_ASSERT_RETURN(processor != nullptr, 0);

  1774. 

  1775.             PluginVst3* const vst3 = processor->vst3;

  1776.             DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, 0);

  1777. 

  1778.             return processor->vst3->getTailSamples();

  1779.         };

  1780.     }

  1781. };

  1782. 

  1783. // --------------------------------------------------------------------------------------------------------------------

  1784. // dpf_state_stream

  1785. 

  1786. struct v3_bstream_cpp : v3_funknown {

  1787.     v3_bstream stream;

  1788. };

  1789. 

  1790. struct dpf_state_stream : v3_bstream_cpp {

  1791.     ScopedPointer<PluginVst3>& vst3;

  1792. 

  1793.     dpf_state_stream(ScopedPointer<PluginVst3>& v)

  1794.         : vst3(v)

  1795.     {

  1796.         static const uint8_t* kSupportedInterfaces[] = {

  1797.             v3_funknown_iid,

  1798.             v3_bstream_iid

  1799.         };

  1800. 

  1801.         // ------------------------------------------------------------------------------------------------------------

  1802.         // v3_funknown

  1803. 

  1804.         query_interface = []V3_API(void* self, const v3_tuid iid, void** iface) -> v3_result

  1805.         {

  1806.             d_stdout("dpf_factory::query_interface      => %p %s %p", self, tuid2str(iid), iface);

  1807.             *iface = NULL;

  1808.             DISTRHO_SAFE_ASSERT_RETURN(self != nullptr, V3_NO_INTERFACE);

  1809. 

  1810.             for (const uint8_t* interface_iid : kSupportedInterfaces)

  1811.             {

  1812.                 if (v3_tuid_match(interface_iid, iid))

  1813.                 {

  1814.                     *iface = self;

  1815.                     return V3_OK;

  1816.                 }

  1817.             }

  1818. 

  1819.             return V3_NO_INTERFACE;

  1820.         };

  1821. 

  1822.         // TODO

  1823.         ref = []V3_API(void*) -> uint32_t { return 1; };

  1824.         unref = []V3_API(void*) -> uint32_t { return 0; };

  1825. 

  1826.         // ------------------------------------------------------------------------------------------------------------

  1827.         // v3_bstream

  1828. 

  1829.         stream.read = []V3_API(void* self, void* buffer, int32_t num_bytes, int32_t* bytes_read) -> v3_result

  1830.         {

  1831.             d_stdout("dpf_state_stream::read  => %p %p %i %p", self, buffer, num_bytes, bytes_read);

  1832.             dpf_state_stream* const stream = *(dpf_state_stream**)self;

  1833.             DISTRHO_SAFE_ASSERT_RETURN(stream != nullptr, V3_NOT_INITIALISED);

  1834. 

  1835.             PluginVst3* const vst3 = stream->vst3;

  1836.             DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALISED);

  1837. 

  1838.             return V3_NOT_IMPLEMENTED;

  1839.         };

  1840. 

  1841.         stream.write = []V3_API(void* self, void* buffer, int32_t num_bytes, int32_t* bytes_written) -> v3_result

  1842.         {

  1843.             d_stdout("dpf_state_stream::write => %p %p %i %p", self, buffer, num_bytes, bytes_written);

  1844.             dpf_state_stream* const stream = *(dpf_state_stream**)self;

  1845.             DISTRHO_SAFE_ASSERT_RETURN(stream != nullptr, V3_NOT_INITIALISED);

  1846. 

  1847.             PluginVst3* const vst3 = stream->vst3;

  1848.             DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALISED);

  1849. 

  1850.             return V3_NOT_IMPLEMENTED;

  1851.         };

  1852. 

  1853.         stream.seek = []V3_API(void* self, int64_t pos, int32_t seek_mode, int64_t* result) -> v3_result

  1854.         {

  1855.             d_stdout("dpf_state_stream::seek  => %p %lu %i %p", self, pos, seek_mode, result);

  1856.             dpf_state_stream* const stream = *(dpf_state_stream**)self;

  1857.             DISTRHO_SAFE_ASSERT_RETURN(stream != nullptr, V3_NOT_INITIALISED);

  1858. 

  1859.             PluginVst3* const vst3 = stream->vst3;

  1860.             DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALISED);

  1861. 

  1862.             return V3_NOT_IMPLEMENTED;

  1863.         };

  1864. 

  1865.         stream.tell = []V3_API(void* self, int64_t* pos) -> v3_result

  1866.         {

  1867.             d_stdout("dpf_state_stream::tell  => %p %p", self, pos);

  1868.             dpf_state_stream* const stream = *(dpf_state_stream**)self;

  1869.             DISTRHO_SAFE_ASSERT_RETURN(stream != nullptr, V3_NOT_INITIALISED);

  1870. 

  1871.             PluginVst3* const vst3 = stream->vst3;

  1872.             DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALISED);

  1873. 

  1874.             return V3_NOT_IMPLEMENTED;

  1875.         };

  1876.     }

  1877. };

  1878. 

  1879. // --------------------------------------------------------------------------------------------------------------------

  1880. // dpf_component

  1881. 

  1882. struct v3_component_cpp : v3_funknown {

  1883.     v3_plugin_base base;

  1884.     v3_component comp;

  1885. };

  1886. 

  1887. struct dpf_component : v3_component_cpp {

  1888.     std::atomic<int> refcounter;

  1889.     ScopedPointer<dpf_component>* self;

  1890.     ScopedPointer<dpf_audio_processor> processor;

  1891.     ScopedPointer<dpf_edit_controller> controller;

  1892.     ScopedPointer<dpf_state_stream> stream;

  1893.     ScopedPointer<PluginVst3> vst3;

  1894. 

  1895.     dpf_component(ScopedPointer<dpf_component>* const s)

  1896.         : refcounter(1),

  1897.           self(s)

  1898.     {

  1899.         static const uint8_t* kSupportedInterfacesBase[] = {

  1900.             v3_funknown_iid,

  1901.             v3_plugin_base_iid,

  1902.             v3_component_iid

  1903.         };

  1904. 

  1905.         // ------------------------------------------------------------------------------------------------------------

  1906.         // v3_funknown

  1907. 

  1908.         query_interface = []V3_API(void* self, const v3_tuid iid, void** iface) -> v3_result

  1909.         {

  1910.             d_stdout("dpf_component::query_interface         => %p %s %p", self, tuid2str(iid), iface);

  1911.             *iface = NULL;

  1912. 

  1913.             for (const uint8_t* interface_iid : kSupportedInterfacesBase)

  1914.             {

  1915.                 if (v3_tuid_match(interface_iid, iid))

  1916.                 {

  1917.                     *iface = self;

  1918.                     return V3_OK;

  1919.                 }

  1920.             }

  1921. 

  1922.             dpf_component* const component = *(dpf_component**)self;

  1923.             DISTRHO_SAFE_ASSERT_RETURN(component != nullptr, V3_NO_INTERFACE);

  1924. 

  1925.             if (v3_tuid_match(v3_audio_processor_iid, iid))

  1926.             {

  1927.                 if (component->processor == nullptr)

  1928.                     component->processor = new dpf_audio_processor(&component->processor, component->vst3);

  1929.                 *iface = &component->processor;

  1930.                 return V3_OK;

  1931.             }

  1932. 

  1933.             if (v3_tuid_match(v3_edit_controller_iid, iid))

  1934.             {

  1935.                 if (component->controller == nullptr)

  1936.                     component->controller = new dpf_edit_controller(&component->controller, component->vst3);

  1937.                 *iface = &component->controller;

  1938.                 return V3_OK;

  1939.             }

  1940. 

  1941.             return V3_NO_INTERFACE;

  1942.         };

  1943. 

  1944.         ref = []V3_API(void* self) -> uint32_t

  1945.         {

  1946.             d_stdout("dpf_component::ref                     => %p", self);

  1947.             dpf_component* const component = *(dpf_component**)self;

  1948.             DISTRHO_SAFE_ASSERT_RETURN(component != nullptr, 0);

  1949. 

  1950.             return ++component->refcounter;

  1951.         };

  1952. 

  1953.         unref = []V3_API(void* self) -> uint32_t

  1954.         {

  1955.             d_stdout("dpf_component::unref                   => %p", self);

  1956.             dpf_component* const component = *(dpf_component**)self;

  1957.             DISTRHO_SAFE_ASSERT_RETURN(component != nullptr, 0);

  1958. 

  1959.             if (const int refcounter = --component->refcounter)

  1960.                 return refcounter;

  1961. 

  1962.             *(dpf_component**)self = nullptr;

  1963.             *component->self = nullptr;

  1964.             return 0;

  1965.         };

  1966. 

  1967.         // ------------------------------------------------------------------------------------------------------------

  1968.         // v3_plugin_base

  1969. 

  1970.         base.initialise = []V3_API(void* self, struct v3_plugin_base::v3_funknown* context) -> v3_result

  1971.         {

  1972.             d_stdout("dpf_component::initialise              => %p %p", self, context);

  1973.             dpf_component* const component = *(dpf_component**)self;

  1974.             DISTRHO_SAFE_ASSERT_RETURN(component != nullptr, V3_NOT_INITIALISED);

  1975. 

  1976.             PluginVst3* const vst3 = component->vst3;

  1977.             DISTRHO_SAFE_ASSERT_RETURN(vst3 == nullptr, V3_INVALID_ARG);

  1978. 

  1979.             d_lastCanRequestParameterValueChanges = true;

  1980. 

  1981.             // default early values

  1982.             if (d_lastBufferSize == 0)

  1983.                 d_lastBufferSize = 2048;

  1984.             if (d_lastSampleRate <= 0.0)

  1985.                 d_lastSampleRate = 44100.0;

  1986. 

  1987.             component->vst3 = new PluginVst3();

  1988.             return V3_OK;

  1989.         };

  1990. 

  1991.         base.terminate = []V3_API(void* self) -> v3_result

  1992.         {

  1993.             d_stdout("dpf_component::terminate               => %p", self);

  1994.             dpf_component* const component = *(dpf_component**)self;

  1995.             DISTRHO_SAFE_ASSERT_RETURN(component != nullptr, V3_NOT_INITIALISED);

  1996. 

  1997.             PluginVst3* const vst3 = component->vst3;

  1998.             DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_INVALID_ARG);

  1999. 

  2000.             component->vst3 = nullptr;

  2001.             return V3_OK;

  2002.         };

  2003. 

  2004.         // ------------------------------------------------------------------------------------------------------------

  2005.         // v3_component

  2006. 

  2007.         comp.get_controller_class_id = []V3_API(void* self, v3_tuid class_id) -> v3_result

  2008.         {

  2009.             d_stdout("dpf_component::get_controller_class_id => %p %s", self, tuid2str(class_id));

  2010.             dpf_component* const component = *(dpf_component**)self;

  2011.             DISTRHO_SAFE_ASSERT_RETURN(component != nullptr, V3_NOT_INITIALISED);

  2012. 

  2013.             PluginVst3* const vst3 = component->vst3;

  2014.             DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALISED);

  2015. 

  2016.             // TODO

  2017.             return V3_NOT_IMPLEMENTED;

  2018.         };

  2019. 

  2020.         comp.set_io_mode = []V3_API(void* self, int32_t io_mode) -> v3_result

  2021.         {

  2022.             d_stdout("dpf_component::set_io_mode             => %p %i", self, io_mode);

  2023.             dpf_component* const component = *(dpf_component**)self;

  2024.             DISTRHO_SAFE_ASSERT_RETURN(component != nullptr, V3_NOT_INITIALISED);

  2025. 

  2026.             PluginVst3* const vst3 = component->vst3;

  2027.             DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALISED);

  2028. 

  2029.             // TODO

  2030.             return V3_NOT_IMPLEMENTED;

  2031.         };

  2032. 

  2033.         comp.get_bus_count = []V3_API(void* self, int32_t media_type, int32_t bus_direction) -> int32_t

  2034.         {

  2035.             // NOTE runs during RT

  2036.             // d_stdout("dpf_component::get_bus_count           => %p %i %i", self, media_type, bus_direction);

  2037.             dpf_component* const component = *(dpf_component**)self;

  2038.             DISTRHO_SAFE_ASSERT_RETURN(component != nullptr, V3_NOT_INITIALISED);

  2039. 

  2040.             PluginVst3* const vst3 = component->vst3;

  2041.             DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALISED);

  2042. 

  2043.             return vst3->getBusCount(media_type, bus_direction);

  2044.         };

  2045. 

  2046.         comp.get_bus_info = []V3_API(void* self, int32_t media_type, int32_t bus_direction,

  2047.                                      int32_t bus_idx, v3_bus_info* info) -> v3_result

  2048.         {

  2049.             d_stdout("dpf_component::get_bus_info            => %p %i %i %i %p", self, media_type, bus_direction, bus_idx, info);

  2050.             dpf_component* const component = *(dpf_component**)self;

  2051.             DISTRHO_SAFE_ASSERT_RETURN(component != nullptr, V3_NOT_INITIALISED);

  2052. 

  2053.             PluginVst3* const vst3 = component->vst3;

  2054.             DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALISED);

  2055. 

  2056.             return vst3->getBusInfo(media_type, bus_direction, bus_idx, info);

  2057.         };

  2058. 

  2059.         comp.get_routing_info = []V3_API(void* self, v3_routing_info* input, v3_routing_info* output) -> v3_result

  2060.         {

  2061.             d_stdout("dpf_component::get_routing_info        => %p %p %p", self, input, output);

  2062.             dpf_component* const component = *(dpf_component**)self;

  2063.             DISTRHO_SAFE_ASSERT_RETURN(component != nullptr, V3_NOT_INITIALISED);

  2064. 

  2065.             PluginVst3* const vst3 = component->vst3;

  2066.             DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALISED);

  2067. 

  2068.             return vst3->getRoutingInfo(input, output);

  2069.         };

  2070. 

  2071.         comp.activate_bus = []V3_API(void* self, int32_t media_type, int32_t bus_direction,

  2072.                                      int32_t bus_idx, v3_bool state) -> v3_result

  2073.         {

  2074.             // NOTE this is called a bunch of times

  2075.             // d_stdout("dpf_component::activate_bus            => %p %i %i %i %u", self, media_type, bus_direction, bus_idx, state);

  2076.             dpf_component* const component = *(dpf_component**)self;

  2077.             DISTRHO_SAFE_ASSERT_RETURN(component != nullptr, V3_NOT_INITIALISED);

  2078. 

  2079.             PluginVst3* const vst3 = component->vst3;

  2080.             DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALISED);

  2081. 

  2082.             return vst3->activateBus(media_type, bus_direction, bus_idx, state);

  2083.         };

  2084. 

  2085.         comp.set_active = []V3_API(void* self, v3_bool state) -> v3_result

  2086.         {

  2087.             d_stdout("dpf_component::set_active              => %p %u", self, state);

  2088.             dpf_component* const component = *(dpf_component**)self;

  2089.             DISTRHO_SAFE_ASSERT_RETURN(component != nullptr, V3_NOT_INITIALISED);

  2090. 

  2091.             PluginVst3* const vst3 = component->vst3;

  2092.             DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALISED);

  2093. 

  2094.             return component->vst3->setActive(state);

  2095.         };

  2096. 

  2097.         comp.set_state = []V3_API(void* self, v3_bstream** stream) -> v3_result

  2098.         {

  2099.             d_stdout("dpf_component::set_state               => %p", self);

  2100.             dpf_component* const component = *(dpf_component**)self;

  2101.             DISTRHO_SAFE_ASSERT_RETURN(component != nullptr, V3_NOT_INITIALISED);

  2102. 

  2103.             PluginVst3* const vst3 = component->vst3;

  2104.             DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALISED);

  2105. 

  2106.             // offset struct by sizeof(v3_funknown), because of differences between C and C++

  2107.             v3_bstream* const streamptr

  2108.                 = stream != nullptr ? (v3_bstream*)((uint8_t*)*(stream)+sizeof(v3_funknown))

  2109.                                     : nullptr;

  2110. 

  2111.             return vst3->setState(streamptr, stream);

  2112.         };

  2113. 

  2114.         comp.get_state = []V3_API(void* self, v3_bstream** stream) -> v3_result

  2115.         {

  2116.             d_stdout("dpf_component::get_state               => %p %p", self, stream);

  2117.             dpf_component* const component = *(dpf_component**)self;

  2118.             DISTRHO_SAFE_ASSERT_RETURN(component != nullptr, V3_NOT_INITIALISED);

  2119. 

  2120.             PluginVst3* const vst3 = component->vst3;

  2121.             DISTRHO_SAFE_ASSERT_RETURN(vst3 != nullptr, V3_NOT_INITIALISED);

  2122. 

  2123.             // offset struct by sizeof(v3_funknown), because of differences between C and C++

  2124.             v3_bstream* const streamptr

  2125.                 = stream != nullptr ? (v3_bstream*)((uint8_t*)*(stream)+sizeof(v3_funknown))

  2126.                                     : nullptr;

  2127. 

  2128.             return vst3->getState(streamptr, stream);

  2129.         };

  2130.     }

  2131. };

  2132. 

  2133. // --------------------------------------------------------------------------------------------------------------------

  2134. // dpf_factory

  2135. 

  2136. struct v3_plugin_factory_cpp : v3_funknown {

  2137.     v3_plugin_factory   v1;

  2138.     v3_plugin_factory_2 v2;

  2139.     v3_plugin_factory_3 v3;

  2140. };

  2141. 

  2142. struct dpf_factory : v3_plugin_factory_cpp {

  2143.     dpf_factory()

  2144.     {

  2145.         static const uint8_t* kSupportedFactories[] = {

  2146.             v3_funknown_iid,

  2147.             v3_plugin_factory_iid,

  2148.             v3_plugin_factory_2_iid,

  2149.             v3_plugin_factory_3_iid

  2150.         };

  2151. 

  2152.         // ------------------------------------------------------------------------------------------------------------

  2153.         // Dummy plugin to get data from

  2154. 

  2155.         d_lastBufferSize = 512;

  2156.         d_lastSampleRate = 44100.0;

  2157.         d_lastCanRequestParameterValueChanges = true;

  2158.         static const PluginExporter gPluginInfo(nullptr, nullptr, nullptr);

  2159.         d_lastBufferSize = 0;

  2160.         d_lastSampleRate = 0.0;

  2161.         d_lastCanRequestParameterValueChanges = false;

  2162. 

  2163.         dpf_tuid_class[2] = dpf_tuid_component[2] = dpf_tuid_controller[2]

  2164.             = dpf_tuid_processor[2] = dpf_tuid_view[2] = gPluginInfo.getUniqueId();

  2165. 

  2166.         // ------------------------------------------------------------------------------------------------------------

  2167.         // v3_funknown

  2168. 

  2169.         query_interface = []V3_API(void* self, const v3_tuid iid, void** iface) -> v3_result

  2170.         {

  2171.             d_stdout("dpf_factory::query_interface      => %p %s %p", self, tuid2str(iid), iface);

  2172.             *iface = NULL;

  2173.             DISTRHO_SAFE_ASSERT_RETURN(self != nullptr, V3_NO_INTERFACE);

  2174. 

  2175.             for (const uint8_t* factory_iid : kSupportedFactories)

  2176.             {

  2177.                 if (v3_tuid_match(factory_iid, iid))

  2178.                 {

  2179.                     *iface = self;

  2180.                     return V3_OK;

  2181.                 }

  2182.             }

  2183. 

  2184.             return V3_NO_INTERFACE;

  2185.         };

  2186. 

  2187.         // we only support 1 plugin per binary, so don't have to care here

  2188.         ref = []V3_API(void*) -> uint32_t { return 1; };

  2189.         unref = []V3_API(void*) -> uint32_t { return 0; };

  2190. 

  2191.         // ------------------------------------------------------------------------------------------------------------

  2192.         // v3_plugin_factory

  2193. 

  2194.         v1.get_factory_info = []V3_API(void*, struct v3_factory_info* const info) -> v3_result

  2195.         {

  2196.             std::memset(info, 0, sizeof(*info));

  2197.             DISTRHO_NAMESPACE::strncpy(info->vendor, gPluginInfo.getMaker(), sizeof(info->vendor));

  2198.             DISTRHO_NAMESPACE::strncpy(info->url, gPluginInfo.getHomePage(), sizeof(info->url));

  2199.             // DISTRHO_NAMESPACE::strncpy(info->email, "", sizeof(info->email)); // TODO

  2200.             return V3_OK;

  2201.         };

  2202. 

  2203.         v1.num_classes = []V3_API(void*) -> int32_t

  2204.         {

  2205.             return 1;

  2206.         };

  2207. 

  2208.         v1.get_class_info = []V3_API(void*, int32_t idx, struct v3_class_info* const info) -> v3_result

  2209.         {

  2210.             std::memset(info, 0, sizeof(*info));

  2211.             DISTRHO_SAFE_ASSERT_RETURN(idx == 0, V3_NO_INTERFACE);

  2212. 

  2213.             std::memcpy(info->class_id, dpf_tuid_class, sizeof(v3_tuid));

  2214.             info->cardinality = 0x7FFFFFFF;

  2215.             DISTRHO_NAMESPACE::strncpy(info->category, "Audio Module Class", sizeof(info->category));

  2216.             DISTRHO_NAMESPACE::strncpy(info->name, gPluginInfo.getName(), sizeof(info->name));

  2217.             return V3_OK;

  2218.         };

  2219. 

  2220.         v1.create_instance = []V3_API(void* self, const v3_tuid class_id, const v3_tuid iid, void** instance) -> v3_result

  2221.         {

  2222.             d_stdout("dpf_factory::create_instance      => %p %s %s %p", self, tuid2str(class_id), tuid2str(iid), instance);

  2223.             DISTRHO_SAFE_ASSERT_RETURN(v3_tuid_match(class_id, *(v3_tuid*)&dpf_tuid_class) &&

  2224.                                        v3_tuid_match(iid, v3_component_iid), V3_NO_INTERFACE);

  2225. 

  2226.             dpf_factory* const factory = *(dpf_factory**)self;

  2227.             DISTRHO_SAFE_ASSERT_RETURN(factory != nullptr, V3_NOT_INITIALISED);

  2228. 

  2229.             ScopedPointer<dpf_component>* const componentptr = new ScopedPointer<dpf_component>;

  2230.             *componentptr = new dpf_component(componentptr);

  2231.             *instance = componentptr;

  2232.             return V3_OK;

  2233.         };

  2234. 

  2235.         // ------------------------------------------------------------------------------------------------------------

  2236.         // v3_plugin_factory_2

  2237. 

  2238.         v2.get_class_info_2 = []V3_API(void*, int32_t idx, struct v3_class_info_2* info) -> v3_result

  2239.         {

  2240.             std::memset(info, 0, sizeof(*info));

  2241.             DISTRHO_SAFE_ASSERT_RETURN(idx == 0, V3_NO_INTERFACE);

  2242. 

  2243.             std::memcpy(info->class_id, dpf_tuid_class, sizeof(v3_tuid));

  2244.             info->cardinality = 0x7FFFFFFF;

  2245.             DISTRHO_NAMESPACE::strncpy(info->category, "Audio Module Class", ARRAY_SIZE(info->category));

  2246.             DISTRHO_NAMESPACE::strncpy(info->name, gPluginInfo.getName(), ARRAY_SIZE(info->name));

  2247. 

  2248.             info->class_flags = 0;

  2249.             // DISTRHO_NAMESPACE::strncpy(info->sub_categories, "", sizeof(info->sub_categories)); // TODO

  2250.             DISTRHO_NAMESPACE::strncpy(info->vendor, gPluginInfo.getMaker(), ARRAY_SIZE(info->vendor));

  2251.             DISTRHO_NAMESPACE::snprintf_u32(info->version, gPluginInfo.getVersion(), ARRAY_SIZE(info->version));

  2252.             DISTRHO_NAMESPACE::strncpy(info->sdk_version, "Travesty", ARRAY_SIZE(info->sdk_version)); // TESTING use "VST 3.7" ?

  2253.             return V3_OK;

  2254.         };

  2255. 

  2256.         // ------------------------------------------------------------------------------------------------------------

  2257.         // v3_plugin_factory_3

  2258. 

  2259.         v3.get_class_info_utf16 = []V3_API(void*, int32_t idx, struct v3_class_info_3* info) -> v3_result

  2260.         {

  2261.             std::memset(info, 0, sizeof(*info));

  2262.             DISTRHO_SAFE_ASSERT_RETURN(idx == 0, V3_NO_INTERFACE);

  2263. 

  2264.             std::memcpy(info->class_id, dpf_tuid_class, sizeof(v3_tuid));

  2265.             info->cardinality = 0x7FFFFFFF;

  2266.             DISTRHO_NAMESPACE::strncpy(info->category, "Audio Module Class", ARRAY_SIZE(info->category));

  2267.             DISTRHO_NAMESPACE::strncpy_utf16(info->name, gPluginInfo.getName(), ARRAY_SIZE(info->name));

  2268. 

  2269.             info->class_flags = 0;

  2270.             // DISTRHO_NAMESPACE::strncpy(info->sub_categories, "", ARRAY_SIZE(info->sub_categories)); // TODO

  2271.             DISTRHO_NAMESPACE::strncpy_utf16(info->vendor, gPluginInfo.getMaker(), sizeof(info->vendor));

  2272.             DISTRHO_NAMESPACE::snprintf_u32_utf16(info->version, gPluginInfo.getVersion(), ARRAY_SIZE(info->version));

  2273.             DISTRHO_NAMESPACE::strncpy_utf16(info->sdk_version, "Travesty", ARRAY_SIZE(info->sdk_version)); // TESTING use "VST 3.7" ?

  2274.             return V3_OK;

  2275.         };

  2276. 

  2277.         v3.set_host_context = []V3_API (void* self, struct v3_funknown* host) -> v3_result

  2278.         {

  2279.             d_stdout("dpf_factory::set_host_context     => %p %p", self, host);

  2280.             return V3_NOT_IMPLEMENTED;

  2281.         };

  2282.     }

  2283. 

  2284.     DISTRHO_PREVENT_HEAP_ALLOCATION

  2285. };

  2286. 

  2287. END_NAMESPACE_DISTRHO

  2288. 

  2289. // --------------------------------------------------------------------------------------------------------------------

  2290. // VST3 entry point

  2291. 

  2292. DISTRHO_PLUGIN_EXPORT

  2293. const void* GetPluginFactory(void);

  2294. 

  2295. const void* GetPluginFactory(void)

  2296. {

  2297.     USE_NAMESPACE_DISTRHO;

  2298.     static const dpf_factory factory;

  2299.     static const v3_funknown* const factoryptr = &factory;

  2300.     return &factoryptr;

  2301. }

  2302. 

  2303. // --------------------------------------------------------------------------------------------------------------------

  2304. // OS specific module load

  2305. 

  2306. #if defined(DISTRHO_OS_MAC)

  2307. # define ENTRYFNNAME bundleEntry

  2308. # define EXITFNNAME bundleExit

  2309. #elif defined(DISTRHO_OS_WINDOWS)

  2310. # define ENTRYFNNAME InitDll

  2311. # define EXITFNNAME ExitDll

  2312. #else

  2313. # define ENTRYFNNAME ModuleEntry

  2314. # define EXITFNNAME ModuleExit

  2315. #endif

  2316. 

  2317. DISTRHO_PLUGIN_EXPORT

  2318. bool ENTRYFNNAME(void*);

  2319. 

  2320. bool ENTRYFNNAME(void*)

  2321. {

  2322.     return true;

  2323. }

  2324. 

  2325. DISTRHO_PLUGIN_EXPORT

  2326. bool EXITFNNAME(void);

  2327. 

  2328. bool EXITFNNAME(void)

  2329. {

  2330.     return true;

  2331. }

  2332. 

  2333. #undef ENTRYFNNAME

  2334. #undef EXITFNNAME

  2335. 

  2336. // --------------------------------------------------------------------------------------------------------------------