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

1092 lines
42KB
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. #include <vector>

  27. 

  28. START_NAMESPACE_DISTRHO

  29. 

  30. // --------------------------------------------------------------------------------------------------------------------

  31. 

  32. #if ! DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  33. static const writeMidiFunc writeMidiCallback = nullptr;

  34. #endif

  35. #if ! DISTRHO_PLUGIN_WANT_PARAMETER_VALUE_CHANGE_REQUEST

  36. static const requestParameterValueChangeFunc requestParameterValueChangeCallback = nullptr;

  37. #endif

  38. 

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

  40. // custom v3_tuid compatible type

  41. 

  42. typedef uint32_t dpf_tuid[4];

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

  44. 

  45. // --------------------------------------------------------------------------------------------------------------------

  46. // custom, constant uids related to DPF

  47. 

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

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

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

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

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

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

  54. 

  55. // --------------------------------------------------------------------------------------------------------------------

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

  57. 

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

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

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

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

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

  63. 

  64. // --------------------------------------------------------------------------------------------------------------------

  65. // Utility functions

  66. 

  67. const char* tuid2str(const v3_tuid iid)

  68. {

  69.     if (v3_tuid_match(iid, v3_funknown_iid))

  70.         return "{v3_funknown}";

  71.     if (v3_tuid_match(iid, v3_plugin_base_iid))

  72.         return "{v3_plugin_base}";

  73.     if (v3_tuid_match(iid, v3_plugin_factory_iid))

  74.         return "{v3_plugin_factory}";

  75.     if (v3_tuid_match(iid, v3_plugin_factory_2_iid))

  76.         return "{v3_plugin_factory_2}";

  77.     if (v3_tuid_match(iid, v3_plugin_factory_3_iid))

  78.         return "{v3_plugin_factory_3}";

  79.     if (v3_tuid_match(iid, v3_component_iid))

  80.         return "{v3_component}";

  81.     if (v3_tuid_match(iid, v3_bstream_iid))

  82.         return "{v3_bstream}";

  83.     if (v3_tuid_match(iid, v3_event_list_iid))

  84.         return "{v3_event_list}";

  85.     if (v3_tuid_match(iid, v3_param_value_queue_iid))

  86.         return "{v3_param_value_queue}";

  87.     if (v3_tuid_match(iid, v3_param_changes_iid))

  88.         return "{v3_param_changes}";

  89.     if (v3_tuid_match(iid, v3_process_context_requirements_iid))

  90.         return "{v3_process_context_requirements}";

  91.     if (v3_tuid_match(iid, v3_audio_processor_iid))

  92.         return "{v3_audio_processor}";

  93.     if (v3_tuid_match(iid, v3_component_handler_iid))

  94.         return "{v3_component_handler}";

  95.     if (v3_tuid_match(iid, v3_edit_controller_iid))

  96.         return "{v3_edit_controller}";

  97.     if (v3_tuid_match(iid, v3_plugin_view_iid))

  98.         return "{v3_plugin_view}";

  99.     if (v3_tuid_match(iid, v3_plugin_frame_iid))

  100.         return "{v3_plugin_frame}";

  101.     if (v3_tuid_match(iid, v3_plugin_view_content_scale_steinberg_iid))

  102.         return "{v3_plugin_view_content_scale_steinberg}";

  103.     if (v3_tuid_match(iid, v3_plugin_view_parameter_finder_iid))

  104.         return "{v3_plugin_view_parameter_finder}";

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

  106.         return "{dpf_tuid_class}";

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

  108.         return "{dpf_tuid_component}";

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

  110.         return "{dpf_tuid_controller}";

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

  112.         return "{dpf_tuid_processor}";

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

  114.         return "{dpf_tuid_view}";

  115. 

  116.     static char buf[46];

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

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

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

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

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

  122.     return buf;

  123. }

  124. 

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

  126. {

  127.     DISTRHO_SAFE_ASSERT_RETURN(size > 0,);

  128. 

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

  130.     {

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

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

  133.     }

  134.     else

  135.     {

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

  137.     }

  138. }

  139. 

  140. void strncpy_16from8(int16_t* const dst, const char* const src, const size_t size)

  141. {

  142.     DISTRHO_SAFE_ASSERT_RETURN(size > 0,);

  143. 

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

  145.     {

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

  147.         {

  148.             // skip non-ascii chars

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

  150.                 continue;

  151. 

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

  153.         }

  154.         dst[len] = 0;

  155.     }

  156.     else

  157.     {

  158.         dst[0] = 0;

  159.     }

  160. }

  161. 

  162. // --------------------------------------------------------------------------------------------------------------------

  163. 

  164. class PluginVst3

  165. {

  166. public:

  167.     PluginVst3()

  168.         : fPlugin(this, writeMidiCallback, requestParameterValueChangeCallback)

  169.     {

  170.     }

  171. 

  172.     // ----------------------------------------------------------------------------------------------------------------

  173.     // stuff for vst3 interfaces

  174. 

  175.     uint32_t getParameterCount() const noexcept

  176.     {

  177.         return fPlugin.getParameterCount();

  178.     }

  179. 

  180.     void getParameterInfo(const uint32_t index, v3_param_info* const info) const noexcept

  181.     {

  182.         // set up flags

  183.         int32_t flags = 0;

  184. 

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

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

  187. 

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

  189. 

  190.         switch (desig)

  191.         {

  192.         case kParameterDesignationNull:

  193.             break;

  194.         case kParameterDesignationBypass:

  195.             flags |= V3_PARAM_IS_BYPASS;

  196.             break;

  197.         }

  198. 

  199.         if (hints & kParameterIsAutomable)

  200.             flags |= V3_PARAM_CAN_AUTOMATE;

  201.         if (hints & kParameterIsOutput)

  202.             flags |= V3_PARAM_READ_ONLY;

  203.         // TODO V3_PARAM_IS_LIST

  204. 

  205.         // set up step_count

  206.         int32_t step_count = 0;

  207. 

  208.         if (hints & kParameterIsBoolean)

  209.             step_count = 1;

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

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

  212. 

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

  214.         info->param_id = index;

  215.         info->flags = flags;

  216.         info->step_count = step_count;

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

  218.         // int32_t unit_id;

  219.         strncpy_16from8(info->title,       fPlugin.getParameterName(index), 128);

  220.         strncpy_16from8(info->short_title, fPlugin.getParameterShortName(index), 128);

  221.         strncpy_16from8(info->units,       fPlugin.getParameterUnit(index), 128);

  222.     }

  223. 

  224.     double getNormalizedParameterValue(const uint32_t index)

  225.     {

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

  227.         return ranges.getNormalizedValue(fPlugin.getParameterValue(index));

  228.     }

  229. 

  230.     void setNormalizedParameterValue(const uint32_t index, const double value)

  231.     {

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

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

  234. 

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

  236. 

  237.         if (hints & kParameterIsBoolean)

  238.         {

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

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

  241.         }

  242. 

  243.         if (hints & kParameterIsInteger)

  244.         {

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

  246.         }

  247. 

  248.         fPlugin.setParameterValue(index, realValue);

  249.     }

  250. 

  251. private:

  252.     // Plugin

  253.     PluginExporter fPlugin;

  254. 

  255.     // VST3 stuff

  256.     // TODO

  257. 

  258. #if DISTRHO_PLUGIN_WANT_PARAMETER_VALUE_CHANGE_REQUEST

  259.     bool requestParameterValueChange(uint32_t, float)

  260.     {

  261.         // TODO

  262.         return true;

  263.     }

  264. 

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

  266.     {

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

  268.     }

  269. #endif

  270. 

  271. #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  272.     bool writeMidi(const MidiEvent& midiEvent)

  273.     {

  274.         // TODO

  275.         return true;

  276.     }

  277. 

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

  279.     {

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

  281.     }

  282. #endif

  283. 

  284. };

  285. 

  286. // --------------------------------------------------------------------------------------------------------------------

  287. // Dummy plugin to get data from

  288. 

  289. static ScopedPointer<PluginExporter> gPluginInfo;

  290. 

  291. // --------------------------------------------------------------------------------------------------------------------

  292. // dpf_plugin_view

  293. 

  294. struct v3_plugin_view_cpp : v3_funknown {

  295.     v3_plugin_view view;

  296. };

  297. 

  298. struct dpf_plugin_view : v3_plugin_view_cpp {

  299.     dpf_plugin_view()

  300.     {

  301.         static const uint8_t* kSupportedFactories[] = {

  302.             v3_funknown_iid,

  303.             v3_plugin_view_iid

  304.         };

  305. 

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

  307.         // v3_funknown

  308. 

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

  310.         {

  311.             d_stdout("dpf_plugin_view::query_interface         => %s | %p %s %p", __PRETTY_FUNCTION__ + 41, self, tuid2str(iid), iface);

  312.             *iface = NULL;

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

  314. 

  315.             for (const uint8_t* factory_iid : kSupportedFactories)

  316.             {

  317.                 if (v3_tuid_match(factory_iid, iid))

  318.                 {

  319.                     *iface = self;

  320.                     return V3_OK;

  321.                 }

  322.             }

  323. 

  324.             return V3_NO_INTERFACE;

  325.         };

  326. 

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

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

  329.         {

  330.             d_stdout("dpf_plugin_view::ref                     => %s | %p", __PRETTY_FUNCTION__ + 41, self);

  331.             return 1;

  332.         };

  333. 

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

  335.         {

  336.             d_stdout("dpf_plugin_view::unref                   => %s | %p", __PRETTY_FUNCTION__ + 41, self);

  337.             return 0;

  338.         };

  339. 

  340.         // ------------------------------------------------------------------------------------------------------------

  341.         // v3_plugin_view

  342. 

  343.         view.is_platform_type_supported = []V3_API(void* self, const char* platform_type) -> v3_result

  344.         {

  345.             d_stdout("dpf_plugin_view::is_platform_type_supported => %s | %p %s", __PRETTY_FUNCTION__ + 41, self, platform_type);

  346.             return V3_OK;

  347.         };

  348. 

  349.         view.attached = []V3_API(void* self, void* parent, const char* platform_type) -> v3_result

  350.         {

  351.             d_stdout("dpf_plugin_view::attached                   => %s | %p %p %s", __PRETTY_FUNCTION__ + 41, self, parent, platform_type);

  352.             return V3_OK;

  353.         };

  354. 

  355.         view.removed = []V3_API(void* self) -> v3_result

  356.         {

  357.             d_stdout("dpf_plugin_view::removed                    => %s | %p", __PRETTY_FUNCTION__ + 41, self);

  358.             return V3_OK;

  359.         };

  360. 

  361.         view.on_wheel = []V3_API(void* self, float distance) -> v3_result

  362.         {

  363.             d_stdout("dpf_plugin_view::on_wheel                   => %s | %p %f", __PRETTY_FUNCTION__ + 41, self, distance);

  364.             return V3_OK;

  365.         };

  366. 

  367.         view.on_key_down = []V3_API(void* self, int16_t key_char, int16_t key_code, int16_t modifiers) -> v3_result

  368.         {

  369.             d_stdout("dpf_plugin_view::on_key_down                => %s | %p %i %i %i", __PRETTY_FUNCTION__ + 41, self, key_char, key_code, modifiers);

  370.             return V3_OK;

  371.         };

  372. 

  373.         view.on_key_up = []V3_API(void* self, int16_t key_char, int16_t key_code, int16_t modifiers) -> v3_result

  374.         {

  375.             d_stdout("dpf_plugin_view::on_key_up                  => %s | %p %i %i %i", __PRETTY_FUNCTION__ + 41, self, key_char, key_code, modifiers);

  376.             return V3_OK;

  377.         };

  378. 

  379.         view.get_size = []V3_API(void* self, v3_view_rect*) -> v3_result

  380.         {

  381.             d_stdout("dpf_plugin_view::get_size                   => %s | %p", __PRETTY_FUNCTION__ + 41, self);

  382.             return V3_OK;

  383.         };

  384. 

  385.         view.set_size = []V3_API(void* self, v3_view_rect*) -> v3_result

  386.         {

  387.             d_stdout("dpf_plugin_view::set_size                   => %s | %p", __PRETTY_FUNCTION__ + 41, self);

  388.             return V3_OK;

  389.         };

  390. 

  391.         view.on_focus = []V3_API(void* self, v3_bool state) -> v3_result

  392.         {

  393.             d_stdout("dpf_plugin_view::on_focus                   => %s | %p %u", __PRETTY_FUNCTION__ + 41, self, state);

  394.             return V3_OK;

  395.         };

  396. 

  397.         view.set_frame = []V3_API(void* self, v3_plugin_frame*) -> v3_result

  398.         {

  399.             d_stdout("dpf_plugin_view::set_frame                  => %s | %p", __PRETTY_FUNCTION__ + 41, self);

  400.             return V3_OK;

  401.         };

  402. 

  403.         view.can_resize = []V3_API(void* self) -> v3_result

  404.         {

  405.             d_stdout("dpf_plugin_view::can_resize                 => %s | %p", __PRETTY_FUNCTION__ + 41, self);

  406.             return V3_OK;

  407.         };

  408. 

  409.         view.check_size_constraint = []V3_API(void* self, v3_view_rect*) -> v3_result

  410.         {

  411.             d_stdout("dpf_plugin_view::check_size_constraint      => %s | %p", __PRETTY_FUNCTION__ + 41, self);

  412.             return V3_OK;

  413.         };

  414.     }

  415. };

  416. 

  417. // --------------------------------------------------------------------------------------------------------------------

  418. // dpf_edit_controller

  419. 

  420. struct v3_edit_controller_cpp : v3_funknown {

  421.     v3_plugin_base base;

  422.     v3_edit_controller controller;

  423. };

  424. 

  425. struct dpf_edit_controller : v3_edit_controller_cpp {

  426.     ScopedPointer<PluginVst3>& vst3;

  427. 

  428.     dpf_edit_controller(ScopedPointer<PluginVst3>& v)

  429.         : vst3(v)

  430.     {

  431.         static const uint8_t* kSupportedFactories[] = {

  432.             v3_funknown_iid,

  433.             v3_edit_controller_iid

  434.         };

  435. 

  436.         // ------------------------------------------------------------------------------------------------------------

  437.         // v3_funknown

  438. 

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

  440.         {

  441.             d_stdout("dpf_edit_controller::query_interface            => %s | %p %s %p", __PRETTY_FUNCTION__ + 53, self, tuid2str(iid), iface);

  442.             *iface = NULL;

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

  444. 

  445.             for (const uint8_t* factory_iid : kSupportedFactories)

  446.             {

  447.                 if (v3_tuid_match(factory_iid, iid))

  448.                 {

  449.                     *iface = self;

  450.                     return V3_OK;

  451.                 }

  452.             }

  453. 

  454.             return V3_NO_INTERFACE;

  455.         };

  456. 

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

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

  459.         {

  460.             d_stdout("dpf_edit_controller::ref                        => %s | %p", __PRETTY_FUNCTION__ + 53, self);

  461.             return 1;

  462.         };

  463. 

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

  465.         {

  466.             d_stdout("dpf_edit_controller::unref                      => %s | %p", __PRETTY_FUNCTION__ + 53, self);

  467.             return 0;

  468.         };

  469. 

  470.         // ------------------------------------------------------------------------------------------------------------

  471.         // v3_plugin_base

  472. 

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

  474.         {

  475.             d_stdout("dpf_edit_controller::initialise                 => %s | %p %p", __PRETTY_FUNCTION__ + 53, self, context);

  476.             return V3_OK;

  477.         };

  478. 

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

  480.         {

  481.             d_stdout("dpf_edit_controller::terminate                  => %s | %p", __PRETTY_FUNCTION__ + 53, self);

  482.             return V3_OK;

  483.         };

  484. 

  485.         // ------------------------------------------------------------------------------------------------------------

  486.         // v3_edit_controller

  487. 

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

  489.         {

  490.             d_stdout("dpf_edit_controller::set_component_state        => %s | %p", __PRETTY_FUNCTION__ + 53, self);

  491.             return V3_OK;

  492.         };

  493. 

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

  495.         {

  496.             d_stdout("dpf_edit_controller::set_state                  => %s | %p", __PRETTY_FUNCTION__ + 53, self);

  497.             return V3_OK;

  498.         };

  499. 

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

  501.         {

  502.             d_stdout("dpf_edit_controller::get_state                  => %s | %p", __PRETTY_FUNCTION__ + 53, self);

  503.             return V3_OK;

  504.         };

  505. 

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

  507.         {

  508.             d_stdout("dpf_edit_controller::get_parameter_count        => %s | %p", __PRETTY_FUNCTION__ + 53, self);

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

  510.             DISTRHO_SAFE_ASSERT_RETURN(controller != nullptr, V3_INVALID_ARG);

  511. 

  512.             PluginVst3* const vst3 = controller->vst3.get();

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

  514.             return vst3->getParameterCount();

  515.         };

  516. 

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

  518.         {

  519.             d_stdout("dpf_edit_controller::get_parameter_info         => %s | %p %i", __PRETTY_FUNCTION__ + 53, self, param_idx);

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

  521.             DISTRHO_SAFE_ASSERT_RETURN(controller != nullptr, V3_INVALID_ARG);

  522.             DISTRHO_SAFE_ASSERT_RETURN(param_idx >= 0, V3_INVALID_ARG);

  523. 

  524.             PluginVst3* const vst3 = controller->vst3.get();

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

  526. 

  527.             const uint32_t uidx = static_cast<uint32_t>(param_idx);

  528.             DISTRHO_SAFE_ASSERT_RETURN(uidx < vst3->getParameterCount(), V3_INVALID_ARG);

  529. 

  530.             vst3->getParameterInfo(uidx, param_info);

  531.             return V3_OK;

  532.         };

  533. 

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

  535.         {

  536.             d_stdout("dpf_edit_controller::get_parameter_string_for_value => %s | %p %f", __PRETTY_FUNCTION__ + 53, self, normalised);

  537. 

  538.             const ParameterRanges& ranges(gPluginInfo->getParameterRanges(index));

  539.             const float realvalue = ranges.getUnnormalizedValue(normalised);

  540.             char buf[24];

  541.             sprintf(buf, "%f", realvalue);

  542.             strncpy_16from8(output, buf, 128);

  543.             return V3_OK;

  544.         };

  545. 

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

  547.         {

  548.             d_stdout("dpf_edit_controller::get_parameter_value_for_string => %s | %p %p %p", __PRETTY_FUNCTION__ + 53, self, input, output);

  549.             return V3_NOT_IMPLEMENTED;

  550.         };

  551. 

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

  553.         {

  554.             d_stdout("dpf_edit_controller::normalised_parameter_to_plain  => %s | %p %f", __PRETTY_FUNCTION__ + 53, self, normalised);

  555.             return normalised;

  556.         };

  557. 

  558.         controller.plain_parameter_to_normalised = []V3_API(void* self, v3_param_id, double normalised) -> double

  559.         {

  560.             d_stdout("dpf_edit_controller::plain_parameter_to_normalised  => %s | %p %f", __PRETTY_FUNCTION__ + 53, self, normalised);

  561.             return normalised;

  562.         };

  563. 

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

  565.         {

  566.             d_stdout("dpf_edit_controller::get_parameter_normalised       => %s | %p", __PRETTY_FUNCTION__ + 53, self);

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

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

  569. 

  570.             PluginVst3* const vst3 = controller->vst3.get();

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

  572.             DISTRHO_SAFE_ASSERT_RETURN(param_idx < vst3->getParameterCount(), 0.0);

  573. 

  574.             return vst3->getNormalizedParameterValue(param_idx);

  575.         };

  576. 

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

  578.         {

  579.             d_stdout("dpf_edit_controller::set_parameter_normalised       => %s | %p %f", __PRETTY_FUNCTION__ + 53, self, normalised);

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

  581.             DISTRHO_SAFE_ASSERT_RETURN(controller != nullptr, V3_INVALID_ARG);

  582. 

  583.             PluginVst3* const vst3 = controller->vst3.get();

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

  585.             DISTRHO_SAFE_ASSERT_RETURN(param_idx < vst3->getParameterCount(), V3_INVALID_ARG);

  586. 

  587.             vst3->setNormalizedParameterValue(param_idx, normalised);

  588.             return V3_OK;

  589.         };

  590. 

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

  592.         {

  593.             d_stdout("dpf_edit_controller::set_component_handler      => %s | %p", __PRETTY_FUNCTION__ + 53, self);

  594.             return V3_NOT_IMPLEMENTED;

  595.         };

  596. 

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

  598.         {

  599.             d_stdout("dpf_edit_controller::create_view                => %s | %p %s", __PRETTY_FUNCTION__ + 53, self, name);

  600.             return nullptr;

  601.         };

  602.     }

  603. };

  604. 

  605. // --------------------------------------------------------------------------------------------------------------------

  606. // dpf_audio_processor

  607. 

  608. struct v3_audio_processor_cpp : v3_funknown {

  609.     v3_audio_processor processor;

  610. };

  611. 

  612. struct dpf_audio_processor : v3_audio_processor_cpp {

  613.     dpf_audio_processor()

  614.     {

  615.         static const uint8_t* kSupportedFactories[] = {

  616.             v3_funknown_iid,

  617.             v3_audio_processor_iid

  618.         };

  619. 

  620.         // ------------------------------------------------------------------------------------------------------------

  621.         // v3_funknown

  622. 

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

  624.         {

  625.             d_stdout("dpf_audio_processor::query_interface         => %s | %p %s %p", __PRETTY_FUNCTION__ + 53, self, tuid2str(iid), iface);

  626.             *iface = NULL;

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

  628. 

  629.             for (const uint8_t* factory_iid : kSupportedFactories)

  630.             {

  631.                 if (v3_tuid_match(factory_iid, iid))

  632.                 {

  633.                     *iface = self;

  634.                     return V3_OK;

  635.                 }

  636.             }

  637. 

  638.             return V3_NO_INTERFACE;

  639.         };

  640. 

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

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

  643.         {

  644.             d_stdout("dpf_audio_processor::ref                     => %s | %p", __PRETTY_FUNCTION__ + 53, self);

  645.             return 1;

  646.         };

  647. 

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

  649.         {

  650.             d_stdout("dpf_audio_processor::unref                   => %s | %p", __PRETTY_FUNCTION__ + 53, self);

  651.             return 0;

  652.         };

  653. 

  654.         // ------------------------------------------------------------------------------------------------------------

  655.         // v3_audio_processor

  656. 

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

  658.                                                   v3_speaker_arrangement* inputs, int32_t num_inputs,

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

  660.         {

  661.             d_stdout("dpf_audio_processor::set_bus_arrangements    => %s | %p %p %i %p %i", __PRETTY_FUNCTION__ + 53, self, inputs, num_inputs, outputs, num_outputs);

  662.             return V3_OK;

  663.         };

  664. 

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

  666.                                                  int32_t idx, v3_speaker_arrangement*) -> v3_result

  667.         {

  668.             d_stdout("dpf_audio_processor::get_bus_arrangement     => %s | %p %i %i", __PRETTY_FUNCTION__ + 53, self, bus_direction, idx);

  669.             return V3_OK;

  670.         };

  671. 

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

  673.         {

  674.             d_stdout("dpf_audio_processor::can_process_sample_size => %s | %p %i", __PRETTY_FUNCTION__ + 53, self, symbolic_sample_size);

  675.             return V3_OK;

  676.         };

  677. 

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

  679.         {

  680.             d_stdout("dpf_audio_processor::get_latency_samples     => %s | %p", __PRETTY_FUNCTION__ + 53, self);

  681.             return 0;

  682.         };

  683. 

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

  685.         {

  686.             d_stdout("dpf_audio_processor::setup_processing        => %s | %p", __PRETTY_FUNCTION__ + 53, self);

  687. 

  688.             d_lastBufferSize = setup->max_block_size;

  689.             d_lastSampleRate = setup->sample_rate;

  690. 

  691.             return V3_OK;

  692.         };

  693. 

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

  695.         {

  696.             d_stdout("dpf_audio_processor::set_processing          => %s | %p %u", __PRETTY_FUNCTION__ + 53, self, state);

  697.             return V3_OK;

  698.         };

  699. 

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

  701.         {

  702.             d_stdout("dpf_audio_processor::process                 => %s | %p", __PRETTY_FUNCTION__ + 53, self);

  703.             return V3_OK;

  704.         };

  705. 

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

  707.         {

  708.             d_stdout("dpf_audio_processor::get_tail_samples        => %s | %p", __PRETTY_FUNCTION__ + 53, self);

  709.             return 0;

  710.         };

  711.     }

  712. };

  713. 

  714. // --------------------------------------------------------------------------------------------------------------------

  715. // dpf_component

  716. 

  717. struct v3_component_cpp : v3_funknown {

  718.     v3_plugin_base base;

  719.     v3_component comp;

  720. };

  721. 

  722. struct dpf_component : v3_component_cpp {

  723.     std::atomic<int> refcounter;

  724.     ScopedPointer<dpf_audio_processor> processor;

  725.     ScopedPointer<dpf_edit_controller> controller;

  726.     ScopedPointer<PluginVst3> vst3;

  727. 

  728.     dpf_component()

  729.         : refcounter(1)

  730.     {

  731.         static const uint8_t* kSupportedBaseFactories[] = {

  732.             v3_funknown_iid,

  733.             v3_plugin_base_iid,

  734.             v3_component_iid

  735.         };

  736. 

  737.         // ------------------------------------------------------------------------------------------------------------

  738.         // v3_funknown

  739. 

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

  741.         {

  742.             d_stdout("dpf_component::query_interface         => %s | %p %s %p", __PRETTY_FUNCTION__ + 41, self, tuid2str(iid), iface);

  743.             *iface = NULL;

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

  745. 

  746.             for (const uint8_t* factory_iid : kSupportedBaseFactories)

  747.             {

  748.                 if (v3_tuid_match(factory_iid, iid))

  749.                 {

  750.                     *iface = self;

  751.                     return V3_OK;

  752.                 }

  753.             }

  754. 

  755.             if (v3_tuid_match(v3_audio_processor_iid, iid))

  756.             {

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

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

  759.                     component->processor = new dpf_audio_processor();

  760.                 *iface = &component->processor;

  761.                 return V3_OK;

  762.             }

  763. 

  764.             if (v3_tuid_match(v3_edit_controller_iid, iid))

  765.             {

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

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

  768.                     component->controller = new dpf_edit_controller(component->vst3);

  769.                 *iface = &component->controller;

  770.                 return V3_OK;

  771.             }

  772. 

  773.             return V3_NO_INTERFACE;

  774.         };

  775. 

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

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

  778.         {

  779.             d_stdout("dpf_component::ref                     => %s | %p", __PRETTY_FUNCTION__ + 41, self);

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

  781.             return ++component->refcounter;

  782.         };

  783. 

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

  785.         {

  786.             d_stdout("dpf_component::unref                   => %s | %p", __PRETTY_FUNCTION__ + 41, self);

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

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

  789.                 return refcounter;

  790.             // delete component;

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

  792.             return 0;

  793.         };

  794. 

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

  796.         // v3_plugin_base

  797. 

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

  799.         {

  800.             d_stdout("dpf_component::initialise              => %s | %p %p", __PRETTY_FUNCTION__ + 41, self, context);

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

  802. 

  803.             // default early values

  804.             if (d_lastBufferSize == 0)

  805.                 d_lastBufferSize = 2048;

  806.             if (d_lastSampleRate <= 0.0)

  807.                 d_lastSampleRate = 44100.0;

  808. 

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

  810.             return V3_OK;

  811.         };

  812. 

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

  814.         {

  815.             d_stdout("dpf_component::terminate               => %s | %p", __PRETTY_FUNCTION__ + 41, self);

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

  817.             component->vst3 = nullptr;

  818.             return V3_OK;

  819.         };

  820. 

  821.         // ------------------------------------------------------------------------------------------------------------

  822.         // v3_component

  823. 

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

  825.         {

  826.             d_stdout("dpf_component::get_controller_class_id => %s | %p %s", __PRETTY_FUNCTION__ + 41, self, tuid2str(class_id));

  827.             return V3_NOT_IMPLEMENTED;

  828.         };

  829. 

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

  831.         {

  832.             d_stdout("dpf_component::set_io_mode             => %s | %p %i", __PRETTY_FUNCTION__ + 41, self, io_mode);

  833.             return V3_INTERNAL_ERR;

  834.         };

  835. 

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

  837.         {

  838.             d_stdout("dpf_component::get_bus_count           => %s | %p %i %i", __PRETTY_FUNCTION__ + 41, self, media_type, bus_direction);

  839.             return 0;

  840.         };

  841. 

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

  843.                                      int32_t bus_idx, v3_bus_info* bus_info) -> v3_result

  844.         {

  845.             d_stdout("dpf_component::get_bus_info            => %s | %p %i %i %i %p", __PRETTY_FUNCTION__ + 41, self, media_type, bus_direction, bus_idx, bus_info);

  846.             return V3_INTERNAL_ERR;

  847.         };

  848. 

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

  850.         {

  851.             d_stdout("dpf_component::get_routing_info        => %s | %p %p %p", __PRETTY_FUNCTION__ + 41, self, input, output);

  852.             return V3_INTERNAL_ERR;

  853.         };

  854. 

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

  856.                                      int32_t bus_idx, v3_bool state) -> v3_result

  857.         {

  858.             d_stdout("dpf_component::activate_bus            => %s | %p %i %i %i %u", __PRETTY_FUNCTION__ + 41, self, media_type, bus_direction, bus_idx, state);

  859.             return V3_INTERNAL_ERR;

  860.         };

  861. 

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

  863.         {

  864.             d_stdout("dpf_component::set_active              => %s | %p %u", __PRETTY_FUNCTION__ + 41, self, state);

  865.             return V3_INTERNAL_ERR;

  866.         };

  867. 

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

  869.         {

  870.             d_stdout("dpf_component::set_state               => %s | %p", __PRETTY_FUNCTION__ + 41, self);

  871.             return V3_INTERNAL_ERR;

  872.         };

  873. 

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

  875.         {

  876.             d_stdout("dpf_component::get_state               => %s | %p", __PRETTY_FUNCTION__ + 41, self);

  877.             return V3_INTERNAL_ERR;

  878.         };

  879.     }

  880. };

  881. 

  882. // --------------------------------------------------------------------------------------------------------------------

  883. // dpf_factory

  884. 

  885. struct v3_plugin_factory_cpp : v3_funknown {

  886.     v3_plugin_factory   v1;

  887.     v3_plugin_factory_2 v2;

  888.     v3_plugin_factory_3 v3;

  889. };

  890. 

  891. struct dpf_factory : v3_plugin_factory_cpp {

  892.     std::vector<dpf_component*> components;

  893. 

  894.     dpf_factory()

  895.     {

  896.         static const uint8_t* kSupportedFactories[] = {

  897.             v3_funknown_iid,

  898.             v3_plugin_factory_iid,

  899.             v3_plugin_factory_2_iid,

  900.             v3_plugin_factory_3_iid

  901.         };

  902. 

  903.         // ------------------------------------------------------------------------------------------------------------

  904.         // v3_funknown

  905. 

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

  907.         {

  908.             d_stdout("dpf_factory::query_interface      => %s | %p %s %p", __PRETTY_FUNCTION__ + 37, self, tuid2str(iid), iface);

  909.             *iface = NULL;

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

  911. 

  912.             for (const uint8_t* factory_iid : kSupportedFactories)

  913.             {

  914.                 if (v3_tuid_match(factory_iid, iid))

  915.                 {

  916.                     *iface = self;

  917.                     return V3_OK;

  918.                 }

  919.             }

  920. 

  921.             return V3_NO_INTERFACE;

  922.         };

  923. 

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

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

  926.         {

  927.             d_stdout("dpf_factory::ref                  => %s | %p", __PRETTY_FUNCTION__ + 37, self);

  928.             return 1;

  929.         };

  930. 

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

  932.         {

  933.             d_stdout("dpf_factory::unref                => %s | %p", __PRETTY_FUNCTION__ + 37, self);

  934.             return 0;

  935.         };

  936. 

  937.         // ------------------------------------------------------------------------------------------------------------

  938.         // v3_plugin_factory

  939. 

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

  941.         {

  942.             d_stdout("dpf_factory::get_factory_info     => %s | %p %p", __PRETTY_FUNCTION__ + 37, self, info);

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

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

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

  946.             return V3_OK;

  947.         };

  948. 

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

  950.         {

  951.             d_stdout("dpf_factory::num_classes          => %s | %p", __PRETTY_FUNCTION__ + 37, self);

  952.             return 1;

  953.         };

  954. 

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

  956.         {

  957.             d_stdout("dpf_factory::get_class_info       => %s | %p %i %p", __PRETTY_FUNCTION__ + 37, self, idx, info);

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

  959. 

  960.             memcpy(info->class_id, dpf_tuid_class, sizeof(v3_tuid));

  961.             info->cardinality = 0x7FFFFFFF;

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

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

  964.             return V3_OK;

  965.         };

  966. 

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

  968.         {

  969.             d_stdout("dpf_factory::create_instance      => %s | %p %s %s %p", __PRETTY_FUNCTION__ + 37, self, tuid2str(class_id), tuid2str(iid), instance);

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

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

  972. 

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

  974.             dpf_component* const component = new dpf_component();

  975.             factory->components.push_back(component);

  976.             *instance = &factory->components.back();

  977.             return V3_OK;

  978.         };

  979. 

  980.         // ------------------------------------------------------------------------------------------------------------

  981.         // v3_plugin_factory_2

  982. 

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

  984.         {

  985.             d_stdout("dpf_factory::get_class_info_2     => %s | %p %i %p", __PRETTY_FUNCTION__ + 37, self, idx, info);

  986.             memcpy(info->class_id, dpf_tuid_class, sizeof(v3_tuid));

  987.             info->cardinality = 0x7FFFFFFF;

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

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

  990. 

  991.             info->class_flags = 0;

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

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

  994.             std::snprintf(info->version, sizeof(info->version), "%u", gPluginInfo->getVersion()); // TODO

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

  996.             return V3_OK;

  997.         };

  998. 

  999.         // ------------------------------------------------------------------------------------------------------------

  1000.         // v3_plugin_factory_3

  1001. 

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

  1003.         {

  1004.             d_stdout("dpf_factory::get_class_info_utf16 => %s | %p %i %p", __PRETTY_FUNCTION__ + 37, self, idx, info);

  1005.             memcpy(info->class_id, dpf_tuid_class, sizeof(v3_tuid));

  1006.             info->cardinality = 0x7FFFFFFF;

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

  1008.             DISTRHO_NAMESPACE::strncpy_16from8(info->name, gPluginInfo->getName(), sizeof(info->name));

  1009. 

  1010.             info->class_flags = 0;

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

  1012.             DISTRHO_NAMESPACE::strncpy_16from8(info->vendor, gPluginInfo->getMaker(), sizeof(info->vendor));

  1013.             // DISTRHO_NAMESPACE::snprintf16(info->version, sizeof(info->version)/sizeof(info->version[0]), "%u", gPluginInfo->getVersion()); // TODO

  1014.             DISTRHO_NAMESPACE::strncpy_16from8(info->sdk_version, "Travesty", sizeof(info->sdk_version)); // TESTING use "VST 3.7" ?

  1015.             return V3_OK;

  1016.         };

  1017. 

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

  1019.         {

  1020.             d_stdout("dpf_factory::set_host_context     => %s | %p %p", __PRETTY_FUNCTION__ + 37, self, host);

  1021.             return V3_NOT_IMPLEMENTED;

  1022.         };

  1023.     }

  1024. };

  1025. 

  1026. END_NAMESPACE_DISTRHO

  1027. 

  1028. // --------------------------------------------------------------------------------------------------------------------

  1029. // VST3 entry point

  1030. 

  1031. DISTRHO_PLUGIN_EXPORT

  1032. const void* GetPluginFactory(void);

  1033. 

  1034. const void* GetPluginFactory(void)

  1035. {

  1036.     USE_NAMESPACE_DISTRHO;

  1037.     static const dpf_factory factory;

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

  1039.     return &factoryptr;

  1040. }

  1041. 

  1042. // --------------------------------------------------------------------------------------------------------------------

  1043. // OS specific module load

  1044. 

  1045. #if defined(DISTRHO_OS_MAC)

  1046. # define ENTRYFNNAME bundleEntry

  1047. # define EXITFNNAME bundleExit

  1048. #elif defined(DISTRHO_OS_WINDOWS)

  1049. # define ENTRYFNNAME InitDll

  1050. # define EXITFNNAME ExitDll

  1051. #else

  1052. # define ENTRYFNNAME ModuleEntry

  1053. # define EXITFNNAME ModuleExit

  1054. #endif

  1055. 

  1056. DISTRHO_PLUGIN_EXPORT

  1057. bool ENTRYFNNAME(void*);

  1058. 

  1059. bool ENTRYFNNAME(void*)

  1060. {

  1061.     USE_NAMESPACE_DISTRHO;

  1062. 

  1063.     if (gPluginInfo == nullptr)

  1064.     {

  1065.         d_lastBufferSize = 512;

  1066.         d_lastSampleRate = 44100.0;

  1067.         gPluginInfo = new PluginExporter(nullptr, nullptr, nullptr);

  1068.         d_lastBufferSize = 0;

  1069.         d_lastSampleRate = 0.0;

  1070. 

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

  1072.             = dpf_tuid_processor[2] = dpf_tuid_view[2] = gPluginInfo->getUniqueId();

  1073.     }

  1074. 

  1075.     return true;

  1076. }

  1077. 

  1078. DISTRHO_PLUGIN_EXPORT

  1079. bool EXITFNNAME(void);

  1080. 

  1081. bool EXITFNNAME(void)

  1082. {

  1083.     USE_NAMESPACE_DISTRHO;

  1084.     gPluginInfo = nullptr;

  1085.     return true;

  1086. }

  1087. 

  1088. #undef ENTRYFNNAME

  1089. #undef EXITFNNAME

  1090. 

  1091. // --------------------------------------------------------------------------------------------------------------------