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

3620 lines
132KB
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. #if DISTRHO_PLUGIN_HAS_UI && ! DISTRHO_PLUGIN_HAS_EMBED_UI

  21. # undef DISTRHO_PLUGIN_HAS_UI

  22. # define DISTRHO_PLUGIN_HAS_UI 0

  23. #endif

  24. 

  25. #if DISTRHO_PLUGIN_HAS_UI && ! defined(HAVE_DGL) && ! DISTRHO_PLUGIN_HAS_EXTERNAL_UI

  26. # undef DISTRHO_PLUGIN_HAS_UI

  27. # define DISTRHO_PLUGIN_HAS_UI 0

  28. #endif

  29. 

  30. #if DISTRHO_PLUGIN_HAS_UI

  31. # include "../extra/RingBuffer.hpp"

  32. #endif

  33. 

  34. #include "travesty/audio_processor.h"

  35. #include "travesty/component.h"

  36. #include "travesty/edit_controller.h"

  37. #include "travesty/factory.h"

  38. #include "travesty/message.h"

  39. 

  40. #include <atomic>

  41. #include <map>

  42. #include <string>

  43. #include <vector>

  44. 

  45. /* TODO items:

  46.  * - base component refcount handling

  47.  * - parameter enumeration as lists

  48.  * - hide parameter outputs?

  49.  * - hide program parameter?

  50.  * - deal with parameter triggers

  51.  * - midi cc parameter mapping

  52.  * - full MIDI1 encode and decode

  53.  * - decode version number (0x010203 -> 1.2.3)

  54.  * - bus arrangements

  55.  * - optional audio buses, create dummy buffer of max_block_size length for them

  56.  * - routing info, do we care?

  57.  * - set sidechain bus name from port group

  58.  * - implement getParameterValueForString (use names from enumeration if available, fallback to std::atof)

  59.  * - set factory class_flags

  60.  * - set factory sub_categories

  61.  * - set factory email (needs new DPF API, useful for LV2 as well)

  62.  * - do something with get_controller_class_id and set_io_mode?

  63.  * - replace dpf_message_create with host-side message creation

  64.  */

  65. 

  66. START_NAMESPACE_DISTRHO

  67. 

  68. // --------------------------------------------------------------------------------------------------------------------

  69. 

  70. #if ! DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  71. static constexpr const writeMidiFunc writeMidiCallback = nullptr;

  72. #endif

  73. #if ! DISTRHO_PLUGIN_WANT_PARAMETER_VALUE_CHANGE_REQUEST

  74. static constexpr const requestParameterValueChangeFunc requestParameterValueChangeCallback = nullptr;

  75. #endif

  76. 

  77. typedef std::map<const String, String> StringMap;

  78. 

  79. // --------------------------------------------------------------------------------------------------------------------

  80. // custom v3_tuid compatible type

  81. 

  82. typedef uint32_t dpf_tuid[4];

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

  84. 

  85. // --------------------------------------------------------------------------------------------------------------------

  86. // custom, constant uids related to DPF

  87. 

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

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

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

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

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

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

  94. 

  95. // --------------------------------------------------------------------------------------------------------------------

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

  97. 

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

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

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

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

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

  103. 

  104. // --------------------------------------------------------------------------------------------------------------------

  105. // custom attribute list struct, used for sending utf8 strings

  106. 

  107. struct v3_attribute_list_utf8 {

  108.     struct v3_funknown;

  109.     v3_result (V3_API *set_string_utf8)(void* self, const char* id, const char* string);

  110.     v3_result (V3_API *get_string_utf8)(void* self, const char* id, char* string, uint32_t size);

  111. };

  112. 

  113. static constexpr const v3_tuid v3_attribute_list_utf8_iid =

  114.     V3_ID(d_cconst('D','P','F',' '),

  115.           d_cconst('c','l','a','s'),

  116.           d_cconst('a','t','t','r'),

  117.           d_cconst('u','t','f','8'));

  118. 

  119. // --------------------------------------------------------------------------------------------------------------------

  120. // Utility functions

  121. 

  122. const char* tuid2str(const v3_tuid iid)

  123. {

  124.     static constexpr const struct {

  125.         v3_tuid iid;

  126.         const char* name;

  127.     } extra_known_iids[] = {

  128.         { V3_ID(0x00000000,0x00000000,0x00000000,0x00000000), "(nil)" },

  129.         // edit-controller

  130.         { V3_ID(0xF040B4B3,0xA36045EC,0xABCDC045,0xB4D5A2CC), "{v3_component_handler2|NOT}" },

  131.         { V3_ID(0x7F4EFE59,0xF3204967,0xAC27A3AE,0xAFB63038), "{v3_edit_controller2|NOT}" },

  132.         { V3_ID(0x067D02C1,0x5B4E274D,0xA92D90FD,0x6EAF7240), "{v3_component_handler_bus_activation|NOT}" },

  133.         { V3_ID(0xDF0FF9F7,0x49B74669,0xB63AB732,0x7ADBF5E5), "{v3_midi_mapping|NOT}" },

  134.         { V3_ID(0xC1271208,0x70594098,0xB9DD34B3,0x6BB0195E), "{v3_edit_controller_host_editing|NOT}" },

  135.         // units

  136.         { V3_ID(0x8683B01F,0x7B354F70,0xA2651DEC,0x353AF4FF), "{v3_program_list_data|NOT}" },

  137.         { V3_ID(0x6C389611,0xD391455D,0xB870B833,0x94A0EFDD), "{v3_unit_data|NOT}" },

  138.         { V3_ID(0x4B5147F8,0x4654486B,0x8DAB30BA,0x163A3C56), "{v3_unit_handler|NOT}" },

  139.         { V3_ID(0xF89F8CDF,0x699E4BA5,0x96AAC9A4,0x81452B01), "{v3_unit_handler2|NOT}" },

  140.         { V3_ID(0x3D4BD6B5,0x913A4FD2,0xA886E768,0xA5EB92C1), "{v3_unit_info|NOT}" },

  141.         // misc

  142.         { V3_ID(0x0F194781,0x8D984ADA,0xBBA0C1EF,0xC011D8D0), "{v3_info_listener|NOT}" },

  143.     };

  144. 

  145.     if (v3_tuid_match(iid, v3_audio_processor_iid))

  146.         return "{v3_audio_processor}";

  147.     if (v3_tuid_match(iid, v3_attribute_list_iid))

  148.         return "{v3_attribute_list_iid}";

  149.     if (v3_tuid_match(iid, v3_attribute_list_utf8_iid))

  150.         return "{v3_attribute_list_utf8_iid|CUSTOM}";

  151.     if (v3_tuid_match(iid, v3_bstream_iid))

  152.         return "{v3_bstream}";

  153.     if (v3_tuid_match(iid, v3_component_iid))

  154.         return "{v3_component}";

  155.     if (v3_tuid_match(iid, v3_component_handler_iid))

  156.         return "{v3_component_handler}";

  157.     if (v3_tuid_match(iid, v3_connection_point_iid))

  158.         return "{v3_connection_point_iid}";

  159.     if (v3_tuid_match(iid, v3_edit_controller_iid))

  160.         return "{v3_edit_controller}";

  161.     if (v3_tuid_match(iid, v3_event_list_iid))

  162.         return "{v3_event_list}";

  163.     if (v3_tuid_match(iid, v3_funknown_iid))

  164.         return "{v3_funknown}";

  165.     if (v3_tuid_match(iid, v3_message_iid))

  166.         return "{v3_message_iid}";

  167.     if (v3_tuid_match(iid, v3_param_value_queue_iid))

  168.         return "{v3_param_value_queue}";

  169.     if (v3_tuid_match(iid, v3_param_changes_iid))

  170.         return "{v3_param_changes}";

  171.     if (v3_tuid_match(iid, v3_plugin_base_iid))

  172.         return "{v3_plugin_base}";

  173.     if (v3_tuid_match(iid, v3_plugin_factory_iid))

  174.         return "{v3_plugin_factory}";

  175.     if (v3_tuid_match(iid, v3_plugin_factory_2_iid))

  176.         return "{v3_plugin_factory_2}";

  177.     if (v3_tuid_match(iid, v3_plugin_factory_3_iid))

  178.         return "{v3_plugin_factory_3}";

  179.     if (v3_tuid_match(iid, v3_plugin_frame_iid))

  180.         return "{v3_plugin_frame}";

  181.     if (v3_tuid_match(iid, v3_plugin_view_iid))

  182.         return "{v3_plugin_view}";

  183.     if (v3_tuid_match(iid, v3_plugin_view_content_scale_iid))

  184.         return "{v3_plugin_view_content_scale_iid}";

  185.     if (v3_tuid_match(iid, v3_plugin_view_parameter_finder_iid))

  186.         return "{v3_plugin_view_parameter_finder}";

  187.     if (v3_tuid_match(iid, v3_process_context_requirements_iid))

  188.         return "{v3_process_context_requirements}";

  189. 

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

  191.         return "{dpf_tuid_class}";

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

  193.         return "{dpf_tuid_component}";

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

  195.         return "{dpf_tuid_controller}";

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

  197.         return "{dpf_tuid_processor}";

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

  199.         return "{dpf_tuid_view}";

  200. 

  201.     for (size_t i=0; i<ARRAY_SIZE(extra_known_iids); ++i)

  202.     {

  203.         if (v3_tuid_match(iid, extra_known_iids[i].iid))

  204.             return extra_known_iids[i].name;

  205.     }

  206. 

  207.     static char buf[46];

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

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

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

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

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

  213.     return buf;

  214. }

  215. 

  216. // --------------------------------------------------------------------------------------------------------------------

  217. 

  218. static void strncpy(char* const dst, const char* const src, const size_t length)

  219. {

  220.     DISTRHO_SAFE_ASSERT_RETURN(length > 0,);

  221. 

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

  223.     {

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

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

  226.     }

  227.     else

  228.     {

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

  230.     }

  231. }

  232. 

  233. void strncpy_utf16(int16_t* const dst, const char* const src, const size_t length)

  234. {

  235.     DISTRHO_SAFE_ASSERT_RETURN(length > 0,);

  236. 

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

  238.     {

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

  240.         {

  241.             // skip non-ascii chars

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

  243.                 continue;

  244. 

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

  246.         }

  247.         dst[len] = 0;

  248.     }

  249.     else

  250.     {

  251.         dst[0] = 0;

  252.     }

  253. }

  254. 

  255. // --------------------------------------------------------------------------------------------------------------------

  256. 

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

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

  259. {

  260.     DISTRHO_SAFE_ASSERT_RETURN(size > 0,);

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

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

  263. }

  264. 

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

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

  267. {

  268.     DISTRHO_SAFE_ASSERT_RETURN(size > 0,);

  269. 

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

  271.     DISTRHO_SAFE_ASSERT_RETURN(tmpbuf != nullptr,);

  272. 

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

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

  275. 

  276.     strncpy_utf16(dst, tmpbuf, size);

  277.     std::free(tmpbuf);

  278. }

  279. 

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

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

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

  283. 

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

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

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

  287. 

  288. // --------------------------------------------------------------------------------------------------------------------

  289. // create message object (implementation comes later)

  290. 

  291. v3_message** dpf_message_create(const char* id);

  292. 

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

  294. // dpf_plugin_view_create (implemented on UI side)

  295. 

  296. v3_plugin_view** dpf_plugin_view_create(void* instancePointer, double sampleRate);

  297. 

  298. // --------------------------------------------------------------------------------------------------------------------

  299. 

  300. /**

  301.  * VST3 DSP class.

  302.  *

  303.  * All the dynamic things from VST3 get implemented here, free of complex low-level VST3 pointer things.

  304.  * The DSP is created during the "initialise" component event, and destroyed during "terminate".

  305.  *

  306.  * The low-level VST3 stuff comes after.

  307.  */

  308. class PluginVst3

  309. {

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

  311.      * Main audio comes first, if available.

  312.      * Then sidechain, also if available.

  313.      * And finally each CV port individually.

  314.      *

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

  316.      */

  317.     struct BusInfo {

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

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

  320.         uint32_t numMainAudio = 0;

  321.         uint32_t numSidechain = 0;

  322.         uint32_t numCV = 0;

  323.     } inputBuses, outputBuses;

  324. 

  325. public:

  326.     PluginVst3()

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

  328.           fComponentHandler(nullptr),

  329. #if DISTRHO_PLUGIN_HAS_UI

  330.           fConnection(nullptr),

  331. #endif

  332.           fParameterOffset(fPlugin.getParameterOffset()),

  333.           fRealParameterCount(fParameterOffset + fPlugin.getParameterCount()),

  334.           fParameterValues(nullptr),

  335.           fChangedParameterValues(nullptr)

  336. #if DISTRHO_PLUGIN_HAS_UI

  337.         , fConnectedToUI(false)

  338.         , fNextSampleRate(0.0)

  339. #endif

  340. #if DISTRHO_PLUGIN_WANT_LATENCY

  341.         , fLastKnownLatency(fPlugin.getLatency())

  342. #endif

  343. #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  344.         , fHostEventOutputHandle(nullptr)

  345. #endif

  346. #if DISTRHO_PLUGIN_WANT_PROGRAMS

  347.         , fCurrentProgram(0)

  348.         , fProgramCountMinusOne(fPlugin.getProgramCount()-1)

  349. #endif

  350.     {

  351. #if DISTRHO_PLUGIN_NUM_INPUTS > 0

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

  353.         {

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

  355. 

  356.             if (hints & kAudioPortIsCV)

  357.                 ++inputBuses.numCV;

  358.             else

  359.                 ++inputBuses.numMainAudio;

  360. 

  361.             if (hints & kAudioPortIsSidechain)

  362.                 ++inputBuses.numSidechain;

  363.         }

  364. 

  365.         if (inputBuses.numMainAudio != 0)

  366.             inputBuses.audio = 1;

  367.         if (inputBuses.numSidechain != 0)

  368.             inputBuses.sidechain = 1;

  369. 

  370.         uint32_t cvInputBusId = 0;

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

  372.         {

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

  374. 

  375.             if (port.hints & kAudioPortIsCV)

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

  377.             else if (port.hints & kAudioPortIsSidechain)

  378.                 port.busId = 1;

  379.             else

  380.                 port.busId = 0;

  381.         }

  382. #endif

  383. #if DISTRHO_PLUGIN_NUM_OUTPUTS > 0

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

  385.         {

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

  387. 

  388.             if (hints & kAudioPortIsCV)

  389.                 ++outputBuses.numCV;

  390.             else

  391.                 ++outputBuses.numMainAudio;

  392. 

  393.             if (hints & kAudioPortIsSidechain)

  394.                 ++outputBuses.numSidechain;

  395.         }

  396. 

  397.         if (outputBuses.numMainAudio != 0)

  398.             outputBuses.audio = 1;

  399.         if (outputBuses.numSidechain != 0)

  400.             outputBuses.sidechain = 1;

  401. 

  402.         uint32_t cvOutputBusId = 0;

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

  404.         {

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

  406. 

  407.             if (port.hints & kAudioPortIsCV)

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

  409.             else if (port.hints & kAudioPortIsSidechain)

  410.                 port.busId = 1;

  411.             else

  412.                 port.busId = 0;

  413.         }

  414. #endif

  415. 

  416.         if (const uint32_t parameterCount = fPlugin.getParameterCount())

  417.         {

  418.             fParameterValues = new float[parameterCount];

  419. 

  420.             for (uint32_t i=0; i < parameterCount; ++i)

  421.                 fParameterValues[i] = fPlugin.getParameterDefault(i);

  422.         }

  423. 

  424.         if (fRealParameterCount != 0)

  425.         {

  426.             fChangedParameterValues = new bool[fRealParameterCount];

  427.             std::memset(fChangedParameterValues, 0, sizeof(bool)*fRealParameterCount);

  428.         }

  429. 

  430. #if DISTRHO_PLUGIN_WANT_STATE

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

  432.         {

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

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

  435.         }

  436. #endif

  437.     }

  438. 

  439.     ~PluginVst3()

  440.     {

  441.         if (fParameterValues != nullptr)

  442.         {

  443.             delete[] fParameterValues;

  444.             fParameterValues = nullptr;

  445.         }

  446. 

  447.         if (fChangedParameterValues != nullptr)

  448.         {

  449.             delete[] fChangedParameterValues;

  450.             fChangedParameterValues = nullptr;

  451.         }

  452.     }

  453. 

  454.     // ----------------------------------------------------------------------------------------------------------------

  455.     // stuff called for UI creation

  456. 

  457.     void* getInstancePointer() const noexcept

  458.     {

  459.         return fPlugin.getInstancePointer();

  460.     }

  461. 

  462.     double getSampleRate() const noexcept

  463.     {

  464.         return fPlugin.getSampleRate();

  465.     }

  466. 

  467.     // ----------------------------------------------------------------------------------------------------------------

  468.     // v3_component interface calls

  469. 

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

  471.     {

  472.         switch (mediaType)

  473.         {

  474.         case V3_AUDIO:

  475.             if (busDirection == V3_INPUT)

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

  477.             if (busDirection == V3_OUTPUT)

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

  479.             break;

  480.         case V3_EVENT:

  481. #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  482.             if (busDirection == V3_INPUT)

  483.                 return 1;

  484. #endif

  485. #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  486.             if (busDirection == V3_OUTPUT)

  487.                 return 1;

  488. #endif

  489.             break;

  490.         }

  491. 

  492.         return 0;

  493.     }

  494. 

  495.     v3_result getBusInfo(const int32_t mediaType,

  496.                          const int32_t busDirection,

  497.                          const int32_t busIndex,

  498.                          v3_bus_info* const info) const

  499.     {

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

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

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

  503. 

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

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

  506. #endif

  507. 

  508.         if (mediaType == V3_AUDIO)

  509.         {

  510.            #if DISTRHO_PLUGIN_NUM_INPUTS+DISTRHO_PLUGIN_NUM_OUTPUTS > 0

  511.             int32_t numChannels;

  512.             v3_bus_flags flags;

  513.             v3_bus_types busType;

  514.             v3_str_128 busName = {};

  515. 

  516.             if (busDirection == V3_INPUT)

  517.             {

  518.                #if DISTRHO_PLUGIN_NUM_INPUTS > 0

  519.                 switch (busId)

  520.                 {

  521.                 case 0:

  522.                     if (inputBuses.audio)

  523.                     {

  524.                         numChannels = inputBuses.numMainAudio;

  525.                         busType = V3_MAIN;

  526.                         flags = V3_DEFAULT_ACTIVE;

  527.                         break;

  528.                     }

  529.                 // fall-through

  530.                 case 1:

  531.                     if (inputBuses.sidechain)

  532.                     {

  533.                         numChannels = inputBuses.numSidechain;

  534.                         busType = V3_AUX;

  535.                         flags = v3_bus_flags(0);

  536.                         break;

  537.                     }

  538.                 // fall-through

  539.                 default:

  540.                     numChannels = 1;

  541.                     busType = V3_AUX;

  542.                     flags = V3_IS_CONTROL_VOLTAGE;

  543.                     break;

  544.                 }

  545. 

  546.                 if (busType == V3_MAIN)

  547.                 {

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

  549.                 }

  550.                 else

  551.                 {

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

  553.                     {

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

  555. 

  556.                         // TODO find port group name for sidechain buses

  557.                         if (port.busId == busId)

  558.                         {

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

  560.                             break;

  561.                         }

  562.                     }

  563.                 }

  564.                #else

  565.                 return V3_INVALID_ARG;

  566.                #endif // DISTRHO_PLUGIN_NUM_INPUTS

  567.             }

  568.             else

  569.             {

  570.                #if DISTRHO_PLUGIN_NUM_OUTPUTS > 0

  571.                 switch (busId)

  572.                 {

  573.                 case 0:

  574.                     if (outputBuses.audio)

  575.                     {

  576.                         numChannels = outputBuses.numMainAudio;

  577.                         busType = V3_MAIN;

  578.                         flags = V3_DEFAULT_ACTIVE;

  579.                         break;

  580.                     }

  581.                 // fall-through

  582.                 case 1:

  583.                     if (outputBuses.sidechain)

  584.                     {

  585.                         numChannels = outputBuses.numSidechain;

  586.                         busType = V3_AUX;

  587.                         flags = v3_bus_flags(0);

  588.                         break;

  589.                     }

  590.                 // fall-through

  591.                 default:

  592.                     numChannels = 1;

  593.                     busType = V3_AUX;

  594.                     flags = V3_IS_CONTROL_VOLTAGE;

  595.                     break;

  596.                 }

  597. 

  598.                 if (busType == V3_MAIN)

  599.                 {

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

  601.                 }

  602.                 else

  603.                 {

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

  605.                     {

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

  607. 

  608.                         // TODO find port group name for sidechain buses

  609.                         if (port.busId == busId)

  610.                         {

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

  612.                             break;

  613.                         }

  614.                     }

  615.                 }

  616.                #else

  617.                 return V3_INVALID_ARG;

  618.                #endif // DISTRHO_PLUGIN_NUM_OUTPUTS

  619.             }

  620. 

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

  622.             info->media_type = V3_AUDIO;

  623.             info->direction = busDirection;

  624.             info->channel_count = numChannels;

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

  626.             info->bus_type = busType;

  627.             info->flags = flags;

  628.             return V3_OK;

  629.            #else

  630.             return V3_INVALID_ARG;

  631.            #endif // DISTRHO_PLUGIN_NUM_INPUTS+DISTRHO_PLUGIN_NUM_OUTPUTS

  632.         }

  633.         else

  634.         {

  635.             if (busDirection == V3_INPUT)

  636.             {

  637.                #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

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

  639.                #else

  640.                 return V3_INVALID_ARG;

  641.                #endif

  642.             }

  643.             else

  644.             {

  645.                #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

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

  647.                #else

  648.                 return V3_INVALID_ARG;

  649.                #endif

  650.             }

  651.             info->media_type = V3_EVENT;

  652.             info->direction = busDirection;

  653.             info->channel_count = 1;

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

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

  656.             info->bus_type = V3_MAIN;

  657.             info->flags = V3_DEFAULT_ACTIVE;

  658.             return V3_OK;

  659.         }

  660.     }

  661. 

  662.     v3_result getRoutingInfo(v3_routing_info*, v3_routing_info*)

  663.     {

  664.         // TODO

  665.         return V3_NOT_IMPLEMENTED;

  666.     }

  667. 

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

  669.                           const int32_t /* busDirection */,

  670.                           const int32_t /* busIndex */,

  671.                           const bool /* state */)

  672.     {

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

  674.         return V3_OK;

  675.     }

  676. 

  677.     v3_result setActive(const bool active)

  678.     {

  679.         if (active)

  680.             fPlugin.activate();

  681.         else

  682.             fPlugin.deactivateIfNeeded();

  683. 

  684.         return V3_OK;

  685.     }

  686. 

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

  688.      * current-program comes first, then dpf key/value states and then parameters.

  689.      * parameters are simply converted to/from strings and floats.

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

  691.      * there are markers for begin and end of state and parameters, so they never conflict.

  692.      */

  693.     v3_result setState(v3_bstream** const stream)

  694.     {

  695. #if DISTRHO_PLUGIN_HAS_UI

  696.         const bool connectedToUI = fConnection != nullptr && fConnectedToUI;

  697. #endif

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

  699. 

  700.         String key, value;

  701.         bool fillingKey = true; // if filling key or value

  702.         char queryingType = 'i'; // can be 'n', 's' or 'p' (none, states, parameters)

  703. 

  704.         char buffer[512], orig;

  705.         buffer[sizeof(buffer)-1] = '\xff';

  706.         v3_result res;

  707. 

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

  709.         {

  710.             res = v3_cpp_obj(stream)->read(stream, buffer, sizeof(buffer)-1, &read);

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

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

  713. 

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

  715.             {

  716.                 // found terminator, stop here

  717.                 if (buffer[i] == '\xfe')

  718.                 {

  719.                     term = 1;

  720.                     break;

  721.                 }

  722. 

  723.                 // store character at read position

  724.                 orig = buffer[read];

  725. 

  726.                 // place null character to create valid string

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

  728. 

  729.                 // append to temporary vars

  730.                 if (fillingKey)

  731.                     key += buffer + i;

  732.                 else

  733.                     value += buffer + i;

  734. 

  735.                 // increase buffer offset by length of string

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

  737. 

  738.                 // restore read character

  739.                 buffer[read] = orig;

  740. 

  741.                 // if buffer offset points to null, we found the end of a string, lets check

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

  743.                 {

  744.                     // special keys

  745.                     if (key == "__dpf_state_begin__")

  746.                     {

  747.                         DISTRHO_SAFE_ASSERT_INT_RETURN(queryingType == 'i' || queryingType == 'n',

  748.                                                        queryingType, V3_INTERNAL_ERR);

  749.                         queryingType = 's';

  750.                         key.clear();

  751.                         value.clear();

  752.                         continue;

  753.                     }

  754.                     if (key == "__dpf_state_end__")

  755.                     {

  756.                         DISTRHO_SAFE_ASSERT_INT_RETURN(queryingType == 's', queryingType, V3_INTERNAL_ERR);

  757.                         queryingType = 'n';

  758.                         key.clear();

  759.                         value.clear();

  760.                         continue;

  761.                     }

  762.                     if (key == "__dpf_parameters_begin__")

  763.                     {

  764.                         DISTRHO_SAFE_ASSERT_INT_RETURN(queryingType == 'i' || queryingType == 'n',

  765.                                                        queryingType, V3_INTERNAL_ERR);

  766.                         queryingType = 'p';

  767.                         key.clear();

  768.                         value.clear();

  769.                         continue;

  770.                     }

  771.                     if (key == "__dpf_parameters_end__")

  772.                     {

  773.                         DISTRHO_SAFE_ASSERT_INT_RETURN(queryingType == 'p', queryingType, V3_INTERNAL_ERR);

  774.                         queryingType = 'x';

  775.                         key.clear();

  776.                         value.clear();

  777.                         continue;

  778.                     }

  779. 

  780.                     // no special key, swap between reading real key and value

  781.                     fillingKey = !fillingKey;

  782. 

  783.                     // if there is no value yet keep reading until we have one (TODO check empty values on purpose)

  784.                     if (value.isEmpty())

  785.                         continue;

  786. 

  787.                     if (key == "__dpf_program__")

  788.                     {

  789.                         DISTRHO_SAFE_ASSERT_INT_RETURN(queryingType == 'i', queryingType, V3_INTERNAL_ERR);

  790.                         queryingType = 'n';

  791. 

  792.                         d_stdout("found program '%s'", value.buffer());

  793. 

  794. #if DISTRHO_PLUGIN_WANT_PROGRAMS

  795.                         const int program = std::atoi(value.buffer());

  796.                         DISTRHO_SAFE_ASSERT_CONTINUE(program >= 0);

  797. 

  798.                         fCurrentProgram = static_cast<uint32_t>(program);

  799.                         fPlugin.loadProgram(fCurrentProgram);

  800. 

  801. # if DISTRHO_PLUGIN_HAS_UI

  802.                         if (connectedToUI)

  803.                         {

  804.                             fChangedParameterValues[0] = false;

  805.                             sendParameterChangeToUI(0, fCurrentProgram);

  806.                         }

  807. # endif

  808. #endif

  809.                     }

  810.                     else if (queryingType == 's')

  811.                     {

  812.                         d_stdout("found state '%s' '%s'", key.buffer(), value.buffer());

  813. 

  814. #if DISTRHO_PLUGIN_WANT_STATE

  815.                         if (fPlugin.wantStateKey(key))

  816.                         {

  817.                             fStateMap[key] = value;

  818.                             fPlugin.setState(key, value);

  819. 

  820. # if DISTRHO_PLUGIN_HAS_UI

  821.                             if (connectedToUI)

  822.                                 sendStateChangeToUI(key, value);

  823. # endif

  824.                         }

  825. #endif

  826.                     }

  827.                     else if (queryingType == 'p')

  828.                     {

  829.                         d_stdout("found parameter '%s' '%s'", key.buffer(), value.buffer());

  830. 

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

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

  833.                         {

  834.                             if (fPlugin.isParameterOutputOrTrigger(j))

  835.                                 continue;

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

  837.                                 continue;

  838. 

  839.                             const float fvalue = fParameterValues[i] = std::atof(value.buffer());

  840.                             fPlugin.setParameterValue(j, fvalue);

  841. #if DISTRHO_PLUGIN_HAS_UI

  842.                             if (connectedToUI)

  843.                             {

  844.                                 // UI parameter updates are handled outside the read loop (after host param restart)

  845.                                 fChangedParameterValues[j + fParameterOffset] = true;

  846.                             }

  847. #endif

  848.                             break;

  849.                         }

  850. 

  851.                     }

  852. 

  853.                     key.clear();

  854.                     value.clear();

  855.                 }

  856.             }

  857.         }

  858. 

  859.         if (paramCount != 0)

  860.         {

  861.             if (fComponentHandler != nullptr)

  862.                 v3_cpp_obj(fComponentHandler)->restart_component(fComponentHandler, V3_RESTART_PARAM_VALUES_CHANGED);

  863. 

  864. #if DISTRHO_PLUGIN_HAS_UI

  865.             if (connectedToUI)

  866.             {

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

  868.                 {

  869.                     if (fPlugin.isParameterOutputOrTrigger(i))

  870.                         continue;

  871.                     fChangedParameterValues[i + fParameterOffset] = false;

  872.                     sendParameterChangeToUI(i + fParameterOffset, fParameterValues[i]);

  873.                 }

  874.             }

  875. #endif

  876.         }

  877. 

  878.         return V3_OK;

  879.     }

  880. 

  881.     v3_result getState(v3_bstream** const stream)

  882.     {

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

  884. #if DISTRHO_PLUGIN_WANT_STATE

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

  886. #else

  887.         const uint32_t stateCount = 0;

  888. #endif

  889. 

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

  891.         {

  892.             char buffer = '\0';

  893.             int32_t ignored;

  894.             return v3_cpp_obj(stream)->write(stream, &buffer, 1, &ignored);

  895.         }

  896. 

  897. #if DISTRHO_PLUGIN_WANT_FULL_STATE

  898.         // Update current state

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

  900.         {

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

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

  903.         }

  904. #endif

  905. 

  906.         String state;

  907. 

  908. #if DISTRHO_PLUGIN_WANT_PROGRAMS

  909.         {

  910.             String tmpStr("__dpf_program__\xff");

  911.             tmpStr += String(fCurrentProgram);

  912.             tmpStr += "\xff";

  913. 

  914.             state += tmpStr;

  915.         }

  916. #endif

  917. 

  918. #if DISTRHO_PLUGIN_WANT_STATE

  919.         if (stateCount != 0)

  920.         {

  921.             state += "__dpf_state_begin__\xff";

  922. 

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

  924.             {

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

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

  927. 

  928.                 // join key and value

  929.                 String tmpStr;

  930.                 tmpStr  = key;

  931.                 tmpStr += "\xff";

  932.                 tmpStr += value;

  933.                 tmpStr += "\xff";

  934. 

  935.                 state += tmpStr;

  936.             }

  937. 

  938.             state += "__dpf_state_end__\xff";

  939.         }

  940. #endif

  941. 

  942.         if (paramCount != 0)

  943.         {

  944.             state += "__dpf_parameters_begin__\xff";

  945. 

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

  947.             {

  948.                 if (fPlugin.isParameterOutputOrTrigger(i))

  949.                     continue;

  950. 

  951.                 // join key and value

  952.                 String tmpStr;

  953.                 tmpStr  = fPlugin.getParameterSymbol(i);

  954.                 tmpStr += "\xff";

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

  956.                 tmpStr += "\xff";

  957. 

  958.                 state += tmpStr;

  959.             }

  960. 

  961.             state += "__dpf_parameters_end__\xff";

  962.         }

  963. 

  964.         // terminator

  965.         state += "\xfe";

  966. 

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

  968. 

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

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

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

  972.         v3_result res;

  973. 

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

  975.         {

  976.             wrtn = 0;

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

  978. 

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

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

  981.         }

  982. 

  983.         return V3_OK;

  984.     }

  985. 

  986.     // ----------------------------------------------------------------------------------------------------------------

  987.     // v3_audio_processor interface calls

  988. 

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

  990.     {

  991.         // TODO

  992.         return V3_NOT_IMPLEMENTED;

  993.     }

  994. 

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

  996.     {

  997.         // TODO

  998.         return V3_NOT_IMPLEMENTED;

  999.     }

  1000. 

  1001.     uint32_t getLatencySamples() const noexcept

  1002.     {

  1003. #if DISTRHO_PLUGIN_WANT_LATENCY

  1004.         return fPlugin.getLatency();

  1005. #else

  1006.         return 0;

  1007. #endif

  1008.     }

  1009. 

  1010.     v3_result setupProcessing(v3_process_setup* const setup)

  1011.     {

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

  1013. 

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

  1015.         fPlugin.deactivateIfNeeded();

  1016. 

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

  1018. 

  1019. #if DISTRHO_PLUGIN_HAS_UI

  1020.         if (d_isNotEqual(setup->sample_rate, fPlugin.getSampleRate()))

  1021.             fNextSampleRate = setup->sample_rate;

  1022. #endif

  1023. 

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

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

  1026. 

  1027.         if (active)

  1028.             fPlugin.activate();

  1029. 

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

  1031. 

  1032.         return V3_OK;

  1033.     }

  1034. 

  1035.     v3_result setProcessing(const bool processing)

  1036.     {

  1037.         if (processing)

  1038.         {

  1039.             if (! fPlugin.isActive())

  1040.                 fPlugin.activate();

  1041.         }

  1042.         else

  1043.         {

  1044.             fPlugin.deactivate();

  1045.         }

  1046. 

  1047.         return V3_OK;

  1048.     }

  1049. 

  1050.     v3_result process(v3_process_data* const data)

  1051.     {

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

  1053. 

  1054.         if (! fPlugin.isActive())

  1055.         {

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

  1057.             fPlugin.activate();

  1058.         }

  1059. 

  1060. #if DISTRHO_PLUGIN_WANT_TIMEPOS

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

  1062.         {

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

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

  1065. 

  1066.             // ticksPerBeat is not possible with VST2

  1067.             fTimePosition.bbt.ticksPerBeat = 1920.0;

  1068. 

  1069.             if (ctx->state & V3_PROCESS_CTX_CONT_TIME_VALID)

  1070.                 fTimePosition.frame = ctx->continuous_time_in_samples;

  1071.             else

  1072.                 fTimePosition.frame = ctx->project_time_in_samples;

  1073. 

  1074.             if (ctx->state & V3_PROCESS_CTX_TEMPO_VALID)

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

  1076.             else

  1077.                 fTimePosition.bbt.beatsPerMinute = 120.0;

  1078. 

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

  1080.             {

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

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

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

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

  1085. 

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

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

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

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

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

  1091. 

  1092.                 if (ctx->project_time_quarters < 0.0)

  1093.                 {

  1094.                     --fTimePosition.bbt.bar;

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

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

  1097.                 }

  1098.             }

  1099.             else

  1100.             {

  1101.                 fTimePosition.bbt.bar         = 1;

  1102.                 fTimePosition.bbt.beat        = 1;

  1103.                 fTimePosition.bbt.tick        = 0.0;

  1104.                 fTimePosition.bbt.beatsPerBar = 4.0f;

  1105.                 fTimePosition.bbt.beatType    = 4.0f;

  1106.             }

  1107. 

  1108.             fTimePosition.bbt.barStartTick = fTimePosition.bbt.ticksPerBeat*

  1109.                                              fTimePosition.bbt.beatsPerBar*

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

  1111. 

  1112.             fPlugin.setTimePosition(fTimePosition);

  1113.         }

  1114. #endif

  1115. 

  1116.         if (data->nframes <= 0)

  1117.         {

  1118.             updateParameterOutputsAndTriggers();

  1119.             return V3_OK;

  1120.         }

  1121. 

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

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

  1124. 

  1125.         {

  1126.             int32_t i = 0;

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

  1128.             {

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

  1130.                 {

  1131.                     DISTRHO_SAFE_ASSERT_INT_BREAK(i < DISTRHO_PLUGIN_NUM_INPUTS, i);

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

  1133.                 }

  1134.             }

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

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

  1137.         }

  1138. 

  1139.         {

  1140.             int32_t i = 0;

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

  1142.             {

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

  1144.                 {

  1145.                     DISTRHO_SAFE_ASSERT_INT_BREAK(i < DISTRHO_PLUGIN_NUM_OUTPUTS, i);

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

  1147.                 }

  1148.             }

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

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

  1151.         }

  1152. 

  1153. #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  1154.         fHostEventOutputHandle = data->output_events;

  1155. #endif

  1156. 

  1157. #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1158.         uint32_t midiEventCount = 0;

  1159. 

  1160. # if DISTRHO_PLUGIN_HAS_UI

  1161.         while (fNotesRingBuffer.isDataAvailableForReading())

  1162.         {

  1163.             uint8_t midiData[3];

  1164.             if (! fNotesRingBuffer.readCustomData(midiData, 3))

  1165.                 break;

  1166. 

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

  1168.             midiEvent.frame = 0;

  1169.             midiEvent.size  = 3;

  1170.             std::memcpy(midiEvent.data, midiData, 3);

  1171. 

  1172.             if (midiEventCount == kMaxMidiEvents)

  1173.                 break;

  1174.         }

  1175. # endif

  1176. 

  1177.         if (v3_event_list** const eventptr = data->input_events)

  1178.         {

  1179.             v3_event event;

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

  1181.             {

  1182.                 if (v3_cpp_obj(eventptr)->get_event(eventptr, i, &event) != V3_OK)

  1183.                     break;

  1184. 

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

  1186.                 switch (event.type)

  1187.                 {

  1188.                 case V3_EVENT_NOTE_ON:

  1189.                 case V3_EVENT_NOTE_OFF:

  1190.                 // case V3_EVENT_DATA:

  1191.                 case V3_EVENT_POLY_PRESSURE:

  1192.                 // case V3_EVENT_NOTE_EXP_VALUE:

  1193.                 // case V3_EVENT_NOTE_EXP_TEXT:

  1194.                 // case V3_EVENT_CHORD:

  1195.                 // case V3_EVENT_SCALE:

  1196.                 case V3_EVENT_LEGACY_MIDI_CC_OUT:

  1197.                     break;

  1198.                 default:

  1199.                     continue;

  1200.                 }

  1201. 

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

  1203.                 midiEvent.frame = event.sample_offset;

  1204. 

  1205.                 // encode event as MIDI

  1206.                 switch (event.type)

  1207.                 {

  1208.                 case V3_EVENT_NOTE_ON:

  1209.                     midiEvent.size = 3;

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

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

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

  1213.                     midiEvent.data[3] = 0;

  1214.                     break;

  1215.                 case V3_EVENT_NOTE_OFF:

  1216.                     midiEvent.size = 3;

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

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

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

  1220.                     midiEvent.data[3] = 0;

  1221.                     break;

  1222.                 case V3_EVENT_POLY_PRESSURE:

  1223.                     midiEvent.size = 3;

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

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

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

  1227.                     midiEvent.data[3] = 0;

  1228.                     break;

  1229.                 case V3_EVENT_LEGACY_MIDI_CC_OUT:

  1230.                     midiEvent.size = 3;

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

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

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

  1234.                     midiEvent.data[3] = 0;

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

  1236.                     break;

  1237.                 default:

  1238.                     midiEvent.size = 0;

  1239.                     break;

  1240.                 }

  1241. 

  1242.                 if (midiEventCount == kMaxMidiEvents)

  1243.                     break;

  1244.             }

  1245.         }

  1246. 

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

  1248. #else

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

  1250. #endif

  1251. 

  1252. #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  1253.         fHostEventOutputHandle = nullptr;

  1254. #endif

  1255. 

  1256.         updateParameterOutputsAndTriggers();

  1257.         return V3_OK;

  1258.     }

  1259. 

  1260.     uint32_t getTailSamples() const noexcept

  1261.     {

  1262.         return 0;

  1263.     }

  1264. 

  1265.     // ----------------------------------------------------------------------------------------------------------------

  1266.     // v3_edit_controller interface calls

  1267. 

  1268. #if 0

  1269.     v3_result setComponentState(v3_bstream*, void*)

  1270.     {

  1271.         // TODO

  1272.         return V3_NOT_IMPLEMENTED;

  1273.     }

  1274. 

  1275.     v3_result setState(v3_bstream*, void*)

  1276.     {

  1277.         // TODO

  1278.         return V3_NOT_IMPLEMENTED;

  1279.     }

  1280. 

  1281.     v3_result getState(v3_bstream*, void*)

  1282.     {

  1283.         // TODO

  1284.         return V3_NOT_IMPLEMENTED;

  1285.     }

  1286. #endif

  1287. 

  1288.     int32_t getParameterCount() const noexcept

  1289.     {

  1290.         return fRealParameterCount;

  1291.     }

  1292. 

  1293.     v3_result getParameterInfo(int32_t rindex, v3_param_info* const info) const noexcept

  1294.     {

  1295.         DISTRHO_SAFE_ASSERT_RETURN(rindex >= 0, V3_INVALID_ARG);

  1296. 

  1297. #if DISTRHO_PLUGIN_WANT_PROGRAMS

  1298.         if (rindex == 0)

  1299.         {

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

  1301.             info->param_id = rindex;

  1302.             info->flags = V3_PARAM_CAN_AUTOMATE | V3_PARAM_IS_LIST | V3_PARAM_PROGRAM_CHANGE;

  1303.             info->step_count = fProgramCountMinusOne;

  1304.             strncpy_utf16(info->title, "Current Program", 128);

  1305.             strncpy_utf16(info->short_title, "Program", 128);

  1306.             return V3_OK;

  1307.         }

  1308.         --rindex;

  1309. #endif

  1310. #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1311.         if (rindex <= 130*16)

  1312.         {

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

  1314.             info->param_id = rindex;

  1315.             info->flags = V3_PARAM_CAN_AUTOMATE | V3_PARAM_IS_HIDDEN;

  1316.             info->step_count = 127;

  1317.             char ccstr[24];

  1318.             snprintf(ccstr, sizeof(ccstr)-1, "MIDI Ch. %d CC %d", rindex / 130 + 1, rindex % 130);

  1319.             strncpy_utf16(info->title, ccstr, 128);

  1320.             snprintf(ccstr, sizeof(ccstr)-1, "Ch.%d CC%d", rindex / 130 + 1, rindex % 130);

  1321.             strncpy_utf16(info->short_title, ccstr+5, 128);

  1322.             return V3_OK;

  1323.         }

  1324.         rindex -= 130*16;

  1325. #endif

  1326. 

  1327.         const uint32_t index = static_cast<uint32_t>(rindex);

  1328.         DISTRHO_SAFE_ASSERT_UINT_RETURN(index < fPlugin.getParameterCount(), index, V3_INVALID_ARG);

  1329. 

  1330.         // set up flags

  1331.         int32_t flags = 0;

  1332. 

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

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

  1335. 

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

  1337. 

  1338.         switch (desig)

  1339.         {

  1340.         case kParameterDesignationNull:

  1341.             break;

  1342.         case kParameterDesignationBypass:

  1343.             flags |= V3_PARAM_IS_BYPASS;

  1344.             break;

  1345.         }

  1346. 

  1347.         if (hints & kParameterIsAutomable)

  1348.             flags |= V3_PARAM_CAN_AUTOMATE;

  1349.         if (hints & kParameterIsOutput)

  1350.             flags |= V3_PARAM_READ_ONLY;

  1351.         // TODO V3_PARAM_IS_LIST

  1352. 

  1353.         // set up step_count

  1354.         int32_t step_count = 0;

  1355. 

  1356.         if (hints & kParameterIsBoolean)

  1357.             step_count = 1;

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

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

  1360. 

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

  1362.         info->param_id = index + fParameterOffset;

  1363.         info->flags = flags;

  1364.         info->step_count = step_count;

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

  1366.         // int32_t unit_id;

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

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

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

  1370.         return V3_OK;

  1371.     }

  1372. 

  1373.     v3_result getParameterStringForValue(v3_param_id rindex, const double normalised, v3_str_128 output)

  1374.     {

  1375.         DISTRHO_SAFE_ASSERT_UINT_RETURN(rindex < fRealParameterCount, rindex, V3_INVALID_ARG);

  1376.         DISTRHO_SAFE_ASSERT_RETURN(normalised >= 0.0 && normalised <= 1.0, V3_INVALID_ARG);

  1377. 

  1378. 

  1379. #if DISTRHO_PLUGIN_WANT_PROGRAMS

  1380.         if (rindex == 0)

  1381.         {

  1382.             const uint32_t program = std::round(normalised * fProgramCountMinusOne);

  1383.             strncpy_utf16(output, fPlugin.getProgramName(program), 128);

  1384.             return V3_OK;

  1385.         }

  1386.         --rindex;

  1387. #endif

  1388. #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1389.         if (rindex <= 130*16)

  1390.         {

  1391.             snprintf_f32_utf16(output, std::round(normalised * 127), 128);

  1392.             return V3_OK;

  1393.         }

  1394.         rindex -= 130*16;

  1395. #endif

  1396. 

  1397.         const ParameterRanges& ranges(fPlugin.getParameterRanges(rindex));

  1398.         snprintf_f32_utf16(output, ranges.getUnnormalizedValue(normalised), 128);

  1399.         return V3_OK;

  1400.     }

  1401. 

  1402.     v3_result getParameterValueForString(v3_param_id rindex, int16_t*, double*)

  1403.     {

  1404.         DISTRHO_SAFE_ASSERT_UINT_RETURN(rindex < fRealParameterCount, rindex, V3_INVALID_ARG);

  1405. 

  1406. #if DISTRHO_PLUGIN_WANT_PROGRAMS

  1407.         if (rindex == 0)

  1408.         {

  1409.             // TODO find program index based on name

  1410.             return V3_NOT_IMPLEMENTED;

  1411.         }

  1412.         --rindex;

  1413. #endif

  1414. #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1415.         if (rindex <= 130*16)

  1416.         {

  1417.             // TODO

  1418.             return V3_NOT_IMPLEMENTED;

  1419.         }

  1420.         rindex -= 130*16;

  1421. #endif

  1422. 

  1423. 

  1424.         // TODO

  1425.         return V3_NOT_IMPLEMENTED;

  1426.     }

  1427. 

  1428.     double normalisedParameterToPlain(v3_param_id rindex, const double normalised)

  1429.     {

  1430.         DISTRHO_SAFE_ASSERT_UINT_RETURN(rindex < fRealParameterCount, rindex, 0.0);

  1431. 

  1432. #if DISTRHO_PLUGIN_WANT_PROGRAMS

  1433.         if (rindex == 0)

  1434.             return std::round(normalised * fProgramCountMinusOne);

  1435.         --rindex;

  1436. #endif

  1437. #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1438.         if (rindex <= 130*16)

  1439.             return std::round(normalised * 127);

  1440.         rindex -= 130*16;

  1441. #endif

  1442. 

  1443.         const ParameterRanges& ranges(fPlugin.getParameterRanges(rindex));

  1444.         return ranges.getUnnormalizedValue(normalised);

  1445.     }

  1446. 

  1447.     double plainParameterToNormalised(v3_param_id rindex, const double plain)

  1448.     {

  1449.         DISTRHO_SAFE_ASSERT_UINT_RETURN(rindex < fRealParameterCount, rindex, 0.0);

  1450. 

  1451. #if DISTRHO_PLUGIN_WANT_PROGRAMS

  1452.         if (rindex == 0)

  1453.             return std::max(0.0, std::min(1.0, plain / fProgramCountMinusOne));

  1454.         --rindex;

  1455. #endif

  1456. #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1457.         if (rindex <= 130*16)

  1458.             return std::max(0.0, std::min(1.0, plain / 127));

  1459.         rindex -= 130*16;

  1460. #endif

  1461. 

  1462.         const ParameterRanges& ranges(fPlugin.getParameterRanges(rindex));

  1463.         return ranges.getNormalizedValue(plain);

  1464.     }

  1465. 

  1466.     double getParameterNormalized(v3_param_id rindex)

  1467.     {

  1468.         DISTRHO_SAFE_ASSERT_UINT_RETURN(rindex < fRealParameterCount, rindex, 0.0);

  1469. 

  1470. #if DISTRHO_PLUGIN_WANT_PROGRAMS

  1471.         if (rindex == 0)

  1472.             return std::max(0.0, std::min(1.0, (double)fCurrentProgram / fProgramCountMinusOne));

  1473.         --rindex;

  1474. #endif

  1475. #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1476.         if (rindex <= 130*16)

  1477.         {

  1478.             // TODO

  1479.             return 0.0;

  1480.         }

  1481.         rindex -= 130*16;

  1482. #endif

  1483. 

  1484.         const float value = fPlugin.getParameterValue(rindex);

  1485.         const ParameterRanges& ranges(fPlugin.getParameterRanges(rindex));

  1486.         return ranges.getNormalizedValue(value);

  1487.     }

  1488. 

  1489.     v3_result setParameterNormalized(v3_param_id rindex, const double value)

  1490.     {

  1491.         DISTRHO_SAFE_ASSERT_UINT_RETURN(rindex < fRealParameterCount, rindex, V3_INVALID_ARG);

  1492.         DISTRHO_SAFE_ASSERT_RETURN(value >= 0.0 && value <= 1.0, V3_INVALID_ARG);

  1493. 

  1494. #if DISTRHO_PLUGIN_HAS_UI

  1495.         const uint32_t orindex = rindex;

  1496. #endif

  1497. #if DISTRHO_PLUGIN_WANT_PROGRAMS

  1498.         if (rindex == 0)

  1499.         {

  1500.             fCurrentProgram = std::round(value * fProgramCountMinusOne);

  1501.             fPlugin.loadProgram(fCurrentProgram);

  1502. 

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

  1504.             {

  1505.                 if (fPlugin.isParameterOutputOrTrigger(i))

  1506.                     continue;

  1507.                 fParameterValues[i] = fPlugin.getParameterValue(i);

  1508.             }

  1509. 

  1510.             if (fComponentHandler != nullptr)

  1511.                 v3_cpp_obj(fComponentHandler)->restart_component(fComponentHandler, V3_RESTART_PARAM_VALUES_CHANGED);

  1512. 

  1513. # if DISTRHO_PLUGIN_HAS_UI

  1514.             fChangedParameterValues[rindex] = true;

  1515. # endif

  1516.             return V3_OK;

  1517.         }

  1518.         --rindex;

  1519. #endif

  1520. #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1521.         if (rindex <= 130*16)

  1522.         {

  1523.             // TODO

  1524.             fChangedParameterValues[rindex] = true;

  1525.             return V3_NOT_IMPLEMENTED;

  1526.         }

  1527.         rindex -= 130*16;

  1528. #endif

  1529. 

  1530.         const uint32_t hints = fPlugin.getParameterHints(rindex);

  1531.         const ParameterRanges& ranges(fPlugin.getParameterRanges(rindex));

  1532. 

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

  1534. 

  1535.         if (hints & kParameterIsBoolean)

  1536.         {

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

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

  1539.         }

  1540. 

  1541.         if (hints & kParameterIsInteger)

  1542.         {

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

  1544.         }

  1545. 

  1546.         fParameterValues[rindex] = realValue;

  1547.         fPlugin.setParameterValue(rindex, realValue);

  1548. #if DISTRHO_PLUGIN_HAS_UI

  1549.         fChangedParameterValues[orindex] = true;

  1550. #endif

  1551.         return V3_OK;

  1552.     }

  1553. 

  1554.     v3_result setComponentHandler(v3_component_handler** const handler) noexcept

  1555.     {

  1556.         fComponentHandler = handler;

  1557.         return V3_OK;

  1558.     }

  1559. 

  1560. #if DISTRHO_PLUGIN_HAS_UI

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

  1562.     // v3_connection_point interface calls

  1563. 

  1564.     void connect(v3_connection_point** const other)

  1565.     {

  1566.         DISTRHO_SAFE_ASSERT(fConnectedToUI == false);

  1567. 

  1568.         fConnection = other;

  1569.         fConnectedToUI = false;

  1570.     }

  1571. 

  1572.     void disconnect()

  1573.     {

  1574.         fConnection = nullptr;

  1575.         fConnectedToUI = false;

  1576.     }

  1577. 

  1578.     v3_result notify(v3_message** const message)

  1579.     {

  1580.         const char* const msgid = v3_cpp_obj(message)->get_message_id(message);

  1581.         DISTRHO_SAFE_ASSERT_RETURN(msgid != nullptr, V3_INVALID_ARG);

  1582. 

  1583.         v3_attribute_list** const attrs = v3_cpp_obj(message)->get_attributes(message);

  1584.         DISTRHO_SAFE_ASSERT_RETURN(attrs != nullptr, V3_INVALID_ARG);

  1585. 

  1586. # if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1587.         if (std::strcmp(msgid, "midi") == 0)

  1588.         {

  1589.             uint8_t* data;

  1590.             uint32_t size;

  1591.             v3_result res;

  1592. 

  1593.             res = v3_cpp_obj(attrs)->get_binary(attrs, "data", (const void**)&data, &size);

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

  1595. 

  1596.             // known maximum size

  1597.             DISTRHO_SAFE_ASSERT_UINT_RETURN(size == 3, size, V3_INTERNAL_ERR);

  1598. 

  1599.             return fNotesRingBuffer.writeCustomData(data, size) && fNotesRingBuffer.commitWrite() ? V3_OK : V3_NOMEM;

  1600.         }

  1601. # endif

  1602. 

  1603.         if (std::strcmp(msgid, "init") == 0)

  1604.         {

  1605.             DISTRHO_SAFE_ASSERT_RETURN(fConnection != nullptr, V3_INTERNAL_ERR);

  1606.             fConnectedToUI = true;

  1607. 

  1608.             if (const double sampleRate = fNextSampleRate)

  1609.             {

  1610.                 fNextSampleRate = 0.0;

  1611.                 sendSampleRateToUI(sampleRate);

  1612.             }

  1613. 

  1614. # if DISTRHO_PLUGIN_WANT_PROGRAMS

  1615.             fChangedParameterValues[0] = false;

  1616.             sendParameterChangeToUI(0, fCurrentProgram);

  1617. # endif

  1618. 

  1619. # if DISTRHO_PLUGIN_WANT_FULL_STATE

  1620.             // Update current state from plugin side

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

  1622.             {

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

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

  1625.             }

  1626. # endif

  1627. 

  1628. # if DISTRHO_PLUGIN_WANT_STATE

  1629.             // Set state

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

  1631.             {

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

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

  1634. 

  1635.                 sendStateChangeToUI(key, value);

  1636.             }

  1637. # endif

  1638. 

  1639.             for (uint32_t i=fParameterOffset; i<fRealParameterCount; ++i)

  1640.             {

  1641.                 fChangedParameterValues[i] = false;

  1642.                 sendParameterChangeToUI(i, fPlugin.getParameterValue(i - fParameterOffset));

  1643.             }

  1644. 

  1645.             sendReadyToUI();

  1646.             return V3_OK;

  1647.         }

  1648. 

  1649.         if (std::strcmp(msgid, "idle") == 0)

  1650.         {

  1651.             DISTRHO_SAFE_ASSERT_RETURN(fConnection != nullptr, V3_INTERNAL_ERR);

  1652.             DISTRHO_SAFE_ASSERT_RETURN(fConnectedToUI, V3_INTERNAL_ERR);

  1653. 

  1654.             for (uint32_t i=0, rindex; i<fRealParameterCount; ++i)

  1655.             {

  1656.                 if (! fChangedParameterValues[i])

  1657.                     continue;

  1658. 

  1659.                 fChangedParameterValues[i] = false;

  1660. 

  1661.                 rindex = i;

  1662. # if DISTRHO_PLUGIN_WANT_PROGRAMS

  1663.                 if (rindex == 0)

  1664.                 {

  1665.                     sendParameterChangeToUI(rindex, fCurrentProgram);

  1666.                     continue;

  1667.                 }

  1668.                 --rindex;

  1669. # endif

  1670. # if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1671.                 if (rindex <= 130*16)

  1672.                     continue;

  1673.                 rindex -= 130*16;

  1674. # endif

  1675. 

  1676.                 sendParameterChangeToUI(rindex + fParameterOffset, fParameterValues[rindex]);

  1677.             }

  1678. 

  1679.             sendReadyToUI();

  1680.             return V3_OK;

  1681.         }

  1682. 

  1683.         if (std::strcmp(msgid, "close") == 0)

  1684.         {

  1685.             fConnectedToUI = false;

  1686.             DISTRHO_SAFE_ASSERT_RETURN(fConnection != nullptr, V3_INTERNAL_ERR);

  1687.             return V3_OK;

  1688.         }

  1689. 

  1690.         if (std::strcmp(msgid, "parameter-edit") == 0)

  1691.         {

  1692.             DISTRHO_SAFE_ASSERT_RETURN(fComponentHandler != nullptr, V3_INTERNAL_ERR);

  1693. 

  1694.             int64_t rindex;

  1695.             int64_t started;

  1696.             v3_result res;

  1697. 

  1698.             res = v3_cpp_obj(attrs)->get_int(attrs, "rindex", &rindex);

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

  1700. 

  1701.             res = v3_cpp_obj(attrs)->get_int(attrs, "started", &started);

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

  1703. 

  1704.             rindex -= fParameterOffset;

  1705.             DISTRHO_SAFE_ASSERT_RETURN(rindex >= 0, V3_INTERNAL_ERR);

  1706. 

  1707.             return started != 0 ? v3_cpp_obj(fComponentHandler)->begin_edit(fComponentHandler, rindex)

  1708.                                 : v3_cpp_obj(fComponentHandler)->end_edit(fComponentHandler, rindex);

  1709.         }

  1710. 

  1711.         if (std::strcmp(msgid, "parameter-set") == 0)

  1712.         {

  1713.             int64_t rindex;

  1714.             double value;

  1715.             v3_result res;

  1716. 

  1717.             res = v3_cpp_obj(attrs)->get_int(attrs, "rindex", &rindex);

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

  1719.             DISTRHO_SAFE_ASSERT_INT_RETURN(rindex >= fParameterOffset, rindex, V3_INTERNAL_ERR);

  1720. 

  1721.             res = v3_cpp_obj(attrs)->get_float(attrs, "value", &value);

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

  1723. 

  1724.             const uint32_t index = static_cast<uint32_t>(rindex - fParameterOffset);

  1725.             return requestParameterValueChange(index, value) ? V3_OK : V3_INTERNAL_ERR;

  1726.         }

  1727. 

  1728. # if DISTRHO_PLUGIN_WANT_STATE

  1729.         if (std::strcmp(msgid, "state-set") == 0)

  1730.         {

  1731.             int16_t* key16;

  1732.             int16_t* value16;

  1733.             uint32_t keySize, valueSize;

  1734.             v3_result res;

  1735. 

  1736.             res = v3_cpp_obj(attrs)->get_binary(attrs, "key", (const void**)&key16, &keySize);

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

  1738. 

  1739.             res = v3_cpp_obj(attrs)->get_binary(attrs, "value", (const void**)&value16, &valueSize);

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

  1741. 

  1742.             // do cheap inline conversion

  1743.             char* const key = (char*)key16;

  1744.             char* const value = (char*)value16;

  1745. 

  1746.             for (uint32_t i=0; i<keySize/sizeof(int16_t); ++i)

  1747.                 key[i] = key16[i];

  1748.             for (uint32_t i=0; i<valueSize/sizeof(int16_t); ++i)

  1749.                 value[i] = value16[i];

  1750. 

  1751.             fPlugin.setState(key, value);

  1752. 

  1753.             // save this key as needed

  1754.             if (fPlugin.wantStateKey(key))

  1755.             {

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

  1757.                 {

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

  1759. 

  1760.                     if (dkey == key)

  1761.                     {

  1762.                         it->second = value;

  1763.                         return V3_OK;

  1764.                     }

  1765.                 }

  1766. 

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

  1768.             }

  1769. 

  1770.             return V3_OK;

  1771.         }

  1772. # endif

  1773. 

  1774.         return V3_NOT_IMPLEMENTED;

  1775.     }

  1776. #endif

  1777. 

  1778.     // ----------------------------------------------------------------------------------------------------------------

  1779. 

  1780. private:

  1781.     // Plugin

  1782.     PluginExporter fPlugin;

  1783. 

  1784.     // VST3 stuff

  1785.     v3_component_handler** fComponentHandler;

  1786. #if DISTRHO_PLUGIN_HAS_UI

  1787.     v3_connection_point** fConnection;

  1788. #endif

  1789. 

  1790.     // Temporary data

  1791.     const uint32_t fParameterOffset;

  1792.     const uint32_t fRealParameterCount; // regular parameters + current program

  1793.     float* fParameterValues;

  1794.     bool* fChangedParameterValues;

  1795. #if DISTRHO_PLUGIN_HAS_UI

  1796.     bool fConnectedToUI;

  1797.     double fNextSampleRate; // if not zero, report to UI

  1798. #endif

  1799. #if DISTRHO_PLUGIN_WANT_LATENCY

  1800.     uint32_t fLastKnownLatency;

  1801. #endif

  1802. #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  1803.     MidiEvent fMidiEvents[kMaxMidiEvents];

  1804. # if DISTRHO_PLUGIN_HAS_UI

  1805.     SmallStackRingBuffer fNotesRingBuffer;

  1806. # endif

  1807. #endif

  1808. #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  1809.     v3_event_list** fHostEventOutputHandle;

  1810. #endif

  1811. #if DISTRHO_PLUGIN_WANT_PROGRAMS

  1812.     uint32_t fCurrentProgram;

  1813.     const uint32_t fProgramCountMinusOne;

  1814. #endif

  1815. #if DISTRHO_PLUGIN_WANT_STATE

  1816.     StringMap fStateMap;

  1817. #endif

  1818. #if DISTRHO_PLUGIN_WANT_TIMEPOS

  1819.     TimePosition fTimePosition;

  1820. #endif

  1821. 

  1822.     // ----------------------------------------------------------------------------------------------------------------

  1823.     // helper functions called during process, cannot block

  1824. 

  1825.     void updateParameterOutputsAndTriggers()

  1826.     {

  1827.         float curValue;

  1828. 

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

  1830.         {

  1831.             if (fPlugin.isParameterOutput(i))

  1832.             {

  1833.                 // NOTE: no output parameter support in VST3, simulate it here

  1834.                 curValue = fPlugin.getParameterValue(i);

  1835. 

  1836.                 if (d_isEqual(curValue, fParameterValues[i]))

  1837.                     continue;

  1838. 

  1839.                 fParameterValues[i] = curValue;

  1840. #if DISTRHO_PLUGIN_HAS_UI

  1841.                 fChangedParameterValues[i] = true;

  1842. #endif

  1843.             }

  1844.             else if (fPlugin.isParameterTrigger(i))

  1845.             {

  1846.                 // NOTE: no trigger support in VST3 parameters, simulate it here

  1847.                 curValue = fPlugin.getParameterValue(i);

  1848. 

  1849.                 if (d_isEqual(curValue, fPlugin.getParameterDefault(i)))

  1850.                     continue;

  1851. 

  1852.                 fPlugin.setParameterValue(i, curValue);

  1853. #if DISTRHO_PLUGIN_HAS_UI

  1854.                 fChangedParameterValues[i] = true;

  1855. #endif

  1856.             }

  1857.             else

  1858.             {

  1859.                 continue;

  1860.             }

  1861. 

  1862.             requestParameterValueChange(i, curValue);

  1863.         }

  1864. 

  1865. #if DISTRHO_PLUGIN_WANT_LATENCY

  1866.         const uint32_t latency = fPlugin.getLatency();

  1867. 

  1868.         if (fLastKnownLatency != latency)

  1869.         {

  1870.             fLastKnownLatency = latency;

  1871. 

  1872.             if (fComponentHandler != nullptr)

  1873.                 v3_cpp_obj(fComponentHandler)->restart_component(fComponentHandler, V3_RESTART_LATENCY_CHANGED);

  1874.         }

  1875. #endif

  1876.     }

  1877. 

  1878. #if DISTRHO_PLUGIN_HAS_UI

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

  1880.     // helper functions called during message passing, can block

  1881. 

  1882.     void sendSampleRateToUI(const double sampleRate)

  1883.     {

  1884.         v3_message** const message = dpf_message_create("sample-rate");

  1885.         DISTRHO_SAFE_ASSERT_RETURN(message != nullptr,);

  1886. 

  1887.         v3_attribute_list** const attrlist = v3_cpp_obj(message)->get_attributes(message);

  1888.         DISTRHO_SAFE_ASSERT_RETURN(attrlist != nullptr,);

  1889. 

  1890.         v3_cpp_obj(attrlist)->set_int(attrlist, "__dpf_msg_target__", 2);

  1891.         v3_cpp_obj(attrlist)->set_float(attrlist, "value", sampleRate);

  1892.         v3_cpp_obj(fConnection)->notify(fConnection, message);

  1893. 

  1894.         v3_cpp_obj_unref(message);

  1895.     }

  1896. 

  1897.     void sendParameterChangeToUI(const v3_param_id rindex, const double value)

  1898.     {

  1899.         v3_message** const message = dpf_message_create("parameter-set");

  1900.         DISTRHO_SAFE_ASSERT_RETURN(message != nullptr,);

  1901. 

  1902.         v3_attribute_list** const attrlist = v3_cpp_obj(message)->get_attributes(message);

  1903.         DISTRHO_SAFE_ASSERT_RETURN(attrlist != nullptr,);

  1904. 

  1905.         v3_cpp_obj(attrlist)->set_int(attrlist, "__dpf_msg_target__", 2);

  1906.         v3_cpp_obj(attrlist)->set_int(attrlist, "rindex", rindex);

  1907.         v3_cpp_obj(attrlist)->set_float(attrlist, "value", value);

  1908.         v3_cpp_obj(fConnection)->notify(fConnection, message);

  1909. 

  1910.         v3_cpp_obj_unref(message);

  1911.     }

  1912. 

  1913.     void sendStateChangeToUI(const char* const key, const char* const value)

  1914.     {

  1915.         v3_message** const message = dpf_message_create("state-set");

  1916.         DISTRHO_SAFE_ASSERT_RETURN(message != nullptr,);

  1917. 

  1918.         v3_attribute_list** const attrlist = v3_cpp_obj(message)->get_attributes(message);

  1919.         DISTRHO_SAFE_ASSERT_RETURN(attrlist != nullptr,);

  1920. 

  1921.         v3_attribute_list_utf8** utf8attrlist = nullptr;

  1922.         DISTRHO_SAFE_ASSERT_RETURN(v3_cpp_obj_query_interface(attrlist, v3_attribute_list_utf8_iid, &utf8attrlist) == V3_OK,);

  1923.         DISTRHO_SAFE_ASSERT_RETURN(utf8attrlist != nullptr,);

  1924. 

  1925.         v3_cpp_obj(attrlist)->set_int(attrlist, "__dpf_msg_target__", 2);

  1926.         v3_cpp_obj(utf8attrlist)->set_string_utf8(utf8attrlist, "key", key);

  1927.         v3_cpp_obj(utf8attrlist)->set_string_utf8(utf8attrlist, "value", value);

  1928.         v3_cpp_obj(fConnection)->notify(fConnection, message);

  1929. 

  1930.         v3_cpp_obj_unref(message);

  1931.     }

  1932. 

  1933.     void sendReadyToUI()

  1934.     {

  1935.         v3_message** const message = dpf_message_create("ready");

  1936.         DISTRHO_SAFE_ASSERT_RETURN(message != nullptr,);

  1937. 

  1938.         v3_attribute_list** const attrlist = v3_cpp_obj(message)->get_attributes(message);

  1939.         DISTRHO_SAFE_ASSERT_RETURN(attrlist != nullptr,);

  1940. 

  1941.         v3_cpp_obj(attrlist)->set_int(attrlist, "__dpf_msg_target__", 2);

  1942.         v3_cpp_obj(fConnection)->notify(fConnection, message);

  1943. 

  1944.         v3_cpp_obj_unref(message);

  1945.     }

  1946. #endif

  1947. 

  1948.     // ----------------------------------------------------------------------------------------------------------------

  1949.     // DPF callbacks

  1950. 

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

  1952.     {

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

  1954. 

  1955.         const uint32_t rindex = index + fParameterOffset;

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

  1957. 

  1958.         const v3_result res_edit = v3_cpp_obj(fComponentHandler)->begin_edit(fComponentHandler, rindex);

  1959.         DISTRHO_SAFE_ASSERT_INT_RETURN(res_edit == V3_TRUE || res_edit == V3_FALSE, res_edit, res_edit);

  1960. 

  1961.         const v3_result res_perf = v3_cpp_obj(fComponentHandler)->perform_edit(fComponentHandler, rindex, normalized);

  1962. 

  1963.         if (res_perf == V3_TRUE)

  1964.             fParameterValues[index] = value;

  1965. 

  1966.         if (res_edit == V3_TRUE)

  1967.             v3_cpp_obj(fComponentHandler)->end_edit(fComponentHandler, rindex);

  1968. 

  1969.         return res_perf == V3_TRUE;

  1970.     }

  1971. 

  1972. #if DISTRHO_PLUGIN_WANT_PARAMETER_VALUE_CHANGE_REQUEST

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

  1974.     {

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

  1976.     }

  1977. #endif

  1978. 

  1979. #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  1980.     bool writeMidi(const MidiEvent& midiEvent)

  1981.     {

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

  1983. 

  1984.         v3_event event;

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

  1986.         event.sample_offset = midiEvent.frame;

  1987. 

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

  1989. 

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

  1991.         {

  1992.         case 0x80:

  1993.             event.type = V3_EVENT_NOTE_OFF;

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

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

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

  1997.             // int32_t note_id;

  1998.             // float tuning;

  1999.             break;

  2000.         case 0x90:

  2001.             event.type = V3_EVENT_NOTE_ON;

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

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

  2004.             // float tuning;

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

  2006.             // int32_t length;

  2007.             // int32_t note_id;

  2008.             break;

  2009.         case 0xA0:

  2010.             event.type = V3_EVENT_POLY_PRESSURE;

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

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

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

  2014.             // int32_t note_id;

  2015.             break;

  2016.         case 0xB0:

  2017.             event.type = V3_EVENT_LEGACY_MIDI_CC_OUT;

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

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

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

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

  2022.             break;

  2023.         default:

  2024.             return true;

  2025.         }

  2026. 

  2027.         return v3_cpp_obj(fHostEventOutputHandle)->add_event(fHostEventOutputHandle, &event) == V3_OK;

  2028.     }

  2029. 

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

  2031.     {

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

  2033.     }

  2034. #endif

  2035. 

  2036. };

  2037. 

  2038. // --------------------------------------------------------------------------------------------------------------------

  2039. 

  2040. /**

  2041.  * VST3 low-level pointer thingies follow, proceed with care.

  2042.  */

  2043. 

  2044. // --------------------------------------------------------------------------------------------------------------------

  2045. 

  2046. struct dpf_attribute_value {

  2047.     char type; // one of: i, f, s, b

  2048.     union {

  2049.         int64_t integer;

  2050.         double v_float;

  2051.         int16_t* string;

  2052.         struct {

  2053.             void* ptr;

  2054.             uint32_t size;

  2055.         } binary;

  2056.     };

  2057. };

  2058. 

  2059. static void dpf_attribute_list_free(std::map<std::string, dpf_attribute_value>& attrs)

  2060. {

  2061.     for (auto& it : attrs)

  2062.     {

  2063.         dpf_attribute_value& v(it.second);

  2064. 

  2065.         switch (v.type)

  2066.         {

  2067.         case 's':

  2068.         case 'b':

  2069.             std::free(v.binary.ptr);

  2070.             break;

  2071.         }

  2072.     }

  2073. }

  2074. 

  2075. // --------------------------------------------------------------------------------------------------------------------

  2076. // dpf_attribute_list_utf8 (the custom variant)

  2077. 

  2078. struct v3_attribute_list_utf8_cpp : v3_funknown {

  2079.     v3_attribute_list_utf8 attr;

  2080. };

  2081. 

  2082. struct dpf_attribute_list_utf8 : v3_attribute_list_utf8_cpp {

  2083.     std::map<std::string, dpf_attribute_value>& attrs;

  2084. 

  2085.     dpf_attribute_list_utf8(std::map<std::string, dpf_attribute_value>& a)

  2086.         : attrs(a)

  2087.     {

  2088.         static const uint8_t* kSupportedInterfaces[] = {

  2089.             v3_funknown_iid,

  2090.             v3_attribute_list_utf8_iid

  2091.         };

  2092. 

  2093.         // ------------------------------------------------------------------------------------------------------------

  2094.         // v3_funknown

  2095. 

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

  2097.         {

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

  2099.             *iface = NULL;

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

  2101. 

  2102.             for (const uint8_t* interface_iid : kSupportedInterfaces)

  2103.             {

  2104.                 if (v3_tuid_match(interface_iid, iid))

  2105.                 {

  2106.                     *iface = self;

  2107.                     return V3_OK;

  2108.                 }

  2109.             }

  2110. 

  2111.             return V3_NO_INTERFACE;

  2112.         };

  2113. 

  2114.         // there is only a single instance of this, so we don't have to care here

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

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

  2117. 

  2118.         // ------------------------------------------------------------------------------------------------------------

  2119.         // v3_attribute_list_utf8

  2120. 

  2121.         attr.set_string_utf8 = []V3_API(void* self, const char* id, const char* string) -> v3_result

  2122.         {

  2123.             dpf_attribute_list_utf8* const attr = *(dpf_attribute_list_utf8**)self;

  2124.             DISTRHO_SAFE_ASSERT_RETURN(attr != nullptr, V3_NOT_INITIALISED);

  2125. 

  2126.             const uint32_t size = std::strlen(string) + 1;

  2127.             int16_t* const copy = (int16_t*)std::malloc(sizeof(int16_t) * size);

  2128.             DISTRHO_SAFE_ASSERT_RETURN(copy != nullptr, V3_NOMEM);

  2129. 

  2130.             DISTRHO_NAMESPACE::strncpy_utf16(copy, string, size);

  2131. 

  2132.             dpf_attribute_value& attrval(attr->attrs[id]);

  2133.             attrval.type = 's';

  2134.             attrval.binary.ptr = copy;

  2135.             attrval.binary.size = sizeof(int16_t) * size;

  2136.             return V3_OK;

  2137.         };

  2138. 

  2139.         attr.get_string_utf8 = []V3_API(void* self, const char* id, char*, uint32_t) -> v3_result

  2140.         {

  2141.             dpf_attribute_list_utf8* const attr = *(dpf_attribute_list_utf8**)self;

  2142.             DISTRHO_SAFE_ASSERT_RETURN(attr != nullptr, V3_NOT_INITIALISED);

  2143. 

  2144.             if (attr->attrs.find(id) == attr->attrs.end())

  2145.                 return V3_INVALID_ARG;

  2146. 

  2147.             return V3_NOT_IMPLEMENTED;

  2148.         };

  2149.     }

  2150. };

  2151. 

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

  2153. // dpf_attribute_list

  2154. 

  2155. struct dpf_attribute_list : v3_attribute_list_cpp {

  2156.     ScopedPointer<dpf_attribute_list_utf8> attrutf8;

  2157.     std::map<std::string, dpf_attribute_value> attrs;

  2158. 

  2159.     dpf_attribute_list()

  2160.     {

  2161.         static const uint8_t* kSupportedInterfacesBase[] = {

  2162.             v3_funknown_iid,

  2163.             v3_attribute_list_iid

  2164.         };

  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_attribute_list::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* interface_iid : kSupportedInterfacesBase)

  2176.             {

  2177.                 if (v3_tuid_match(interface_iid, iid))

  2178.                 {

  2179.                     *iface = self;

  2180.                     return V3_OK;

  2181.                 }

  2182.             }

  2183. 

  2184.             dpf_attribute_list* const attr = *(dpf_attribute_list**)self;

  2185.             DISTRHO_SAFE_ASSERT_RETURN(attr != nullptr, V3_NO_INTERFACE);

  2186. 

  2187.             if (v3_tuid_match(v3_attribute_list_utf8_iid, iid))

  2188.             {

  2189.                 if (attr->attrutf8 == nullptr)

  2190.                     attr->attrutf8 = new dpf_attribute_list_utf8(attr->attrs);

  2191.                 *iface = &attr->attrutf8;

  2192.                 return V3_OK;

  2193.             }

  2194. 

  2195.             return V3_NO_INTERFACE;

  2196.         };

  2197. 

  2198.         // there is only a single instance of this, so we don't have to care here

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

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

  2201. 

  2202.         // ------------------------------------------------------------------------------------------------------------

  2203.         // v3_attribute_list

  2204. 

  2205.         attrlist.set_int = []V3_API(void* self, const char* id, int64_t value) -> v3_result

  2206.         {

  2207.             dpf_attribute_list* const attr = *(dpf_attribute_list**)self;

  2208.             DISTRHO_SAFE_ASSERT_RETURN(attr != nullptr, V3_NOT_INITIALISED);

  2209. 

  2210.             dpf_attribute_value& attrval(attr->attrs[id]);

  2211.             attrval.type = 'i';

  2212.             attrval.integer = value;

  2213.             return V3_OK;

  2214.         };

  2215. 

  2216.         attrlist.get_int = []V3_API(void* self, const char* id, int64_t* value) -> v3_result

  2217.         {

  2218.             dpf_attribute_list* const attr = *(dpf_attribute_list**)self;

  2219.             DISTRHO_SAFE_ASSERT_RETURN(attr != nullptr, V3_NOT_INITIALISED);

  2220. 

  2221.             if (attr->attrs.find(id) == attr->attrs.end())

  2222.                 return V3_INVALID_ARG;

  2223. 

  2224.             const dpf_attribute_value& attrval(attr->attrs[id]);

  2225.             DISTRHO_SAFE_ASSERT_RETURN(attrval.type == 'i', V3_INVALID_ARG);

  2226. 

  2227.             *value = attrval.integer;

  2228.             return V3_OK;

  2229.         };

  2230. 

  2231.         attrlist.set_float = []V3_API(void* self, const char* id, double value) -> v3_result

  2232.         {

  2233.             dpf_attribute_list* const attr = *(dpf_attribute_list**)self;

  2234.             DISTRHO_SAFE_ASSERT_RETURN(attr != nullptr, V3_NOT_INITIALISED);

  2235. 

  2236.             dpf_attribute_value& attrval(attr->attrs[id]);

  2237.             attrval.type = 'f';

  2238.             attrval.v_float = value;

  2239.             return V3_OK;

  2240.         };

  2241. 

  2242.         attrlist.get_float = []V3_API(void* self, const char* id, double* value) -> v3_result

  2243.         {

  2244.             dpf_attribute_list* const attr = *(dpf_attribute_list**)self;

  2245.             DISTRHO_SAFE_ASSERT_RETURN(attr != nullptr, V3_NOT_INITIALISED);

  2246. 

  2247.             if (attr->attrs.find(id) == attr->attrs.end())

  2248.                 return V3_INVALID_ARG;

  2249. 

  2250.             const dpf_attribute_value& attrval(attr->attrs[id]);

  2251.             DISTRHO_SAFE_ASSERT_RETURN(attrval.type == 'f', V3_INVALID_ARG);

  2252. 

  2253.             *value = attrval.v_float;

  2254.             return V3_OK;

  2255.         };

  2256. 

  2257.         attrlist.set_string = []V3_API(void* self, const char* id, const int16_t* /*string*/) -> v3_result

  2258.         {

  2259.             dpf_attribute_list* const attr = *(dpf_attribute_list**)self;

  2260.             DISTRHO_SAFE_ASSERT_RETURN(attr != nullptr, V3_NOT_INITIALISED);

  2261. 

  2262.             dpf_attribute_value& attrval(attr->attrs[id]);

  2263.             attrval.type = 's';

  2264.             attrval.binary.ptr = nullptr;

  2265.             attrval.binary.size = 0;

  2266.             return V3_NOT_IMPLEMENTED;

  2267.         };

  2268. 

  2269.         attrlist.get_string = []V3_API(void* self, const char* id, int16_t* /*string*/, uint32_t /*size*/) -> v3_result

  2270.         {

  2271.             dpf_attribute_list* const attr = *(dpf_attribute_list**)self;

  2272.             DISTRHO_SAFE_ASSERT_RETURN(attr != nullptr, V3_NOT_INITIALISED);

  2273. 

  2274.             if (attr->attrs.find(id) == attr->attrs.end())

  2275.                 return V3_INVALID_ARG;

  2276. 

  2277.             const dpf_attribute_value& attrval(attr->attrs[id]);

  2278.             DISTRHO_SAFE_ASSERT_RETURN(attrval.type == 's', V3_INVALID_ARG);

  2279. 

  2280.             return V3_NOT_IMPLEMENTED;

  2281.         };

  2282. 

  2283.         attrlist.set_binary = []V3_API(void* self, const char* id, const void* data, uint32_t size) -> v3_result

  2284.         {

  2285.             dpf_attribute_list* const attr = *(dpf_attribute_list**)self;

  2286.             DISTRHO_SAFE_ASSERT_RETURN(attr != nullptr, V3_NOT_INITIALISED);

  2287. 

  2288.             void* const copy = std::malloc(size);

  2289.             DISTRHO_SAFE_ASSERT_RETURN(copy != nullptr, V3_NOMEM);

  2290. 

  2291.             std::memcpy(copy, data, size);

  2292. 

  2293.             dpf_attribute_value& attrval(attr->attrs[id]);

  2294.             attrval.type = 'b';

  2295.             attrval.binary.ptr = copy;

  2296.             attrval.binary.size = size;

  2297.             return V3_NOT_IMPLEMENTED;

  2298.         };

  2299. 

  2300.         attrlist.get_binary = []V3_API(void* self, const char* id, const void** data, uint32_t* size) -> v3_result

  2301.         {

  2302.             dpf_attribute_list* const attr = *(dpf_attribute_list**)self;

  2303.             DISTRHO_SAFE_ASSERT_RETURN(attr != nullptr, V3_NOT_INITIALISED);

  2304. 

  2305.             if (attr->attrs.find(id) == attr->attrs.end())

  2306.                 return V3_INVALID_ARG;

  2307. 

  2308.             const dpf_attribute_value& attrval(attr->attrs[id]);

  2309.             DISTRHO_SAFE_ASSERT_RETURN(attrval.type == 's' || attrval.type == 'b', V3_INVALID_ARG);

  2310. 

  2311.             *data = attrval.binary.ptr;

  2312.             *size = attrval.binary.size;

  2313.             return V3_OK;

  2314.         };

  2315.     }

  2316. };

  2317. 

  2318. // --------------------------------------------------------------------------------------------------------------------

  2319. // dpf_message

  2320. 

  2321. struct dpf_message : v3_message_cpp {

  2322.     std::atomic<int> refcounter;

  2323.     ScopedPointer<dpf_message>* self;

  2324.     ScopedPointer<dpf_attribute_list> attrlist;

  2325.     String id;

  2326. 

  2327.     dpf_message(ScopedPointer<dpf_message>* const s, const char* const id2)

  2328.         : self(s),

  2329.           id(id2)

  2330.     {

  2331.         static const uint8_t* kSupportedInterfaces[] = {

  2332.             v3_funknown_iid,

  2333.             v3_message_iid

  2334.         };

  2335. 

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

  2337.         // v3_funknown

  2338. 

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

  2340.         {

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

  2342.             *iface = NULL;

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

  2344. 

  2345.             for (const uint8_t* interface_iid : kSupportedInterfaces)

  2346.             {

  2347.                 if (v3_tuid_match(interface_iid, iid))

  2348.                 {

  2349.                     *iface = self;

  2350.                     return V3_OK;

  2351.                 }

  2352.             }

  2353. 

  2354.             return V3_NO_INTERFACE;

  2355.         };

  2356. 

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

  2358.         {

  2359.             d_stdout("dpf_message::ref                     => %p", self);

  2360.             dpf_message** const messageptr = static_cast<dpf_message**>(self);

  2361.             DISTRHO_SAFE_ASSERT_RETURN(messageptr != nullptr, 0);

  2362.             dpf_message* const message = *messageptr;

  2363.             DISTRHO_SAFE_ASSERT_RETURN(message != nullptr, 0);

  2364. 

  2365.             return ++message->refcounter;

  2366.         };

  2367. 

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

  2369.         {

  2370.             dpf_message** const messageptr = static_cast<dpf_message**>(self);

  2371.             DISTRHO_SAFE_ASSERT_RETURN(messageptr != nullptr, 0);

  2372.             dpf_message* const message = *messageptr;

  2373.             DISTRHO_SAFE_ASSERT_RETURN(message != nullptr, 0);

  2374. 

  2375.             if (const int refcounter = --message->refcounter)

  2376.                 return refcounter;

  2377. 

  2378.             if (message->attrlist != nullptr)

  2379.                 dpf_attribute_list_free(message->attrlist->attrs);

  2380. 

  2381.             *message->self = nullptr;

  2382.             delete messageptr;

  2383.             return 0;

  2384.         };

  2385. 

  2386.         msg.get_message_id = []V3_API(void* const self) -> const char*

  2387.         {

  2388.             dpf_message* const message = *(dpf_message**)self;

  2389.             DISTRHO_SAFE_ASSERT_RETURN(message != nullptr, nullptr);

  2390. 

  2391.             return message->id;

  2392.         };

  2393. 

  2394.         msg.set_message_id = []V3_API(void* const self, const char* const id) -> void

  2395.         {

  2396.             d_stdout("dpf_message::set_message_id => %p %s", self, id);

  2397.             dpf_message* const message = *(dpf_message**)self;

  2398.             DISTRHO_SAFE_ASSERT_RETURN(message != nullptr,);

  2399. 

  2400.             message->id = id;

  2401.         };

  2402. 

  2403.         msg.get_attributes = []V3_API(void* const self) -> v3_attribute_list**

  2404.         {

  2405.             dpf_message* const message = *(dpf_message**)self;

  2406.             DISTRHO_SAFE_ASSERT_RETURN(message != nullptr, nullptr);

  2407. 

  2408.             if (message->attrlist == nullptr)

  2409.                 message->attrlist = new dpf_attribute_list();

  2410. 

  2411.             return (v3_attribute_list**)&message->attrlist;

  2412.         };

  2413.     }

  2414. };

  2415. 

  2416. v3_message** dpf_message_create(const char* const id)

  2417. {

  2418.     ScopedPointer<dpf_message>* const messageptr = new ScopedPointer<dpf_message>;

  2419.     *messageptr = new dpf_message(messageptr, id);

  2420.     return static_cast<v3_message**>(static_cast<void*>(messageptr));

  2421. }

  2422. 

  2423. #if DISTRHO_PLUGIN_HAS_UI

  2424. // --------------------------------------------------------------------------------------------------------------------

  2425. // dpf_dsp_connection_point

  2426. 

  2427. enum ConnectionPointType {

  2428.     kConnectionPointComponent,

  2429.     kConnectionPointController,

  2430.     kConnectionPointBridge

  2431. };

  2432. 

  2433. struct v3_connection_point_cpp : v3_funknown {

  2434.     v3_connection_point point;

  2435. };

  2436. 

  2437. struct dpf_dsp_connection_point : v3_connection_point_cpp {

  2438.     ScopedPointer<PluginVst3>& vst3;

  2439.     const ConnectionPointType type;

  2440.     v3_connection_point** other;

  2441.     v3_connection_point** bridge; // when type is controller this points to ctrl<->view point

  2442.     bool shortcircuit; // plugin as controller, should pass directly to view

  2443. 

  2444.     dpf_dsp_connection_point(const ConnectionPointType t, ScopedPointer<PluginVst3>& v)

  2445.         : vst3(v),

  2446.           type(t),

  2447.           other(nullptr),

  2448.           bridge(nullptr),

  2449.           shortcircuit(false)

  2450.     {

  2451.         static const uint8_t* kSupportedInterfaces[] = {

  2452.             v3_funknown_iid,

  2453.             v3_connection_point_iid

  2454.         };

  2455. 

  2456.         // ------------------------------------------------------------------------------------------------------------

  2457.         // v3_funknown

  2458. 

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

  2460.         {

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

  2462.             *iface = NULL;

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

  2464. 

  2465.             for (const uint8_t* interface_iid : kSupportedInterfaces)

  2466.             {

  2467.                 if (v3_tuid_match(interface_iid, iid))

  2468.                 {

  2469.                     *iface = self;

  2470.                     return V3_OK;

  2471.                 }

  2472.             }

  2473. 

  2474.             return V3_NO_INTERFACE;

  2475.         };

  2476. 

  2477.         // there is only a single instance of this, so we don't have to care here

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

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

  2480. 

  2481.         // ------------------------------------------------------------------------------------------------------------

  2482.         // v3_connection_point

  2483. 

  2484.         point.connect = []V3_API(void* self, struct v3_connection_point** other) -> v3_result

  2485.         {

  2486.             d_stdout("dpf_dsp_connection_point::connect         => %p %p", self, other);

  2487.             dpf_dsp_connection_point* const point = *(dpf_dsp_connection_point**)self;

  2488.             DISTRHO_SAFE_ASSERT_RETURN(point != nullptr, V3_NOT_INITIALISED);

  2489.             DISTRHO_SAFE_ASSERT_RETURN(point->other == nullptr, V3_INVALID_ARG);

  2490.             DISTRHO_SAFE_ASSERT(point->bridge == nullptr);

  2491. 

  2492.             point->other = other;

  2493. 

  2494.             if (point->type == kConnectionPointComponent)

  2495.                 if (PluginVst3* const vst3 = point->vst3)

  2496.                     vst3->connect((v3_connection_point**)self);

  2497. 

  2498.             return V3_OK;

  2499.         };

  2500. 

  2501.         point.disconnect = []V3_API(void* self, struct v3_connection_point** other) -> v3_result

  2502.         {

  2503.             d_stdout("dpf_dsp_connection_point::disconnect      => %p %p", self, other);

  2504.             dpf_dsp_connection_point* const point = *(dpf_dsp_connection_point**)self;

  2505.             DISTRHO_SAFE_ASSERT_RETURN(point != nullptr, V3_NOT_INITIALISED);

  2506.             DISTRHO_SAFE_ASSERT_RETURN(point->other != nullptr, V3_INVALID_ARG);

  2507. 

  2508.             point->other = nullptr;

  2509.             point->bridge = nullptr;

  2510. 

  2511.             if (point->type == kConnectionPointComponent)

  2512.                 if (PluginVst3* const vst3 = point->vst3)

  2513.                     vst3->disconnect();

  2514. 

  2515.             return V3_OK;

  2516.         };

  2517. 

  2518.         point.notify = []V3_API(void* self, struct v3_message** message) -> v3_result

  2519.         {

  2520.             dpf_dsp_connection_point* const point = *(dpf_dsp_connection_point**)self;

  2521.             DISTRHO_SAFE_ASSERT_RETURN(point != nullptr, V3_NOT_INITIALISED);

  2522. 

  2523.             PluginVst3* const vst3 = point->vst3;

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

  2525. 

  2526.             v3_connection_point** const other = point->other;

  2527.             DISTRHO_SAFE_ASSERT_RETURN(other != nullptr, V3_NOT_INITIALISED);

  2528. 

  2529.             v3_attribute_list** const attrlist = v3_cpp_obj(message)->get_attributes(message);

  2530.             DISTRHO_SAFE_ASSERT_RETURN(attrlist != nullptr, V3_INVALID_ARG);

  2531. 

  2532.             int64_t target = 0;

  2533.             const v3_result res = v3_cpp_obj(attrlist)->get_int(attrlist, "__dpf_msg_target__", &target);

  2534.             DISTRHO_SAFE_ASSERT_RETURN(res == V3_OK, res);

  2535.             DISTRHO_SAFE_ASSERT_INT_RETURN(target == 1 || target == 2, target, V3_INTERNAL_ERR);

  2536. 

  2537.             switch (point->type)

  2538.             {

  2539.             // message belongs to component (aka plugin)

  2540.             case kConnectionPointComponent:

  2541.                 if (target == 1)

  2542.                 {

  2543.                     // view -> edit controller -> component

  2544.                     return vst3->notify(message);

  2545.                 }

  2546.                 else

  2547.                 {

  2548.                     // message is from component to controller to view

  2549.                     return v3_cpp_obj(other)->notify(other, message);

  2550.                 }

  2551. 

  2552.             // message belongs to edit controller

  2553.             case kConnectionPointController:

  2554.                 if (target == 1)

  2555.                 {

  2556.                     // we are in view<->dsp short-circuit, all happens in the controller without bridge

  2557.                     if (point->shortcircuit)

  2558.                         return vst3->notify(message);

  2559. 

  2560.                     // view -> edit controller -> component

  2561.                     return v3_cpp_obj(other)->notify(other, message);

  2562.                 }

  2563.                 else

  2564.                 {

  2565.                     // we are in view<->dsp short-circuit, all happens in the controller without bridge

  2566.                     if (point->shortcircuit)

  2567.                         return v3_cpp_obj(other)->notify(other, message);

  2568. 

  2569.                     // message is from component to controller to view

  2570.                     v3_connection_point** const bridge = point->bridge;

  2571.                     DISTRHO_SAFE_ASSERT_RETURN(bridge != nullptr, V3_NOT_INITIALISED);

  2572.                     return v3_cpp_obj(bridge)->notify(bridge, message);

  2573.                 }

  2574. 

  2575.             // message belongs to bridge (aka ui)

  2576.             case kConnectionPointBridge:

  2577.                 if (target == 1)

  2578.                 {

  2579.                     // view -> edit controller -> component

  2580.                     v3_connection_point** const bridge = point->bridge;

  2581.                     DISTRHO_SAFE_ASSERT_RETURN(bridge != nullptr, V3_NOT_INITIALISED);

  2582.                     return v3_cpp_obj(bridge)->notify(bridge, message);

  2583.                 }

  2584.                 else

  2585.                 {

  2586.                     // message is from component to controller to view

  2587.                     return v3_cpp_obj(other)->notify(other, message);

  2588.                 }

  2589.             }

  2590. 

  2591.             return V3_INTERNAL_ERR;

  2592.         };

  2593.     }

  2594. };

  2595. #endif

  2596. 

  2597. // --------------------------------------------------------------------------------------------------------------------

  2598. // dpf_edit_controller

  2599. 

  2600. struct v3_edit_controller_cpp : v3_funknown {

  2601.     v3_plugin_base base;

  2602.     v3_edit_controller controller;

  2603. };

  2604. 

  2605. struct dpf_edit_controller : v3_edit_controller_cpp {

  2606. #if DISTRHO_PLUGIN_HAS_UI

  2607.     ScopedPointer<dpf_dsp_connection_point> connectionComp;   // kConnectionPointController

  2608.     ScopedPointer<dpf_dsp_connection_point> connectionBridge; // kConnectionPointBridge

  2609. #endif

  2610.     ScopedPointer<PluginVst3>& vst3;

  2611.     bool initialized;

  2612.     // cached values

  2613.     v3_component_handler** handler;

  2614. 

  2615.     dpf_edit_controller(ScopedPointer<PluginVst3>& v)

  2616.         : vst3(v),

  2617.           initialized(false),

  2618.           handler(nullptr)

  2619.     {

  2620.         static const uint8_t* kSupportedInterfacesBase[] = {

  2621.             v3_funknown_iid,

  2622.             v3_edit_controller_iid

  2623.         };

  2624. 

  2625.         // ------------------------------------------------------------------------------------------------------------

  2626.         // v3_funknown

  2627. 

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

  2629.         {

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

  2631.             *iface = NULL;

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

  2633. 

  2634.             for (const uint8_t* interface_iid : kSupportedInterfacesBase)

  2635.             {

  2636.                 if (v3_tuid_match(interface_iid, iid))

  2637.                 {

  2638.                     *iface = self;

  2639.                     return V3_OK;

  2640.                 }

  2641.             }

  2642. 

  2643. #if DISTRHO_PLUGIN_HAS_UI

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

  2645.             DISTRHO_SAFE_ASSERT_RETURN(controller != nullptr, V3_NO_INTERFACE);

  2646. 

  2647.             if (v3_tuid_match(v3_connection_point_iid, iid))

  2648.             {

  2649.                 if (controller->connectionComp == nullptr)

  2650.                     controller->connectionComp = new dpf_dsp_connection_point(kConnectionPointController,

  2651.                                                                               controller->vst3);

  2652.                 *iface = &controller->connectionComp;

  2653.                 return V3_OK;

  2654.             }

  2655. #endif

  2656. 

  2657.             return V3_NO_INTERFACE;

  2658.         };

  2659. 

  2660.         // there is only a single instance of this, so we don't have to care here

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

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

  2663. 

  2664.         // ------------------------------------------------------------------------------------------------------------

  2665.         // v3_plugin_base

  2666. 

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

  2668.         {

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

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

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

  2672. 

  2673.             const bool initialized = controller->initialized;

  2674.             DISTRHO_SAFE_ASSERT_RETURN(! initialized, V3_INVALID_ARG);

  2675. 

  2676.             controller->initialized = true;

  2677.             return V3_OK;

  2678.         };

  2679. 

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

  2681.         {

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

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

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

  2685. 

  2686.             const bool initialized = controller->initialized;

  2687.             DISTRHO_SAFE_ASSERT_RETURN(initialized, V3_INVALID_ARG);

  2688. 

  2689.             controller->initialized = false;

  2690.             return V3_OK;

  2691.         };

  2692. 

  2693.         // ------------------------------------------------------------------------------------------------------------

  2694.         // v3_edit_controller

  2695. 

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

  2697.         {

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

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

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

  2701. 

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

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

  2704. 

  2705. #if 0

  2706.             return vst3->setComponentState(stream);

  2707. #endif

  2708. 

  2709.             // TODO, returning ok to make renoise happy

  2710.             return V3_OK;

  2711.         };

  2712. 

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

  2714.         {

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

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

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

  2718. 

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

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

  2721. 

  2722. #if 0

  2723.             return vst3->setState(stream);

  2724. #endif

  2725.             return V3_NOT_IMPLEMENTED;

  2726.         };

  2727. 

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

  2729.         {

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

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

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

  2733. 

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

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

  2736. 

  2737. #if 0

  2738.             return vst3->getState(stream);

  2739. #endif

  2740.             return V3_NOT_IMPLEMENTED;

  2741.         };

  2742. 

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

  2744.         {

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

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

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

  2748. 

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

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

  2751. 

  2752.             return vst3->getParameterCount();

  2753.         };

  2754. 

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

  2756.         {

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

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

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

  2760. 

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

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

  2763. 

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

  2765.         };

  2766. 

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

  2768.         {

  2769.             // NOTE very noisy, called many times

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

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

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

  2773. 

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

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

  2776. 

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

  2778.         };

  2779. 

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

  2781.         {

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

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

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

  2785. 

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

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

  2788. 

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

  2790.         };

  2791. 

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

  2793.         {

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

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

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

  2797. 

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

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

  2800. 

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

  2802.         };

  2803. 

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

  2805.         {

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

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

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

  2809. 

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

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

  2812. 

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

  2814.         };

  2815. 

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

  2817.         {

  2818.             // NOTE very noisy, called many times

  2819.             // d_stdout("dpf_edit_controller::get_parameter_normalised       => %p %u", self, index);

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

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

  2822. 

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

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

  2825. 

  2826.             return vst3->getParameterNormalized(index);

  2827.         };

  2828. 

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

  2830.         {

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

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

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

  2834. 

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

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

  2837. 

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

  2839.         };

  2840. 

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

  2842.         {

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

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

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

  2846. 

  2847.             controller->handler = handler;

  2848. 

  2849.             if (PluginVst3* const vst3 = controller->vst3)

  2850.                 return vst3->setComponentHandler(handler);

  2851. 

  2852.             return V3_NOT_INITIALISED;

  2853.         };

  2854. 

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

  2856.         {

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

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

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

  2860. 

  2861. #if DISTRHO_PLUGIN_HAS_UI

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

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

  2864. 

  2865.             // if there is a component connection, we require it to be active

  2866.             if (controller->connectionComp != nullptr)

  2867.             {

  2868.                 DISTRHO_SAFE_ASSERT_RETURN(controller->connectionComp->other != nullptr, nullptr);

  2869.             }

  2870.             // otherwise short-circuit and deal with this ourselves (assume local usage)

  2871.             else

  2872.             {

  2873.                 controller->connectionComp = new dpf_dsp_connection_point(kConnectionPointController,

  2874.                                                                           controller->vst3);

  2875.                 controller->connectionComp->shortcircuit = true;

  2876.             }

  2877. 

  2878.             v3_plugin_view** const view = dpf_plugin_view_create(vst3->getInstancePointer(),

  2879.                                                                  vst3->getSampleRate());

  2880.             DISTRHO_SAFE_ASSERT_RETURN(view != nullptr, nullptr);

  2881. 

  2882.             v3_connection_point** uiconn = nullptr;

  2883.             if (v3_cpp_obj_query_interface(view, v3_connection_point_iid, &uiconn) == V3_OK)

  2884.             {

  2885.                 d_stdout("view connection query ok %p | shortcircuit %d",

  2886.                          uiconn, controller->connectionComp->shortcircuit);

  2887. 

  2888.                 v3_connection_point** const ctrlconn = (v3_connection_point**)&controller->connectionComp;

  2889. 

  2890.                 if (controller->connectionComp->shortcircuit)

  2891.                 {

  2892.                     vst3->disconnect();

  2893. 

  2894.                     v3_cpp_obj(uiconn)->connect(uiconn, ctrlconn);

  2895.                     v3_cpp_obj(ctrlconn)->connect(ctrlconn, uiconn);

  2896. 

  2897.                     vst3->connect(ctrlconn);

  2898.                 }

  2899.                 else

  2900.                 {

  2901.                     controller->connectionBridge = new dpf_dsp_connection_point(kConnectionPointBridge,

  2902.                                                                                 controller->vst3);

  2903. 

  2904.                     v3_connection_point** const bridgeconn = (v3_connection_point**)&controller->connectionBridge;

  2905.                     v3_cpp_obj(uiconn)->connect(uiconn, bridgeconn);

  2906.                     v3_cpp_obj(bridgeconn)->connect(bridgeconn, uiconn);

  2907. 

  2908.                     controller->connectionComp->bridge = bridgeconn;

  2909.                     controller->connectionBridge->bridge = ctrlconn;

  2910.                 }

  2911.             }

  2912. 

  2913.             return view;

  2914. #else

  2915.             return nullptr;

  2916. #endif

  2917.         };

  2918.     }

  2919. };

  2920. 

  2921. // --------------------------------------------------------------------------------------------------------------------

  2922. // dpf_process_context_requirements

  2923. 

  2924. struct v3_process_context_requirements_cpp : v3_funknown {

  2925.     v3_process_context_requirements req;

  2926. };

  2927. 

  2928. struct dpf_process_context_requirements : v3_process_context_requirements_cpp {

  2929.     dpf_process_context_requirements()

  2930.     {

  2931.         static const uint8_t* kSupportedInterfaces[] = {

  2932.             v3_funknown_iid,

  2933.             v3_process_context_requirements_iid

  2934.         };

  2935. 

  2936.         // ------------------------------------------------------------------------------------------------------------

  2937.         // v3_funknown

  2938. 

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

  2940.         {

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

  2942.             *iface = NULL;

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

  2944. 

  2945.             for (const uint8_t* interface_iid : kSupportedInterfaces)

  2946.             {

  2947.                 if (v3_tuid_match(interface_iid, iid))

  2948.                 {

  2949.                     *iface = self;

  2950.                     return V3_OK;

  2951.                 }

  2952.             }

  2953. 

  2954.             return V3_NO_INTERFACE;

  2955.         };

  2956. 

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

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

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

  2960. 

  2961.         // ------------------------------------------------------------------------------------------------------------

  2962.         // v3_process_context_requirements

  2963. 

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

  2965.         {

  2966. #if DISTRHO_PLUGIN_WANT_TIMEPOS

  2967.             return 0x0

  2968.                 |V3_PROCESS_CTX_NEED_CONTINUOUS_TIME  // V3_PROCESS_CTX_CONT_TIME_VALID

  2969.                 |V3_PROCESS_CTX_NEED_PROJECT_TIME     // V3_PROCESS_CTX_PROJECT_TIME_VALID

  2970.                 |V3_PROCESS_CTX_NEED_TEMPO            // V3_PROCESS_CTX_TEMPO_VALID

  2971.                 |V3_PROCESS_CTX_NEED_TIME_SIG         // V3_PROCESS_CTX_TIME_SIG_VALID

  2972.                 |V3_PROCESS_CTX_NEED_TRANSPORT_STATE; // V3_PROCESS_CTX_PLAYING

  2973. #else

  2974.             return 0x0;

  2975. #endif

  2976.         };

  2977.     }

  2978. 

  2979.     DISTRHO_PREVENT_HEAP_ALLOCATION

  2980. };

  2981. 

  2982. // --------------------------------------------------------------------------------------------------------------------

  2983. // dpf_audio_processor

  2984. 

  2985. struct v3_audio_processor_cpp : v3_funknown {

  2986.     v3_audio_processor processor;

  2987. };

  2988. 

  2989. struct dpf_audio_processor : v3_audio_processor_cpp {

  2990.     ScopedPointer<PluginVst3>& vst3;

  2991. 

  2992.     dpf_audio_processor(ScopedPointer<PluginVst3>& v)

  2993.         : vst3(v)

  2994.     {

  2995.         static const uint8_t* kSupportedInterfacesBase[] = {

  2996.             v3_funknown_iid,

  2997.             v3_audio_processor_iid

  2998.         };

  2999. 

  3000.         // ------------------------------------------------------------------------------------------------------------

  3001.         // v3_funknown

  3002. 

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

  3004.         {

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

  3006.             *iface = NULL;

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

  3008. 

  3009.             for (const uint8_t* interface_iid : kSupportedInterfacesBase)

  3010.             {

  3011.                 if (v3_tuid_match(interface_iid, iid))

  3012.                 {

  3013.                     *iface = self;

  3014.                     return V3_OK;

  3015.                 }

  3016.             }

  3017. 

  3018.             if (v3_tuid_match(v3_process_context_requirements_iid, iid))

  3019.             {

  3020.                 static dpf_process_context_requirements context_req;

  3021.                 static dpf_process_context_requirements* context_req_ptr = &context_req;;

  3022.                 *iface = &context_req_ptr;

  3023.                 return V3_OK;

  3024.             }

  3025. 

  3026.             return V3_NO_INTERFACE;

  3027.         };

  3028. 

  3029.         // there is only a single instance of this, so we don't have to care here

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

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

  3032. 

  3033.         // ------------------------------------------------------------------------------------------------------------

  3034.         // v3_audio_processor

  3035. 

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

  3037.                                                   v3_speaker_arrangement* inputs, int32_t num_inputs,

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

  3039.         {

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

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

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

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

  3044. 

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

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

  3047. 

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

  3049.         };

  3050. 

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

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

  3053.         {

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

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

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

  3057. 

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

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

  3060. 

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

  3062.         };

  3063. 

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

  3065.         {

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

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

  3068.         };

  3069. 

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

  3071.         {

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

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

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

  3075. 

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

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

  3078. 

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

  3080.         };

  3081. 

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

  3083.         {

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

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

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

  3087. 

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

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

  3090. 

  3091.             d_lastBufferSize = setup->max_block_size;

  3092.             d_lastSampleRate = setup->sample_rate;

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

  3094.         };

  3095. 

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

  3097.         {

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

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

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

  3101. 

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

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

  3104. 

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

  3106.         };

  3107. 

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

  3109.         {

  3110.             // NOTE runs during RT

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

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

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

  3114. 

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

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

  3117. 

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

  3119.         };

  3120. 

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

  3122.         {

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

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

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

  3126. 

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

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

  3129. 

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

  3131.         };

  3132.     }

  3133. };

  3134. 

  3135. // --------------------------------------------------------------------------------------------------------------------

  3136. // dpf_component

  3137. 

  3138. struct v3_component_cpp : v3_funknown {

  3139.     v3_plugin_base base;

  3140.     v3_component comp;

  3141. };

  3142. 

  3143. struct dpf_component : v3_component_cpp {

  3144.     std::atomic<int> refcounter;

  3145.     ScopedPointer<dpf_component>* self;

  3146.     ScopedPointer<dpf_audio_processor> processor;

  3147. #if DISTRHO_PLUGIN_HAS_UI

  3148.     ScopedPointer<dpf_dsp_connection_point> connection; // kConnectionPointComponent

  3149. #endif

  3150.     ScopedPointer<dpf_edit_controller> controller;

  3151.     ScopedPointer<PluginVst3> vst3;

  3152. 

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

  3154.         : refcounter(1),

  3155.           self(s)

  3156.     {

  3157.         static const uint8_t* kSupportedInterfacesBase[] = {

  3158.             v3_funknown_iid,

  3159.             v3_plugin_base_iid,

  3160.             v3_component_iid

  3161.         };

  3162. 

  3163.         // ------------------------------------------------------------------------------------------------------------

  3164.         // v3_funknown

  3165. 

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

  3167.         {

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

  3169.             *iface = NULL;

  3170. 

  3171.             for (const uint8_t* interface_iid : kSupportedInterfacesBase)

  3172.             {

  3173.                 if (v3_tuid_match(interface_iid, iid))

  3174.                 {

  3175.                     *iface = self;

  3176.                     return V3_OK;

  3177.                 }

  3178.             }

  3179. 

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

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

  3182. 

  3183.             if (v3_tuid_match(v3_audio_processor_iid, iid))

  3184.             {

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

  3186.                     component->processor = new dpf_audio_processor(component->vst3);

  3187.                 *iface = &component->processor;

  3188.                 return V3_OK;

  3189.             }

  3190. 

  3191. #if DISTRHO_PLUGIN_HAS_UI

  3192.             if (v3_tuid_match(v3_connection_point_iid, iid))

  3193.             {

  3194.                 if (component->connection == nullptr)

  3195.                     component->connection = new dpf_dsp_connection_point(kConnectionPointComponent,

  3196.                                                                          component->vst3);

  3197.                 *iface = &component->connection;

  3198.                 return V3_OK;

  3199.             }

  3200. #endif

  3201. 

  3202.             if (v3_tuid_match(v3_edit_controller_iid, iid))

  3203.             {

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

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

  3206.                 *iface = &component->controller;

  3207.                 return V3_OK;

  3208.             }

  3209. 

  3210.             return V3_NO_INTERFACE;

  3211.         };

  3212. 

  3213. #if 1

  3214.         // TODO fix this up later

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

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

  3217. #else

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

  3219.         {

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

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

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

  3223. 

  3224.             return ++component->refcounter;

  3225.         };

  3226. 

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

  3228.         {

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

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

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

  3232. 

  3233.             if (const int refcount = --component->refcounter)

  3234.             {

  3235.                 d_stdout("dpf_component::unref                   => %p | refcount %i", self, refcount);

  3236.                 return refcount;

  3237.             }

  3238. 

  3239.             d_stdout("dpf_component::unref                   => %p | refcount is zero, deleting everything now!", self);

  3240.             *component->self = nullptr;

  3241.             delete (dpf_component**)self;

  3242.             return 0;

  3243.         };

  3244. #endif

  3245. 

  3246.         // ------------------------------------------------------------------------------------------------------------

  3247.         // v3_plugin_base

  3248. 

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

  3250.         {

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

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

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

  3254. 

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

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

  3257. 

  3258.             d_lastCanRequestParameterValueChanges = true;

  3259. 

  3260.             // default early values

  3261.             if (d_lastBufferSize == 0)

  3262.                 d_lastBufferSize = 2048;

  3263.             if (d_lastSampleRate <= 0.0)

  3264.                 d_lastSampleRate = 44100.0;

  3265. 

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

  3267.             return V3_OK;

  3268.         };

  3269. 

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

  3271.         {

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

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

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

  3275. 

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

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

  3278. 

  3279.             component->vst3 = nullptr;

  3280.             return V3_OK;

  3281.         };

  3282. 

  3283.         // ------------------------------------------------------------------------------------------------------------

  3284.         // v3_component

  3285. 

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

  3287.         {

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

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

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

  3291. 

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

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

  3294. 

  3295.             // TODO

  3296.             return V3_NOT_IMPLEMENTED;

  3297.         };

  3298. 

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

  3300.         {

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

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

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

  3304. 

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

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

  3307. 

  3308.             // TODO

  3309.             return V3_NOT_IMPLEMENTED;

  3310.         };

  3311. 

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

  3313.         {

  3314.             // NOTE runs during RT

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

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

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

  3318. 

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

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

  3321. 

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

  3323.         };

  3324. 

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

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

  3327.         {

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

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

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

  3331. 

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

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

  3334. 

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

  3336.         };

  3337. 

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

  3339.         {

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

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

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

  3343. 

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

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

  3346. 

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

  3348.         };

  3349. 

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

  3351.                                      int32_t bus_idx, v3_bool state) -> v3_result

  3352.         {

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

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

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

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

  3357. 

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

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

  3360. 

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

  3362.         };

  3363. 

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

  3365.         {

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

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

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

  3369. 

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

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

  3372. 

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

  3374.         };

  3375. 

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

  3377.         {

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

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

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

  3381. 

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

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

  3384. 

  3385.             return vst3->setState(stream);

  3386.         };

  3387. 

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

  3389.         {

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

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

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

  3393. 

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

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

  3396. 

  3397.             return vst3->getState(stream);

  3398.         };

  3399.     }

  3400. };

  3401. 

  3402. // --------------------------------------------------------------------------------------------------------------------

  3403. // dpf_factory

  3404. 

  3405. struct v3_plugin_factory_cpp : v3_funknown {

  3406.     v3_plugin_factory   v1;

  3407.     v3_plugin_factory_2 v2;

  3408.     v3_plugin_factory_3 v3;

  3409. };

  3410. 

  3411. struct dpf_factory : v3_plugin_factory_cpp {

  3412.     std::vector<ScopedPointer<dpf_component>*> components;

  3413. 

  3414.     dpf_factory()

  3415.     {

  3416.         static const uint8_t* kSupportedFactories[] = {

  3417.             v3_funknown_iid,

  3418.             v3_plugin_factory_iid,

  3419.             v3_plugin_factory_2_iid,

  3420.             v3_plugin_factory_3_iid

  3421.         };

  3422. 

  3423.         // ------------------------------------------------------------------------------------------------------------

  3424.         // Dummy plugin to get data from

  3425. 

  3426.         d_lastBufferSize = 512;

  3427.         d_lastSampleRate = 44100.0;

  3428.         d_lastCanRequestParameterValueChanges = true;

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

  3430.         d_lastBufferSize = 0;

  3431.         d_lastSampleRate = 0.0;

  3432.         d_lastCanRequestParameterValueChanges = false;

  3433. 

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

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

  3436. 

  3437.         // ------------------------------------------------------------------------------------------------------------

  3438.         // v3_funknown

  3439. 

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

  3441.         {

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

  3443.             *iface = NULL;

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

  3445. 

  3446.             for (const uint8_t* factory_iid : kSupportedFactories)

  3447.             {

  3448.                 if (v3_tuid_match(factory_iid, iid))

  3449.                 {

  3450.                     *iface = self;

  3451.                     return V3_OK;

  3452.                 }

  3453.             }

  3454. 

  3455.             return V3_NO_INTERFACE;

  3456.         };

  3457. 

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

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

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

  3461. 

  3462.         // ------------------------------------------------------------------------------------------------------------

  3463.         // v3_plugin_factory

  3464. 

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

  3466.         {

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

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

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

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

  3471.             return V3_OK;

  3472.         };

  3473. 

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

  3475.         {

  3476.             return 1;

  3477.         };

  3478. 

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

  3480.         {

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

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

  3483. 

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

  3485.             info->cardinality = 0x7FFFFFFF;

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

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

  3488.             return V3_OK;

  3489.         };

  3490. 

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

  3492.         {

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

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

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

  3496. 

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

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

  3499. 

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

  3501.             *componentptr = new dpf_component(componentptr);

  3502.             *instance = componentptr;

  3503.             factory->components.push_back(componentptr);

  3504.             return V3_OK;

  3505.         };

  3506. 

  3507.         // ------------------------------------------------------------------------------------------------------------

  3508.         // v3_plugin_factory_2

  3509. 

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

  3511.         {

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

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

  3514. 

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

  3516.             info->cardinality = 0x7FFFFFFF;

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

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

  3519. 

  3520.             info->class_flags = 0;

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

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

  3523.             DISTRHO_NAMESPACE::snprintf_u32(info->version, gPluginInfo.getVersion(), ARRAY_SIZE(info->version)); // FIXME

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

  3525.             return V3_OK;

  3526.         };

  3527. 

  3528.         // ------------------------------------------------------------------------------------------------------------

  3529.         // v3_plugin_factory_3

  3530. 

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

  3532.         {

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

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

  3535. 

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

  3537.             info->cardinality = 0x7FFFFFFF;

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

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

  3540. 

  3541.             info->class_flags = 0;

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

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

  3544.             DISTRHO_NAMESPACE::snprintf_u32_utf16(info->version, gPluginInfo.getVersion(), ARRAY_SIZE(info->version)); // FIXME

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

  3546.             return V3_OK;

  3547.         };

  3548. 

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

  3550.         {

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

  3552.             return V3_NOT_IMPLEMENTED;

  3553.         };

  3554.     }

  3555. 

  3556.     ~dpf_factory()

  3557.     {

  3558.         d_stdout("dpf_factory deleting");

  3559. 

  3560.         for (ScopedPointer<dpf_component>* componentptr : components)

  3561.         {

  3562.             *componentptr = nullptr;

  3563.             delete componentptr;

  3564.         }

  3565.     }

  3566. 

  3567.     DISTRHO_PREVENT_HEAP_ALLOCATION

  3568. };

  3569. 

  3570. END_NAMESPACE_DISTRHO

  3571. 

  3572. // --------------------------------------------------------------------------------------------------------------------

  3573. // VST3 entry point

  3574. 

  3575. DISTRHO_PLUGIN_EXPORT

  3576. const void* GetPluginFactory(void);

  3577. 

  3578. const void* GetPluginFactory(void)

  3579. {

  3580.     USE_NAMESPACE_DISTRHO;

  3581.     static const dpf_factory factory;

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

  3583.     return &factoryptr;

  3584. }

  3585. 

  3586. // --------------------------------------------------------------------------------------------------------------------

  3587. // OS specific module load

  3588. 

  3589. #if defined(DISTRHO_OS_MAC)

  3590. # define ENTRYFNNAME bundleEntry

  3591. # define EXITFNNAME bundleExit

  3592. #elif defined(DISTRHO_OS_WINDOWS)

  3593. # define ENTRYFNNAME InitDll

  3594. # define EXITFNNAME ExitDll

  3595. #else

  3596. # define ENTRYFNNAME ModuleEntry

  3597. # define EXITFNNAME ModuleExit

  3598. #endif

  3599. 

  3600. DISTRHO_PLUGIN_EXPORT

  3601. bool ENTRYFNNAME(void*);

  3602. 

  3603. bool ENTRYFNNAME(void*)

  3604. {

  3605.     return true;

  3606. }

  3607. 

  3608. DISTRHO_PLUGIN_EXPORT

  3609. bool EXITFNNAME(void);

  3610. 

  3611. bool EXITFNNAME(void)

  3612. {

  3613.     return true;

  3614. }

  3615. 

  3616. #undef ENTRYFNNAME

  3617. #undef EXITFNNAME

  3618. 

  3619. // --------------------------------------------------------------------------------------------------------------------